configliere 0.3.4 → 0.4.4

data/lib/configliere/prompt.rb

@@ -0,0 +1,23 @@
+# Settings.use :prompt
+# you must install the highline gem
+
+require 'highline/import'
+module Configliere
+  #
+  # Method to prompt for
+  #
+  module Prompt
+
+    # Retrieve the given param, or prompt for it
+    def prompt_for attr, hint=nil
+      return self[attr] if has_key?(attr)
+      hint ||= definition_of(attr, :description)
+      hint   = " (#{hint})" if hint
+      self[attr] = ask("#{attr}#{hint}? ")
+    end
+  end
+
+  Param.on_use(:prompt) do
+    extend Configliere::Prompt
+  end
+end

data/spec/configliere/commandline_spec.rb

@@ -1,116 +1,215 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-Configliere.use :commandline
 
 describe "Configliere::Commandline" do
-
+  before do
+    @config = Configliere::Param.new :date => '11-05-1955', :cat => :hat
+    @config.use :commandline
+  end
   after do
     ::ARGV.replace []
   end
-  
-  describe "processing long-format flags" do
-    before do
-      @config = Configliere::Param.new :param_1 => 'val 1', :cat => :hat
-    end
 
-    it 'should handle --param=val pairs' do
-      ::ARGV.replace ['--my_param=my_val']
+  describe "with long-format argvs" do
+    it 'accepts --param=val pairs' do
+      ::ARGV.replace ['--enchantment=under_sea']
       @config.resolve!
-      @config.should == { :my_param => 'my_val', :param_1 => 'val 1', :cat => :hat}
+      @config.should == { :enchantment => 'under_sea', :date => '11-05-1955', :cat => :hat}
     end
-    it 'should handle --dotted.param.name=val pairs' do
+    it 'accepts --dotted.param.name=val pairs as deep keys' do
       ::ARGV.replace ['--dotted.param.name=my_val']
       @config.resolve!
       @config.rest.should be_empty
-      @config.should == { :dotted => { :param => { :name => 'my_val' }}, :param_1 => 'val 1', :cat => :hat}
+      @config.should == { :dotted => { :param => { :name => 'my_val' }}, :date => '11-05-1955', :cat => :hat }
     end
-    it 'should handle --dashed-param-name=val pairs' do
+    it 'NO LONGER accepts --dashed-param-name=val pairs as deep keys' do
       ::ARGV.replace ['--dashed-param-name=my_val']
+      @config.should_receive(:warn).with("Configliere uses _underscores not dashes for params")
       @config.resolve!
       @config.rest.should be_empty
-      @config.should == { :dashed => { :param => { :name => 'my_val' }}, :param_1 => 'val 1', :cat => :hat}
+      @config.should == { :'dashed-param-name' => 'my_val', :date => '11-05-1955', :cat => :hat }
     end
-    it 'should handle the last-seen of the commandline values' do
-      ::ARGV.replace ['--param_1=A', '--param_1=B']
+    it 'adopts only the last-seen of duplicate commandline flags' do
+      ::ARGV.replace ['--date=A', '--date=B']
       @config.resolve!
       @config.rest.should be_empty
-      @config.should == { :param_1 => 'B', :cat => :hat}
+      @config.should == { :date => 'B', :cat => :hat}
+    end
+    it 'does NOT set a bare parameter (no "=") followed by a non-param to that value' do
+      ::ARGV.replace ['--date', '11-05-1985', '--heavy', '--power.source', 'household waste', 'go']
+      @config.resolve!
+      @config.rest.should == ['11-05-1985', 'household waste', 'go']
+      @config.should == { :date => true, :heavy => true, :power => { :source => true }, :cat => :hat }
     end
-    it 'should set a bare parameter (no "=") to true' do
-      ::ARGV.replace ['--param_1', '--deep.param']
+    it 'sets a bare parameter (no "=") to true' do
+      ::ARGV.replace ['--date', '--deep.param']
       @config.resolve!
       @config.rest.should be_empty
