prompt 0.0.2 → 0.0.3

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+This is updated when a new version is pushed to http://rubygems.org
+
+## 0.0.3 (Feb 22, 2011)
+
+* DSL change: `variable` & `dynamic_variable` were renamed to `param`
+* A glob parameter (e.g. `*param`) will now return its matches as an array of strings
+* Quoted strings will now work as expected with glob parameters
+* Dynamic variables are cached until the next command is run
+* Added LICENSE.txt
+
+## 0.0.2 (Feb 17, 2011)
+
+* Allow the command prompt to be changed while it's running
+* Quoted strings will now match to a single `:param`
+* Use a `*param` to match one or more words
+* [BUG] Don't memoize Command#regex.  This prevented dynamic variables
+  from working correctly after the values changed
+
+## 0.0.1 (Feb 16, 2011)
+
+* Initial release

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Mu Dynamics
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -18,7 +18,7 @@ extend Prompt::DSL
 
 desc "Move"
 
-variable :direction, "A cardinal direction", %w(north east south west)
+param :direction, "A cardinal direction", %w(north east south west)
 
 command "go :direction", "Walk in the specified direction" do |direction|
   puts "You walked #{direction} and were eaten by a grue."
@@ -39,7 +39,7 @@ Prompt::Console.start
 
 ### Tab completion
 
-Tab completion is hooked up automatically after you define your commands and variables
+Tab completion is hooked up automatically after you define your commands and parameters
 
     $ my_app
     > g<TAB>
@@ -68,8 +68,8 @@ The `help` command is built-in.  It will print all of the commands that you've d
     > help
     Console commands
 
-      help -v
-      help
+      help                                     List all commands
+      help -v                                  List all commands, including parameters
       exit
 
     Move
@@ -96,9 +96,9 @@ desc "Burger commands"
 command ...
 ```
 
-## Using Variables
+## Using Parameters
 
-Variables can be used in a command.
+Parameters can be used in a command:
 
 ```ruby
 command "name :first :last" do |first, last|
@@ -106,39 +106,39 @@ command "name :first :last" do |first, last|
 end
 ```
 
-Here, the variables are named `first` and `last`.  Their values are be passed as arguments to the command's block, in the order in which they appear.
+Here, the parameters are named `first` and `last`.  Their values are be passed as arguments to the command's block, in the order in which they appear.
 
 
-Each `:variable` only matches a single word.  If you want to match multiple words to one variable, use a `*variable`.
+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 say '#{sentence}'"
+  puts "You said #{sentence.length} words"
 end
 ```
 
-### Defining variables
+### Defining parameters
 
-It's not necessary to define a variable before using it in a command, but doing so will allow you to provide a useful description and valid values for the variable.
+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.
 
 ```ruby
-variable :name, "Description"
+param :name, "Description"
 ```
 
 ### Specifying a static list of valid values
 
-You can specify a static list of valid values for a variable.  These will be expanded when using tab completion.
+You can specify a static list of valid values for a parameter.  These will be expanded when using tab completion.
 
 ```ruby
-variable :name, "Description", %w(value1 value2)
+param :name, "Description", %w(value1 value2)
 ```
 
 ### Specifying a dynamic list of valid values
 
-Instead of specifying a static list, you can specify a block that will dynamically return a list of valid values for a variable.  These will be expanded when using tab completion.  
+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.
 
 ```ruby
-dynamic_variable :file, "JPG file" do
+param :file, "JPG file" do
   Dir.glob "*.jpg"
 end
 ```

data/examples/file_manager

@@ -11,7 +11,7 @@ end
 @pwd = File.absolute_path Dir.pwd
 change_prompt @pwd
 
-dynamic_variable :dir, "Directory" do
+param :dir, "Directory" do
   Dir.entries(@pwd).select do |e|
     File.directory?(File.join(@pwd, e))
   end
