command-set 0.8.4 → 0.9.0

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

@@ -1,10 +1,12 @@
 require 'strscan'
 require 'thread'
+require 'forwardable'
 require 'command-set/arguments'
 require 'command-set/command'
 require 'command-set/subject'
 require 'command-set/results'
 require 'command-set/dsl'
+require 'command-set/command-common'
 
 
 #:stopdoc:
@@ -122,13 +124,24 @@ module Command
   class ArgumentInvalidException < CommandException
     def initialize(pairs)
       @pairs = pairs.dup
-      super("Bad arguments: #{pairs.inspect}")
+      super("Invalid arguments: #{pairs.map{|n,v| "#{n}: #{v.inspect}"}.join(", ")}")
     end
 
     attr_reader :pairs
   end
   class ArgumentUnrecognizedException < CommandException; end
 
+  class RootCommand < Command
+    class << self
+      def single_consume(argument, arg_hash, subject, terms)
+        if not argument.required? and parent.command_names.include?(terms.first)
+          raise OutOfArgumentsException, "next is a command name"
+        end
+        super
+      end
+    end
+  end
+
   #This class packs up a set of commands, for presentation to an
   #interpreter.  CommandSet objects are defined using methods from
   #DSL::CommandSetDefinition
@@ -136,13 +149,15 @@ module Command
     def initialize(parent=nil, name="")
       @parent = parent
       @name = name
-      @command_list = Hash.new 
+      @command_list = { nil => RootCommand.setup(self, nil) {} }
       @subject_template = nil
       @documentation = ""
       @prompt = nil
+      @arguments = []
+      @most_recent_args = {}
     end
 
-    attr_accessor :documentation, :parent
+    attr_accessor :documentation, :parent, :most_recent_args
 
     class << self
       #The preferred way to use a CommandSet is to call CommandSet::define_commands with
@@ -173,9 +188,44 @@ module Command
     end
 
     include DSL::CommandSetDefinition
+    include Common
+    extend Forwardable
+
+    def_delegators("@command_list[nil]", *CommandClassMethods.instance_methods)
+    def_delegators("@command_list[nil]", *DSL::CommandDefinition.instance_methods)
 
     #:section: Workhorse methods - not usually used by client code
     #
+    def each_command(&block)
+      @command_list.each_value do |command|
+        command.each_command(&block)
+      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
+
+      visitor.leave_from(terms, self)
+
+      visitor.arrive_at(terms, next_hop)
+
+      return next_hop.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
+      return arg_hash
+    end
 
     def get_root
       command = @command_list[nil]
@@ -204,61 +254,6 @@ module Command
       return subject
     end
 
-    #Given a set of terms, returns a Command or CommandSet, plus an extraneous (probably argument) terms
-    def find_command(*terms)
-      if terms.empty?
-        return self,[] 
-      end
-
-      command_name = terms.shift
-
-      command = @command_list[command_name]
-
-      if Class === command && Command > command
-	if command.defined?
-	  return command,terms
-	else
-	  raise CommandError, "#{command_name}: unfinalized command: #{command.inspect}"
-	end
-      elsif CommandSet === command
-	return command.find_command(*terms)
-      elsif command.nil?
-        if @command_list[nil].nil?
-          raise CommandException, "Unknown command: #{command_name.inspect}"
-        else
-          return @command_list[nil], terms.unshift(command_name)
-        end
-      else
-	raise ScriptError, "Somehow a non-command made it's " +
-	  "way into the command registry. -- (#{command.inspect})"
-      end
-    end
-
-    def completion_list(terms, prefix, subject)
-      if terms.length == 0
-	list = @command_list.keys.grep(%r{^#{prefix}.*})
-	if @command_list.has_key?(nil)
-	  list += @command_list[nil].completion_list([], prefix, subject)
-	end
-	return list
-      end
-
-      begin
-	command,terms = find_command(*terms)
-	return command.completion_list(terms, prefix, subject)
-      rescue CommandException => ce
-	return []
-      end
-    end
-
-    def path
-      if @parent.nil?
-        return []
-      else
-        return @parent.path + [@name]
-      end
-    end
-
     def documentation(width, parent="")
       docs = ""
       docs = @command_list.to_a.reject do |el|
@@ -278,6 +273,10 @@ module Command
     def command_list
       return @command_list.dup
     end
+
+    def command_names
+      return @command_list.keys.compact
+    end
   end
 end
 

data/lib/command-set/command.rb

@@ -1,4 +1,5 @@
 require 'command-set/arguments'
+require 'command-set/command-common'
 module Command
 
   #A thin wrapper on Array to maintain undo/redo state.
@@ -46,41 +47,22 @@ module Command
 
     attr_accessor :task_id, :command, :args_hash, :terms
 
-    def resolve_command_class(command_set)
-      if Class === @command && Command > @command
-        return @command
+    def resolve_command_class(command_set, subject)
+      unless Class === @command && Command > @command
+        command_path = @command
+        result = command_set.process_terms(command_path, subject)
+        @command = result.command_class
+        @args_hash = result.arg_hash.merge(@args_hash)
+        @terms = command_path
       end
 
-      command_path = @command
-      @command,terms = command_set.find_command(*command_path)
-
-      if CommandSet === @command
-        if (cmd = @command.get_root).nil?
-          raise CommandException, "Incomplete command #{command_path.join(" ")}"
-        else
-          terms = [@command]
-          @command = cmd
-        end
-      end
-
-      @terms = terms
-
       return @command
     end
 
-    def assign_terms(cmd)
-      terms = @terms.dup
-      cmd.each_consumer do |consumer|
-        terms = consumer[terms]
-      end
-
-      cmd.consume_hash(@args_hash)
-    end
-
     def command_instance(command_set, subject)
-      command_class = resolve_command_class(command_set)
+      command_class = resolve_command_class(command_set, subject)
       command = command_class.new(subject, task_id)
-      assign_terms(command)
+      command.consume_hash(@args_hash)
       return command
     end
   end
@@ -99,30 +81,88 @@ module Command
 
   class ResumeFromOnlyThis < ResumeFrom; end
 
+  module CommandClassMethods
+    attr_reader :subject_requirements, :argument_list, 
+      :advice_block, :parent_arguments
+
+    def consume_terms(terms, subject, arg_hash)
+      begin
+        argument_list.each do |argument|
+          raise TypeError, "#{terms.inspect} isn't an Array!" unless Array === terms
+          begin
+            if terms.empty?
+              raise OutOfArgumentsException, "argument #{argument.inspect} required!"
+            end
+            single_consume(argument, arg_hash, subject, terms)
+          rescue ArgumentInvalidException => aie
+            @validation_problem = aie
+            raise
+          end
+        end
+      rescue OutOfArgumentsException
+      end
+      @validation_problem = nil
+      return arg_hash
+    end
+
+    def embed_argument(arg)
+      unless argument_list.last.nil? or argument_list.last.required?
+        if arg.required?
+          raise NoMethodError, "Can't define required arguments after optionals"
+        end
+      end
+      @subject_requirements += arg.subject_requirements
+
+      argument_list << arg
+    end
+
+    def executeable?
+      instance_methods.include?("execute")
+    end
+
+    def optional_argument(arg, values=nil, &get_values)
+      optional.argument(arg, values, &get_values)
+    end
+
+    def factory
+      return self
+    end
+  end
+
   class Command
     @name = "unnamed command"
     @parent = nil
     @argument_list=[]
+    @parent_arguments=[]
     @doc_text = nil
     @subject_requirements=[:chain_of_command]
     @defined = false
     @advice_block = proc {}
+
     class << self
       alias_method :instance, :new
 
-      attr_reader :name, :argument_list
-      alias_method :required_argument_list, :argument_list 
-      alias_method :optional_argument_list, :argument_list 
-      attr_reader :doc_text, :subject_requirements, :defined, :advice_block
+      attr_reader :name, :doc_text, :defined 
       attr_accessor :parent
 
       def inherited(subclass)
-        subclass.instance_variable_set("@name", name.dup)
-        subclass.instance_variable_set("@argument_list", argument_list.dup )
-        subclass.instance_variable_set("@doc_text", doc_text.dup) unless doc_text.nil?
-        subclass.instance_variable_set("@subject_requirements", subject_requirements.dup)
-        subclass.instance_variable_set("@defined", false)
-        subclass.instance_variable_set("@advice_block", advice_block.dup)
+        [ [:name, proc {name.dup}],
+          [:argument_list, proc {argument_list.dup }],
+          [:parent_arguments, proc {parent_arguments.dup }],
+          [:doc_text, proc {doc_text.nil? ? nil : doc_text.dup}], 
+          [:subject_requirements, proc {subject_requirements.dup}],
+          [:defined, proc {false}],
+          [:advice_block, proc {advice_block.dup}],
+        ].each do |var, prok|
+          subclass.instance_variable_set("@#{var.to_s}", prok.call)
+        end
+      end
+
+      def initialize_copy(original)
+        super
+        @argument_list = original.argument_list.dup
+        @parent_arguments = original.parent_arguments.dup
+        @subject_requirements = original.subject_requirements.dup
       end
 
       #Establishes a subclass of Command.  This is important because commands are actually
@@ -140,8 +180,6 @@ module Command
 
         command_class = Class.new(self)
         new_name = new_name.to_s
-        #Of interest: klass.instance_eval { def method } creates klass::method
-        #but klass.class_eval { def method } creates klass#method
 
         command_class.instance_variable_set("@name", new_name)
         command_class.instance_variable_set("@parent", parent)
@@ -152,8 +190,27 @@ module Command
         return command_class
       end
 
+      def each_command(&block)
+        block.call(self)
+      end
+
+      def visit(terms, visitor)
+        result = visitor.arrive_at(terms, self)
+
+        if(terms.empty?)
+          return visitor.command_out_of_terms(self)
+        else
+          return visitor.extra_terms(terms, self)
+        end
+      end
+
+      def single_consume(argument, arg_hash, subject, terms)
+        arg_hash.merge! argument.consume(subject, terms)
+      end
+
       def defined
         @defined = true
+        create_argument_methods
       end
 
       def defined?
@@ -162,18 +219,8 @@ module Command
 
       def inspect
         arguments = argument_list.map{|arg| arg.name}
-        argument_list.each do |argument|
-          arguments << argument.name
-        end
-        return "#<Class:#{self.object_id} - Command:#{path().join(" ")}(#{arguments.join(", ")})>"
-      end
 
-      def path
-        if @parent.nil?
-          [@name]
-        else
-          @parent.path + [@name]
-        end
+        return "#<Class:#{"%#x" % self.object_id} - Command:#{path().join(" ")}(#{arguments.join(", ")})>"
       end
 
       def documentation(width, parent="")
@@ -186,21 +233,22 @@ module Command
       end
 
       def short_docs(width, parent="")
-        docs = ((parent.empty? ? [name]:[parent, name]) + required_argument_list.map do |arg|
-          "<#{arg.name}> "
-        end + optional_argument_list.map do |arg|
-          "[<#{arg.name}>]"
-        end).join(" ")
-
-        return docs.wrap(width)
-      end
+        docs = [path]
+        docs += argument_list.map do |arg|
+          if arg.required?
+            "<#{arg.name}>"
+          else
+            "[#{arg.name}]"
+          end
+        end
+        
 
-      def add_requirements(subject)
-        subject.required_fields(*(@subject_requirements.uniq))
+        return docs.join(" ").wrap(width)
       end
 
       def completion_list(terms, prefix, subject)
         arguments = argument_list.dup
+        subject = subject.get_image(subject_requirements)
 
         until(terms.empty? or arguments.empty?) do
           arguments.first.match_terms(subject, terms, arguments)
@@ -214,42 +262,28 @@ module Command
         return completion
       end
 
-      def create_argument_methods(name)
-        define_method(name) do
-          @arg_hash[name]
+      def create_argument_methods
+        names = (argument_list + parent_arguments).inject([]) do |list, arg|
+          list + [*arg.names]
         end
-        private(name)
-
-        define_method(name.to_s + "=") do |value|
-          @arg_hash[name] = value
-        end
-        private(name.to_s + "=")
-      end
-
-      def embed_argument(arg)
-        names = [*arg.name]
 
         names.each do |name|
-          create_argument_methods(name)
-        end
+          define_method(name) do
+            @arg_hash[name]
+          end
+          private(name)
 
-        unless argument_list.last.nil? or argument_list.last.required?
-          if arg.required?
-            raise NoMethodError, "Can't define required arguments after optionals"
+          define_method(name.to_s + "=") do |value|
+            @arg_hash[name] = value
           end
+          private(name.to_s + "=")
         end
-
-        argument_list << arg
-      end
-
-      def optional_argument(arg, values=nil, &get_values)
-        optional.argument(arg, values, &get_values)
       end
-
     end
 
     extend DSL::CommandDefinition
-    extend DSL::Argument
+    extend CommandClassMethods
+    extend Common
     include DSL::Action
 
     class DontResume; end
@@ -287,7 +321,7 @@ module Command
     end
 
     def all_arguments
-      self.class.argument_list
+      self.class.argument_list + self.class.parent_arguments
     end
 
     def subject_requirements
@@ -296,7 +330,7 @@ module Command
 
     def inspect
       name = self.class.name
-      return "#<Command:#{name}>:#{self.object_id} #{@arg_hash.keys.inspect}"
+      return "#<Command:#{name}>:#{"%#x" % self.object_id} #{@arg_hash.inspect}"
     end
 
     def parent
@@ -306,7 +340,7 @@ module Command
     def go(collector)
       return if @resume_from == DontResume
       unless self.respond_to? :execute
-        raise CommandException, "#{@name}: command declared but no action defined" 
+        raise CommandException, "#{self.class.path}: command declared but no action defined" 
       end
 
       @main_collector = collector
@@ -387,34 +421,6 @@ module Command
       @validation_problem = nil
     end
 
-    def yield_consumer(argument, &block)
-      blk = proc(&block)
-      consumer = proc do |args|
-        raise TypeError, "#{args.inspect} isn't an Array!" unless Array === args
-        begin
-          if args.empty?
-            raise OutOfArgumentsException, "argument #{argument.inspect} required!"
-          end
-          @arg_hash.merge! argument.consume(@subject, args)
-          return args
-        rescue ArgumentInvalidException => aie
-          @validation_problem = aie
-          raise
-        end
-      end
-      blk[consumer]
-    end
-
-    def each_consumer(&block)
-      begin
-        all_arguments.each do |argument|
-          yield_consumer(argument, &block)
-        end
-      rescue OutOfArgumentsException
-      end
-      @validation_problem = nil
-    end
-
     def undoable?
       return false
     end