prompt 0.0.3 → 0.1.0

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 This is updated when a new version is pushed to http://rubygems.org
 
+## 0.1.0 (Mar 8, 2011)
+
+* DSL change: `desc` was renamed to `group`
+* Tab completion will now list only the completions for the current word, instead of
+  the whole command.  This makes it behave like bash and works much better with `*params`
+* Hitting ENTER with an empty line will no longer print a Command Not Found error
+
 ## 0.0.3 (Feb 22, 2011)
 
 * DSL change: `variable` & `dynamic_variable` were renamed to `param`

data/README.md

@@ -16,7 +16,7 @@ Commands are defined with a Sinatra-inspired DSL:
 require 'prompt'
 extend Prompt::DSL
 
-desc "Move"
+group "Move"
 
 param :direction, "A cardinal direction", %w(north east south west)
 
@@ -24,7 +24,7 @@ command "go :direction", "Walk in the specified direction" do |direction|
   puts "You walked #{direction} and were eaten by a grue."
 end
 
-desc "Interact"
+group "Interact"
 
 command "look", "Look around" do
   puts "You're in a dark room."
@@ -44,7 +44,7 @@ Tab completion is hooked up automatically after you define your commands and par
     $ my_app
     > g<TAB>
     > go <TAB>
-    go east   go north  go south  go west
+    east   north  south  west
     > go n<TAB>
     > go north
 
@@ -86,12 +86,12 @@ The `help` command is built-in.  It will print all of the commands that you've d
 You can put commands in logical groups.  This only affects how help is printed.
 
 ```ruby
-desc "Taco commands"
+group "File commands"
 
 command ...
 command ...
 
-desc "Burger commands"
+group "Directory commands"
 
 command ...
 ```
@@ -112,30 +112,28 @@ Here, the parameters are named `first` and `last`.  Their values are be passed a
 Each `:parameter` only matches a single word.  If you want to match multiple words to one parameter, use a `*parameter`.
 
 ```ruby
-command "say *sentence" do |sentence|
-  puts "You said #{sentence.length} words"
+command "cp *file :dest" do |files, dest|
+  puts "You copied #{files.length} files to #{dest}"
 end
 ```
 
 ### Defining parameters
 
-It's not necessary to define a parameter before using it in a command, but doing so will allow you to provide a useful description and valid values for the parameter.
+It's not necessary to define a parameter before using it in a command, but doing so will allow you to provide a useful description and list of possible completions for the parameter.
 
 ```ruby
 param :name, "Description"
 ```
 
-### Specifying a static list of valid values
+### Specifying parameter completions
 
-You can specify a static list of valid values for a parameter.  These will be expanded when using tab completion.
+You can specify the completions for a parameter as a static list:
 
 ```ruby
-param :name, "Description", %w(value1 value2)
+param :color, "A color", %w(red green blue)
 ```
 
