command-set 0.8.4 → 0.9.0

data/doc/argumentDSL

@@ -30,7 +30,9 @@ The shorthand argument methods are:
 +multiword_argument+:: MultiArgument
 +nonvalidating_proc_argument+:: NoValidateProcArgument
 +number_argument+:: NumberArgument
++parent_argument+:: ParentArgument
 +proc_argument+:: ProcArgument
++range_argument+:: NumberArgument
 +regex_argument+:: RegexpArgument
 +regexp_argument+:: RegexpArgument
 +rest_argument+:: RestOfLineArgument

data/lib/command-set/arguments.rb

@@ -11,12 +11,29 @@ module Command
       DSL::Argument::register_argument(self, shorthand, type)
     end
 
-    def initialize(name)
+    def initialize(name, basis=nil)
       @name = name.to_s
-      @value = nil
+      @basis = basis
     end
 
-    attr_reader :name, :value
+    attr_reader :name
+
+    def names
+      return name()
+    end
+
+    def basis(subject = nil)
+      return @basis unless DSL::Argument::SubjectDeferral === @basis
+      return @basis.realize(subject)
+    end
+
+    def subject_requirements
+      if DSL::Argument::SubjectDeferral === @basis
+        return @basis.subject_requirements
+      else
+        return []
+      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
@@ -39,7 +56,7 @@ module Command
       unless validate(term, subject)
 	raise ArgumentInvalidException, {@name => term}
       end
-      return {@name => parse(subject, term)}
+      return {@name => term}
     end
 
     def consume_hash(subject, hash)
@@ -59,9 +76,10 @@ module Command
       end
     end
 
-    #Used for completion, to skip along terms and arguments until we're at a place where completion begins.
-    #Both the terms and arguments arrays are modified by this method, so a number of clever tricks can be played
-    #to make completion work.
+    #Used for completion, to skip along terms and arguments until we're at a
+    #place where completion begins.  Both the terms and arguments arrays are
+    #modified by this method, so a number of clever tricks can be played to
+    #make completion work.
     def match_terms(subject, terms, arguments)
       arguments.shift
       validate(terms.shift, subject)
@@ -83,7 +101,18 @@ module Command
     end
   end
 
+  class ParentArgument < Argument
+    register "parent"
+
+
+    def match_terms(subject, terms, arguments)
+      arguments.shift
+    end
+  end
+
   class ArgumentDecorator < Argument
+    include DSL::Argument
+
     def self.register(name)
       DSL::Argument::register_decorator(self, name)
     end
@@ -122,13 +151,7 @@ module Command
   #Input has to be a number, in the range passed to create the argument
   class NumberArgument < Argument
     register "number", Range
-
-    def initialize(name, range=nil)
-      super(name)
-      @range = range
-    end
-
-    attr_accessor :range
+    register "range"
 
     def complete(prefix, subject)
       return [] unless validate(prefix, subject)
@@ -137,13 +160,14 @@ module Command
 
     def validate(term, subject)
       value = parse(subject, term)
+      range = basis(subject)
       return false if not range.nil? and not range.include?(value) 
       return true if %r{^0(\D.*)?} =~ term
       return value != 0
     end
 
     def parse(subject, term)
-      @value = term.to_i
+      return term.to_i
     end
   end
 
@@ -152,21 +176,29 @@ module Command
     register "regexp", Regexp
     register "regex"
 
-    def initialize(name, regex)
-      super(name)
-      @regex = regex
-    end
-
     def complete(prefix, subject)
       return [prefix]
     end
 
     def validate(term, subject)
-      return @regex =~ term
+      return basis(subject) =~ term
     end
   end
 
+
   #File access. Completes paths, validates file options.
+  #You create a FileArgument either with an optional  hash of options, or
+  #a block that evaluates whether or not a path is acceptable.
+  #
+  #The default options hash looks like:
+  #
+  # :prune_patterns => [/^\./],  #regexs of paths to eliminate from
+  #                              #completion
+  # :dirs => [ENV['PWD']],       #works essentially the PATH env variable
+  # :acceptor => proc do |path|  #Is a good path?
+  #   return (File.exists?(path) and not File.directory?(path))
+  # end                          #The default wants existent non-dirs
+  #
   class FileArgument < Argument
     register "file"
     Defaults = { 
@@ -177,30 +209,18 @@ module Command
       end
     }
 
