command-set 0.9.1 → 0.9.2

data/lib/command-set/results.rb

@@ -1,4 +1,5 @@
 require 'command-set/result-list'
+require 'Win32/Console/ANSI' if PLATFORM =~ /win32/
 
 module Kernel
   def puts(*args)
@@ -50,7 +51,6 @@ module Command
   class OutputStandin < IO
     def initialize(io)
       @_dc_obj = io
-      @dispatch_stack = nil
       unless io.fileno.nil?
         super(io.fileno,"w")
       end
@@ -112,7 +112,18 @@ module Command
     end
 
     def relevant_collector
-      Thread.current[thread_stack_index] || @dispatch_stack
+      Thread.current[thread_stack_index] || 
+        Thread.main[thread_stack_index]
+    end
+
+    def define_dispatch_methods(dispatcher)# :nodoc:
+      dispatcher.dispatches.each do |dispatch|
+        (class << self; self; end).module_eval <<-EOS
+          def #{dispatch}(*args)
+            dispatched_method(:#{dispatch.to_s}, *args)
+          end
+        EOS
+      end
     end
 
     def dispatched_method(method, *args)# :nodoc:
@@ -128,35 +139,18 @@ module Command
       define_dispatch_methods(collector)
     end
     alias set_thread_collector add_thread_local_dispatcher
-
-    #Puts the dispatcher in place to handle normal IO methods.
-    def add_dispatcher(collector)
-      @dispatch_stack = collector
-      define_dispatch_methods(collector)
-    end
+    alias add_dispatcher add_thread_local_dispatcher
     alias set_default_collector add_dispatcher
 
-    def define_dispatch_methods(dispatcher)# :nodoc:
-      dispatcher.dispatches.each do |dispatch|
-        (class << self; self; end).module_eval <<-EOS
-          def #{dispatch}(*args)
-            dispatched_method(:#{dispatch.to_s}, *args)
-          end
-        EOS
-      end
-    end
-
     #Unregisters the dispatcher.
     def remove_dispatcher(dispatcher)
-      @dispatch_stack = nil if @dispatch_stack == dispatcher
-    end
-    alias remove_collector remove_dispatcher
-
-    def remove_thread_local_dispatcher(dispatcher)
       if Thread.current[thread_stack_index] == dispatcher
         Thread.current[thread_stack_index] = nil
       end
     end
+
+    alias remove_collector remove_dispatcher
+    alias remove_thread_local_dispatcher remove_dispatcher
     alias remove_thread_collector remove_thread_local_dispatcher
   end
 
@@ -405,6 +399,56 @@ module Command
     #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
@@ -458,8 +502,9 @@ module Command
         end
       end
 
-      def initialize(io)
-        @out_to = io
+      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
@@ -471,8 +516,11 @@ module Command
           @advice[type].inject(default_advice(type)) do |advice, advisor|
           result = advisor[item]
           break if result == :DONE
-          advice.merge!(result) if Hash === result
-          advice
+          if Hash === result
+            advice.merge(result)
+          else
+            advice
+          end
           end
       end
 
@@ -532,6 +580,7 @@ module Command
     class StrategyFormatter < Formatter
       class FormatStrategy
         extend Forwardable
+        include Formatter::Styler
 
         def initialize(name, formatter)
           @name = name
@@ -546,7 +595,10 @@ module Command
         attr_reader :name
 
         def switch_to(name)
-          @formatter.push_strategy(name)
+          unless name == self.name
+            return true
+          end
+          return false
         end
 
         def finish
@@ -564,13 +616,6 @@ module Command
 
         #Presenter callback: a list opened, tree order
         def closed_begin_list(list); 
-          unless list.options[:strategy_start] == self or list.options[:format_advice].nil?
-            switch_to(list.options[:format_advice][:type])
-            if (next_strat = @formatter.current_strategy) != self
-              list.options[:strategy_start] = next_strat
-              next_strat.closed_begin_list(list)
-            end
-          end
         end
 
         #Presenter callback: an item added, tree order
@@ -582,6 +627,15 @@ module Command
             finish
           end
         end
+
+        private
+        def out
+          @formatter.out_to
+        end
+
+        def err
+          @formatter.err_to
+        end
       end
 
       @strategies = {:default => FormatStrategy}
@@ -611,14 +665,16 @@ module Command
         end
       end
 
-      def initialize(io)
-        super(io)
+      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, :closed_begin_list, :closed_item, :closed_end_list
+        :saw_end_list
 
       def current_strategy
         @strategy_stack.last
@@ -636,6 +692,34 @@ module Command
         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
@@ -643,18 +727,21 @@ module Command
       end
 
       strategy :progress do
+        def switch_to(name); false; end
         def closed_begin_list(list)
-          print list.to_s.ljust(50)
+          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 "."
+          print style(".", item.options)
           flush
         end
 
-        def finish
-          super
+        def closed_end_list(list)
           puts
+          super
         end
       end
 
@@ -664,31 +751,32 @@ module Command
         end
 
         def indent
-          return "  " * [0, @indent_level].max
+          return "  " * @indent_level
         end
 
         def closed_begin_list(list)
-          puts indent + list.to_s
-          @indent_level += 1
           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 + 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
+        def closed_item(value); end
       end
 
       strategy :skip do
@@ -698,15 +786,33 @@ module Command
       end
 
       strategy :chatty do
-        def saw_begin_list(list); $stderr.print "B"; end
-        def saw_item(list); $stderr.print "."; end
-        def saw_end_list(list); $stderr.print "E"; end
+        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; 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
@@ -715,8 +821,8 @@ module Command
     #indents.  Might be handy for more complicated output processing, since you could feed the document
     #to a XSLT processor.
     class XMLFormatter < Formatter
-      def initialize(io, indent="  ", newline="\n")
-        super(io)
+      def initialize(out = nil, err = nil, indent="  ", newline="\n")
+        super(out, err)
         @indent = indent
         @newline = newline
         @indent_level=0
@@ -727,12 +833,12 @@ module Command
       end
 
       def closed_begin_list(name)
-        line "<#{name}>"
+        line "<#{name}#{xmlize_options(name)}>"
         @indent_level += 1
       end
 
       def closed_item(value)
-        line "<item value=\"#{value}\" />"
+        line "<item value=\"#{value}\"#{xmlize_options(value)} />"
       end
 
       def closed_end_list(name)
@@ -743,6 +849,25 @@ module Command
         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

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

@@ -131,6 +131,7 @@ module Command
          end
          line = new_line
        end
+       line.pop if line.last.empty?
        return CommandSetup.new(line)
      end
 
@@ -153,39 +154,46 @@ module Command
        end
      end
 
-     def readline_complete(buffer, prefix)
+     def readline_complete(buffer, rl_prefix)
        parsed_input = split_line(buffer)
-       unless prefix.empty?
-         parsed_input.pop
-       end
+       prefix = parsed_input.pop
+
+       #Lest this kill coverage: hide exists to fix readline's irritating
+       #word splitting
+       hide = prefix.sub(/#{rl_prefix}$/, "")
 
-       return current_command_set.completion_list(parsed_input, 
+       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 + '"'
+           else
+             complete + '"'
+           end
+         else
+           complete
+         end
+       end
+
+       return completes
      end
 
      def split_line(line)
-       line_array = []
+       line_array = [""]
        scanner = StringScanner.new(line)
+       scanner.scan(/\s*/)
 
        until scanner.eos?
-         scanner.scan(/\s*/)
-         quote = scanner.scan(/['"]/)
-         unless quote.nil?
+         next_break = scanner.scan(/['"]/) || '\s'
+         line_array.last << scanner.scan(/[^#{next_break}\\]*/)
+         stopped_by = scanner.scan(/[#{next_break}\\]/)
+         if stopped_by == '\\'
+           line_array.last << scanner.getch
+         elsif not (stopped_by.nil? or stopped_by =~ /['"]/)
+           scanner.scan(/\s*/)
            line_array << ""
-           until scanner.eos?
-             line_array.last << scanner.scan(/[^#{quote}\\]*/)
-             stopped_by = scanner.scan(/[#{quote}\\]/)
-             break unless stopped_by == '\\'
-             line_array.last << scanner.getch
-           end
-         else
-           line_array << ""
-           until scanner.eos?
-             line_array.last << scanner.scan(/[^\s\\]*/)
-             stopped_by = scanner.scan(/[\s\\]/)
-             break unless stopped_by == '\\'
-             line_array.last << scanner.getch
-           end
          end
        end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: command-set
 version: !ruby/object:Gem::Version 
-  version: 0.9.1
-date: 2008-01-11 00:00:00 -08:00
+  version: 0.9.2
+date: 2008-01-15 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.1 RDoc
+- command-set-0.9.2 RDoc
 extra_rdoc_files: 
 - doc/README
 - doc/GUIDED_TOUR