command-set 0.8.0 → 0.8.1

data/GUIDED_TOUR

@@ -0,0 +1,24 @@
+The quickest way to get a handle on what CommandSet can do for you is to
+look at the various pieces and get a handle on how they work together.
+
+The rough sketch is that you enumerate a series of commands, which you then 
+feed to an interpreter.  The interpreter will set you up with a template for 
+your porgram's subject, which you fill in with some defaults.  Then, give 
+the filled in subject back to the interpreter and let it run.
+
+Here's the appropriate places to get started:
+
+0. DSL (Read thoroughly - especially the sub modules)
+0. BaseInterpreter#subject_template
+0. BaseInterpreter#subject=
+0. TextInterpreter#go
+
+A couple of handy tricks can be found at
+
+0. BaseInterpreter#process_input
+0. StandardCommands
+0. QuickInterpreter
+
+More advanced stuff that worth learning once your app is off the ground:
+
+0. Results

data/doc/Specifications

@@ -214,6 +214,6 @@ Command::Results::Presenter driving a Formatter
 Command::Results::Presenter driving a strict Formatter
 - should send notifications in correct order
 
-Finished in 0.174402 seconds
+Finished in 0.24242 seconds
 
 137 examples, 0 failures

data/lib/command-set/arguments.rb

@@ -176,12 +176,13 @@ module Command
 
     def initialize(name, options={})
       super(name)
+      options ||= {}
       if Hash === options
         @options = Defaults.merge(options)
         @acceptor = @options[:acceptor]
       elsif Proc === options
         @options = Defaults.dup
-        @acceptor = options
+        @acceptor = proc &options
       else
         raise "File argument needs hash or proc!"
       end
@@ -323,6 +324,19 @@ module Command
     end
   end
 
+  class RestOfLineArgument < StringArgument
+    register "rest"
+
+    def consume(subject, arguments)
+      term = arguments.join(" ")
+      arguments.clear
+      unless validate(term, subject)
+	raise ArgumentInvalidException, {@name => term}
+      end
+      return {@name => parse(subject, term)}
+    end
+  end
+
   class ProcArgument < Argument
     register "proc", Proc
 

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

@@ -42,7 +42,7 @@ Command::wrap_stdout
 
 #:startdoc:
 
-#Command::CommandSet is a tight little library that let's you clearly and
+#Command::CommandSet is a tight little library that lets you clearly and
 #easily describe a set of commands for an interactive application.  The
 #command set can then be handed to one of a number of interpreters that will
 #facilitate interaction with the user.
@@ -153,6 +153,23 @@ module Command
 	set.define_commands(&block)
 	return set
       end
+
+      #In driver code, it's often quickest to yank in commands from a file.
+      #To do that, create a code file with a module in it.  The module needs
+      #a method of the form 
+      #
+      #  def self.define_commands()
+      #
+      #define_commands should return a CommandSet.  Then, pass the require
+      #path and module name to require_commands, and it'll take care of
+      #creating the command set.  You can even call
+      #DSL::CommandSetDefinition#define_commands on the set that's returned
+      #in order to add one-off commands or fold in other command sets.
+      def require_commands(file, mod, cmd_path=[])
+        set = self.new
+        set.require_commands(file, mod, cmd_path)
+        return set
+      end
     end
 
     include DSL::CommandSetDefinition

data/lib/command-set/dsl.rb

@@ -37,7 +37,31 @@ Action:: utility functions within the command action block
             @command_list[name] = command.dup
             @command_list[name].parent=self
           end
-          #paths_update(command, name)
+        end
+      end
+
+      #If you've got a file dedicated to a set of commands, (and you really
+      #should) you can use require_commands to require it, call
+      #+define_commands+ on a specific Module, pick out a specific
+      #subcommand (by passing a path), and then including specific commands
+      #from it.
+      def require_commands(file, module_name, path = [], *commands)
+        require file
+        module_path = module_name.to_s.split("::")
+        mod = Object
+        module_path.each do |part|
+          mod = mod.const_get(part)
+        end
+
+        set = mod.define_commands
+        set = set.find_command(*path)
+
+        if CommandSet === set
+          include_commands(set, *commands)
+        elsif Class === set and Command > set
+          command(set)
+        else
+          raise RuntimeError,"#{set.inspect} isn't a CommandSet or a Command"
         end
       end
 
@@ -353,6 +377,40 @@ Action:: utility functions within the command action block
       end
     end
 
