command-set 0.10.1 → 0.10.2

data/lib/command-set/dsl.rb

@@ -626,12 +626,38 @@ Action:: utility functions within the command action block
         raise CommandException, "#{@name} cannot be undone"
       end   
 
-      #This method is deprecated but remains as a nicety.  As it stands, any
-      #command can be interrupted at the command line with Ctrl-C, and
-      #return to the prompt.
-      def interruptable
-        yield
+      #For big jobs - splitting them into subthreads and
+      #such.  But they need to be debugged, and IIRC there's a deadlock
+      #condition
+      def action_thread(&block)
+        collector = sub_collector
+        return Thread.new do
+          $stdout.set_thread_collector(collector)
+          block.call
+          $stdout.remove_thread_collector(collector)
+        end
       end
+
+      def fan_out(threads_at_a_time, array, &block) 
+        require 'thwait'
+
+        array = array.to_a
+        first_batch = (array[0...threads_at_a_time]||[]).map do |item|
+          action_thread { block.call(item) }
+        end
+
+        rest = (array[threads_at_a_time..-1] || [])
+
+        waiter = ThreadsWait.new(*first_batch)
+
+        rest.each do |item|
+          waiter.next_wait
+          waiter.join_nowait(action_thread{block.call(item)})
+        end
+
+        waiter.join
+      end
+
     end
   end
 end

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

@@ -109,9 +109,7 @@ module Command::Results
       end
     end
 
-    def initialize(out = nil, err = nil)
-      @out_to = out || ::Command::raw_stdout
-      @err_to = err || ::Command::raw_stderr
+    def initialize()
       @advisor = FormatAdvisor.new(self)
       @advice = {:list => [], :item => [], :output => []}
     end
@@ -141,15 +139,6 @@ module Command::Results
       {}
     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
 
@@ -175,10 +164,26 @@ module Command::Results
     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.
+  #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 initialize(out = nil, err = nil)
+      @out_to = out || ::Command::raw_stdout
+      @err_to = err || ::Command::raw_stderr
+      super()
+    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
+
     def closed_item(value)
       puts value
     end

data/lib/command-set/formatter/hash-array.rb

@@ -0,0 +1,41 @@
+require 'command-set/results'
+
+module Command::Results
+  class HashArrayFormatter < Formatter
+    def initialize
+      @hash_stack = [{:array => []}]
+      super
+    end
+
+    def hash
+      @hash_stack.last
+    end
+
+    def array
+      hash[:array]
+    end
+
+    def closed_begin_list(list)
+      list_array = []
+      list_hash = {:array => list_array}
+      array.push(list_array)
+      hash[array().length.to_s] = list_hash
+      hash[list.name] = list_hash
+      @hash_stack.push(list_hash)
+    end
+
+    def closed_item(item)
+      thing = item.value
+      array().push(thing)
+      hash()[array().length.to_s] = thing
+    end
+
+    def closed_end_list(list)
+      @hash_stack.pop
+    end
+
+    def structure
+      @hash_stack.first
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 require 'command-set/formatter/base'
 
 module Command::Results
-    class StrategyFormatter < Formatter
+    class StrategyFormatter < TextFormatter
       class FormatStrategy
         extend Forwardable
         include Formatter::Styler

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

@@ -4,7 +4,7 @@ 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
+  class XMLFormatter < TextFormatter
     def initialize(out = nil, err = nil, indent="  ", newline="\n")
       super(out, err)
       @indent = indent

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

@@ -54,7 +54,7 @@ module Command
     end
 
     def initialize
-      @formatter_factory = proc {Results::Formatter.new(::Command::raw_stdout)}
+      @formatter_factory = proc {Results::TextFormatter.new(::Command::raw_stdout)}
       super
     end
 

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

@@ -1,66 +1,7 @@
-require 'readline'
 require 'command-set'
-require 'dl/import'
 require 'command-set/interpreter/base'
-require 'command-set/formatter/strategy'
-
-#This really locks text-interpreter down to Linux, maybe Unix-like
-#platforms, I'm thinking.  A more flexible way of doing this would rock,
-#regardless of length.
-module Readline
-  begin
-    extend DL::Importable
-    found_libreadline = false
-    ls_so_dirs = [
-      %w{lib},
-      %w{usr lib},
-      %w{usr local lib}
-    ].each{|path| path.unshift("")} 
-    
-    begin
-      File::open("/etc/ld.so.conf", "r") do |ld_so_conf|
-        ld_so_conf.each do |line|
-          unless /^#/ =~ line or /^%s*$/ =~ line
-            ls_so_dirs << line.chomp.split(File::Separator)
-          end
-        end
-      end
-    rescue Exception
-    end
-
-    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 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
-      p = RLLB.ptr
-      if p.nil?
-        return p
-      else
-        return p.to_s
-      end
-    end
-  rescue RuntimeError => rte
-    warn "Couldn't find libreadline - tab-completion will be unpredictable at best."
-    warn "The problem was: " + rte.message
-  end
-end
+require 'command-set/formatter/base'
+require 'command-set/readline'
 
 module Command
    class TextInterpreter < BaseInterpreter

