command-set 0.9.2 → 0.10.0

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

@@ -50,7 +50,7 @@ module StdCmd
               end
             else
               command = subject.command_set.find_command(terms)
-              docs = command.documentation(width)
+              docs = command.documentation(width, terms)
               docs.each do |docline|
                 puts docline
               end
@@ -133,7 +133,7 @@ module StdCmd
           doesnt_undo
 
           action do
-            subject.interpreter.push_mode(parent)
+            subject.interpreter.push_mode(nesting)
           end
         end
 

data/lib/command-set/structural.rb

@@ -0,0 +1,230 @@
+require 'command-set/arguments'
+require 'forwardable'
+
+module Command
+  class SetVisitor
+    def initialize
+      @subject_context = []
+      @command_path = []
+    end
+    attr_reader :subject_context, :command_path
+
+    def leave_from(via, terms, node)
+      @command_path << via
+    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
+
+  class RequirementsCollector < SetVisitor
+    def initialize(subject)
+      super()
+      @subject = subject
+    end
+
+    attr_reader :subject
+    
+    def arrive_at(terms, node)
+      @subject.required_fields(node.subject_requirements.uniq, @subject_context)
+      node.argument_list.each do |argument|
+        @subject.required_fields(argument.subject_requirements.uniq)
+      end
+    end
+  end
+
+  class CommandFinder < SetVisitor
+    def initialize
+      super()
+      @command = nil
+    end
+
+    attr_reader :command
+
+    def set_out_of_terms(node)
+      @command ||= node
+    end
+
+    def command_out_of_terms(node)
+      @command ||= node
+    end
+
+    def extra_terms(terms, node)
+      term_without_hop(terms, node)
+    end
+
+    def term_without_hop(terms, node)
+      raise CommandException, "No such command #{terms.first}"
+    end
+  end
+
+  class CommandSetup < SetVisitor
+    def initialize(terms = [], hash = {})
+      super()
+      @command_class = nil 
+      @subject = subject 
+      @arg_hash = hash
+      @terms = terms.dup
+      @task_id = nil
+      @set_nesting = []
+    end
+
+    
+    attr_accessor :arg_hash, :terms, :subject, 
+      :task_id, :command_class, :set_nesting
+
+    def arrive_at(terms, node)
+      @command_class = node
+      subject = @subject.get_image(node.subject_requirements, @subject_context)
+      return node.consume_terms(terms, subject, @arg_hash)
+    end
+
+    def leave_from(via, terms, node)
+      if CommandSet === node
+        @set_nesting << node
+      end
+      super
+    end
+
+    def term_without_hop(terms, node)
+      if CommandSet === node
+        raise CommandException, "No such command: #{terms.first}"
+      end
+    end
+
+    def class_resolution(command_set)
+      @command_class = command_set.find_command(@terms.dup)
+    end
+
+    def resolve_command_class(command_set)
+      return if Class === @command_class && Command > @command_class
+      class_resolution(command_set)
+      #@args_hash = @arg_hash.merge(@args_hash)
+    end
+
+    def command_instance(command_set, subject)
+      @subject ||= subject
+      resolve_command_class(command_set)
+      command = self.command_class.new(self, task_id)
+      command.consume_hash(self.arg_hash)
+      return command
+    end
+  end
+
+  class CompletionsLister < SetVisitor
+    def initialize(prefix, subject, terms)
+      super()
+      @prefix = prefix 
+      @subject = subject
+      @completion_list = []
+      @arguments = []
+      @original_terms = terms.dup
+    end
+
+    attr_reader :prefix, :subject, :completion_list
+
+    def arrive_at(terms, node)
+      @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 set_out_of_terms(node)
+      if @arguments.empty? or not @arguments.first.required?
+        @completion_list = node.command_names.grep(%r{^#{prefix}.*})
+      end
+    end
+
+    def command_out_of_terms(node)
+      image = @subject.get_image(node.subject_requirements)
+      @arguments.each do |handler|
+        @completion_list += handler.complete(@original_terms, @prefix, image)
+        break unless handler.omittable?
+      end 
+    end
+
+    def term_without_hop(terms, node)
+      return []
+    end
+  end
+
+  module Common
+    def path
+      if @parent.nil?
+        return []
+      else
+        return @parent.path + [@name]
+      end
+    end
+
+    def add_requirements(subject)
+      each_command([], RequirementsCollector.new(subject))
+      return subject
+    end
+
+    def find_command(path)
+      visitor = CommandFinder.new
+      visit(path, visitor)
+      return visitor.command
+    end
+
+    def process_terms(terms, subject)
+      visitor = CommandSetup.new(terms)
+      visitor.subject = subject
+      root_visit(terms, visitor)
+      return visitor
+    end
+
+    def completion_list(terms, prefix, subject)
+      visitor = CompletionsLister.new(prefix, subject, terms)
+      visit(terms, visitor)
+      return visitor.completion_list
+    end
+  end
+
+  class SetItem
+    extend Forwardable
+    def initialize(decorates)
+      @decorated = decorates
+    end
+
+    def_delegators :@decorated, :subject_requirements, :consume_terms
+
+    def decoration(terms, visitor); end
+
+    def each_command(terms, visitor)
+      decoration(terms, visitor)
+      return @decorated.each_command(terms, visitor)
+    end
+
+    def visit(terms, visitor)
+      decoration(terms, visitor)
+      return @decorated.visit(terms, visitor)
+    end
+  end
+
+  class ContextBoundary < SetItem
+    def initialize(decorate, context)
+      super(decorate)
+      @context = context
+    end
+
+    def decoration(terms, visitor)
+      visitor.subject_context << @context
+    end
+  end
+end

data/lib/command-set/subject.rb

@@ -19,77 +19,191 @@ module Command
     class UndefinedField; end
     Undefined = UndefinedField.new
 
-    def required_fields(*field_names)
+    def initialize
+      @fields = {}
+      @contexts = {}
+      @protected_subfields = Hash.new {|h,k| h[k] = []}
+    end
+
+    def required_fields(field_names, required_at=[])
+      unless required_at.empty?
+        unless @contexts.has_key?(required_at.first)
+          create_context(required_at.first, Subject.new)
+        end
+        return @contexts[required_at.shift].required_fields(field_names, 
+                                                            required_at)
+      end
+
       field_names.map! {|name| name.to_s}
       field_names -= instance_variables.map {|var| var.sub(/^@/, "")}
+      bad_fields = field_names.find_all do |name|
+        @contexts.has_key?(name.to_sym)
+      end
+      unless bad_fields.empty?
+        raise CommandError, "#{bad_fields.join(", ")} are context names!" 
+      end
+      
       field_names.each do |field|
-	add_accessor(field)
+        add_field(field)
       end
     end
 
     def verify
-      missing = instance_variables.find_all do |var| 
-	UndefinedField === instance_variable_get(var)
+      missing = @fields.keys.find_all do |var| 
+        UndefinedField === @fields[var]
       end
       unless missing.empty?
         missing.map! {|m| m.sub(/^@/,"")}
-	raise RuntimeError, "Undefined subject field#{missing.length > 1 ? "s" : ""}: #{missing.join(", ")}" 
+        raise RuntimeError, "Undefined subject field#{missing.length > 1 ? "s" : ""}: #{missing.join(", ")}" 
       end	
       return nil
     end
 
-    def get_image(with_fields)
+    def get_image(with_fields, in_context=[])
+      in_context = in_context.dup
+      fields = @fields.dup
+      context = self
+      until in_context.empty?
+        protected_fields = @protected_subfields[in_context]
+        context_name = in_context.shift.to_sym
+        context = context.contexts[context_name]
+        raise CommandError, "no context: #{context_name}" if context.nil?
+        context.fields.each_pair do |name, value|
+          if not fields.key?(name) or fields[name] == Undefined or 
+            protected_fields.include?(name)
+            fields[name] = value
+          end
+        end
+      end
+
       image = SubjectImage.new
-      missing_fields = []
+      with_fields.map! {|field| field.to_s}
+      missing_fields = with_fields - fields.keys
+      unless missing_fields.empty? 
+        raise CommandError, "Subject is missing fields: #{missing_fields.join(", ")}"
+      end
       with_fields.each do |field|
-        begin 
-          field = field.to_s
-          value = instance_variable_get("@#{field}")
-          image.add_field(field, value)
-        rescue NameError
-          missing_fields << field
+        image.add_field(field, fields[field])
+      end
+      return image
+    end
+
+    def protect(*path)
+      field_name = path.pop.to_s
+      path.map! {|el| el.to_sym}
+      @protected_subfields[path] << field_name
+    end
+
+    def merge(context, other)
+      other.fields.keys.each do |name|
+        add_field_writer(name)
+      end
+
+      unless context.nil?
+        context = context.to_sym
+        if @contexts[context].nil?
+          return create_context(context, other)
+        else
+          return @contexts[context].merge(nil, other)
         end
       end
-      unless missing_fields.empty? 
-        raise CommandException, "Subject is missing fields: #{missing_fields.join(", ")}"
+
+      raise CommandError unless (defined_fields & other.defined_fields).empty?
+
+      copy_fields(other)
+    end
+
+    def absorb(other)
+      other.all_fields.each do |name|
+        add_field_writer(name)
       end
-      image
+
+      copy_fields(other)
+      copy_contexts(other)
     end
 
     protected
-    def add_accessor(name)
-      self.instance_variable_set("@#{name}", Undefined)
-      meta = class << self; self; end
+    attr_reader :fields, :contexts
 
-    meta.instance_eval do
+    def all_fields
+      fields = @fields.keys
+      @contexts.values.inject(fields) do |fields, context|
+        fields + context.all_fields
+      end
+      return fields
+    end
 
-      define_method("#{name}=") do |value|
-	return instance_variable_set("@#{name}", value)
+    def create_context(name, subject)
+      raise CommandError if @fields.has_key?(name.to_s)
+      @contexts[name] = subject
+      (class << self; self; end).instance_eval do
+        define_method("#{name}") do 
+          return @contexts[name]
+        end
+      end
+      return self
+    end
+
+    def defined_fields
+      @fields.keys.reject do |name| 
+        @fields[name] == Undefined
       end
     end
-  end
-end
 
-#This is the object type that's actually passed to a command.  It's
-#populated using the subject_methods that the command declared, using values
-#from the application Subject.
-class SubjectImage
+    def copy_fields(from)
+      which = from.fields.keys
+      required_fields(which)
+      other_fields = from.instance_variable_get("@fields")
+      which.each do |field|
+        @fields[field] = other_fields[field]
+      end
+      return self
+    end
 
-  #You shouldn't really need to ever call this - it's used by the
-  #interpreter to set up the image before it's passed to the command
-  def add_field(name, value)
-    (class << self; self; end).instance_eval do
-      define_method("#{name}") do
-        return value
+    def copy_contexts(from)
+      from.contexts.each_pair do |name, subject|
+        if contexts[name].nil?
+          contexts[name] = subject
+        else
+          contexts[name].merge(nil, subject)
+        end
       end
     end
-  end
 
-  def get_image(fields)
-    #TODO: fail if I don't respond to a field
-    return self
+    def add_field(name)
+      @fields[name] ||= Undefined
+      add_field_writer(name)
+    end
+
+    def add_field_writer(name)
+      (class << self; self; end).instance_eval do
+        define_method("#{name}=") do |value|
+          return @fields[name] = value
+        end
+      end
+    end
   end
-end  
+
+  #This is the object type that's actually passed to a command.  It's
+  #populated using the subject_methods that the command declared, using values
+  #from the application Subject.
+  class SubjectImage
+
+    #You shouldn't really need to ever call this - it's used by the
+    #interpreter to set up the image before it's passed to the command
+    def add_field(name, value)
+      (class << self; self; end).instance_eval do
+        define_method("#{name}") do
+          return value
+        end
+      end
+    end
+
+    def get_image(fields)
+      #TODO: fail if I don't respond to a field
+      return self
+    end
+  end  
 
 
 end