command-set 0.9.2 → 0.10.0

data/doc/Specifications

@@ -18,7 +18,26 @@ An established command set
 - should return subcommands
 - should accept new commands in a subcommand
 - should add Command objects
-- should have Commands that know their own paths
+
+Command::CommandSet with nested arguments
+- should honor all arguments
+- should prefer to parse commands over optional parent arguments
+
+Command::CommandSet with cascading alternating subject-based arguments
+- should complete properly
+- should stash string for mode command retrieval
+- should stash number for mode command retrieval
+
+Command::CommandSet with subject defaults
+- should set defaults on its subject
+- should be useable with an interpreter without update
+- should override the defaults of included sets
+- should not raise an error when included sets collide
+- should raise an error when included sets collide
+
+Command::CommandSet with contextualized inclusions
+- should properly assign context to commands
+- should keep items neatly in contexts
 
 Command::DSL::Argument
 - should create an ArrayArgument from an array
@@ -74,24 +93,36 @@ Command::AlternatingArgument with reused subargument names
 - should consume to number
 - should raise with invalid arguments
 
+Command::Argument with a complex set of decorators
+- should parse one pick
+- should parse many numbers
+- should parse numbers, pick and more numbers
+- should complete 'when now'
+- should complete 'when now now'
+- should not complete 'now'
+
 Command::CommandSetup
-- should create Command from complete path
 - should create Command from command path and arg hash
 - should create Command from command path and arg hash (string keys)
-- should create Command from incomplete path and arg hash
-- should create Command from class and arg hash
 
 Command::TextInterpreter
 - should verify and return the subject that it's passed
 - should set up and verify an actual subject
 - should return the same command_set it's assigned
-- should raise Runtime Error if told to start without subject
 - should split line at spaces
 - should split around quoted strings
 - should not split escaped spaces
-- should safely absorb wrapping spaces
 - should ignore embedded quotes
 - should ignore escaped quotes
+- should ignore escaped quotes
+- should split multiple spaces only once
+- should ignore leading spaces
+- should leave an empty word at the end of a line
+- should leave an empty word at the end of a line after quoted words
+
+Command::TextInterpreter has a readline completion routine that
+- should complete prefixes of space-embedding arguments
+- should return tricky error message instead of raising an exception
 
 Command::TextInterpreter all set up
 - should complete words in the commmand-line
@@ -106,16 +137,33 @@ Command::TextInterpreter with a command with a named argument
 - should complete words in the commmand-line
 - should process a command-line
 
+Command::TextInterpreter with a complex command set
+- should process commands in mode that reference mode subject
+- should issue an error message on bad commands
+
 Command::TextInterpreter with serious problems
 - should ask the user to quit instead of Ctrl-C
 - should catch command errors and continue
 - should catch exceptions and quit
 
-A fresh Subject
+Command::Subject
 - should allow a field to be required
 - should allow multiple fields to be required
 
-A Subject with required fields
+Command::Subject when merging with other subjects
+- should not allow a merge with colliding fields
+- should allow a merge with colliding unfulfilled requirements
+- should allow a colliding merge into a context
+- should not allow contexts to collide with fields
+- should not allow fields to collide with contexts
+
+Command::Subject with contextual sub-subjects
+- should project an image without context
+- should not absorb fields from contexts
+- should project an image within a context
+- should allow assignment of fields within contexts
+
+Command::Subject with required fields
 - should not verify if fields are not set
 - should not verify if some fields are not set
 - should verify if all fields are set
@@ -163,12 +211,13 @@ Command::Command with tasks
 - should resume after the designated task
 
 A chain of commands
-- should chain with a complete command path
-- should chain when an optional argument is omitted
 - should chain with a path to the command and hashed args
-- should chain with mixed and overlapping terms
 - should chain with a class and an arg hash
 
+Command::Command with a subject argument basis
+- should use the subject to accept input
+- should use the subject to reject input
+
 Command::Results::Formatter
 - should process into the correct list
 - should allow explicit options to come through from command
@@ -176,9 +225,6 @@ Command::Results::Formatter
 - should mark up items as directed by Command#format_advice
 - should mark up items as directed by Command#format_advice
 