-      @config.should == { :param_1 => true, :deep => { :param => true }, :cat => :hat}
+      @config.should == { :date => true, :deep => { :param => true }, :cat => :hat}
     end
-    it 'should set an explicit blank to nil' do
-      ::ARGV.replace ['--param_1=', '--deep.param=']
+    it 'sets an explicit blank to nil' do
+      ::ARGV.replace ['--date=', '--deep.param=']
       @config.resolve!
-      @config.should == { :param_1 => nil, :deep => { :param => nil }, :cat => :hat}
+      @config.should == { :date => nil, :deep => { :param => nil }, :cat => :hat}
     end
 
-    it 'should save non --param args into rest' do
-      ::ARGV.replace ['--param_1', 'file1', 'file2']
+    it 'captures non --param args into Settings.rest' do
+      ::ARGV.replace ['--date', 'file1', 'file2']
       @config.resolve!
-      @config.should == { :param_1 => true, :cat => :hat}
+      @config.should == { :date => true, :cat => :hat}
       @config.rest.should == ['file1', 'file2']
     end
 
-    it 'should stop processing on "--"' do
-      ::ARGV.replace ['--param_1=A', '--', '--param_1=B']
+    it 'stops processing args on "--"' do
+      ::ARGV.replace ['--date=A', '--', '--date=B']
       @config.resolve!
-      @config.rest.should == ['--param_1=B']
-      @config.should == { :param_1 => 'A', :cat => :hat}
+      @config.rest.should == ['--date=B']
+      @config.should == { :date => 'A', :cat => :hat}
     end
-  end
 
-  describe "processing single-letter flags" do
+    it 'places undefined argvs into #unknown_argvs' do
+      @config.define :raven, :description => 'squawk'
+      ::ARGV.replace ['--never=more', '--lenore', '--raven=ray_lewis']
+      @config.resolve!
+      @config.unknown_argvs.should == [:never, :lenore]
+      @config.should == { :date => '11-05-1955', :cat => :hat, :never => 'more', :lenore => true, :raven => 'ray_lewis' }
+    end
+  end
 
+  describe "with single-letter flags" do
     before do
-      @config = Configliere::Param.new :param_1 => 'val 1', :cat => nil, :foo => nil
-      @config.param_definitions = { :param_1 => { :flag => :p }, :cat =>  { :flag => 'c' } }
+      @config.define :date,    :flag => :d
+      @config.define :cat,     :flag => 'c'
+      @config.define :process, :flag => :p
     end
 
-    it 'should parse flags given separately' do
+    it 'accepts them separately' do
       ::ARGV.replace ['-p', '-c']
       @config.resolve!
       @config.rest.should == []
-      @config.should == { :param_1 => true, :cat => true, :foo => nil}
+      @config.should == { :date => '11-05-1955', :cat => true, :process => true}
     end
 
-    it 'should parse flags given together' do
+    it 'accepts them as a group ("-abc")' do
       ::ARGV.replace ['-pc']
       @config.resolve!
       @config.rest.should == []
-      @config.should == { :param_1 => true, :cat => true, :foo => nil}
+      @config.should == { :date => '11-05-1955', :cat => true, :process => true}
     end
 
-    # it 'should parse a single-letter flag with a value' do
-    #   ::ARGV.replace ['-p=new_val', '-c']
-    #   @config.resolve!
-    #   @config.rest.should == []
-    #   @config.should == { :param_1 => 'new_val', :cat => true, :foo => nil }
-    # end
+    it 'accepts a value with -d=new_val' do
+      ::ARGV.replace ['-d=new_val', '-c']
+      @config.resolve!
+      @config.rest.should == []
+      @config.should == { :date => 'new_val', :cat => true }
+    end
 
