command-set 0.9.2 → 0.10.0

data/lib/command-set/{interpreter.rb → interpreter/base.rb}

@@ -13,24 +13,34 @@ module Command
   #objects.  Other methods can be overridden - especially consider
   # #get_formatter, and #prompt_user
   class BaseInterpreter
-    attr_accessor :command_set, :out_io, :logger
-    attr_reader :subject
+    attr_accessor :out_io, :logger
+    attr_reader :subject, :command_set
 
-    #:section: Client app methods
-
-    #Subject has an intentionally very tight interface (q.v.) the gist of
-    #which is that you can only assign to fields that commands require, and
-    #you can only access fields within a command that you declared that
-    #command required.  
-    def subject_template
-      raise "CommandSet unset!" if @command_set.nil?
-      return prep_subject(get_subject)
+    def initialize
+      @command_set=nil
+      @sub_modes = []
+      @behavior = {
+        :screen_width => 76,
+        :warn_no_undo => true
+      }
+      @out_io = $stdout
+      @stop = false
+      @subject = nil
+      @logger = Logger.new($stderr)
+      @logger.level=Logger::FATAL
+      @undo_stack = UndoStack.new
+      @commands_pending = []
+      @pause_decks = Hash.new {|h,k| h[k]=[]}
     end
 
+    #:section: Client app methods
+    alias subject_template subject 
+
     #Before running an interpreter on input, you must set the subject.
     #Get a subject object by calling subject_template, assign it's fields,
     #and then pass it into subject=
     def subject= (subject)
+      subject
       begin
         subject.get_image(subject_requirements())
       rescue CommandException
@@ -41,8 +51,14 @@ module Command
       @subject = subject
     end
 
+
+    def command_set=(set)
+      @command_set = set
+      @subject = prep_subject(get_subject)
+    end
+
     def fill_subject
-      template = subject_template
+      template = self.subject
       yield template
       self.subject=(template)
     end
@@ -53,33 +69,17 @@ module Command
       @behavior.merge!(hash)
     end
 
-    def initialize
-      @command_set=nil
-      @sub_modes = []
-      @behavior = {
-        :screen_width => 76,
-        :warn_no_undo => true
-      }
-      @out_io = $stdout
-      @stop = false
-      @subject = nil
-      @logger = Logger.new($stderr)
-      @logger.level=Logger::FATAL
-      @undo_stack = UndoStack.new
-      @commands_pending = []
-      @pause_decks = Hash.new {|h,k| h[k]=[]}
-    end
-
     #:section: Command behavior related method
 
     #  Puts a CommandSet ahead of the current one for processing.  Useful for command
     #  modes, like Cisco's IOS with configure modes, et al.
-    def push_mode(mode)
+    def push_mode(nesting)
+      mode = nesting.pop
       unless CommandSet === mode
         raise RuntimeError, "Sub-modes must be CommandSets!" 
       end
 
-      @sub_modes.push([mode, mode.most_recent_args])
+      @sub_modes.push([mode, mode.most_recent_args, nesting])
       return nil
     end
 
@@ -106,7 +106,8 @@ module Command
     #interpreter.
     def prep_subject(subject)
       @command_set.add_requirements(subject)
-      subject.required_fields(*subject_requirements())
+      @command_set.add_defaults(subject)
+      subject.required_fields(subject_requirements())
       subject.undo_stack = @undo_stack
       subject.interpreter_behavior = @behavior
       subject.chain_of_command = @commands_pending
@@ -118,7 +119,8 @@ module Command
     #You'll almost never want to override this method.
     def next_command
       setup = @commands_pending.shift
-      setup.args_hash = default_arg_hash.merge(setup.args_hash)
+      setup.arg_hash = default_arg_hash.merge(setup.arg_hash)
+      setup.set_nesting = current_nesting + setup.set_nesting
       return setup.command_instance(current_command_set, build_subject)
     end
 
@@ -193,17 +195,22 @@ module Command
 
     def default_arg_hash
       return {} if @sub_modes.empty?
-      return @sub_modes.last.last
+      return @sub_modes.last[1]
     end
 
     def current_command_set
       return @command_set if @sub_modes.empty?