@@ -38,4 +38,11 @@ command "pwd", "Print current directory" do
   puts @pwd
 end
 
+param :files, "A list of files"
+
+command "cp *files :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
+
 Prompt::Console.start

data/examples/mud

@@ -9,7 +9,7 @@ GRUE = 3
 
 desc "Move"
 
-variable :direction, "A cardinal direction", %w(north east south west)
+param :direction, "A cardinal direction", %w(north east south west)
 
 command "go :direction", "Walk in the specified direction" do |direction|
   puts "You walked #{direction}"
@@ -31,7 +31,7 @@ command "look", "Look around" do
 end
 
 command "say *something", "Say something" do |something|
-  puts "You say '#{something}'"
+  puts "You say '#{something.join(" ")}'"
 end
 
 Prompt::Console.start

data/lib/prompt/application.rb

@@ -15,8 +15,8 @@ module Prompt
       @current_command_group_name = desc
     end
 
-    def define_command name, desc = nil, variables, &block
-      current_command_group.commands << Command.new(name, desc, variables, &block)
+    def add_command command
+      current_command_group.commands << command
     end
 
     def exec command_str
@@ -25,22 +25,28 @@ module Prompt
         return command.run(args) if args
       end
       raise CommandNotFound.new(command_str)
+    ensure
+      clear_cached_values
     end
 
-    def completions starting_with = nil
-      return all_expansions unless starting_with
-
+    def completions starting_with
       all_expansions.grep /^#{Regexp.escape(starting_with)}/
     end
 
     private
 
+    def clear_cached_values
+      commands.each do |c|
+        c.clear_cached_values
+      end
+    end
+
     def commands
-      @command_groups.map(&:commands).reduce [] { |a, b| a + b }
+      @command_groups.map(&:commands).flatten(1)
     end
 
     def all_expansions
-      commands.map(&:expansions).flatten
+      commands.map(&:expansions).flatten(1)
     end
 
     def current_command_group

data/lib/prompt/command.rb

@@ -1,38 +1,45 @@
+require 'strscan'
+require 'prompt/parameter'
+
 module Prompt
   class Command
 
+    SEP = "\036" # RS - record separator
+    S_QUOTED_ARG = /'([^']*)'/
+    D_QUOTED_ARG = /"([^"]*)"/
+    UNQUOTED_ARG = /[^\s]+/
+
     attr :name
     attr :desc
+    attr :parameters
 
-    def initialize(name, desc = nil, all_variables = [], &block)
-      @name = name
+    def initialize(words, desc = nil, &block)
+      @words = words
       @desc = desc
-      @all_variables = all_variables
       @action = block
+
+      @name = words.join(" ")
+      @parameters = words.select {|w| w.kind_of? Parameter}
     end
 
     def run args
       @action.call *args
     end
 
-    def match(str)
-      if m = regex.match(str.strip)
-        variables.map {|v| m[v.name.to_s] }
+    def match str
+      if m = regex.match(to_args(str).join(SEP))
+        @parameters.map {|v| v.matches(m[v.name]) }
       end
     end
 
-    def variables
-      @variables ||= words.select {|w| w.kind_of? Variable}
-    end
-
     def expansions
-      expand words
+      expand @words
     end
 
     def usage
-      words.map do |word|
+      @words.map do |word|
         case word
-        when Variable
+        when Parameter
           "<#{word.name}>"
         else
           word
@@ -40,33 +47,42 @@ module Prompt
       end.join(" ")
     end
 
+    def clear_cached_values
+      @parameters.each do |p|
+        p.clear_cached_value if p.respond_to?(:clear_cached_value)
+      end
+    end
+
     private
 
+    # 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
+        end
+        ss.scan(/\s+/)
+      end
+      args
+    end
+
     def regex
       begin
-        regex_strs = words.map do |word|
+        regex_strs = @words.map do |word|
            case word
-           when Variable
+           when Parameter
              word.regex
            else
              Regexp.escape(word)
            end
         end
