command-set 0.9.2 → 0.10.0

data/lib/command-set/formatter/base.rb

@@ -0,0 +1,186 @@
+module Command::Results
+  #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
+end

data/lib/command-set/formatter/strategy.rb

@@ -0,0 +1,243 @@
+require 'command-set/formatter/base'
+
+module Command::Results
+    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
+end

data/lib/command-set/formatter/xml.rb

@@ -0,0 +1,56 @@
+require 'command-set/formatter/base'
+
+module Command::Results
+  #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