-      return @sub_modes.last.first
+      return @sub_modes.last[0]
+    end
+
+    def current_nesting
+      return [] if @sub_modes.empty?
+      return @sub_modes.last[2]
     end
 
     def build_subject
       if @subject.nil?
-        subject=(subject_template())
+        self.subject=(subject_template())
       end
       return @subject
     end

data/lib/command-set/{quick-interpreter.rb → interpreter/quick.rb}

@@ -1,4 +1,4 @@
-require 'command-set/interpreter'
+require 'command-set/interpreter/base'
 
 module Command
   #A looser Subject, used by QuickInterpreter for testing purposes.
@@ -7,11 +7,11 @@ module Command
   #easier.
   class PermissiveSubject < Subject
     protected
-    def add_accessor(name)
+    def add_field_writer(name)
       super
       (class << self; self; end).instance_eval do
         define_method(name) do
-          return instance_variable_get("@#{name}")
+          return @fields[name]
         end
       end
     end
@@ -84,7 +84,7 @@ module Command
 
     #Passes the arguments to process_input directly to CommandSetup
     def cook_input(words)
-      CommandSetup.new(words)
+      current_command_set.process_terms(words, subject)
     end
 
     def complete_input(terms, word)

data/lib/command-set/{text-interpreter.rb → interpreter/text.rb}

@@ -1,7 +1,7 @@
 require 'readline'
 require 'command-set'
 require 'dl/import'
-require 'command-set/interpreter'
+require 'command-set/interpreter/base'
 
 #This really locks text-interpreter down to Linux, maybe Unix-like
 #platforms, I'm thinking.  A more flexible way of doing this would rock,
@@ -97,8 +97,7 @@ module Command
        rescue CommandException => ce
          output_exception("Error", ce)
        rescue Exception => e
-         output_exception("Exception", e)
-         pause_before_dying
+         self.pause_before_dying(e)
        ensure
          unless old_proc.nil?
            set_readline_completion(&old_proc)
@@ -115,7 +114,8 @@ module Command
        end
      end
 
-     def pause_before_dying
+     def pause_before_dying(exception)
+       output_exception("Exception", exception)
        puts "Waiting for return"
        $stdin.gets
        stop
@@ -132,7 +132,7 @@ module Command
          line = new_line
        end
        line.pop if line.last.empty?
-       return CommandSetup.new(line)
+       return self.current_command_set.process_terms(line, self.subject)
      end
 
      alias single_command process_input
@@ -155,29 +155,33 @@ module Command
      end
 
      def readline_complete(buffer, rl_prefix)
