/stdhome

To get this branch, use:
bzr branch http://bzr.ed.am/stdhome

« back to all changes in this revision

Viewing changes to lib/stdhome/program.py

  • Committer: Tim Marston
  • Date: 2014-02-12 21:51:08 UTC
  • Revision ID: tim@ed.am-20140212215108-stk5z0nlvgpi4oa8
added bzr as a vcs backend; finished init command; implemented deployment

Show diffs side-by-side

added added

removed removed

lib/stdhome/program.py
21
21
 
22
22
import os, sys, getopt
23
23
import the
24
 
from config import Config
25
 
from vcs.vcs import Vcs
26
24
 
27
25
 
28
26
class Program:
63
61
                print "  update        update files in your home directory"
64
62
                print "  resolve       try to finish an update (that had conflicts)"
65
63
                print "  add           add local files/changes to the repository"
66
 
#               print "  remove        remove a local file from the repository"
 
64
                print "  remove        remove a local file from the repository"
67
65
                print "  status        list files that have changed locally"
68
66
                print "  diff          shows changes made to local files"
69
 
                print "  revert        undo changes made to local files"
70
 
#               print "  stage-add     add (but don't commit) files/changes to local repository"
71
 
#               print "  stage-remove  delete *but don't comit) files from the local repository"
72
 
                print "  stage-revert  revert changes in the local repository"
73
 
#               print "  stage-status  show status of local repository"
74
 
#               print "  stage-diff    shows changes in local repository"
75
 
#               print "  stage-commit  commit changes in the local repository"
 
67
                print "  revert        undo changes made to a local file"
 
68
                print "  stage-add     stage local files/changes"
 
69
                print "  stage-remove  stage the removal of files"
 
70
                print "  stage-revert  revert staged changes"
 
71
                print "  stage-status  show status of staging area"
 
72
                print "  stage-diff    shows staged changes"
 
73
                print "  stage-commit  commit staged changes to repository"
76
74
                print
77
75
                print "For help about a particular command (including the additional options that the"
78
76
                print "command accepts) try typing:"
83
81
        def print_version( self ):
84
82
                print "stdhome " + self.version
85
83
                print
86
 
                print "Copyright (C) 2013 to 2014 Tim Marston"
 
84
                print "Copyright (C) 2013 Tim Marston"
87
85
                print
88
86
                #      01234567890123456789012345678901234567890123456789012345678901234567890123456789
89
87
                print "This program is free software, and you may use, modify and redistribute it"
98
96
 
99
97
 
100
98
        def check_command( self, command ):
101
 
                """Check that the given command is valid and return the full name of the
102
 
                command.
103
 
 
104
 
                @param command the given command
105
 
                """
106
 
 
 
99
                """
 
100
                Check that the given command is valid and return the full name of the command.
 
101
        
 
102
                Arguments:
 
103
                - `command`: the given command
 
104
                """
107
105
                # commands
