command-set 0.9.0 → 0.9.1

data/doc/argumentDSL

@@ -16,10 +16,8 @@ Decorator methods, and the classes they add:
 
 +repeating+:: Repeating
 +many+:: Repeating
-+multi+:: AlternatingArgument
 +named+:: Named
 +optional+:: Optional
-+alternating+:: AlternatingArgument
 
 The shorthand argument methods are:
 

data/lib/command-set/arguments.rb

@@ -39,7 +39,7 @@ module Command
     #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(prefix, subject)
+    def complete(original_terms, prefix, subject)
       raise NotImplementedError, "complete not implemented in #{self.class.name}"
     end
 
@@ -60,11 +60,11 @@ module Command
     end
 
     def consume_hash(subject, hash)
-      unless((term = hash[@name]).nil?)
+      unless((term = hash[name]).nil?)
         if validate(term, subject)
-          return {@name => parse(subject, term)}
+          return {name => parse(subject, term)}
         else
-          raise ArgumentInvalidException, {@name => term}
+          raise ArgumentInvalidException, {name => term}
         end
       end
       return {}
@@ -110,41 +110,46 @@ module Command
     end
   end
 
-  class ArgumentDecorator < Argument
+  class ArgumentDecorator
     include DSL::Argument
 
-    def self.register(name)
-      DSL::Argument::register_decorator(self, name)
+    def initialize(wrapped_by, wrap_with, &block)
+      @wrapped_by = wrapped_by
+      @wrap_with = wrap_with
     end
 
-    class << self
-      alias register_as register
+    def embed_argument(arg)
+      @wrapped_by.embed_argument(@wrap_with.new(@wrapped_with, arg))
     end
+  end
 
-    def self.decoration(&block)
-      @decor = block
+  class ArgumentDecoration < Argument
+    class << self
+      def register(name)
+        DSL::Argument::register_decorator(self, name)
+      end
+      alias register_as register
     end
 
-    def self.decor
-      @decor
+    Argument.instance_methods(false).each do |method|
+      class_eval(<<-EOM, __FILE__, __LINE__)
+      def #{method}(*args, &block)
+        decorated.#{method}(*args, &block)
+      end
+      EOM
     end
 
-    def decor
-      self.class.decor
+    def pretty_print_instance_variables
+      ["@decorated"]
     end
 
-    def initialize(up)
+    def initialize(up, down)
       @wrapping_decorator = up
+      @decorated = down
     end
 
-    def embed_argument(argument)
-      @wrapping_decorator.embed_argument(decorate(argument))
-    end
-
-    def decorate(argument)
-      block = decor
-      (class << argument; self; end).class_eval &block
-      return argument
+    def decorated
+      @decorated
     end
   end
 
@@ -153,7 +158,7 @@ module Command
     register "number", Range
     register "range"
 
-    def complete(prefix, subject)
+    def complete(terms, prefix, subject)
       return [] unless validate(prefix, subject)
       return [prefix]
     end
@@ -176,7 +181,7 @@ module Command
     register "regexp", Regexp
     register "regex"
 
-    def complete(prefix, subject)
+    def complete(terms, prefix, subject)
       return [prefix]
     end
 
@@ -227,7 +232,7 @@ module Command
       File::Separator
     end
 
-    def complete(prefix, subject)
+    def complete(terms, prefix, subject)
       list = []
       options = basis(subject)
       search_path = options[:dirs].dup
@@ -340,7 +345,7 @@ module Command
     register "array", Array
     register "choose"
 