-    it 'should not complain about bad single-letter flags by default' do
-      ::ARGV.replace ['-pcz']
+    it 'accepts a space-separated value (-d new_val)' do
+      ::ARGV.replace ['-d', 'new_val', '-c', '-p']
       @config.resolve!
       @config.rest.should == []
-      @config.should == { :param_1 => true, :cat => true, :foo => nil}
+      @config.should == { :date => 'new_val', :cat => true, :process => true }
+    end
+
+    it 'accepts a space-separated value only if the next arg is not a flag' do
+      ::ARGV.replace ['-d', 'new_val', '-c', '-p', 'vigorously']
+      @config.resolve!
+      @config.rest.should == []
+      @config.should == { :date => 'new_val', :cat => true, :process => 'vigorously' }
+    end
+
+    it 'stores unknown single-letter flags in unknown_argvs' do
+      ::ARGV.replace ['-dcz']
+      lambda{ @config.resolve! }.should_not raise_error(Configliere::Error)
+      @config.should == { :date => true, :cat => true }
+      @config.unknown_argvs.should == ['z']
     end
+  end
 
-    it 'should raise an error about bad single-letter flags if asked' do
-      ::ARGV.replace ['-pcz']
-      @config.complain_about_bad_flags!
-      lambda { @config.resolve! }.should raise_error(Configliere::Error)
+  def capture_help_message
+    stderr_output = ''
+    @config.should_receive(:warn){|str| stderr_output << str }
+    begin
+      yield
+      fail('should exit via system exit')
+    rescue SystemExit
+      true # pass
     end
-    
+    stderr_output
   end
 
-  describe "constructing help messages" do
-    it "should not display a help message about environment variables if no environment variables exist with documentation" do
-      @config = Configliere::Param.new :param_1 => 'val 1', :cat => :hat
-      @config.env_var_help.should be_nil
+  describe "the help message" do
+    it 'displays help' do
+      ::ARGV.replace ['--help']
+      stderr_output = capture_help_message{ @config.resolve! }
+      stderr_output.should_not be_nil
+      stderr_output.should_not be_empty
+
+      @config.help.should_not be_nil
+      @config.help.should_not be_empty
+    end
+
+    it "displays the single-letter flags" do
+      @config.define :cat, :flag => :c, :description => "I like single-letter commands."
+      ::ARGV.replace ['--help']
+      stderr_output = capture_help_message{ @config.resolve! }
+      stderr_output.should match(/-c,/m)
+    end
+
+    it "displays command line options" do
+      ::ARGV.replace ['--help']
+
+      @config.define :logfile, :type => String,     :description => "Log file name", :default => 'myapp.log', :required => false
+      @config.define :debug, :type => :boolean,     :description => "Log debug messages to console?", :required => false
+      @config.define :dest_time, :type => DateTime, :description => "Arrival time", :required => true
+      @config.define :takes_opt, :flag => 't',      :description => "Takes a single-letter flag '-t'"
+      @config.define :foobaz, :internal => true,    :description => "You won't see me"
+      @config.define 'delorean.power_source', :env_var => 'POWER_SOURCE', :description => 'Delorean subsytem supplying power to the Flux Capacitor.'
+      @config.define :password, :required => true, :encrypted => true
+      @config.description = 'This is a sample script to demonstrate the help message. Notice how pretty everything lines up YAY'
+
+      stderr_output = capture_help_message{ @config.resolve! }
+      stderr_output.should_not be_nil
+      stderr_output.should_not be_empty
+
+      stderr_output.should =~ %r{--debug\s}s                                 # type :boolean
+      stderr_output.should =~ %r{--logfile=String\s}s                        # type String
+      stderr_output.should =~ %r{--dest_time=DateTime[^\n]+\[Required\]}s    # shows required params
+      stderr_output.should =~ %r{--password=String[^\n]+\[Encrypted\]}s      # shows encrypted params
+      stderr_output.should =~ %r{--delorean.power_source=String\s}s          # undefined type
+      stderr_output.should =~ %r{--password=String\s*password}s              # uses name as dummy description
+      stderr_output.should =~ %r{-t, --takes_opt}s                           # single-letter flags
+
+      stderr_output.should =~ %r{delorean\.power_source[^\n]+Env Var: POWER_SOURCE}s    # environment variable
+      stderr_output.should =~ %r{This is a sample script}s                         # extra description
+    end
+
+    it 'lets me die' do
+      stderr_output = ''
+      @config.should_receive(:dump_help).with("****\nhi mom\n****")
+      @config.should_receive(:exit).with(3)
+      @config.die("hi mom", 3)
+    end
+  end
+
+  describe 'recycling a commandline' do
+    it 'exports dashed flags' do
+      @config.define :has_underbar, :type => Integer,  :default => 1
+      @config.define :not_here,     :type => Integer
+      @config.define :is_truthy,    :type => :boolean, :default => true
+      @config.define :is_falsehood, :type => :boolean, :default => false
+      @config.dashed_flags(:has_underbar, :not_here, :is_truthy, :is_falsehood, :date, :cat
+        ).should == ["--has-underbar=1", "--is-truthy", "--date=11-05-1955", "--cat=hat"]
     end
   end