data/lib/command-set/readline.rb

@@ -0,0 +1,60 @@
+require 'readline'
+require 'dl/import'
+
+#This really locks text-interpreter down to Linux, maybe Unix-like
+#platforms, I'm thinking.  A more flexible way of doing this would rock,
+#regardless of length.
+module Readline
+  begin
+    extend DL::Importable
+    found_libreadline = false
+    ls_so_dirs = [
+      %w{lib},
+      %w{usr lib},
+      %w{usr local lib}
+    ].each{|path| path.unshift("")} 
+    
+    begin
+      File::open("/etc/ld.so.conf", "r") do |ld_so_conf|
+        ld_so_conf.each do |line|
+          unless /^#/ =~ line or /^%s*$/ =~ line
+            ls_so_dirs << line.chomp.split(File::Separator)
+          end
+        end
+      end
+    rescue Exception
+    end
+
+    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 path
+        RLLB = symbol("rl_line_buffer")
+        found_libreadline = true
+        break
+      rescue RuntimeError
+      end
+    end
+
+    raise RuntimeError,"couldn't find libreadline" unless found_libreadline
+
+    def self.line_buffer
+      p = RLLB.ptr
+      if p.nil?
+        return p
+      else
+        return p.to_s
+      end
+    end
+  rescue RuntimeError => rte
+    warn "Couldn't find libreadline - tab-completion will be unpredictable at best."
+    warn "The problem was: " + rte.message
+  end
+end

data/lib/command-set/result-list.rb

@@ -13,7 +13,7 @@ module Command
         @order = nil
         @parent = nil
         @options = {}
-        @depth = nil
+        @depth = 0
       end
 
       attr_reader :value, :sequence

data/lib/command-set/results.rb

@@ -1,5 +1,6 @@
 require 'command-set/result-list'
 require 'Win32/Console/ANSI' if PLATFORM =~ /win32/
+require 'thread'
 
 module Kernel
   def puts(*args)
@@ -172,9 +173,9 @@ module Command
     #understand that other Collectors could be running at the same time - that's the 
     #Presenter's job.
     class Collector
-      def initialize(presenter)
+      def initialize(presenter, list_root)
         @presenter = presenter
-        @nesting = []
+        @nesting = [list_root]
       end
 
       def initialize_copy(original)
@@ -194,23 +195,11 @@ module Command
       end
 
       def item( obj, options={} )
-        @presenter.item(@nesting.dup + [obj], options)
+        @presenter.item(@nesting.last, obj, options)
       end
 
       def begin_list( name, options={} )
-        @nesting.push(name)
-        @presenter.begin_list(@nesting.dup, options)
-        if block_given?
-          yield
-          end_list
-        end
-      end
-
-      def open_list(name, options={})
-        @nesting.push(name)
-        unless @presenter.list_open?(@nesting)
-          @presenter.begin_list(@nesting.dup, options)
-        end
+        @nesting << @presenter.begin_list(@nesting.last, name, options)
         if block_given?
           yield
           end_list
@@ -218,8 +207,7 @@ module Command
       end
 
       def end_list
-        @presenter.end_list(@nesting.dup)
-        @nesting.pop
+        @presenter.end_list(@nesting.pop)
       end
 
       @dispatches = {}
@@ -236,8 +224,8 @@ module Command
         self.class.dispatches
       end
 
-      #Use to register an IO +method+ to handle.  The block will be passed a Collector and the
-      #arguments passed to +method+.
+      #Use to register an IO +method+ to handle.  The block will be passed a
+      #Collector and the arguments passed to +method+.
       def self.dispatch(method, &block)
         @dispatches[method] = true
         define_method(method, &block)
@@ -263,7 +251,7 @@ module Command
     end
 
     #Gets item and list events from Collectors, and emits two kinds of
-    #events to Formatters: 
+    #events to Formatters:
     #[+saw+ events] occur in chronological order, with no guarantee regarding timing.  
     #[+closed+ events] occur in tree order.  
     #
@@ -272,14 +260,15 @@ module Command
     #soon as the relevant output element enters the system.
     #
     #On the other hand, +closed+ events will be generated in the natural
