/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: 2016-12-13 21:40:34 UTC
  • Revision ID: tim@ed.am-20161213214034-nd5t7ztnlrjd627i
fix add command and generic filename expansion/resolution to expend to
homedir-relative filename and absolute filename based on original filename, as
specified, rather than a fully, symlink-resolved filename.  So, e.g., if ~/bob
was a symlink to ~/fred, then ~/bob/a would resolve to the relative filename
bob/a, becuase it is inside the homedir (it would resolve to fred/a otherwise)

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