-        Regexp.new("^#{regex_strs.join("\s+")}$")
-      end
-    end
-
-    def words
-      @words ||= @name.split(/\s/).map do |word|
-         if word[0] == ":"
-           sym = word[1..-1].to_sym
-           @all_variables.find {|v| v.name == sym} || Variable.new(sym, sym.to_s)
-         elsif word[0] == "*"
-           sym = word[1..-1].to_sym
-           @all_variables.find {|v| v.name == sym} || GlobVariable.new(sym, sym.to_s)
-         else
-           word
-         end
+        Regexp.new("^#{regex_strs.join(SEP)}$")
       end
     end
 
@@ -77,7 +93,7 @@ module Prompt
       tail = a[1..-1]
 
       case head
-      when Variable
+      when Parameter
         head = head.expansions
       else
         head = [head]

data/lib/prompt/console/builtins.rb

@@ -8,12 +8,12 @@ module Prompt
 
       desc "Console commands"
 
-      command "help -v" do
-        print_help true
+      command "help", "List all commands" do
+        print_help
       end
 
-      command "help" do
-        print_help
+      command "help -v", "List all commands, including parameters" do
+        print_help true
       end
 
       command "exit" do
@@ -30,7 +30,7 @@ module Prompt
           cg.commands.each do |cmd|
             puts "  %-40s %s" % [cmd.usage, cmd.desc]
             if verbose
-              cmd.variables.each do |v|
+              cmd.parameters.each do |v|
                 puts " "*43 + ("%-10s %s" % ["<#{v.name}>", "#{v.desc}"])
               end
             end

data/lib/prompt/dsl.rb

@@ -1,6 +1,7 @@
-require 'prompt/variable'
-require 'prompt/proc_variable'
-require 'prompt/glob_variable'
+require 'prompt/parameter'
+require 'prompt/proc_parameter'
+require 'prompt/glob_parameter'
+require 'prompt/dsl_helper'
 
 module Prompt
   module DSL
@@ -19,19 +20,19 @@ module Prompt
     end
 
     def command(name, desc = nil, &block)
-      Prompt.application.define_command(name, desc, @variables || {}, &block)
+      words = DSLHelper.words(name, @parameters || [])
+      command = Command.new(words, desc, &block)
+      Prompt.application.add_command(command)
     end
 
-    def variable(name, desc, values = nil)
-      @variables = [] unless defined? @variables
-      raise "variable :#{name} is already defined" if @variables.find {|v| v.name == name}
-      @variables << Variable.new(name, desc, values)
-    end
-
-    def dynamic_variable(name, desc, &block)
-      @variables = [] unless defined? @variables
-      raise "variable :#{name} is already defined" if @variables.find {|v| v.name == name}
-      @variables << ProcVariable.new(name, desc, &block)
+    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)
+      else
+        @parameters << Parameter.new(name, desc, values)
+      end
     end
 
   end

data/lib/prompt/dsl_helper.rb

@@ -0,0 +1,25 @@
+module Prompt
+  module DSLHelper
+
+    # Split command into an array of Strings and Parameters
+    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
+      end
+    end
+
+  end
+end

data/lib/prompt/glob_parameter.rb

@@ -0,0 +1,17 @@
+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/{variable.rb → parameter.rb}

@@ -1,11 +1,11 @@
 module Prompt
-  class Variable
+  class Parameter
 
     attr :name
     attr :desc
     attr :values
 
-    def initialize(name, desc, values = nil)
+    def initialize(name, desc = nil, values = nil)
       @name = name
       @desc = desc
       @values = values
@@ -15,12 +15,22 @@ module Prompt
       if values
         "(?<#{name}>#{values.map{|v| Regexp.escape(v)}.join("|")})"
       else
-        "('(?<#{name}>[^\']*)'|\"(?<#{name}>[^\"]*)\"|(?<#{name}>[^\s]+))"
+        "(?<#{name}>([^#{Prompt::Command::SEP}]*))"
       end
     end
 
     def expansions