108
106
                if [ 'init', 'update', 'resolve', 'add', 'remove', 'revert', 'status',
109
107
                         'diff', 'stage-add', 'stage-remove', 'stage-revert',
112
110
                        return command
113
111
 
114
112
                # resolve aliases
115
 
                alias = {
116
 
                        'up': 'update',
117
 
                        'rm': 'remove',
118
 
                        'st': 'status',
119
 
                        'co': 'init',
120
 
                }.get( command, False )
121
 
                if alias: return alias
 
113
                elif command == 'up':
 
114
                        return 'update'
 
115
                elif command == 'rm':
 
116
                        return 'remove'
122
117
 
123
118
                # invalid
124
 
                return None
 
119
                else:
 
120
                        return None
125
121
 
126
122
 
127
123
        def get_command_argument( self, args ):
128
 
                """Find the first program argument what isn't an option argument.
129
 
 
130
 
                @param args the program arguments
131
124
                """
 
125
                Find the first program argument what isn't an option argument.
132
126
 
 
127
        Arguments:
 
128
        - `args`: the program arguments
 
129
        """
133
130
                while args:
134
131
                        if args[ 0 ] == '--':
135
132
                                return args[ 1 ] if len( args ) > 1 else None
141
138
 
142
139
        def run( self ):
143
140
                # make an initial attempt to parse the command line, looking only for
144
 
                # --help, --version and --verbose, so that they have the chance to run
145
 
                # without a command being specified
 
141
                # --help and --version, so that they have the chance to run without a
 
142
                # command being specified
146
143
                try:
147
144
                        opts, args = getopt.gnu_getopt(
148
 
                                sys.argv[ 1: ], "v",
149
 
                                [ "verbose", "help", "version" ] )
 
145
                                sys.argv[ 1: ], "",
 
146
                                [ "help", "version" ] )
150
147
 
151
148
                        for opt, optarg in opts:
152
149
                                # we only show help if there are no non-option arguments (e.g.,
153
150
                                # a command) specified.  If a command has been specified it will
154
151
                                # have to be parsed and --help will be handled by it, instead)
155
 
                                if opt in [ '--verbose', '-v' ]:
156
 
                                        the.verbose += 1
157
 
                                elif opt == "--help" and len( args ) == 0:
 
152
                                if opt == "--help" and len( args ) == 0:
158
153
                                        self.print_help()
159
154
                                elif opt == "--version":
160
155
                                        self.print_version()
163
158
                        # ignore errors -- we aren't parsing the command line properly yet
164
159
                        pass
165
160
 
166
 
                # read program configuration
167
 
                the.config = Config()
168
 
 
169
 
                # find the command by grabbing the first program argument that doesn't
170
 
                # look like an option (note: the first argument that doesn't look like
171
 
                # an option may actually be an argument to an option, so this is far
172
 
                # from perfect, but, provided the user is mindful, this is preferable to
173
 
                # forcing the user to always specify options after the command)
 
161
                # find the first non-option argument (the command)
174
162
                the.command = self.get_command_argument( sys.argv[ 1: ] )
175
163
                if the.command == None:
176
164
                        self.print_usage( "missing command" )
181
169
                        self.print_usage( "bad command" )
182
170
 
183
171
                # calculate module and class name
184
 
                class_name = module_name = ''
185
172
                bits = the.command.split( '-' )
 
173
                class_name = 'Command'
 
174
                module_name = 'command'
186
175
                for bit in bits:
187
176
                        class_name += bit[ 0 ].upper() + bit[ 1 : ]
188
 
                        if module_name: module_name += '_'
189
 
                        module_name += bit
190
 
                class_name += 'Command'
 
177
                        module_name += '_' + bit
191
178
 
192
179
                # import module and instantiate the class
193
 
                module = __import__( 'stdhome.command.' + module_name,
 
180
                module = __import__( 'stdhome.' + module_name,
194
181
                                                         fromlist = [ class_name ] )
195
182
                instance = getattr( module, class_name )()
196
183
 
197
 
                # fully parse the command line, as per the command
 
184
                # run the command
198
185
                try:
199
186
                        instance.parse_command_line()
200
 
                except( getopt.GetoptError, self.UsageError ) as e:
 
187
                        instance.run()
 
188
                except ( getopt.GetoptError, self.UsageError ) as e:
201
189
                        self.print_usage( e.msg )
202
190
                except self.FatalError as e:
203
 
                        self.die( e.msg )
204
 
 
205
 
                # do late initialisation
206
 
                the.late_init()
207
 
 
208
 
                # run the command
209
 
                try:
210
 
                        instance.run()
211
 
                except Vcs.VcsError as e:
212
191
                        message = e.msg.rstrip()
213
 
                        if the.verbose >= 1:
 
192
                        if the.verbose and hasattr( e, 'output' ) and e.output:
214
193
                                message += '\n\nOUTPUT:\n' + e.output.rstrip()
215
194
                        self.die( message )
216
 
                except self.FatalError as e:
217
 
                        self.die( e.msg )
218
195
 
219
196
 
220
197
        class UsageError( Exception ):
225
202
 
226
203
        class FatalError( Exception ):
227
204
 
228
 
                def __init__( self, message ):
 
205
                def __init__( self, message, output = None ):
229
206
                        self.msg = message
 
207
                        self.output = output