-       parsed_input = split_line(buffer)
-       prefix = parsed_input.pop
-
-       #Lest this kill coverage: hide exists to fix readline's irritating
-       #word splitting
-       hide = prefix.sub(/#{rl_prefix}$/, "")
-
-       completes = current_command_set.completion_list(parsed_input, 
-                                                  prefix, build_subject)
-       completes.map! do |complete|
-         complete = complete.sub(/^#{hide}/, "")
-         if split_line(complete).length > 1
-           if hide.empty?
-             '"' + complete + '"'
+       begin
+         parsed_input = split_line(buffer)
+         prefix = parsed_input.pop
+
+         #Lest this kill coverage: hide exists to fix readline's irritating
+         #word splitting
+         hide = prefix.sub(%r{#{rl_prefix}$}, "")
+           
+         if /"#{prefix}$/ =~ buffer
+           hide = '"' + hide
+         end
+
+         completes = current_command_set.completion_list(parsed_input, 
+                                                         prefix, build_subject)
+         completes.map! do |complete|
+           if split_line(complete).length > 1
+             ('"' + complete + '"').sub(/^#{hide}/, "")
            else
-             complete + '"'
+             complete.sub(/^#{hide}/, "")
            end
-         else
-           complete
          end
-       end
 
-       return completes
+         return completes
+       rescue Object => ex
+         #It's really irritating for an app to crap out in completion
+         return ["#{ex.class}: #{ex.message}", ""]
+       end
      end
 
      def split_line(line)
@@ -209,7 +213,7 @@ module Command
 
        prompt.sub!(*(@command_set.prompt))
        @sub_modes.each do |mode|
-         prompt.sub!(*(mode.prompt))
+         prompt.sub!(*(mode[0].prompt))
        end
        prompt.sub!(*(@behavior[:prompt]))
      end

data/lib/command-set/results.rb

@@ -391,484 +391,10 @@ module Command
         return list
       end
     end
-
-    #The end of the Results train.  Formatter objects are supposed to output to the user events that they
-    #receive from their presenters.  To simplify this process, a number of common IO functions are delegated
-    #to an IO object - usually Command::raw_stdout.
-    #
-    #This class in particular is pretty quiet - probably not helpful for everyday use.
-    #Of course, for some purposes, singleton methods might be very useful
-    class Formatter
-      module Styler
-        Foregrounds = { 
-          'black'   => 30,
-          'red'     => 31, 
-          'green'   => 32, 
-          'yellow'  => 33,
-          'blue'    => 34,
-          'magenta' => 35,
-          'cyan'    => 36,
-          'white'   => 37
-        }
-
-        Backgrounds = {}
-        
-        Foregrounds.each() do |name, value|
-          Backgrounds[name] = value + 10
-        end
-
-        Extras = {
-          'clear'     => 0, 
-          'bold'      => 1,
-          'underline' => 4,
-          'reversed'  => 7
-        }
-
-        def style(text, options)
-          options ||= {}
-          if options.key? :format_advice
-            options = options.merge(options[:format_advice]) 
-          end
-          aliased = {
-            :foreground => options[:color],
-            :extra => options[:text_style]
-          }
-          options = aliased.merge(options)
-          markup = code_for(Foregrounds, options[:foreground]) + 
-              code_for(Backgrounds, options[:background]) + 
-              code_for(Extras, options[:extra])
-          return text if markup.empty?
-          return markup + text + code_for(Extras, "clear")
-        end
-
-        def code_for(kind, name)
-          if kind.has_key?(name.to_s)
-            "\e[#{kind[name.to_s]}m"
-          else
-            ""
-          end
-        end
-      end
-      extend Forwardable
-
-      class FormatAdvisor
-        def initialize(formatter)
-          @advisee = formatter
-        end
-
-        def list(&block)
-          @advisee.advice[:list] << proc(&block)
-        end
-
-        def item(&block)
-          @advisee.advice[:item] << proc(&block)
-        end
-
-        def output(&block)
-          @advisee.advice[:output] << proc(&block)
-        end
-      end
-
-      def notify(msg, item)
-        if msg == :start
-          start
-          return
-        end
-        if msg == :done
-          finish
-          return
-        end
-
-        apply_advice(item)
-
-        if List === item
-          case msg
-          when :saw_begin
-            saw_begin_list(item)
-          when :saw_end
-            saw_end_list(item)
-          when :arrive
-            closed_begin_list(item)
-          when :leave
-            closed_end_list(item)
-          end
-        else
-          case msg
-          when :arrive
-            closed_item(item)
-          when :saw
-            saw_item(item)
-          end
-        end
-      end
-
-      def initialize(out = nil, err = nil)
-        @out_to = out || ::Command::raw_stdout
-        @err_to = err || ::Command::raw_stderr
-        @advisor = FormatAdvisor.new(self)
-        @advice = {:list => [], :item => [], :output => []}
-      end
-
-      def apply_advice(item)
-        type = List === item ? :list : :item
-
-        item.options[:format_advice] = 
-          @advice[type].inject(default_advice(type)) do |advice, advisor|
-          result = advisor[item]
-          break if result == :DONE
-          if Hash === result
-            advice.merge(result)
-          else
-            advice
-          end
-          end
-      end
-
-      attr_reader :advice
-
-      def receive_advice(&block)
-        @advisor.instance_eval(&block)
-      end
-
-      def default_advice(type)
-        {}
-      end
-
-      def_delegators :@out_to, :p, :puts, :print, :printf, :putc, :write, :write_nonblock, :flush
-
-      def self.inherited(sub)
-        sub.extend Forwardable
-        sub.class_eval do
-          def_delegators :@out_to, :p, :puts, :print, :printf, :putc, :write, :write_nonblock, :flush
-        end
-      end
-
-      #Presenter callback: output is beginning
-      def start; end
-
-      #Presenter callback: a list has just started
-      def saw_begin_list(list); end
-
-      #Presenter callback: an item has just been added
-      def saw_item(item); end
-
-      #Presenter callback: a list has just ended
-      def saw_end_list(list); end
-
-      #Presenter callback: a list opened, tree order
-      def closed_begin_list(list); end
-
-      #Presenter callback: an item added, tree order
-      def closed_item(item); end
-
-      #Presenter callback: an list closed, tree order
-      def closed_end_list(list); end
-
-      #Presenter callback: output is done
-      def finish; end
-    end
-
-    #The simplest useful Formatter: it outputs the value of every item in tree order.  Think of
-    #it as what would happen if you just let puts and p go directly to the screen, without the 
-    #annoying consequences of threading, etc.
-    class TextFormatter < Formatter
-      def closed_item(value)
-        puts value
-      end
-    end
-
-    class StrategyFormatter < Formatter
-      class FormatStrategy
-        extend Forwardable
-        include Formatter::Styler
-
-        def initialize(name, formatter)
-          @name = name
-          @formatter = formatter
-          setup
-        end
-
-        def setup; end
-
-        def_delegators :@formatter, :p, :puts, :print, :printf, :putc, :write, :write_nonblock, :flush
-
-        attr_reader :name
-
-        def switch_to(name)
-          unless name == self.name
-            return true
-          end
-          return false
-        end
-
-        def finish
-          @formatter.pop_strategy(self.name)
-        end
-
-        #Presenter callback: a list has just started
-        def saw_begin_list(list); end
-
-        #Presenter callback: an item has just been added
-        def saw_item(item); end
-
-        #Presenter callback: a list has just ended
-        def saw_end_list(list); end
-
-        #Presenter callback: a list opened, tree order
-        def closed_begin_list(list); 
-        end
-
-        #Presenter callback: an item added, tree order
-        def closed_item(item); end
-
-        #Presenter callback: an list closed, tree order
-        def closed_end_list(list); 
-          if list.options[:strategy_start] == self
-            finish
-          end
-        end
-
-        private
-        def out
-          @formatter.out_to
-        end
-
-        def err
-          @formatter.err_to
-        end
-      end
-
-      @strategies = {:default => FormatStrategy}
-
-      class << self
-        def strategy(name, base_klass = FormatStrategy, &def_block)
-          @strategies[name.to_sym] = Class.new(base_klass, &def_block)
-        end
-
-        def inherited(sub)
-          self.instance_variables.each do |var|
-            value = self.instance_variable_get(var)
-            if value.nil?
-              sub.instance_variable_set(var, nil)
-            else
-              sub.instance_variable_set(var, value.dup)
-            end
-          end
-        end
-
-        def strategy_set(formatter)
-          set = {}
-          @strategies.each_pair do |name, klass|
-            set[name] = klass.new(name, formatter)
-          end
-          return set
-        end
-      end
-
-      def initialize(out = nil, err = nil)
-        super(out, err)
-        @strategies = self.class.strategy_set(self)
-        @strategy_stack = [@strategies[:default]]
-      end
-
-      attr_reader :out_to, :err_to
-
-      def_delegators :current_strategy, :saw_begin_list, :saw_item, 
-        :saw_end_list
-
-      def current_strategy
-        @strategy_stack.last
-      end
-
-      def push_strategy(name)
-        if @strategies.has_key?(name)
-          @strategy_stack.push(@strategies[name])
-        end
-      end
-
-      def pop_strategy(name)
-        if current_strategy.name == name
-          @strategy_stack.pop
-        end
-      end
-
-      def closed_begin_list(list)
-        going_to = current_strategy.name
-        unless list.options[:format_advice].nil? or 
-          (next_strategy = list.options[:format_advice][:type]).nil? or
-          @strategies[next_strategy].nil? or
-          not current_strategy.switch_to(next_strategy)
-          going_to = next_strategy
-        end
-        push_strategy(going_to)
-        current_strategy.closed_begin_list(list)
-      end
-
-      def closed_end_list(list)
-        current_strategy.closed_end_list(list)
-        current_strategy.finish
-      end
-
-      def closed_item(item)
-        unless item.options[:format_advice].nil? or 
-          (once = item.options[:format_advice][:type]).nil? or
-          @strategies[once].nil? or
-          not current_strategy.switch_to(once)
-          @strategies[once].closed_item(item)
-        else
-          current_strategy.closed_item(item)
-        end
-      end
-
-      strategy :default do
-        def closed_item(value)
-          puts value
-        end
-      end
-
-      strategy :progress do
-        def switch_to(name); false; end
-        def closed_begin_list(list)
-          puts unless list.depth == 0
-          justify = 0 || list[:format_advice][:justify]
-          print style(list.to_s.ljust(justify), list.options)
-        end
-
-        def closed_item(item)
-          print style(".", item.options)
-          flush
-        end
-
-        def closed_end_list(list)
-          puts
-          super
-        end
-      end
-
-      strategy :indent do
-        def setup
-          @indent_level = 0
-        end
-
-        def indent
-          return "  " * @indent_level
-        end
-
-        def closed_begin_list(list)
-          super
-          puts indent + style(list.to_s, list.options)
-          @indent_level += 1
-          @indent_level
-        end
-
-        def closed_item(item)
-          item.to_s.split(/\s*\n\s*/).each do |line|
-            puts indent + style(line, item.options)
-          end
-          super
-        end
-
-        def closed_end_list(list)
-          @indent_level -= 1
-          @indent_level
-          super
-        end
-      end
-
-      strategy :invisible do
-        def closed_item(value); end
-      end
-
-      strategy :skip do
-        def closed_begin_list(list)
-          finish
-        end
-      end
-
-      strategy :chatty do
-        def switch_to(name); false; end
-
-        def saw_begin_list(list)
-          err.print style("B", list.options)
-        end
-
-        def saw_item(list)
-          err.print style(".", list.options)
-        end
-
-        def saw_end_list(list)
-          err.print style("E", list.options)
-        end
-
-        def closed_begin_list(list); 
-          clean_options = list.options.dup
-          clean_options.delete(:strategy_start)
-          puts "> #{list.to_s} (depth=#{list.depth} #{clean_options.inspect})"
-        end
-        def closed_item(list)
-          puts "  " + list.to_s + 
-            unless(list.options.empty?)
-              " " + list.options.inspect
-            else
-              ""
-            end
-        end
-        def closed_end_list(list); puts "< " + list.to_s; end
-      end
-    end
-
-    #A trivial and obvious Formatter: produces well-formed XML fragments based on events.  It even 
-    #indents.  Might be handy for more complicated output processing, since you could feed the document
-    #to a XSLT processor.
-    class XMLFormatter < Formatter
-      def initialize(out = nil, err = nil, indent="  ", newline="\n")
-        super(out, err)
-        @indent = indent
-        @newline = newline
-        @indent_level=0
-      end
-
-      def line(string)
-        print "#{@indent * @indent_level}#{string}#@newline"
-      end
-
-      def closed_begin_list(name)
-        line "<#{name}#{xmlize_options(name)}>"
-        @indent_level += 1
-      end
-
-      def closed_item(value)
-        line "<item value=\"#{value}\"#{xmlize_options(value)} />"
-      end
-
-      def closed_end_list(name)
-        @indent_level -= 1
-        if @indent_level < 0
-          @indent_level = 0 
-          return
-        end
-        line "</#{name}>"
-      end
-
-      private
-
-      def flatten_value(value)
-        case value
-        when Hash
-          return value.map do |name, value|
-            "#{name}: #{value}"
-          end.join("; ")
-        else
-          return value.to_s
-        end
-      end
-
-      def xmlize_options(item)
-        item.options.inject("") do |string, (name, value)|
-          string + " #{name}=\"#{flatten_value(value)}\""
-        end
-      end
-    end
   end
 end
 
+#TODO migrate these requires to only where they're needed
+require 'command-set/formatter/base'
+require 'command-set/formatter/strategy'
+require 'command-set/formatter/xml'