-      values || ["<#{name}>"]
+      if values
+        values.map do |v|
+          (v =~ /\s/) ?  "\"#{v}\"" : v
+        end
+      else
+        ["<#{name}>"]
+      end
+    end
+
+    def matches s
+      s
     end
 
   end

data/lib/prompt/{proc_variable.rb → proc_parameter.rb}

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

data/lib/prompt/prompt_module.rb

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

data/spec/prompt/command_spec.rb

@@ -1,6 +1,6 @@
 require 'prompt/command'
-require 'prompt/variable'
-require 'prompt/glob_variable'
+require 'prompt/parameter'
+require 'prompt/glob_parameter'
 
 include Prompt
 
@@ -10,119 +10,158 @@ describe Prompt::Command do
   SPEEDS = %w{quickly slowly}
 
   describe "#match" do
-    it "matches correctly" do
-      c = Command.new("hi")
 
-      c.match("hi").should == []
-      c.match("hi ").should == []
-      c.match(" hi").should == []
+    describe "hi" do
+
+      it "matches correctly" do
+        c = Command.new ["hi"]
+
+        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
+      end
 
-      c.match("bye").should be_nil
-      c.match("h").should be_nil
-      c.match("").should be_nil
     end
 
-    it "matches correctly with a variable" do
-      c = Command.new("hi :name")
+    describe "hi :name" do
 
-      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 == [""]
+      it "matches correctly" do
+        c = Command.new ["hi", Parameter.new(:name)]
 
-      c.match("hi '").should == ["'"]
-      c.match('hi "').should == ['"']
-      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 "some guy"').should == ["some guy"]
+        c.match('hi ""').should == [""]
 
-      c.match("higuy").should be_nil
-      c.match("higuy guy").should be_nil
-    end
+        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
 
-    it "matches correctly with a variable and multiple spaces" do
-      c = Command.new("hi :name")
+        c.match(" hi guy").should == ["guy"]
+        c.match("hi  guy").should == ["guy"]
+        c.match("hi guy ").should == ["guy"]
+      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
+      end
 
-      c.match(" hi guy").should == ["guy"]
-      c.match("hi  guy").should == ["guy"]
-      c.match("hi guy ").should == ["guy"]
     end
 
-    it "matches correctly with 2 variables" do
-      c = Command.new("hi :first :last")
+    describe "hi :first :last" do
+
+      it "matches correctly" do
+        c = Command.new ["hi", Parameter.new(:first), Parameter.new(:last)]
+
+        c.match("hi agent smith").should == ["agent", "smith"]
+        c.match("hi agent").should be_nil
+        c.match("hi agent smith guy").should be_nil
+      end
 
-      c.match("hi agent smith").should == ["agent", "smith"]
-      c.match("hi agent").should be_nil
-      c.match("hi agent smith guy").should be_nil
     end
 
-    it "matches correctly with variable value constraint" do
-      v = [Variable.new(:dir, "", DIRECTIONS)]
-      c = Command.new("go :dir", nil, v)
+    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"]]
+      end
 
-      c.match("go n").should == ["n"]
-      c.match("go s").should == ["s"]
-      c.match("go x").should be_nil
-      c.match("go nn").should be_nil
     end
 
-    it "matches correctly with glob variable" do
-      c = Command.new("say *stuff")
+    describe "say *stuff :adverb" do
+
+      it "matches correctly" do
+        c = Command.new ["say", GlobParameter.new(:stuff), Parameter.new(:adverb)]
+
+        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"]
+      end
 
-      c.match("say hello").should == ["hello"]
-      c.match("say hello world").should == ["hello world"]
     end
 