-Command::Results::StrategyFormatter
-- should
-
 A command set with the Set command
 - should actually have the set command
 - should reply to empty arguments with first level keys
@@ -200,8 +246,9 @@ A CommandSet with Help
 - should gracefully recover if a command has nil documentation
 - should cope with nil command names in full help listing
 
-#<Command::CommandSet:0xb75fe940>
+Command::StandardCommands::Mode
 - should enter and leave a mode
+- should retain the arguments to the mode
 
 Command::StandardCommand::Resume
 - should pause and resume
@@ -256,6 +303,6 @@ Command::Results::StrategyFormatter with chatty strategy
 Command::Results::StrategyFormatter with progress strategy
 - should format two lists
 
-Finished in 0.304894 seconds
+Finished in 0.677035 seconds
 
-161 examples, 0 failures
+190 examples, 0 failures

data/lib/command-set.rb

@@ -1,3 +1,3 @@
 require 'command-set/command'
 require 'command-set/command-set'
-require 'command-set/text-interpreter'
+require 'command-set/interpreter/text'

data/lib/command-set/arguments.rb

@@ -1,12 +1,12 @@
 require 'command-set/dsl'
 
 module Command
-  #An Argument has a name and a value.  They're used to to validate input, provide input prompts (like
-  #tab-completion or pop-up menus.
+  #An Argument has a name and a value.  They're used to to validate input,
+  #provide input prompts (like tab-completion or pop-up menus.
   class Argument
 
-    #Used for new Argument subclasses to register the types they can be based on, and the explicit names of the
-    # arguments
+    #Used for new Argument subclasses to register the types they can be
+    #based on, and the explicit names of the arguments
     def self.register(shorthand, type=nil)
       DSL::Argument::register_argument(self, shorthand, type)
     end
@@ -35,22 +35,23 @@ module Command
       end
     end
 
-    #Provides a list of completion options based on a string prefix and the subject
-    #The completion should be an array of completion options.  If the completions have a common
-    #prefix, completion will enter it for the user.  As a clever trick for providing hints:
-    #  [ "This is a hint", "" ]
+    #Provides a list of completion options based on a string prefix and the
+    #subject The completion should be an array of completion options.  If
+    #the completions have a common prefix, completion will enter it for the
+    #user.  As a clever trick for providing hints: [ "This is a hint", "" ]
     def complete(original_terms, prefix, subject)
       raise NotImplementedError, "complete not implemented in #{self.class.name}"
     end
 
-    #Validates the input string against the type of the argument.  Returns true if the input is valid, or else
-    #false
+    #Validates the input string against the type of the argument.  Returns
+    #true if the input is valid, or else false
     def validate(term, subject)
       raise NotImplementedError, "validate not implemented in #{self.class.name}"
     end
 
-    #Pulls strings from an ordered list of inputs and provides the parsed data to the host command
-    #Returns the parsed data or raises ArgumentInvalidException
+    #Pulls strings from an ordered list of inputs and provides the parsed
+    #data to the host command Returns the parsed data or raises
+    #ArgumentInvalidException
     def consume(subject, arguments)
       term = arguments.shift
       unless validate(term, subject)
@@ -90,7 +91,8 @@ module Command
       false
     end
 
-    #Used in validation to require some arguments, and allow others to be optional
+    #Used in validation to require some arguments, and allow others to be
+    #optional
     def required?
       true
     end
@@ -119,7 +121,7 @@ module Command
     end
 
     def embed_argument(arg)
-      @wrapped_by.embed_argument(@wrap_with.new(@wrapped_with, arg))
+      @wrapped_by.embed_argument(@wrap_with.new(arg))
     end
   end
 
@@ -143,8 +145,7 @@ module Command
       ["@decorated"]
     end
 
-    def initialize(up, down)
-      @wrapping_decorator = up
+    def initialize(down)
       @decorated = down
     end
 
@@ -219,8 +220,8 @@ module Command
       if Hash === options
         options = Defaults.merge(options)
       elsif Proc === options
-        options = Defaults.dup
         acceptor = proc &options
+        options = Defaults.dup
         options[:acceptor] = acceptor
       else
         raise "File argument needs hash or proc!"