-  
+
+  describe '#resolve!' do
+    it 'calls super and returns self' do
+      Configliere::ParamParent.class_eval do def resolve!() dummy ; end ; end
+      @config.should_receive(:dummy)
+      @config.resolve!.should equal(@config)
+      Configliere::ParamParent.class_eval do def resolve!() self ; end ; end
+    end
+  end
+
 end
 

data/spec/configliere/commands_spec.rb

@@ -1,64 +1,65 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-Configliere.use :commands
 
 describe "Configliere::Commands" do
+  before do
+    @config = Configliere::Param.new
+    @config.use :commands
+  end
 
   after do
     ::ARGV.replace []
   end
 
   describe "when no commands are defined" do
-    before do
-      @config = Configliere::Param.new
-    end
-
     it "should know that no commands are defined" do
-      @config.commands?.should be_false
+      @config.commands.should be_empty
     end
 
     it "should not shift the ARGV when resolving" do
       ::ARGV.replace ['not_command_but_arg', 'another_arg']
       @config.resolve!
       @config.rest.should == ['not_command_but_arg', 'another_arg']
-      @config.command.should be_nil
+      @config.command_name.should be_nil
+      @config.command_info.should be_nil
     end
 
-    it "should still recognize a git-style binary command" do
+    it "should still recognize a git-style-binary command" do
       ::ARGV.replace ['not_command_but_arg', 'another_arg']
       File.should_receive(:basename).and_return('prog-subcommand')
       @config.resolve!
       @config.rest.should == ['not_command_but_arg', 'another_arg']
-      @config.command_name.should == 'subcommand'
-      @config.command.should be_nil
+      @config.command_name.should == :subcommand
+      @config.command_info.should be_nil
     end
   end
-  
+
   describe "a simple command" do
     before do
-      @config = Configliere::Param.new :param => 'val 1' 
-      @config.define_command "the_command", :description => "foobar"
+      @config.defaults :fuzziness => 'smooth'
+      @config.define_command :the_command, :description => "foobar"
     end
 
     it "should continue to parse flags when the command is given" do
-      ::ARGV.replace ['the_command', '--param=wuzz', 'an_arg']
+      ::ARGV.replace ['the_command', '--fuzziness=wuzzy', 'an_arg']
       @config.resolve!
-      @config.should == { :param => 'wuzz' }
+      @config.should == { :fuzziness => 'wuzzy' }
     end
 
     it "should continue to set args when the command is given" do
-      ::ARGV.replace ['the_command', '--param=wuzz', 'an_arg']
+      ::ARGV.replace ['the_command', '--fuzziness=wuzzy', 'an_arg']
       @config.resolve!
       @config.rest.should == ['an_arg']
     end