-    it "matches correctly with glob variable and other variable" do
-      c = Command.new("say *stuff :adverb")
+    describe "say *first *second" do
+
+      it "matches correctly" do
+        c = Command.new ["say", GlobParameter.new(:first), GlobParameter.new(: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"]]
+      end
 
-      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"]
     end
-  end
 
-  describe "#variables" do
+  end # describe "#match"
+
+  describe "#parameters" do
     it "returns correctly" do
-      color = Variable.new(:color, "")
-      flavor = Variable.new(:flavor, "")
-
-      Command.new("one").variables.should == []
-      vs = Command.new("one :color").variables
-      vs.length.should == 1
-      vs.first.name.should == :color
-      Command.new("one :color", nil, [color]).variables.should == [color]
-      Command.new("one :color", nil, [color, flavor]).variables.should == [color]
+      color = Parameter.new(:color, "")
+      flavor = GlobParameter.new(:flavor, "")
+
+      Command.new(["one"]).parameters.should == []
+      Command.new(["one", color]).parameters.should == [color]
+      Command.new(["one", color, flavor]).parameters == [color, flavor]
     end
   end
 
   describe "#expansions" do
-    it "expands correctly with no variables" do
-      Command.new("one").expansions.should == ["one"]
+    it "expands correctly with no parameters" do
+      Command.new(["one"]).expansions.should == ["one"]
     end
 
-    it "expands correctly with undefined variables" do
-      Command.new("go :dir").expansions.should == ["go <dir>"]
+    it "expands correctly with undefined parameters" do
+      Command.new(["go", Parameter.new(:dir)]).expansions.should == ["go <dir>"]
     end
 
-    it "expands correctly with defined variables" do
-      v = [Variable.new(:dir, "", DIRECTIONS), Variable.new(:speed, "", SPEEDS)]
-      Command.new("go :dir", nil, v).expansions.should == ["go n", "go e", "go s", "go w"]
-      Command.new("go :dir :speed", nil, v).expansions.should ==
+    it "expands correctly with defined parameters" do
+      dir = Parameter.new(:dir, "", 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"]
     end
+
+    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"']
+    end
   end
 
   describe "#usage" do
     it "returns correctly" do
-      color = Variable.new(:color, "")
+      color = Parameter.new(:color, "")
 
-      Command.new("one").usage.should == "one"
-      Command.new("one :color").usage.should == "one <color>"
-      Command.new("one :color", nil, [color]).usage.should == "one <color>"
-      Command.new("one :color three").usage.should == "one <color> three"
+      Command.new(["one"]).usage.should == "one"
+      Command.new(["one", color]).usage.should == "one <color>"
+      Command.new(["one", color, "three"]).usage.should == "one <color> three"
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prompt
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-17 00:00:00.000000000 Z
+date: 2012-02-23 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
@@ -19,6 +19,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- CHANGELOG.md
+- LICENSE.txt
 - lib/prompt/application.rb
 - lib/prompt/command.rb
 - lib/prompt/command_group.rb
@@ -27,10 +29,11 @@ files:
 - lib/prompt/console/console_module.rb
 - lib/prompt/console.rb
 - lib/prompt/dsl.rb
-- lib/prompt/glob_variable.rb
-- lib/prompt/proc_variable.rb
+- lib/prompt/dsl_helper.rb
+- lib/prompt/glob_parameter.rb
+- lib/prompt/parameter.rb
+- lib/prompt/proc_parameter.rb
 - lib/prompt/prompt_module.rb
-- lib/prompt/variable.rb
 - lib/prompt.rb
 - spec/prompt/command_spec.rb
 - examples/file_manager
@@ -55,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: A small framework that makes it easy to build slick command-line applications

data/lib/prompt/glob_variable.rb

@@ -1,14 +0,0 @@
-module Prompt
-  class GlobVariable < Variable
-
-    def initialize(name, desc, &block)
-      super(name, desc, nil)
-      @proc = block
-    end
-
-    def regex
-      "(?<#{name}>.+)"
-    end
-
-  end
-end