@@ -431,11 +432,6 @@ module Command
   class Named < ArgumentDecoration
     register_as "named"
 
-    def initialize(*args)
-      super
-      @name_pos = nil
-    end
-
     def consume(subject, arguments)
       if arguments.first == name
         arguments.shift
@@ -447,23 +443,19 @@ module Command
 
     def match_terms(subject, terms, arguments)
       if terms.first == name.to_s
-        @name_pos = terms.length
         terms.shift
-        decorated.match_terms(subject, terms, arguments)
+        arguments.shift
+        arguments.unshift(decorated)
       else
         arguments.shift
       end
     end
 
     def complete(terms, prefix, subject)
-      if not @name_pos.nil? and terms[-@name_pos] == name.to_s
-        return decorated.complete(terms, prefix, subject)
+      if %r{^#{prefix.to_s}.*} =~ name.to_s
+        return [name.to_s]
       else
-        if %r{^#{prefix.to_s}.*} =~ name.to_s
-          return [name.to_s]
-        else
-          return []
-        end
+        return []
       end
     end
 
@@ -527,6 +519,9 @@ module Command
   #
   #Will collect an array into +some_files+ of validated files.
   class Repeating < ArgumentDecoration
+    class Omittable < ArgumentDecoration
+      def omittable?; true; end
+    end
     register "repeating"
     register "many"
 
@@ -554,12 +549,20 @@ module Command
 
     def match_terms(subject, terms, arguments)
       old_length = terms.length + 1
+      middle_arguments = nil
       while terms.length < old_length and not terms.empty? do
+        middle_arguments = [decorated]
         old_length = terms.length
-        decorated.match_terms(subject, terms, arguments.dup)
+        until middle_arguments.empty? or terms.empty? do
+          middle_arguments.first.match_terms(subject, terms, middle_arguments)
+        end
       end 
 
-      arguments.shift
+      if(terms.empty? and middle_arguments.empty?)
+        middle_arguments = [Omittable.new(decorated)]
+      end
+
+      arguments[0,1] = *middle_arguments
       return true
     end
 
@@ -576,7 +579,7 @@ module Command
   #"decorator" method with the argument declarations inside.  The first
   #argument that can parse the input will be assigned - others will get nil.
   class AlternatingArgument < Argument
-# initialize(embed_in){ yield if block_given? }
+    # initialize(embed_in){ yield if block_given? }
     def initialize(embed_in, &block)
       @wrapping_decorator = embed_in
       @names = []
@@ -623,7 +626,8 @@ module Command
         list + arg.subject_requirements
       end
     end
-    #If a hash is used for arguments that includes more than one of alternating argument's sub-arguments, the behavior is undefined
+    #If a hash is used for arguments that includes more than one of
+    #alternating argument's sub-arguments, the behavior is undefined
     def consume_hash(subject, hash)
       result = @sub_arguments.inject({}) do |result, arg|
         result.merge arg.consume_hash(subject, hash)
@@ -651,7 +655,7 @@ module Command
 
     def embed_argument(arg)
       @names << arg.name
-      @sub_arguments << Optional.new(self, arg)
+      @sub_arguments << Optional.new(arg)
     end
     private
 

data/lib/command-set/command-set.rb

@@ -6,7 +6,7 @@ require 'command-set/command'
 require 'command-set/subject'
 require 'command-set/results'
 require 'command-set/dsl'
-require 'command-set/command-common'
+require 'command-set/structural'
 
 
 #:stopdoc:
@@ -114,7 +114,7 @@ module Command
           return @raw_input.inspect() +": "+ super
         end
       else
-        return @command.class.path.join(" ") +": "+ super
+        return @command.path.join(" ") +": "+ super
       end
     end
 
@@ -133,8 +133,14 @@ module Command
 
   class RootCommand < Command
     class << self
+      def setup(host, name)
+        klass = super(name)
+        klass.instance_variable_set("@host", host)
+        return klass
+      end
+
       def single_consume(argument, arg_hash, subject, terms)
-        if not argument.required? and parent.command_names.include?(terms.first)
+        if not argument.required? and @host.command_names.include?(terms.first)
           raise OutOfArgumentsException, "next is a command name"
         end
         super
@@ -146,18 +152,32 @@ module Command
   #interpreter.  CommandSet objects are defined using methods from
   #DSL::CommandSetDefinition
   class CommandSet
-    def initialize(parent=nil, name="")
-      @parent = parent
+    def initialize(name="")
       @name = name
       @command_list = { nil => RootCommand.setup(self, nil) {} }
+      @included_sets = []
       @subject_template = nil
       @documentation = ""
       @prompt = nil
       @arguments = []
       @most_recent_args = {}
+      @subject_defaults = proc {|s|}
+      @context = []
+      @root_blocks = []
     end
 
-    attr_accessor :documentation, :parent, :most_recent_args
+    def initialize_copy(original)
+      super
+      base_list = original.instance_variable_get("@command_list")
+      @command_list = {}
+      @context = [] #original.context.dup
+      base_list.each_pair do |name, cmd|
+        @command_list[name] = cmd.dup
+      end
+    end
+
+    attr_accessor :documentation, :most_recent_args
+    attr_reader :root_blocks
 
     class << self
       #The preferred way to use a CommandSet is to call CommandSet::define_commands with
@@ -196,31 +216,33 @@ module Command
 
     #:section: Workhorse methods - not usually used by client code
     #
-    def each_command(&block)
-      @command_list.each_value do |command|
-        command.each_command(&block)
+    def each_command(path, visitor)
+      @command_list.each_pair do |term, command|
+        command.each_command(path + [term], visitor)
       end
     end
 
-    def visit(terms, visitor)
-      if(terms.empty?)
-        return visitor.set_out_of_terms(self)
-      end
-
-      next_hop = @command_list[terms.first]
-      if(next_hop.nil?)
-        return visitor.term_without_hop(terms, self)
-      else
-        terms.shift
-      end
+    def root_visit(terms, visitor)
+      next_hop = if(terms.empty?)
+                   visitor.set_out_of_terms(self)
+                   @command_list[nil]
+                 else
+                   @command_list[terms.first]
+                 end
 
-      visitor.leave_from(terms, self)
+      return visitor.term_without_hop(terms, self) if(next_hop.nil?)
 
-      visitor.arrive_at(terms, next_hop)
+      visitor.leave_from(terms.shift, terms, self)
 
       return next_hop.visit(terms, visitor)
     end
 
+    def visit(terms, visitor)
+      visitor.arrive_at(terms, self)
+
+      root_visit(terms, visitor)
+    end
+
     def consume_terms(terms, subject, arg_hash)
       @command_list[nil].consume_terms(terms, subject, arg_hash)
       @most_recent_args = arg_hash.dup
@@ -231,6 +253,28 @@ module Command
       command = @command_list[nil]
     end
 
+    def apply_root_blocks(blocks)
+      @root_blocks += blocks
+      blocks.each do |block|
+        @command_list[nil].instance_eval(&block)
+      end
+    end
+
+    def get_subject
+      subject = Subject.new
+      add_requirements(subject)
+      add_defaults(subject)
+      return subject
+    end
+
+    def add_defaults(subject)
+      included_subject = @included_sets.inject(Subject.new) do |merger, (subset, options)|
+        merger.merge(options[:context], subset.get_subject)
+      end
+      subject.absorb(included_subject)
+      @subject_defaults.call(subject)
+    end
+
     def prompt
       if @prompt.nil?
         if @name.empty?
@@ -247,20 +291,13 @@ module Command
       @prompt = [match, replace]
     end
 
-    def add_requirements(subject)
-      @command_list.each_value do |command|
-	command.add_requirements subject
-      end
-      return subject
-    end
-
-    def documentation(width, parent="")
+    def documentation(width, prefix=[])
       docs = ""
       docs = @command_list.to_a.reject do |el|
 	el[0].nil?
       end
       
-      parent = [parent, @name].join(" ")
+      parent = prefix + [@name]
       docs = docs.sort_by{|el| el[0]}.inject([]) do |doclist,cmd|
 	doclist += cmd[1].short_docs(width, parent)
       end