command-set 0.10.2 → 0.10.4

data/bin/cmdset-playback

@@ -0,0 +1,42 @@
+#!/bin/env ruby
+# vim: filetype=ruby
+
+require 'optparse'
+require 'command-set/interpreter/recording'
+
+recording = nil
+pause_for = 0
+
+option_parser = OptionParser.new do |opts|
+  opts.on("-i", "--input RECORDING", "The path to load the session recording from") do |path|
+    recording = path
+  end
+
+  opts.on("-d", "--delay [DURATION]", Float, "How long to pause before next input - helps present the illusion of watching a playback.") do |pause|
+    if pause.nil?
+      pause_for = 0.2
+    else
+      pause_for = pause
+    end
+  end
+
+  opts.on_tail("-h", "--help", "Show this help") do
+    puts opts
+    exit
+  end
+end
+
+option_parser.parse!(ARGV)
+
+if(recording.nil?)
+  puts "Session recording required!"
+  exit 1
+end
+
+interpreter = Command::PlaybackInterpreter.new(recording, pause_for)
+interpreter.behavior(:debug_commands => true)
+
+puts "Beginning playback:"
+
+interpreter.go
+puts "Done."

data/bin/cmdset-record

@@ -0,0 +1,54 @@
+#!/bin/env ruby
+# vim: filetype=ruby
+
+
+require 'optparse'
+require 'command-set/interpreter/recording'
+
+file = nil
+mod = nil
+recording = nil
+
+option_parser = OptionParser.new do |opts|
+  opts.on("-f", "--file SET_FILE", "The file that defines the command set") do |path|
+    file = path
+  end
+
+  opts.on("-o", "--output RECORDING", "The path to dump the session recording to") do |path|
+    recording = path
+  end
+
+  opts.on("-m", "--module SET_MODULE", "The name of the module that declares define_commands") do |modname|
+    mod = modname
+  end
+
+  opts.on_tail("-h", "--help", "Show this help") do
+    puts opts
+    exit
+  end
+end
+
+option_parser.parse!(ARGV)
+
+if(file.nil?)
+  puts "Command set file required!"
+  exit 1
+end
+
+if(mod.nil?)
+  puts "Command set module name required!"
+  exit 1
+end
+
+if(recording.nil?)
+  recording = "script.out"
+end
+
+
+interpreter = Command::RecordingInterpreter.new(file, mod)
+interpreter.behavior(:debug_commands => true)
+interpreter.go
+
+File::open(recording, "w") do |record|
+  interpreter.dump_to(record)
+end

data/doc/Specifications

@@ -35,6 +35,14 @@ Command::CommandSet with subject defaults
 - should not raise an error when included sets collide
 - should raise an error when included sets collide
 
+Command::CommandSet with mode commands
+- should not allow access outside of the mode
+- should allow access in the mode
+- should include mode_commands from included sets
+
+Command::CommandSet with aliased commands
+- should have identical commands with different names
+
 Command::CommandSet with contextualized inclusions
 - should properly assign context to commands
 - should keep items neatly in contexts
@@ -123,6 +131,7 @@ Command::TextInterpreter
 Command::TextInterpreter has a readline completion routine that
 - should complete prefixes of space-embedding arguments
 - should return tricky error message instead of raising an exception
+- should complete 'quit'
 
 Command::TextInterpreter all set up
 - should complete words in the commmand-line
@@ -214,10 +223,21 @@ A chain of commands
 - should chain with a path to the command and hashed args
 - should chain with a class and an arg hash
 
+Command::Command chaining from a deep subcommand
+- should chain from immediate parent by default
+- should access immediate parent of parent
+- should access relative subcommands
+- should access the absolute root command set
+
 Command::Command with a subject argument basis
 - should use the subject to accept input
 - should use the subject to reject input
 
+Command::Command that fans out to threads
+- should fan out to one thread
+- should fan out to a few threads
+- should fan out to lots of threads
+
 Command::Results::Formatter
 - should process into the correct list
 - should allow explicit options to come through from command
@@ -225,6 +245,12 @@ Command::Results::Formatter
 - should mark up items as directed by Command#format_advice
 - should mark up items as directed by Command#format_advice
 
+Command::Results::HashArrayFormatter
+- should assemble a set of items
+- should pack a list into a hash with an array
+- should usefully structure mixed lists and items
+- should nest arrays for nested lists
+
 A command set with the Set command
 - should actually have the set command
 - should reply to empty arguments with first level keys
@@ -269,22 +295,23 @@ Command::OutputStandin dispatched via thread
 - should send #p to the collector
 - should go back to sending puts to IO if collector removed
 