-    #order you'd expect the output to appear in.  Most Formatter subclasses use
-    #+closed+ events.
+    #order you'd expect the output to appear in.  Most Formatter subclasses
+    #use +closed+ events.
     #
     #A list which has not received a "list_end" event from upstream will
     #block lists later in tree order until it closes.  A Formatter that
     #listens only to +closed+ events can present them to the user in a way
     #that should be reasonable, although output might be halting for any
     #process that takes noticeable time.
+    #
     class Presenter
       class Exception < ::Exception; end
 
@@ -287,57 +276,48 @@ module Command
         @results = List.new("")
         @leading_edge = @results
         @formatters = []
+        @list_lock = Mutex.new
       end
 
       def create_collector
-        return Collector.new(self)
+        return Collector.new(self, @results)
       end
 
-      def item( item_path, options={} )
-        item = item_path.pop
-        home = get_collection(item_path)
-        item = home.add item
-        item.options = home.options.merge(options)
-        item.depth = item_path.length
-        notify(:saw, item)
-        advance_leading_edge
+      def register_formatter(formatter)
+        @formatters << formatter
+        formatter.notify(:start, nil)
       end
 
       def leading_edge?(list)
         return list == @leading_edge
       end
 
-      def register_formatter(formatter)
-        @formatters << formatter
+      def item( home, value, options={} )
+        item = ListItem.new(value)
 
-        formatter.notify(:start, nil)
+        add_item(home, item, options)
+
+        notify(:saw, item)
+        return nil
       end
 
-      def begin_list( list_path, options={} )
-        list = list_path.pop
-        home = get_collection(list_path)
-        list = List.new(list)
-        list.options = home.options.merge(options)
-        list.depth = list_path.length
+      def begin_list( home, name, options={} )
+        list = List.new(name)
+
+        add_item(home, list, options)
+
         notify(:saw_begin, list)
-        home.add(list)
-        advance_leading_edge
+        return list
       end
 
-      def list_open?(list_path)
-        begin 
-          get_collection(list_path)
-          return true
-        rescue Exception
-          return false
+      def end_list( list )
+        @list_lock.synchronize do
+          list.close
+          advance_leading_edge
         end
-      end
 
-      def end_list( list_path )
-        list = get_collection( list_path )
         notify(:saw_end, list)
-        list.close
-        advance_leading_edge
+        return nil
       end
 
       def done
@@ -346,8 +326,9 @@ module Command
         notify(:done, nil)
       end
 
-      #Returns the current list of results.  A particularly advanced Formatter might treat +saw_*+ events 
-      #like notifications, and then use the List#filter functionality to discover the specifics about the
+      #Returns the current list of results.  A particularly advanced
+      #Formatter might treat +saw_*+ events like notifications, and then use
+      #the List#filter functionality to discover the specifics about the
       #item or list just closed.
       def output
         @results
@@ -372,23 +353,21 @@ module Command
         end
       end
 
-      def notify(msg, item)
-        @formatters.each do |f|
-          f.notify(msg, item)
+      def add_item(home, item, options)
+        item.depth = home.depth + 1
+
+        @list_lock.synchronize do
+          #home = get_collection(path)
+          item.options = home.options.merge(options)
+          home.add(item)
+          advance_leading_edge
         end
       end
 
-      def get_collection(path)
-        thumb = @results.values
-        list = @results
-        path.each do |step|
-          list = thumb.find{|member| List === member && member.open? && member.name == step}
-          if list.nil?
-            raise Exception, "#{step} in #{path.inspect} missing from #{thumb}!"
-          end
-          thumb = list.values
+      def notify(msg, item)
+        @formatters.each do |f|
+          f.notify(msg, item)
         end
-        return list
       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.10.1
-date: 2008-02-12 00:00:00 -08:00
+  version: 0.10.2
+date: 2008-02-19 00:00:00 -08:00
 summary: Framework for interactive programs focused around a DSL for commands
 require_paths: 
 - lib
@@ -45,11 +45,13 @@ files:
 - lib/command-set/dsl.rb
 - lib/command-set/formatter
 - lib/command-set/formatter/strategy.rb
+- lib/command-set/formatter/hash-array.rb
 - lib/command-set/formatter/base.rb
 - lib/command-set/formatter/xml.rb
 - lib/command-set/command.rb
 - lib/command-set/standard-commands.rb
 - lib/command-set/results.rb
+- lib/command-set/readline.rb
 - doc/README
 - doc/GUIDED_TOUR
 - doc/Specifications
@@ -61,7 +63,7 @@ rdoc_options:
 - --main
 - Command
 - --title
-- command-set-0.10.1 RDoc
+- command-set-0.10.2 RDoc
 extra_rdoc_files: 
 - doc/README
 - doc/GUIDED_TOUR