-    
+
     it "should recognize the command when given" do
-      ::ARGV.replace ['the_command', '--param=wuzz', 'an_arg']
+      ::ARGV.replace ['the_command', '--fuzziness=wuzzy', 'an_arg']
       @config.resolve!
-      @config.command_name.should == 'the_command'
+      @config.command_name.should == :the_command
+      @config.command_info.should == { :description => "foobar", :config => { :fuzziness => 'wuzzy' } }
     end
 
     it "should recognize when the command is not given" do
-      ::ARGV.replace ['bogus_command', '--param=wuzz', 'an_arg']
+      ::ARGV.replace ['bogus_command', '--fuzziness=wuzzy', 'an_arg']
       @config.resolve!
       @config.rest.should == ['bogus_command', 'an_arg']
       @config.command_name.should be_nil
@@ -67,27 +68,71 @@ describe "Configliere::Commands" do
 
   describe "a complex command" do
     before do
-      @config = Configliere::Param.new :outer_param => 'val 1' 
-      @config.define_command "the_command", :description => "the command" do |command|
-        command.define :inner_param, :description => "inside"
+      @config.defaults :outer => 'val 1'
+      @config.define_command "the_command", :description => "the command" do |cmd|
+        cmd.define :inner, :description => "inside"
       end
     end
 
     it "should still recognize the outer param and the args" do
-      ::ARGV.replace ['the_command', '--outer_param=wuzz', 'an_arg', '--inner_param=buzz']
+      ::ARGV.replace ['the_command', '--outer=wuzzy', 'an_arg', '--inner=buzz']
       @config.resolve!
       @config.rest.should == ['an_arg']
-      @config.command_name.should == 'the_command'
-      @config[:outer_param].should == 'wuzz'
+      @config.command_name.should == :the_command
+      @config[:outer].should == 'wuzzy'
     end
 
     it "should recognize the inner param" do
-      ::ARGV.replace ['the_command', '--outer_param=wuzz', 'an_arg', '--inner_param=buzz']
+      ::ARGV.replace ['the_command', '--outer=wuzzy', 'an_arg', '--inner=buzz']
       @config.resolve!
-      @config[:inner_param].should == 'buzz'
-      @config.command[:config][:inner_param].should == 'buzz'
+      @config[:inner].should == 'buzz'
+      @config.command_info[:config][:inner].should == 'buzz'
+    end
+  end
+
+
+  def capture_help_message
+    stderr_output = ''
+    @config.should_receive(:warn){|str| stderr_output << str }
+    begin
+      yield
+      fail('should exit via system exit')
+    rescue SystemExit
+      true # pass
+    end
+    stderr_output
+  end
+
+  describe "the help message" do
+    before do
+      @config.define_command :run, :description => "forrest"
+      @config.define_command :stop, :description => "hammertime"
+      @config.define :reel, :type => Integer
+    end
+
+    it "displays a modified usage" do
+      ::ARGV.replace ['--help']
+      stderr_output = capture_help_message{ @config.resolve! }
+      stderr_output.should =~ %r{usage:.*\[command\]}m
+    end
+
+    it "displays the commands and their descriptions" do
+      ::ARGV.replace ['--help']
+      stderr_output = capture_help_message{ @config.resolve! }
+      stderr_output.should =~ %r{Available commands:\s+run\s*forrest\s+stop\s+hammertime}m
+      stderr_output.should =~ %r{Params:.*--reel=Integer\s+reel}m
+    end
+  end
+
+
+  describe '#resolve!' do
+    it 'calls super and returns self' do
+      Configliere::ParamParent.class_eval do def resolve!() dummy ; end ; end
+      @config.should_receive(:dummy)
+      @config.resolve!.should equal(@config)
+      Configliere::ParamParent.class_eval do def resolve!() self ; end ; end
     end
-    
   end
+
 end