-    #You create a FileArgument either with an optional  hash of options, or
-    #a block that evaluates whether or not a path is acceptable.
-    #
-    #The default options hash looks like:
-    #
-    # :prune_patterns => [/^\./],  #regexs of paths to eliminate from
-    #                              #completion
-    # :dirs => [ENV['PWD']],       #essentially the PATH env variable
-    # :acceptor => proc do |path|  #Is a good path?
-    #   return (File.exists?(path) and not File.directory?(path))
-    # end                          #The default wants existent non-dirs
-    #
-    def initialize(name, options={})
-      super(name)
-      options ||= {}
+    def basis(subject=nil)
+      options = super(subject) || {}
       if Hash === options
-        @options = Defaults.merge(options)
-        @acceptor = @options[:acceptor]
+        options = Defaults.merge(options)
       elsif Proc === options
-        @options = Defaults.dup
-        @acceptor = proc &options
+        options = Defaults.dup
+        acceptor = proc &options
+        options[:acceptor] = acceptor
       else
         raise "File argument needs hash or proc!"
       end
+      return options
     end
 
     def fs
@@ -209,7 +229,8 @@ module Command
 
     def complete(prefix, subject)
       list = []
-      search_path = @options[:dirs].dup
+      options = basis(subject)
+      search_path = options[:dirs].dup
       match = %r{^#{Regexp.escape(prefix)}.*}
       infix = "" 
 
@@ -237,7 +258,7 @@ module Command
 	    catch(:bad_path) do
 	      next unless match =~ path
 
-	      @options[:prune_patterns].each do |pat|
+	      options[:prune_patterns].each do |pat|
 		if pat =~ path
 		  throw :bad_path 
 		end
@@ -245,7 +266,7 @@ module Command
 
 	      candidate = File.join(dir,path)
 	      if(File.file?(candidate))
-		throw :bad_path unless @acceptor[candidate]
+		throw :bad_path unless options[:acceptor].call(candidate)
 	      end
 
 	      if(File.directory?(candidate))
@@ -268,27 +289,32 @@ module Command
     end
 
     def validate(term, subject)
+      options = basis(subject)
+      acceptor = options[:acceptor]
       if(%r{^#{fs}} =~ term)
-	return @acceptor[term]
+	return acceptor[term]
       end
 
-      @options[:dirs].each do |dir|
+      options[:dirs].each do |dir|
 	path = File.join(dir, term)
 	if(File.exists?(path))
-	  return @acceptor[path]
+	  return acceptor[path]
 	end
       end
 
-      return @acceptor[File.join(@options[:dirs].first, term)]
+      return acceptor[File.join(options[:dirs].first, term)]
     end
   end
 
   #Using FiddlyArguments is sometimes unavoidable, but it kind of stinks.
   #You assign blocks that validate, complete and parse the input.  You're 
   #probably better off subclassing Argument.
+  #
+  #n.b. that FiddlyArguments can't use the +subject+ keyword to use the 
+  #application state as their basis
   class FiddlyArgument < Argument
-    def initialize(name, &block)
-      super(name)
+    def initialize(name, block)
+      super(name, nil)
 
       (class << self; self; end).class_eval &block
     end
@@ -298,7 +324,6 @@ module Command
       define_method :complete, &block
     end
 
-
     def self.validation(&block)
       raise TypeError unless block.arity == 2
       define_method :validate, &block
@@ -315,17 +340,12 @@ module Command
     register "array", Array
     register "choose"
 
-    def initialize(name, array)
-      super(name)
-      @options = array
-    end
-
     def complete(prefix, subject)
-      return @options.grep(%r{^#{prefix}.*})
+      return basis(subject).grep(%r{^#{prefix}.*})
     end
 
     def validate(term, subject)
-      return @options.include?(term)
+      return basis(subject).include?(term)
     end
   end
 
@@ -334,13 +354,8 @@ module Command
     register "string", String
     register "any"
 
-    def initialize(name, string)
-      super(name)
-      @description = string
-    end
-
     def complete(prefix, subject)
-      return [@description, ""]
+      return [basis(subject), ""]
     end
 
     def validate(term, subject)
@@ -356,10 +371,7 @@ module Command
     def consume(subject, arguments)
       term = arguments.join(" ")
       arguments.clear
-      unless validate(term, subject)
-	raise ArgumentInvalidException, {@name => term}
-      end
-      return {@name => parse(subject, term)}
+      return {@name => term}
     end
   end
 
@@ -376,7 +388,7 @@ module Command
 
     def initialize(name, prok)
       raise TypeError, "Block not arity 2: #{prok.arity}" unless prok.arity == 2
-      super(name)
+      super(name, nil)
       @process = proc &prok
     end
 
@@ -456,7 +468,7 @@ module Command
 
     def initialize(name, block)
       raise TypeError, "Block arity is #{prok.arity}, not 2" unless block.arity == 2
-      super(name)
+      super(name,nil)
       @process = proc &block
     end
 
@@ -465,7 +477,7 @@ module Command
     end
 
     def validate(terms, subject)
-      return (not @process[[*terms], subject].empty?)
+      return (not @process[[*terms.dup], subject].empty?)
     end
 
     def consume(subject, arguments)
@@ -523,7 +535,7 @@ module Command
         until arguments.empty? do
           trying = arguments.shift
           if(validate(trying, subject))
-            value << parse(subject,trying)
+            value << trying
           else
             arguments.unshift(trying)
             break
@@ -564,8 +576,8 @@ module Command
         return @names
       else
         name = name.to_s
-        @names << name
         @name = name
+        @names << name
       end
     end
 
@@ -588,22 +600,24 @@ module Command
       term = arguments.first
       catcher = first_catch(term, subject)
       result = catcher.consume(subject, arguments)
-      @value = catcher.value
       return result.merge({@name => result[catcher.name]})
     end
 
+    def subject_requirements
+      @sub_arguments.inject([]) do |list, arg|
+        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
     def consume_hash(subject, hash)
+      result = {}
       begin
-        return super(subject, hash)
+        result.merge! super(subject, hash)
       rescue OutOfArgumentsException; end
-      @sub_arguments.each do |arg|
-        unless hash[arg.name].nil?
-          result = arg.consume_hash(subject, hash)
-          return result.merge({@name => result[arg.name]})
-        end
+
+      return @sub_arguments.inject(result) do |result, arg|
+        result.merge arg.consume_hash(subject, hash)
       end
-      raise OutOfArgumentsException, "Missing argument: #@name!"
     end
 
     def match_terms(subject, terms, arguments)

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

@@ -0,0 +1,109 @@
+require 'command-set/arguments'
+require 'ostruct'
+
+module Command
+  class SetVisitor < OpenStruct
+    def leave_from(terms, node)
+    end
+
+    def arrive_at(terms, node)
+    end
+
+    def set_out_of_terms(node)
+    end
+
+    def command_out_of_terms(node)
+    end
+
+    def term_without_hop(terms, node)
+    end
+
+    def extra_terms(terms, node)
+    end
+  end
+
+  module Common
+    def path
+      if @parent.nil?
+        return []
+      else
+        return @parent.path + [@name]
+      end
+    end
+
+    def add_requirements(subject)
+      each_command do |command|
+        subject.required_fields(*(command.subject_requirements.uniq))
+        command.argument_list.each do |argument|
+          subject.required_fields(*(argument.subject_requirements.uniq))
+        end
+      end
+      return subject
+    end
+
+    def find_command(path)
+      visitor = SetVisitor.new(:command => nil)
+      def visitor.set_out_of_terms(node)
+        self.command = node
+      end
+
+      def visitor.arrive_at(terms, node)
+        self.command = node
+      end
+
+      def visitor.term_without_hop(terms, node)
+        raise CommandException, "No such command #{terms.first}"
+      end
+        
+      visit(path, visitor)
+      return visitor.command
+    end
+
+    def process_terms(terms, subject, arg_hash={})
+      visitor = SetVisitor.new(:command_class => nil, :subject => subject, :arg_hash => {})
+      def visitor.arrive_at(terms, node)
+        self.command_class = node.factory
+        subject = self.subject.get_image(node.subject_requirements)
+        return node.consume_terms(terms, subject, self.arg_hash)
+      end
+      visit(terms, visitor)
+      return visitor
+    end
+
+    def completion_list(terms, prefix, subject)
+      visitor = SetVisitor.new(:prefix => prefix, 
+                               :subject => subject,
+                               :completion_list => [],
+                               :arguments => [])
+      def visitor.arrive_at(terms, node)
+        self.arguments = node.argument_list.dup
+        image = subject.get_image(node.subject_requirements)
+        until(terms.empty? or arguments.empty?) do
+          arguments.first.match_terms(image, terms, arguments)
+        end
+      end
+
+      def visitor.set_out_of_terms(node)
+        if arguments.empty? or not arguments.first.required?
+          self.completion_list = node.command_names.grep(%r{^#{prefix}.*})
+        end
+        self.command_out_of_terms(node)
+      end
+
+      def visitor.command_out_of_terms(node)
+        image = subject.get_image(node.subject_requirements)
+        arguments.each do |handler|
+          self.completion_list += handler.complete(prefix, image)
+          break unless handler.omittable?
+        end 
+      end
+
+      def visitor.term_without_hop(terms, node)
+        return []
+      end
+
+      visit(terms, visitor)
+      return visitor.completion_list
+    end
+  end
+end