-Command::Results::Collector
-- should spawn dispatchers
-
 Command::Results::Collector sending messages
 - should send simple #item calls to its presenter
 - should send begin_list and end list calls to presenter
 - should prefix items with list nesting
 
+A pair of Command::Results::Collector
+- should collect results when used in sequence
+- should collect results when calls are scrambled
+- should collect results when calls appear nested
+- should collect results when one gets delayed
+
 Command::Results::Presenter
 - should collect items
 - should nest lists
-- should complain about lists not begun
-- should complain about mis-nested item
 
 Command::Results::Presenter driving a Formatter
-- should emit #saw_item before #closed_item
+- should emit #saw_item and #closed_item
 - should emit #closed_item within known tree order
 - should emit #closed_item only once per item
 
@@ -303,6 +330,6 @@ Command::Results::StrategyFormatter with chatty strategy
 Command::Results::StrategyFormatter with progress strategy
 - should format two lists
 
-Finished in 0.677035 seconds
+Finished in 1.365823 seconds
 
-190 examples, 0 failures
+207 examples, 0 failures

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

@@ -343,7 +343,7 @@ module Command
     end
 
     def command_names
-      return @command_list.keys.compact
+      return @command_list.keys.compact + @mode_commands.keys.compact
     end
   end
 end

data/lib/command-set/critic.rb

@@ -0,0 +1,105 @@
+require 'spec/matchers'
+require 'spec/example'
+require 'spec/extensions'
+require 'spec/runner'
+
+describe "A well written command", :shared => true do
+  it "should have useful documentation" do
+    @command.documentation(70).length.should be > @command.short_docs(70).length
+  end
+
+  it "should have a classy response to undo" do
+    unless @command.allocate.undoable?
+      pending "#{@command.name} handling undo"
+    end
+  end
+end
+
+describe "A well written command set", :shared => true do
+  it "should include quit" do
+    @set.command_names.should include("quit")
+  end
+
+  it "should include help" do
+    @set.command_names.should include("help")
+  end
+end
+
+module Command
+  require 'rake'
+  require 'spec/rake/spectask'
+  class CritiqueLoader < ::Spec::Runner::ExampleGroupRunner
+    def initialize(opts, command_set)
+      super(opts)
+      @command_set_module = command_set
+    end
+
+    def load_files(files)
+      set = CommandSet::new
+      set.require_commands(@command_set_module)
+      Critic.criticize(set)
+    end
+  end
+
+  module Critic
+    def self.criticize(set, path = ["Main"])
+      Kernel::describe "Command set: #{path.join(" ")}" do
+        it_should_behave_like "A well written command set"
+        before do
+          @set = set
+        end
+      end
+
+      set.command_list.each_pair do |name, cmd|
+        if CommandSet === cmd
+          Command::Spec::Critic.criticize(cmd, path + [name])
+        else
+          Kernel::describe "Command: #{path.join(" ")} #{name}" do
+            it_should_behave_like "A well written command"
+            before do
+              @command = cmd
+            end
+          end
+        end
+      end
+    end
+
+    class Task < ::Rake::TaskLib
+      def initialize(name = :critique)
+        @name = name
+        @spec_opts = []
+        @ruby_opts = []
+
+        @command_set_file = nil
+        @command_set_module = nil
+        yield self if block_given?
+        define
+      end
+
+      attr_accessor :spec_opts, :command_set_file, :command_set_module, :ruby_opts
+
+      def define
+        spec_opts = @spec_opts
+        unless spec_opts.include?("-f") or spec_opts.include?("--format")
+          spec_opts += %w{--format specdoc}
+        end
+
+        spec_opts = @spec_opts + ["-r", @command_set_file, 
+        "-r", __FILE__,
+        "-U", "Command::CritiqueLoader:" + @command_set_module,
+        "--color"] #Because color is nice...
+
+        csf = @command_set_file
+
+        desc "Critique the command set defined in #@command_set_module"
+        Spec::Rake::SpecTask.new(@name) do |t|
+          t.spec_opts = spec_opts
+          t.ruby_opts = self.ruby_opts
+          t.spec_files = [csf]
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -93,7 +93,7 @@ module Command
     #If your interpreter needs extra fields in the subject, alter
     #subject_requirements to return an array of those fields.
     def subject_requirements