-### Specifying a dynamic list of valid values
-
-Instead of a static list, you can specify a block that will dynamically return a list of valid values for a parameter.  These will also be expanded when using tab completion.
+or as a dynamically-generated one:
 
 ```ruby
 param :file, "JPG file" do

data/examples/file_manager

@@ -8,7 +8,7 @@ def change_prompt dir
   Prompt.application.prompt = "#{@pwd}> "
 end
 
-@pwd = File.absolute_path Dir.pwd
+@pwd = File.expand_path Dir.pwd
 change_prompt @pwd
 
 param :dir, "Directory" do
@@ -18,7 +18,7 @@ param :dir, "Directory" do
 end
 
 command "cd :dir", "Change directory" do |dir|
-  @pwd = File.absolute_path File.join(@pwd, dir)
+  @pwd = File.expand_path File.join(@pwd, dir)
   change_prompt @pwd
 end
 
@@ -38,9 +38,11 @@ command "pwd", "Print current directory" do
   puts @pwd
 end
 
-param :files, "A list of files"
+param :file, "File" do
+  Dir.entries(@pwd)
+end
 
-command "cp *files :dir", "Copy one or more files to dest" do |files, dir|
+command "cp *file :dir", "Copy one or more files to dest" do |files, dir|
   puts "Copying #{files.length} file(s) to #{dir}"
   # doesn't actually do it...
 end

data/examples/mud

@@ -7,7 +7,7 @@ extend Prompt::DSL
 GRUE = 3
 @moves = 0
 
-desc "Move"
+group "Move"
 
 param :direction, "A cardinal direction", %w(north east south west)
 
@@ -20,7 +20,7 @@ command "go :direction", "Walk in the specified direction" do |direction|
   end
 end
 
-desc "Interact"
+group "Interact"
 
 command "look", "Look around" do
   if @moves < GRUE

data/lib/prompt/application.rb

@@ -1,5 +1,8 @@
 require 'prompt/command_group'
 require 'prompt/command'
+require 'prompt/matcher'
+require 'prompt/simple_matcher'
+require 'prompt/multi_matcher'
 
 module Prompt
   class Application
@@ -11,7 +14,7 @@ module Prompt
       @prompt = "> "
     end
 
-    def use_command_group desc
+    def select_group desc
       @current_command_group_name = desc
     end
 
@@ -19,22 +22,32 @@ module Prompt
       current_command_group.commands << command
     end
 
-    def exec command_str
+    def exec words
       commands.each do |command|
-        args = command.match(command_str)
+        args = command.match(words)
         return command.run(args) if args
       end
-      raise CommandNotFound.new(command_str)
+      raise CommandNotFound.new
     ensure
       clear_cached_values
     end
 
-    def completions starting_with
-      all_expansions.grep /^#{Regexp.escape(starting_with)}/
+    def completions line_starting_with, word_starting_with
+      args = Console.split(line_starting_with)
+      last_idx = index_of_last_word(line_starting_with)
+      all_expansions(args[0,last_idx], word_starting_with)
     end
 
     private
 
+    def index_of_last_word line
+      ss = StringScanner.new(line)
+      ss.scan(/\s+/)
+      idx = 0
+      idx += 1 while ss.scan(/[^\s]+\s+/)
+      idx
+    end
+
     def clear_cached_values
       commands.each do |c|
         c.clear_cached_values
@@ -45,8 +58,10 @@ module Prompt
       @command_groups.map(&:commands).flatten(1)
     end
 
-    def all_expansions
-      commands.map(&:expansions).flatten(1)
+    def all_expansions(args, partial_arg)
+      commands.select { |c| c.could_match? args }.map do |c|
+        c.expansions(args.length, partial_arg)
+      end.flatten(1)
     end
 
     def current_command_group

data/lib/prompt/command.rb

@@ -1,13 +1,11 @@
 require 'strscan'
 require 'prompt/parameter'
+require 'prompt/console/console_module'
 
 module Prompt
   class Command
 
     SEP = "\036" # RS - record separator
-    S_QUOTED_ARG = /'([^']*)'/
-    D_QUOTED_ARG = /"([^"]*)"/
-    UNQUOTED_ARG = /[^\s]+/
 
     attr :name
     attr :desc
@@ -19,28 +17,27 @@ module Prompt
       @action = block
 
       @name = words.join(" ")
-      @parameters = words.select {|w| w.kind_of? Parameter}
+      @matchers = words.select {|w| w.kind_of?(Matcher) }
+      @parameters = @matchers.map { |m| m.parameter }
     end
 
     def run args
       @action.call *args
     end
 
-    def match str
-      if m = regex.match(to_args(str).join(SEP))
-        @parameters.map {|v| v.matches(m[v.name]) }
+    def match words
+      if args = regex.match(words.join(SEP))
+        @matchers.map {|m| m.matches(args[m.parameter.name]) }
       end
     end
 
-    def expansions
-      expand @words
-    end
-
     def usage
       @words.map do |word|
         case word
-        when Parameter
-          "<#{word.name}>"
+        when MultiMatcher
+          "<#{word.parameter.name}> ..."
+        when Matcher
+          "<#{word.parameter.name}>"
         else
           word
         end
@@ -53,30 +50,43 @@ module Prompt
       end
     end
 
-    private
+    def expansions(word_idx, starting_with)
+      # TODO - combine glob parameters with any that follow
+      word = @words[0..word_idx].find { |w| w.kind_of? MultiMatcher }
+      word = word || @words[word_idx]
+
+      return [] if word.nil?
+
+      case word
+      when Matcher 
+        word.parameter.expansions(starting_with)
+      when String
+        word.start_with?(starting_with) ? [word] : []
+      end
+    end
 
-    # Splits a command string into an argument list.
-    # This understands how to make "quoted strings" into a single arg
-    def to_args command
-      args = []
-      ss = StringScanner.new(command)
-      ss.scan(/\s+/)
-      until ss.eos?
-        if ss.scan(S_QUOTED_ARG) or ss.scan(D_QUOTED_ARG)
-          args << ss[1]
-        elsif arg = ss.scan(UNQUOTED_ARG)
-          args << arg
+    def could_match?(words)
+      words.each_with_index do |w, i|
+        word = @words[i]
+        case word
+        when nil
+          return false
+        when MultiMatcher
+          return true
+        when String
+          return false unless word.start_with?(w)
         end
-        ss.scan(/\s+/)
       end
-      args
+      return true
     end
 
+    private
+
     def regex
       begin
         regex_strs = @words.map do |word|
            case word
-           when Parameter
+           when Matcher
              word.regex
            else
              Regexp.escape(word)
@@ -86,29 +96,5 @@ module Prompt
       end
     end
 
-    def expand a
-      return [] if a.empty?
-
-      head = a[0]
-      tail = a[1..-1]
-
-      case head
-      when Parameter
-        head = head.expansions
-      else
-        head = [head]
-      end
-
-      return head if tail.empty?
-
-      result = []
-      head.each do |h|
-        expand(tail).each do |e|
-          result << "#{h} #{e}"
-        end
-      end
-      result
-    end
-
   end
 end

data/lib/prompt/command_not_found.rb

@@ -1,7 +1,4 @@
 module Prompt
   class CommandNotFound < RuntimeError
-    def initialize(command_str)
-      super "Command not found: #{command_str}"
-    end
   end
 end

data/lib/prompt/console/builtins.rb

@@ -6,7 +6,7 @@ module Prompt
     class Builtins
       extend DSL
 
-      desc "Console commands"
+      group "Console commands"
 
       command "help", "List all commands" do
         print_help

data/lib/prompt/console/console_module.rb

@@ -1,13 +1,15 @@
 require 'readline'
 require 'prompt'
+require 'strscan'
 
 module Prompt
   module Console
 
     HISTORY_MAX_SIZE = 100
 
-    CompletionProc = proc do |s|
-      Prompt.application.completions(s)
+    CompletionProc = proc do |word_starting_with|
+      line_starting_with = Readline.line_buffer[0...Readline.point]
+      Prompt.application.completions(line_starting_with, word_starting_with)
     end
 
     def self.start(history_file = nil)
@@ -19,17 +21,17 @@ module Prompt
         save_history history_file if history_file
       end
 
-      Readline.basic_word_break_characters = ""
-      Readline.completion_append_character = " "
       Readline.completion_proc = CompletionProc
 
       load_history history_file if history_file
 
       while line = Readline.readline(Prompt.application.prompt, true)
         begin
-          Prompt.application.exec(line).nil?
-        rescue ::Prompt::CommandNotFound => e
-          STDERR.puts e.message
+          words = split(line)
+          next if words == []
+          Prompt.application.exec words
+        rescue CommandNotFound
+          STDERR.puts "Command not found: #{line}"
         end
       end
     end
@@ -51,5 +53,35 @@ module Prompt
       end
     end
 
+    private
+
+    S_QUOTED_ARG = /'([^']*)'/
+    D_QUOTED_ARG = /"([^"]*)"/
+    UNQUOTED_ARG = /[^\s]+/
+
+    # Splits a command string into an argument (word) list.
+    # This understands how to make "quoted strings" into a single word
+    def self.split command
+      args = []
+      ss = StringScanner.new(command)
+      ss.scan(/\s+/)
+      until ss.eos?
+        arg = ""
+        while true
+          segment = if ss.scan(S_QUOTED_ARG) or ss.scan(D_QUOTED_ARG)
+            ss[1]
+          else
+            ss.scan(UNQUOTED_ARG)
+          end
+          break unless segment
+          arg << segment
+        end
+        args << arg
+        ss.scan(/\s+/)
+      end
+      args
+    end
+
+
   end # module Console
 end

data/lib/prompt/dsl.rb

@@ -1,6 +1,4 @@
 require 'prompt/parameter'
-require 'prompt/proc_parameter'
-require 'prompt/glob_parameter'
 require 'prompt/dsl_helper'
 
 module Prompt
@@ -12,11 +10,11 @@ module Prompt
       else
         "Commands"
       end
-      Prompt.application.use_command_group(name)
+      Prompt.application.select_group(name)
     end
 
-    def desc desc
-      Prompt.application.use_command_group(desc)
+    def group desc
+      Prompt.application.select_group(desc)
     end
 
     def command(name, desc = nil, &block)
@@ -28,10 +26,10 @@ module Prompt
     def param(name, desc, values = nil, &block)
       @parameters = [] unless defined? @parameters
       raise "parameter :#{name} is already defined" if @parameters.find {|v| v.name == name}
-      if block
-        @parameters << ProcParameter.new(name, desc, &block)
+      @parameters << if block
+        Parameter.new(name, desc, &block)
       else
-        @parameters << Parameter.new(name, desc, values)
+        Parameter.new(name, desc, values)
       end
     end
 

data/lib/prompt/dsl_helper.rb

@@ -1,25 +1,28 @@
+require 'prompt/simple_matcher'
+require 'prompt/multi_matcher'
+
 module Prompt
   module DSLHelper
 
-    # Split command into an array of Strings and Parameters
+    # Split command into an array of Strings and Matchers
     def self.words command_name, parameters
       command_name.strip.split(/\s+/).map do |word|
-         if word[0] == ":"
-           sym = word[1..-1].to_sym
-           parameters.find {|p| p.name == sym} || Parameter.new(sym)
-         elsif word[0] == "*"
-           sym = word[1..-1].to_sym
-           param = parameters.find {|p| p.name == sym}
-           # Since GlobParameters can't be defined ahead of time in the DSL, we
-           # always create a new one and copy the description
-           # This is kinda jankey
-           desc = param ? param.desc : nil
-           GlobParameter.new(sym, desc)
-         else
-           word
-         end
+        if word[0] == ":"
+          param = find_param word, parameters
+          SimpleMatcher.new param
+        elsif word[0] == "*"
+          param = find_param word, parameters
+          MultiMatcher.new param
+        else
+          word
+        end
       end
     end
 
+    def self.find_param word, parameters
+      sym = word[1..-1].to_sym
+      parameters.find {|p| p.name == sym} || Parameter.new(sym)
+    end
+
   end
 end

data/lib/prompt/matcher.rb

@@ -0,0 +1,13 @@
+module Prompt
+  class Matcher
+
+    SEP = Prompt::Command::SEP
+
+    attr :parameter
+
+    def initialize param
+      @parameter = param
+    end
+
+  end
+end

data/lib/prompt/multi_matcher.rb

@@ -0,0 +1,21 @@
+module Prompt
+  class MultiMatcher < Matcher
+
+    def regex
+      "(?<#{parameter.name}>([^#{SEP}]*)(#{SEP}[^#{SEP}]*)*)"
+    end
+
+    def matches s
+      return [""] if s.length == 0
+      ss = StringScanner.new(s)
+      r = Regexp.new "[^#{SEP}]*"
+      res = []
+      until ss.eos?
+        ss.scan /#{SEP}/
+        res << ss.scan(r)
+      end
+      res
+    end
+
+  end
+end

data/lib/prompt/parameter.rb

@@ -3,34 +3,26 @@ module Prompt
 
     attr :name
     attr :desc
-    attr :values
 
-    def initialize(name, desc = nil, values = nil)
+    def initialize(name, desc = nil, values = nil, &block)
       @name = name
       @desc = desc
-      @values = values
+      @values = values || []
+      @proc = block if block_given?
     end
 
-    def regex
-      if values
-        "(?<#{name}>#{values.map{|v| Regexp.escape(v)}.join("|")})"
-      else
-        "(?<#{name}>([^#{Prompt::Command::SEP}]*))"
-      end
+    def clear_cached_values
+      @cached_value = nil
     end
 
-    def expansions
-      if values
-        values.map do |v|
-          (v =~ /\s/) ?  "\"#{v}\"" : v
-        end
+    def expansions(starting_with = "")
+      all = if @proc
+        @cached_value = @proc.call
       else
-        ["<#{name}>"]
+        @values
       end
-    end
 
-    def matches s
-      s
+      all.grep /^#{starting_with}/
     end
 
   end

data/lib/prompt/prompt_module.rb

@@ -1,5 +1,5 @@
 module Prompt
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 
   class << self
 

data/lib/prompt/simple_matcher.rb

@@ -0,0 +1,13 @@
+module Prompt
+  class SimpleMatcher < Matcher
+
+    def regex
+      "(?<#{parameter.name}>[^#{Prompt::Command::SEP}]*)"
+    end
+
+    def matches s
+      s
+    end
+
+  end
+end

data/spec/prompt/command_spec.rb

@@ -1,13 +1,12 @@
-require 'prompt/command'
-require 'prompt/parameter'
-require 'prompt/glob_parameter'
+require 'prompt'
+require 'spec_helper'
 
 include Prompt
 
 describe Prompt::Command do
 
   DIRECTIONS = %w{n e s w}
-  SPEEDS = %w{quickly slowly}
+  SPEEDS = %w{slow slower}
 
   describe "#match" do
 
@@ -16,13 +15,11 @@ describe Prompt::Command do
       it "matches correctly" do
         c = Command.new ["hi"]
 
-        c.match("hi").should == []
-        c.match("hi ").should == []
-        c.match(" hi").should == []
+        c.match(["hi"]).should == []
 
-        c.match("bye").should be_nil
-        c.match("h").should be_nil
-        c.match("").should be_nil
+        c.match(["bye"]).should be_nil
+        c.match(["h"]).should be_nil
+        c.match([""]).should be_nil
       end
 
     end
@@ -30,35 +27,24 @@ describe Prompt::Command do
     describe "hi :name" do
 
       it "matches correctly" do
-        c = Command.new ["hi", Parameter.new(:name)]
+        c = Command.new ["hi", matcher(:name)]
 
-        c.match("hi guy").should == ["guy"]
-        c.match("hi 'some guy'").should == ["some guy"]
-        c.match("hi ''").should == [""]
-        c.match('hi "some guy"').should == ["some guy"]
-        c.match('hi ""').should == [""]
+        c.match(["hi", "guy"]).should == ["guy"]
+        c.match(["hi", "some guy"]).should == ["some guy"]
+        c.match(["hi", ""]).should == [""]
 
-        c.match("hi '").should == ["'"]
-        c.match('hi "').should == ['"']
-        c.match('hi \'"').should == ['\'"']
-
-        c.match("higuy").should be_nil
-        c.match("higuy guy").should be_nil
-
-        c.match(" hi guy").should == ["guy"]
-        c.match("hi  guy").should == ["guy"]
-        c.match("hi guy ").should == ["guy"]
+        c.match(["higuy"]).should be_nil
+        c.match(["higuy", "guy"]).should be_nil
       end
 
       it "matches correctly (with parameter value constraint)" do
-        c = Command.new ["hi", Parameter.new(:name, "", ["alice", "bob", "charlie rose"])]
-
-        c.match("hi alice").should == ["alice"]
-        c.match("hi bob").should == ["bob"]
-        c.match("hi 'charlie rose'").should == ["charlie rose"]
-        c.match("hi charlie rose").should be_nil
-        c.match("hi zack").should be_nil
-        c.match("hi ali").should be_nil
+        name = Parameter.new(:name, "", ["alice", "bob", "charlie rose"])
+        c = Command.new ["hi", matcher(name)]
+
+        c.match(["hi", "alice"]).should == ["alice"]
+        c.match(["hi", "bob"]).should == ["bob"]
+        c.match(["hi", "charlie rose"]).should == ["charlie rose"]
+        c.match(["hi", "zack"]).should == ["zack"]
       end
 
     end
@@ -66,11 +52,12 @@ describe Prompt::Command do
     describe "hi :first :last" do
 
       it "matches correctly" do
-        c = Command.new ["hi", Parameter.new(:first), Parameter.new(:last)]
+        c = Command.new ["hi", matcher(:first), matcher(:last)]
+
+        c.match(%w(hi agent smith)).should == ["agent", "smith"]
 
-        c.match("hi agent smith").should == ["agent", "smith"]
-        c.match("hi agent").should be_nil
-        c.match("hi agent smith guy").should be_nil
+        c.match(%w(hi agent)).should be_nil
+        c.match(%w(hi agent smith guy)).should be_nil
       end
 
     end
@@ -78,14 +65,12 @@ describe Prompt::Command do
     describe "say *stuff" do
 
       it "matches correctly" do
-        c = Command.new ["say", GlobParameter.new(:stuff)]
-
-        c.match("say hello").should == [["hello"]]
-        c.match("say hello world").should == [["hello", "world"]]
-        c.match("say hello  world").should == [["hello", "world"]]
-        c.match("say  hello  world").should == [["hello", "world"]]
-        c.match("say 'hello world'").should == [["hello world"]]
-        c.match('say "hello world"').should == [["hello world"]]
+        c = Command.new ["say", multi_matcher(:stuff)]
+
+        c.match(["say", "hello"]).should == [["hello"]]
+        c.match(["say", "hello", "world"]).should == [["hello", "world"]]
+        c.match(["say", ""]).should == [[""]]
+        c.match(["say", "hello", ""]).should == [["hello", ""]]
       end
 
     end
@@ -93,12 +78,13 @@ describe Prompt::Command do
     describe "say *stuff :adverb" do
 
       it "matches correctly" do
-        c = Command.new ["say", GlobParameter.new(:stuff), Parameter.new(:adverb)]
+        c = Command.new ["say", multi_matcher(:stuff), matcher(:adverb)]
+
+        c.match(["say", "hello", "world"]).should == [["hello"], "world"]
+        c.match(["say", "hello", "world", "loudly"]).should == [["hello", "world"], "loudly"]
+        c.match(["say", "hello", "world loudly"]).should == [["hello"], "world loudly"]
 
-        c.match("say hello").should be_nil
-        c.match("say hello loudly").should == [["hello"], "loudly"]
-        c.match("say hello world loudly").should == [["hello", "world"], "loudly"]
-        c.match("say hello 'world loudly'").should == [["hello"], "world loudly"]
+        c.match(["say", "hello"]).should be_nil
       end
 
     end
@@ -106,12 +92,12 @@ describe Prompt::Command do
     describe "say *first *second" do
 
       it "matches correctly" do
-        c = Command.new ["say", GlobParameter.new(:first), GlobParameter.new(:second)]
+        c = Command.new ["say", multi_matcher(:first), multi_matcher(:second)]
 
-        c.match("say one").should be_nil
-        c.match("say one two").should == [["one"], ["two"]]
-        c.match("say one two three").should == [["one", "two"], ["three"]]
-        c.match("say one 'two three'").should == [["one"], ["two three"]]
+        c.match(["say", "one"]).should be_nil
+        c.match(["say", "one", "two"]).should == [["one"], ["two"]]
+        c.match(["say", "one", "two", "three"]).should == [["one", "two"], ["three"]]
+        c.match(["say", "one", "two three"]).should == [["one"], ["two three"]]
       end
 
     end
@@ -121,37 +107,58 @@ describe Prompt::Command do
   describe "#parameters" do
     it "returns correctly" do
       color = Parameter.new(:color, "")
-      flavor = GlobParameter.new(:flavor, "")
+      flavor = Parameter.new(:flavor, "")
 
       Command.new(["one"]).parameters.should == []
-      Command.new(["one", color]).parameters.should == [color]
-      Command.new(["one", color, flavor]).parameters == [color, flavor]
+      Command.new(["one", matcher(color)]).parameters.should == [color]
+      Command.new(["one", matcher(color), matcher(flavor)]).parameters == [color, flavor]
     end
   end
 
   describe "#expansions" do
+
     it "expands correctly with no parameters" do
-      Command.new(["one"]).expansions.should == ["one"]
+      c = Command.new ["one"]
+      c.expansions(0, "").should == ["one"]
+      c.expansions(0, "on").should == ["one"]
+      c.expansions(0, "z").should == []
+      c.expansions(1, "").should == []
+
+      c = Command.new ["help", "-v"]
+      c.expansions(0, "").should == ["help"]
+      c.expansions(0, "he").should == ["help"]
+      c.expansions(0, "z").should == []
+      c.expansions(1, "").should == ["-v"]
+      c.expansions(1, "-v").should == ["-v"]
+      c.expansions(1, "z").should == []
     end
 
     it "expands correctly with undefined parameters" do
-      Command.new(["go", Parameter.new(:dir)]).expansions.should == ["go <dir>"]
+      c = Command.new(["go", matcher(:dir)])
+      c.expansions(0, "").should == ["go"]
+      c.expansions(0, "g").should == ["go"]
+      c.expansions(0, "go").should == ["go"]
+      c.expansions(1, "").should == []
     end
 
     it "expands correctly with defined parameters" do
       dir = Parameter.new(:dir, "", DIRECTIONS)
+      c = Command.new(["go", matcher(dir)])
+      c.expansions(1, "").should == DIRECTIONS
+
       speed = Parameter.new(:speed, "", SPEEDS)
-      Command.new(["go", dir]).expansions.should == ["go n", "go e", "go s", "go w"]
-      Command.new(["go", dir, speed]).expansions.should ==
-        ["go n quickly", "go n slowly",
-         "go e quickly", "go e slowly",
-         "go s quickly", "go s slowly",
-         "go w quickly", "go w slowly"]
+      c = Command.new(["go", matcher(dir), matcher(speed)])
+      c.expansions(2, "").should == SPEEDS
+      c.expansions(2, "slow").should == SPEEDS
+      c.expansions(2, "slowe").should == ["slower"]
     end
 
-    it"expands correctly if parameter values have spaces" do
+    it "expands correctly if parameter values have spaces" do
       speed = Parameter.new(:speed, "", ["fast", "very fast"])
-      Command.new(["go", speed]).expansions.should == ['go fast', 'go "very fast"']
+      c = Command.new(["go", matcher(speed)])
+      c.expansions(1, "").should == ['fast', 'very fast']
+      c.expansions(1, "f").should == ['fast']
+      c.expansions(1, "v").should == ['very fast']
     end
   end
 
@@ -160,8 +167,8 @@ describe Prompt::Command do
       color = Parameter.new(:color, "")
 
       Command.new(["one"]).usage.should == "one"
-      Command.new(["one", color]).usage.should == "one <color>"
-      Command.new(["one", color, "three"]).usage.should == "one <color> three"
+      Command.new(["one", matcher(color)]).usage.should == "one <color>"
+      Command.new(["one", matcher(color), "three"]).usage.should == "one <color> three"
     end
   end
 

data/spec/prompt/console_spec.rb

@@ -0,0 +1,79 @@
+require 'prompt'
+
+include Prompt
+
+describe Prompt::Console do
+  describe ".split" do
+
+    context "simple words" do
+      {
+        "hi"       => %w(hi),
+        "one two"  => %w(one two),
+        "one :two" => %w(one :two),
+        "one *two" => %w(one *two),
+        "one_two"  => %w(one_two)
+      }.each do |line, words|
+        it line do
+          Console.split(line).should == words
+        end
+      end
+    end
+
+    context "extra whitespace" do
+      {
+        " hi"      => %w(hi),
+        "hi "      => %w(hi),
+        "   hi  "  => %w(hi),
+        "one  two" => %w(one two),
+      }.each do |line, words|
+        it line do
+          Console.split(line).should == words
+        end
+      end
+    end
+
+    context "quoted strings" do
+      {
+        "say 'hello'"     => %w(say hello),
+        'say "hello"'     => %w(say hello),
+        "say 'hi world'"  => ["say", "hi world"],
+        'say "hi world"'  => ["say", "hi world"],
+        'say ""'          => ["say", ""],
+        "say ''"          => ["say", ""],
+        "say '' ok"       => ["say", "", "ok"],
+        "say 'hi  world'" => ["say", "hi  world"]
+      }.each do |line, words|
+        it line do
+          Console.split(line).should == words
+        end
+      end
+    end
+
+    context "unmatched quotes" do
+      {
+        "'"          => %w('),
+        '"'          => %w("),
+        "alice's"    => %w(alice's),
+        'alice"s'    => %w(alice"s),
+        "'one' 'two" => %w(one 'two)
+      }.each do |line, words|
+        it line do
+          Console.split(line).should == words
+        end
+      end
+    end
+
+    context "quoted substrings" do
+      {
+        "'one'two"     => %w(onetwo),
+        "'one''two'"   => %w(onetwo),
+        "'one'\"two\"" => %w(onetwo)
+      }.each do |line, words|
+        it line do
+          Console.split(line).should == words
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'prompt/matcher'
+
+def matcher(symbol_or_parameter)
+  SimpleMatcher.new(param(symbol_or_parameter))
+end
+
+def multi_matcher(symbol_or_parameter)
+  MultiMatcher.new(param(symbol_or_parameter))
+end
+
+def param(symbol_or_parameter)
+  if symbol_or_parameter.kind_of? Parameter
+    symbol_or_parameter
+  else
+    Parameter.new(symbol_or_parameter)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prompt
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-23 00:00:00.000000000 Z
+date: 2012-03-08 00:00:00.000000000 Z
 dependencies: []
 description: Prompt makes it easy to build slick command-line applications with Tab
   Completion, Command History, and Built-in Help
@@ -30,12 +30,15 @@ files:
 - lib/prompt/console.rb
 - lib/prompt/dsl.rb
 - lib/prompt/dsl_helper.rb
-- lib/prompt/glob_parameter.rb
+- lib/prompt/matcher.rb
+- lib/prompt/multi_matcher.rb
 - lib/prompt/parameter.rb
-- lib/prompt/proc_parameter.rb
 - lib/prompt/prompt_module.rb
+- lib/prompt/simple_matcher.rb
 - lib/prompt.rb
 - spec/prompt/command_spec.rb
+- spec/prompt/console_spec.rb
+- spec/spec_helper.rb
 - examples/file_manager
 - examples/mud
 homepage: http://github.com/mudynamics/prompt
@@ -49,16 +52,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: A small framework that makes it easy to build slick command-line applications

data/lib/prompt/glob_parameter.rb

@@ -1,17 +0,0 @@
-module Prompt
-  class GlobParameter < Parameter
-
-    def initialize(name, desc = nil)
-      super(name, desc)
-    end
-
-    def regex
-      "(?<#{name}>(([^#{Prompt::Command::SEP}]*)#{Prompt::Command::SEP}?)+)"
-    end
-
-    def matches s
-      s.split(Prompt::Command::SEP)
-    end
-
-  end
-end

data/lib/prompt/proc_parameter.rb

@@ -1,18 +0,0 @@
-module Prompt
-  class ProcParameter < Parameter
-
-    def initialize(name, desc, &block)
-      super(name, desc, nil)
-      @proc = block
-    end
-
-    def values
-      @cached_value ||= @proc.call
-    end
-
-    def clear_cached_value
-      @cached_value = nil
-    end
-
-  end
-end