-    def complete(prefix, subject)
+    def complete(terms, prefix, subject)
       return basis(subject).grep(%r{^#{prefix}.*})
     end
 
@@ -354,7 +359,7 @@ module Command
     register "string", String
     register "any"
 
-    def complete(prefix, subject)
+    def complete(terms, prefix, subject)
       return [basis(subject), ""]
     end
 
@@ -392,7 +397,7 @@ module Command
       @process = proc &prok
     end
 
-    def complete(prefix, subject)
+    def complete(terms, prefix, subject)
       return @process.call(prefix, subject)
     end
 
@@ -413,50 +418,58 @@ module Command
   #Most common decorator.  Tags a argument as omitable.  Otherwise, the
   #interpreter will return an error to the user if they leave out an
   #argument.  Optional arguments that aren't provided are set to nil.
-  class Optional < ArgumentDecorator
+  class Optional < ArgumentDecoration
     register_as "optional"
 
-    decoration do
-      def required?
-        false
-      end
+    def required?
+      false
     end
   end
 
   #Indicated that the name of the argument has to appear on the command line
   #before it will be recognized.  Useful for optional or alternating arguments
-  class Named < ArgumentDecorator
+  class Named < ArgumentDecoration
     register_as "named"
 
-    decoration do
-      alias_method(:old_consume, :consume)
-      alias_method(:old_complete, :complete)
-      alias_method(:old_match_terms, :match_terms)
-      def consume(subject, arguments)
-        if arguments.first == @name
-          arguments.shift
-          return old_consume(subject,arguments)
-        else
-          raise ArgumentInvalidException, "Name \"#{@name}\" required."
-        end
+    def initialize(*args)
+      super
+      @name_pos = nil
+    end
+
+    def consume(subject, arguments)
+      if arguments.first == name
+        arguments.shift
+        return decorated.consume(subject,arguments)
+      else
+        raise ArgumentInvalidException, "Name \"#{name}\" required."
       end
+    end
 
-      def match_terms(subject, terms, arguments)
-        if terms.first == @name.to_s
-          terms.shift
-        else
-          old_match_terms(subject, terms, arguments)
-        end
+    def match_terms(subject, terms, arguments)
+      if terms.first == name.to_s
+        @name_pos = terms.length
+        terms.shift
+        decorated.match_terms(subject, terms, arguments)
+      else
+        arguments.shift
       end
+    end
 
-      def complete(prefix, subject)
-        if %r{^#{prefix.to_s}.*} =~ @name.to_s
-          return [@name.to_s]
+    def complete(terms, prefix, subject)
+      if not @name_pos.nil? and terms[-@name_pos] == name.to_s
+        return decorated.complete(terms, prefix, subject)
+      else
+        if %r{^#{prefix.to_s}.*} =~ name.to_s
+          return [name.to_s]
         else
-          return old_complete(prefix, subject)
+          return []
         end
       end
     end
+
+    def validate(term, subject)
+      return term == name || super
+    end
   end
 
 
@@ -472,7 +485,7 @@ module Command
       @process = proc &block
     end
 
-    def complete(prefix, subject)
+    def complete(terms, prefix, subject)
       return @process[[*prefix], subject]
     end
 
@@ -513,58 +526,59 @@ module Command
   #  repeating.file_argument :some_files
   #
   #Will collect an array into +some_files+ of validated files.
-  class Repeating < ArgumentDecorator
+  class Repeating < ArgumentDecoration
     register "repeating"
     register "many"
 
-    decoration do
-      def consume_hash(subject, hash)
-        term = hash[@name]
-        return {} if term.nil?
-
-        term = [*term]
-        if term.find{|it| not validate(it, subject)}
-          raise ArgumentInvalidException, {@name => term}
+    def consume_hash(subject, hash)
+      result = [*names].inject({}) do |arg_hash, name|
+        terms = hash[name]
+        if terms.nil?
+          arg_hash
         else
-          return {@name => term.map{|it| parse(subject,it)}}
+          [*terms].inject(arg_hash) do |a_h, term|
+            merge_hashes(a_h, decorated.consume_hash(subject, {name => term}))
+          end
         end
       end
+      return result
+    end
 
-      def consume(subject, arguments)
-        value = []
-        until arguments.empty? do
-          trying = arguments.shift
-          if(validate(trying, subject))
-            value << trying
-          else
-            arguments.unshift(trying)
-            break
-          end
-        end
-        return {@name => value}
+    def consume(subject, arguments)
+      result = {}
+      until arguments.empty? or not validate(arguments.first, subject) do
+        merge_hashes(result, decorated.consume(subject, arguments))
       end
+      return result
+    end
 
-      def match_terms(subject, terms, arguments)
-        validated = validate(terms.first, subject)
-        if(validated)
-          terms.shift
-        else
-          arguments.shift
-        end
-        return true
+    def match_terms(subject, terms, arguments)
+      old_length = terms.length + 1
+      while terms.length < old_length and not terms.empty? do
+        old_length = terms.length
+        decorated.match_terms(subject, terms, arguments.dup)
+      end 
+
+      arguments.shift
+      return true
+    end
+
+    def merge_hashes(hash, other_hash)
+      other_hash.each_pair do |name, value|
+        hash[name] ||= []
+        hash[name] << value
       end
+      return hash
     end
   end
 
   #Allows several arguments to share a position.  Pass a block to the
   #"decorator" method with the argument declarations inside.  The first
   #argument that can parse the input will be assigned - others will get nil.
-  class AlternatingArgument < ArgumentDecorator
-    register "alternating"
-    register "multi"
+  class AlternatingArgument < Argument
 # initialize(embed_in){ yield if block_given? }
     def initialize(embed_in, &block)
-      super(embed_in)
+      @wrapping_decorator = embed_in
       @names = []
       @sub_arguments = []
       self.instance_eval &block
@@ -581,9 +595,9 @@ module Command
       end
     end
 
-    def complete(prefix, subject)
+    def complete(terms, prefix, subject)
       return sub_arguments.inject([]) do |list, sub_arg|
-        list.concat sub_arg.complete(prefix, subject)
+        list.concat sub_arg.complete(terms, prefix, subject)
       end
     end
 
@@ -600,6 +614,7 @@ module Command
       term = arguments.first
       catcher = first_catch(term, subject)
       result = catcher.consume(subject, arguments)
+      return result if @name.nil?
       return result.merge({@name => result[catcher.name]})
     end
 
@@ -610,14 +625,13 @@ module Command
     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
-        result.merge! super(subject, hash)
-      rescue OutOfArgumentsException; end
-
-      return @sub_arguments.inject(result) do |result, arg|
+      result = @sub_arguments.inject({}) do |result, arg|
         result.merge arg.consume_hash(subject, hash)
       end
+      unless @name.nil?
+        result[@name] = parse(subject, hash[@name])
+      end
+      return result
     end
 
     def match_terms(subject, terms, arguments)
@@ -637,7 +651,7 @@ module Command
 
     def embed_argument(arg)
       @names << arg.name
-      @sub_arguments << optional.decorate(arg)
+      @sub_arguments << Optional.new(self, arg)
     end
     private
 

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

@@ -74,7 +74,8 @@ module Command
       visitor = SetVisitor.new(:prefix => prefix, 
                                :subject => subject,
                                :completion_list => [],
-                               :arguments => [])
+                               :arguments => [],
+                               :original_terms => terms.dup)
       def visitor.arrive_at(terms, node)
         self.arguments = node.argument_list.dup
         image = subject.get_image(node.subject_requirements)
@@ -93,7 +94,7 @@ module Command
       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)
+          self.completion_list += handler.complete(original_terms, prefix, image)
           break unless handler.omittable?
         end 
       end

data/lib/command-set/command.rb

@@ -246,22 +246,6 @@ module Command
         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)
-        end
-
-        completion = []
-        arguments.each do |handler|
-          completion += handler.complete(prefix, subject)
-          break unless handler.omittable?
-        end 
-        return completion
-      end
-
       def create_argument_methods
         names = (argument_list + parent_arguments).inject([]) do |list, arg|
           list + [*arg.names]

data/lib/command-set/dsl.rb

@@ -281,7 +281,7 @@ Action:: utility functions within the command action block
       #Don't look to closely at the source.  It does bad things.
       def create_decorator(&block)
         me = /:in `([^']*)/.match(caller(0)[0])[1]
-        return @@decorator_map[me].new(self, &block)
+        return ArgumentDecorator.new(self, @@decorator_map[me], &block) 
       end
 
       #This method functions analogously to create_decorator, except it
@@ -328,11 +328,13 @@ Action:: utility functions within the command action block
       #alternating argument is a series of arguments, any of which could be
       #set.  They either need to be of distinct types, or use +named+ to
       #distinguish between them.
-      def alternating_argument(name, &block)
+      def alternating_argument(name=nil, &block)
         arg = AlternatingArgument.new(self, &block)
         arg.name(name)
       end
 
+      alias alternating alternating_argument 
+
       #The method used to instantiate arguments based on their values.
       #Searches all registered Argument classes, from children up, until one
       #admits to being able to create arguments based on the value.

data/lib/command-set/results.rb

@@ -1,4 +1,3 @@
-require 'delegate'
 require 'command-set/result-list'
 
 module Kernel
@@ -88,12 +87,6 @@ module Command
       __setobj__(__getobj__.dup)
     end
 
-    #This looks gnarly, but DelegateClass takes out methods defined by
-    #Kernel -- Which usually makes sense, but IO has a bunch of methods that
-    #Kernel defines to basically delegate to an IO.... I have a headache
-    #now.
-    #It might just make sense to explicitly do the delegation, rather than
-    #use DelegateClass
     methods = IO.public_instance_methods(false)
     methods -= self.public_instance_methods(false)
     methods |= ['class']

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

@@ -1,7 +1,6 @@
 require 'readline'
 require 'command-set'
 require 'dl/import'
-require 'logger'
 require 'command-set/interpreter'
 
 #This really locks text-interpreter down to Linux, maybe Unix-like
@@ -28,16 +27,24 @@ module Readline
     rescue Exception
     end
 
-    ls_so_dirs.each do |libreadline_location|
+    libreadline_names = %w{libreadline.so libreadline.dylib libreadline.dll}
+
+    libreadline_paths = ls_so_dirs.inject([]) do |list, dir|
+      list + libreadline_names.map do |name|
+        File::join(*(dir + [name]))
+      end
+    end
+
+    libreadline_paths.each do |path|
       begin
-        dlload File::join(*(libreadline_location + ["libreadline.so"]))
+        dlload path
         RLLB = symbol("rl_line_buffer")
         found_libreadline = true
         break
       rescue RuntimeError
       end
     end
-    
+
     raise RuntimeError,"couldn't find libreadline.so" unless found_libreadline
 
     def self.line_buffer

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: command-set
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
-date: 2008-01-08 00:00:00 -08:00
+  version: 0.9.1
+date: 2008-01-11 00:00:00 -08:00
 summary: Framework for interactive programs focused around a DSL for commands
 require_paths: 
 - lib
@@ -56,7 +56,7 @@ rdoc_options:
 - --main
 - Command
 - --title
-- command-set-0.9.0 RDoc
+- command-set-0.9.1 RDoc
 extra_rdoc_files: 
 - doc/README
 - doc/GUIDED_TOUR