-      return [:undo_stack, :interpreter, :interpreter_behavior, 
+      return [:undo_stack, :command_set, :interpreter, :interpreter_behavior, 
         :chain_of_command, :pause_decks, :mode_stack]
     end
 
@@ -108,6 +108,7 @@ module Command
       @command_set.add_defaults(subject)
       subject.required_fields(subject_requirements())
       subject.undo_stack = @undo_stack
+      subject.command_set = @command_set
       subject.interpreter = self
       subject.interpreter_behavior = @behavior
       subject.chain_of_command = @commands_pending
@@ -138,8 +139,10 @@ module Command
       @commands_pending << cook_input(raw_input)
 
       presenter = Results::Presenter.new
-      formatter = get_formatter
-      presenter.register_formatter(formatter)
+      formatters = get_formatters
+      formatters.each do |formatter|
+        presenter.register_formatter(formatter)
+      end
       collector = presenter.create_collector
 
       begin
@@ -157,7 +160,7 @@ module Command
             end
           end
           begin
-            execute(cmd, formatter, collector)
+            execute(cmd, formatters, collector)
           rescue CommandException => ce
             ce.command = cmd
             raise
@@ -183,13 +186,19 @@ module Command
     #Gets the final Results::Formatter object to output to.  Override this
     #if you won't be reporting output to the standard output.
     def get_formatter
-      return Results::Formatter.new(::Command::raw_stdout)
+      return Results::TextFormatter.new(::Command::raw_stdout)
+    end
+
+    def get_formatters
+      return [get_formatter]
     end
 
     protected
 
-    def execute(command, formatter, collector)
-      command.advise_formatter(formatter)
+    def execute(command, formatters, collector)
+      formatters.each do |formatter|
+        command.advise_formatter(formatter)
+      end
       command.go(collector)
       return nil
     end

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

@@ -0,0 +1,128 @@
+require 'command-set/interpreter/text'
+require 'command-set/formatter/hash-array'
+require 'yaml'
+require 'enumerator'
+
+module Command
+  class RecordingInterpreter < TextInterpreter
+    class Event
+      def playback(prompt, interpreter, previous)
+        raise NotImplementedError
+      end
+    end
+
+    class Complete < Event
+      def initialize(buffer, prefix, result)
+        @buffer, @prefix, @result = buffer, prefix, result
+      end
+
+      attr_reader :buffer, :prefix, :result
+
+      def eql?(other)
+        return (self.buffer.eql?(other.buffer) and self.prefix.eql?(other.prefix))
+      end
+
+      def playback(prompt, interpreter, previous)
+        complete_list = interpreter.readline_complete(@buffer, @prefix)
+        if complete_list.nil?
+          puts prompt + @buffer + "<TAB>"
+          puts
+        elsif complete_list.length > 1 
+          if previous.eql?(self)
+            puts "<TAB>"
+            complete_list.map{|item| item.ljust(15)}.each_slice(5) do|cons|
+              puts cons.join
+            end
+          else
+            print "\n" + prompt + @buffer + "<TAB>"
+          end
+        else
+          puts "\n" + prompt + @buffer + "<TAB>"
+          complete_list.map{|item| item.ljust(15)}.each_slice(5) do|cons|
+            puts cons.join
+          end
+        end
+      end
+    end
+
+    class Execute < Event
+      def initialize(line)
+        @line = line
+        @result = nil
+      end
+
+      def playback(prompt, interpreter, previous)
+        puts "\n" + prompt + @line
+        interpreter.process_input(@line)
+      end
+
+      attr_writer :result
+    end
+
+    def initialize(file, mod)
+      @events = []
+      @current_hash_array = nil
+      @set_path = File::expand_path(file)
+      @module_name = mod
+      super()
+      self.command_set = CommandSet::define_commands do
+        require_commands(mod, file)
+      end
+    end
+
+    def readline_complete(buffer, prefix)
+      result = super
+      @events << Complete.new(buffer, prefix, result)
+      return result
+    end
+
+    def process_line(line)
+      event = Execute.new(line)
+      @events << event
+      super
+      event.result = @current_hasharray.structure
+    end
+
+    def get_formatters
+      @current_hasharray = Results::HashArrayFormatter.new
+      return [get_formatter, @current_hasharray]
+    end
+
+    def dump_to(io)
+      setup = {
+        'events' => @events,
+        'set_path' => @set_path,
+        'module_name' => @module_name
+      }
+      io.write(YAML::dump(setup))
+    end
+  end
+
+  class PlaybackInterpreter < TextInterpreter
+    def initialize(recording, pause_for)
+      setup = nil
+      File::open(recording) do |record|
+        setup = YAML::load(record)
+      end
+     
+      @events = setup['events']
+      module_name = setup['module_name']
+      command_set_path = setup['set_path']
+
+      super()
+      self.command_set = CommandSet::define_commands do
+        require_commands(module_name, command_set_path)
+      end
+
+      @pause_for = pause_for
+    end
+
+    def go
+      ([nil] + @events).each_cons(2) do |last, event|
+        sleep(@pause_for) unless @pause_for.nil?
+        event.playback(get_prompt, self, last)
+        $stdout.flush
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 require 'command-set'
 require 'command-set/interpreter/base'
-require 'command-set/formatter/base'
-require 'command-set/readline'
+require 'command-set/formatter/strategy'
+require 'compatible-readline/readline'
 
 module Command
    class TextInterpreter < BaseInterpreter
@@ -146,8 +146,8 @@ module Command
        return line_array
      end
 
-     def get_formatter
-       return Results::StrategyFormatter.new(::Command::raw_stdout)
+     def get_formatters
+       return [Results::StrategyFormatter.new(::Command::raw_stdout)]
      end
 
      def get_prompt

metadata

@@ -3,15 +3,15 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: command-set
 version: !ruby/object:Gem::Version 
-  version: 0.10.2
-date: 2008-02-19 00:00:00 -08:00
-summary: Framework for interactive programs focused around a DSL for commands
+  version: 0.10.4
+date: 2008-03-10 00:00:00 -07:00
+summary: User interface framework for with a focus on a DSL for discrete commands
 require_paths: 
 - lib
 email: nyarly@gmail.com
 homepage: 
 rubyforge_project: 
-description: CommandSet is a interactive program framework.  Its focus is a DSL for defining commands, much like Rake or RSpec.  The actual interpreter is left as an open question, although a default readline based terminal interpreter is included, it could very well be adapted to interact with CGI or a GUI.
+description: "CommandSet is a user interface framework.  Its focus is a DSL for defining commands, much like Rake or RSpec.  A default readline based terminal interpreter (complete with context sensitive tab completion, and the amenities of readline: history editing, etc) is included.  It could very well be adapted to interact with CGI or a GUI - both are planned.  CommandSet has a lot of very nice features.  First is the domain-specific language for defining commands and sets of commands.  Those sets can further be neatly composed into larger interfaces, so that useful or standard commands can be resued.  Optional application modes, much like Cisco's IOS, with a little bit more flexibility.  Arguments have their own sub-language, that allows them to provide interface hints (like tab completion) as well as input validation.  On the output side of things, CommandSet has a very flexible output capturing mechanism, which generates a tree of data as it's generated, even capturing writes to multiple places at once (even from multiple threads) and keeping everything straight.  Methods that normally write to stdout are interposed and fed into the tree, so you can hack in existing scripts with minimal adjustment.  The final output can be presented to the user in a number of formats, including contextual coloring and indentation, or even progress hashes.  XML is also provided, although it needs some work.  Templates are on the way.  While you're developing your application, you might find the record and playback utilities useful.  cmdset-record will start up with your defaults for your command set, and spit out an interaction script.  Then you can replay the script against the live set with cmdset-playback.  Great for ad hoc testing, usability surveys and general demos."
 autorequire: 
 default_executable: 
 bindir: bin
@@ -35,6 +35,7 @@ files:
 - lib/command-set/arguments.rb
 - lib/command-set/og.rb
 - lib/command-set/interpreter
+- lib/command-set/interpreter/recording.rb
 - lib/command-set/interpreter/text.rb
 - lib/command-set/interpreter/base.rb
 - lib/command-set/interpreter/quick.rb
@@ -43,6 +44,7 @@ files:
 - lib/command-set/result-list.rb
 - lib/command-set/structural.rb
 - lib/command-set/dsl.rb
+- lib/command-set/critic.rb
 - lib/command-set/formatter
 - lib/command-set/formatter/strategy.rb
 - lib/command-set/formatter/hash-array.rb
@@ -51,7 +53,8 @@ files:
 - lib/command-set/command.rb
 - lib/command-set/standard-commands.rb
 - lib/command-set/results.rb
-- lib/command-set/readline.rb
+- bin/cmdset-playback
+- bin/cmdset-record
 - doc/README
 - doc/GUIDED_TOUR
 - doc/Specifications
@@ -63,17 +66,26 @@ rdoc_options:
 - --main
 - Command
 - --title
-- command-set-0.10.2 RDoc
+- command-set-0.10.4 RDoc
 extra_rdoc_files: 
 - doc/README
 - doc/GUIDED_TOUR
 - doc/Specifications
 - doc/argumentDSL
-executables: []
-
+executables: 
+- cmdset-record
+- cmdset-playback
 extensions: []
 
 requirements: []
 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: orichalcum
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.0
+    version: 

data/lib/command-set/readline.rb

@@ -1,60 +0,0 @@
-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