+    #The DSL for formatting.  A lot of code will do just fine with the
+    #Kernel#puts #that Results intercepts.  More involved output control
+    #starts by including CommandSet::DSL::Formatting, and using
+    #Formatting#list and Formatting#item to structure output for the
+    #formatters.
+    module Formatting
+      #To create lists and sublist of data, you can use #list to wrap code
+      #in a #begin_list / #end_list pair.  
+      def list(name, options={}) #:yield: 
+        begin_list(name, options)
+        yield if block_given?
+        end_list
+      end
+
+      #Tells the main collector to begin a list.  Subsequent output will be
+      #gathered into that list.  For more, check out Results::Collector
+      def begin_list(name, options={})
+        @main_collector.begin_list(name, options)
+      end
+
+      #Tells the main collector to end the current list.  For more, check out
+      #Results::Collector
+      def end_list  
+        @main_collector.end_list
+      end
+
+      #Clean way to create an item of output.  Allows for various options to
+      #be added.  The normal output method (#puts, #p, #write...) are all
+      #diverted within a command, and effectively create no-option items.
+      def item(name, options={})
+        @main_collector.item(name, options)
+      end
+    end
+
     #The methods available within the DSL::CommandDefinition#action method
     #
     #The trickiest thing to realize about writing Commands is that a
@@ -365,6 +423,7 @@ Action:: utility functions within the command action block
     #which will be local to the invocation of the command.  This is
     #especially useful for undo and redo.
     module Action
+      include Formatting
 
       #:section: Basics
 
@@ -383,35 +442,6 @@ Action:: utility functions within the command action block
         @subject
       end
 
-      #:section: Formatting
-
-      #To create lists and sublist of data, you can use #list to wrap code
-      #in a #begin_list / #end_list pair.  
-      def list(name, options={}) #:yield: 
-        begin_list(name, options)
-        yield if block_given?
-        end_list
-      end
-
-      #Tells the main collector to begin a list.  Subsequent output will be
-      #gathered into that list.  For more, check out Results::Collector
-      def begin_list(name, options={})
-        @main_collector.begin_list(name, options)
-      end
-
-      #Tells the main collector to end the current list.  For more, check out
-      #Results::Collector
-      def end_list  
-        @main_collector.end_list
-      end
-
-      #Clean way to create an item of output.  Allows for various options to
-      #be added.  The normal output method (#puts, #p, #write...) are all
-      #diverted within a command, and effectively create no-option items.
-      def item(name, options={})
-        @main_collector.item(name, options)
-      end
-
       #:section: Pause and Resume
 
       #Stop here.  Return control to the user.  If several commands are

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

@@ -8,16 +8,49 @@ require 'command-set/interpreter'
 #platforms, I'm thinking.  A more flexible way of doing this would rock,
 #regardless of length.
 module Readline
-  extend DL::Importable
-  dlload "/lib/libreadline.so"
-  RLLB = symbol("rl_line_buffer")
-  def self.line_buffer
-    p = RLLB.ptr
-    if p.nil?
-      return p
-    else
-      return p.to_s
+  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
+
+    ls_so_dirs.each do |libreadline_location|
+      begin
+        dlload File::join(*(libreadline_location + ["libreadline.so"]))
+        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
 
@@ -147,7 +180,7 @@ module Command
      end
 
      def get_formatter
-       return Results::TextFormatter.new(::Command::raw_stdout)
+       return Results::StrategyFormatter.new(::Command::raw_stdout)
      end
 
      def get_prompt

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: command-set
 version: !ruby/object:Gem::Version 
-  version: 0.8.0
-date: 2007-11-27 00:00:00 -08:00
+  version: 0.8.1
+date: 2007-12-13 00:00:00 -08:00
 summary: Framework for interactive programs focused around a DSL for commands
 require_paths: 
 - lib
@@ -47,6 +47,7 @@ files:
 - doc/README
 - doc/Specifications
 - doc/argumentDSL
+- GUIDED_TOUR
 test_files: []
 
 rdoc_options: 
@@ -55,11 +56,9 @@ rdoc_options:
 - --main
 - Command
 - --title
-- command-set-0.8.0 RDoc
+- command-set-0.8.1 RDoc
 extra_rdoc_files: 
-- doc/README
-- doc/Specifications
-- doc/argumentDSL
+- GUIDED_TOUR
 executables: []
 
 extensions: []