choosy 0.1.0 → 0.2.0

data/lib/choosy/printing/terminal.rb

@@ -0,0 +1,53 @@
+require 'choosy/errors'
+require 'choosy/printing/color'
+
+module Choosy::Printing
+  module Terminal
+    DEFAULT_LINE_COUNT = 25
+    DEFAULT_COLUMN_COUNT = 80
+
+    def lines
+      @lines ||= find_terminal_size('LINES', 'lines', 0) || DEFAULT_LINE_COUNT
+    end
+
+    def lines=(value)
+      @lines = value
+    end
+
+    def columns
+      @columns ||= find_terminal_size('COLUMNS', 'cols', 1) || DEFAULT_COLUMN_COUNT
+    end
+
+    def columns=(value)
+      @columns = value
+    end
+
+    def color
+      @color ||= Color.new
+    end
+
+    # directly from hirb
+    def command_exists?(command)
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? {|d| File.exists? File.join(d, command) }
+    end
+
+    private
+    # https://github.com/cldwalker/hirb
+    # modified from hirb
+    def find_terminal_size(env_name, tput_name, stty_index)
+      begin 
+        if ENV[env_name] =~ /^\d$/
+          ENV[env_name].to_i
+        elsif (RUBY_PLATFORM =~ /java/ || (!STDIN.tty? && ENV['TERM'])) && command_exists?('tput')
+          `tput #{tput_name}`.to_i
+        elsif STDIN.tty? && command_exists?('stty')
+          `stty size`.scan(/\d+/).map { |s| s.to_i }[stty_index]
+        else
+          nil
+        end
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/choosy/super_command.rb

@@ -6,7 +6,7 @@ require 'choosy/dsl/super_command_builder'
 
 module Choosy
   class SuperCommand < BaseCommand
-    attr_reader :command_builders
+    attr_accessor :metaname
 
     def command_builders
       @command_builders ||= {}
@@ -21,7 +21,7 @@ module Choosy
     end
 
     def parsimonious?
-      @parsimonous ||= false
+      @parsimonious ||= false
     end
 
     def execute!(args)
@@ -52,12 +52,12 @@ module Choosy
     def handle_help(hc)
       command_name = hc.message
 
-      if command_name.to_s == @name.to_s
-        printer.print!(self)
+      if command_name == Choosy::DSL::SuperCommandBuilder::SUPER
+        puts printer.print!(self)
       else
         builder = command_builders[command_name]
         if builder
-          printer.print!(builder.command)
+          puts printer.print!(builder.command)
         else
           $stdout << "#{@name}: #{format_help(command_name)}\n"
           exit 1
@@ -66,7 +66,7 @@ module Choosy
     end
 
     def format_help(command)
-      help = if command_builders[:help]
+      help = if command_builders[Choosy::DSL::SuperCommandBuilder::HELP]
                "See '#{@name} help'."
              else
                ""

data/lib/choosy/super_parser.rb

@@ -1,40 +1,50 @@
 require 'choosy/errors'
 require 'choosy/parser'
 require 'choosy/parse_result'
+require 'choosy/verifier'
+require 'choosy/dsl/super_command_builder'
 
 module Choosy
   class SuperParser
-    attr_reader :terminals
+    attr_reader :terminals, :verifier
 
-    def initialize(super_command, parsimonious=nil)
+    def initialize(super_command)
       @super_command = super_command
-      @parsimonious = parsimonious || false
+      @verifier = Verifier.new
       generate_terminals
     end
 
-    def parsimonious?
-      @parsimonious
-    end
-
     def parse!(args)
       result = parse_globals(args)
       unparsed = result.unparsed
 
       while unparsed.length > 0
         command_result = parse_command(unparsed, terminals)
-        command_result.options.merge!(result.options)
         result.subresults << command_result
         
         unparsed = command_result.unparsed
       end
 
+      result.subresults.each do |subresult|
+        if subresult.command.name == Choosy::DSL::SuperCommandBuilder::HELP
+          verifier.verify!(subresult)
+        end
+      end
+
+      verifier.verify!(result)
+
+      result.subresults.each do |subresult|
+        subresult.options.merge!(result.options)
+        verifier.verify!(subresult)
+      end
+
       result
     end
 
     private
     def generate_terminals
       @terminals = []
-      if parsimonious?
+      if @super_command.parsimonious?
         @super_command.commands.each do |c|
           @terminals << c.name.to_s
         end
@@ -43,14 +53,14 @@ module Choosy
 
     def parse_globals(args)
       result = SuperParseResult.new(@super_command)
-      parser = Parser.new(@super_command, true)
+      parser = Parser.new(@super_command, true, @terminals)
       parser.parse!(args, result)
-      result.verify!
+      verifier.verify_special!(result)
 
       # if we found a global action, we should have hit it by now...
       if result.unparsed.length == 0
-        if @super_command.command_builders[:help]
-          raise Choosy::HelpCalled.new(@super_command.name)
+        if @super_command.command_builders[Choosy::DSL::SuperCommandBuilder::HELP]
+          raise Choosy::HelpCalled.new(Choosy::DSL::SuperCommandBuilder::SUPER)
         else
           raise Choosy::SuperParseError.new("requires a command")
         end
@@ -72,9 +82,10 @@ module Choosy
 
       command = command_builder.command
       parser = Parser.new(command, false, terminals)
-      command_result = parser.parse!(args)
+      command_result = Choosy::ParseResult.new(command, true)
+      parser.parse!(args, command_result)
 
-      command_result.verify!
+      command_result
     end
   end
 end

data/lib/choosy/verifier.rb

@@ -3,29 +3,61 @@ require 'choosy/dsl/option_builder'
 
 module Choosy
   class Verifier
-    def verify_options!(result)
+    def verify!(result)
       result.command.options.each do |option|
         required?(option, result)
         populate!(option, result)
         convert!(option, result)
         validate!(option, result)
       end
+
+      verify_arguments!(result)
+    end
+
+    def verify_special!(result)
+      result.command.options.each do |option|
+        if special?(option)
+          validate!(option, result) 
+        end
+      end
     end
 
     def verify_arguments!(result)
-      if result.command.respond_to?(:argument_validation) && result.command.argument_validation
-        result.command.argument_validation.call(result.args)
+      if result.command.is_a?(Choosy::Command)
+        prefix = if result.subresult?
+                   "#{result.command.name}: "
+                 else
+                   ""
+                 end
+
+        if result.command.arguments
+          arguments = result.command.arguments
+
+          if result.args.length < arguments.arity.min
+            raise Choosy::ValidationError.new("#{prefix}too few arguments (minimum is #{arguments.arity.min})")
+          elsif result.args.length > arguments.arity.max
+            raise Choosy::ValidationError.new("#{prefix}too many arguments (max is #{arguments.arity.max}): '#{result.args[arguments.arity.max]}'")
+          end 
+
+          if arguments.validation_step
+            arguments.validation_step.call(result.args, result.options)
+          end
+        else
+          if result.args.length > 0
+            raise Choosy::ValidationError.new("#{prefix}no arguments allowed: #{result.args.join(' ')}")
+          end
+        end
       end
     end
 
     def required?(option, result)
       if option.required? && result[option.name].nil?
-        raise ValidationError.new("Required option '#{option.long_flag}' missing.")
+        raise ValidationError.new("required option missing: '#{option.long_flag}'")
       end
     end
     
     def populate!(option, result)
-      return if option.name == Choosy::DSL::OptionBuilder::HELP || option.name == Choosy::DSL::OptionBuilder::VERSION
+      return if special?(option)
 
       if !result.options.has_key?(option.name) # Not already set
         if !option.default_value.nil? # Has default?
@@ -47,10 +79,23 @@ module Choosy
       end
     end
 
+    def restricted?(option, result)
+      return unless option.restricted?
+      
+      value = result[option.name]
+      if option.arity.max > 1
+        value.each do |val|
+          check(option.allowable_values, val)
+        end
+      else
+        check(option.allowable_values, value)
+      end
+    end
+
     def validate!(option, result)
       value = result[option.name]
       if option.validation_step && exists?(value)
-        option.validation_step.call(value)
+        option.validation_step.call(value, result.options)
       end
     end
 
@@ -58,5 +103,15 @@ module Choosy
     def exists?(value)
       value && value != []
     end
+
+    def special?(option)
+      option.name == Choosy::DSL::OptionBuilder::HELP || option.name == Choosy::DSL::OptionBuilder::VERSION
+    end
+
+    def check(allowable, value)
+      if !allowable.include?(value)
+        raise ValidationError.new("unrecognized value (only #{allowable.map{|s| "'#{s}'"}.join(', ')} allowed): '#{value}'")
+      end
+    end
   end
 end

data/spec/choosy/base_command_spec.rb

@@ -3,9 +3,34 @@ require 'choosy/command'
 
 module Choosy
   describe BaseCommand do
+    before :each do
+      @cmd = Command.new :cmd
+    end
     it "should finalize the builder" do
-      cmd = Command.new :cmd
-      cmd.printer.should be_a(Choosy::Printing::HelpPrinter)
+      @cmd.printer.should be_a(Choosy::Printing::HelpPrinter)
     end 
+
+    it "should order the options in dependency order" do
+      @cmd.alter do
+        integer :count, "Count" do
+          depends_on :bold
+        end
+
+        boolean :bold, "Bold" do
+          depends_on :font, :config
+        end
+
+        symbol :font, "Font" do
+          depends_on :config
+        end
+
+        file :config, "The config"
+        file :access, "Access code" do
+          depends_on :config, :count
+        end
+      end
+
+      @cmd.options.map {|o| o.name}.should eql([:config, :font, :bold, :count, :access])
+    end
   end
 end

data/spec/choosy/command_spec.rb

@@ -5,13 +5,15 @@ require 'choosy/printing/help_printer'
 module Choosy
   describe Command do
     before :each do
-      @c = Command.new :foo
+      @c = Command.new :foo do
+        arguments
+      end
     end
 
     describe :parse! do
       it "should print out the version number" do
-        @c.alter do |c|
-          c.version "blah"
+        @c.alter do
+          version "blah"
         end
 
         o = capture :stdout do
@@ -24,16 +26,15 @@ module Choosy
       end
 
       it "should print out the help info" do
-        @c.alter do |c|
-          c.summary "Summary"
-          c.desc "this is a description"
-          c.help
+        @c.alter do
+          summary "Summary"
+          help
         end
 
         o = capture :stdout do
-          attempting {
+          #attempting {
             @c.parse!(['--help'])
-          }.should raise_error(SystemExit)
+          #}.should raise_error(SystemExit)
         end
 
         o.should match(/-h, --help/)
@@ -46,6 +47,27 @@ module Choosy
          @c.execute!(['a', 'b'])
         }.should raise_error(Choosy::ConfigurationError, /No executor/)
       end
+
+      it "should call an proc" do
+        p = nil
+        @c.executor = Proc.new {|args, options| p = args}
+        @c.execute!(['a', 'b'])
+        p.should eql(['a', 'b'])
+      end
+
+      class FakeExecutor
+        attr_reader :called
+        def execute!(args, options)
+          @called = args
+        end
+      end
+
+      it "should call an executor if given" do
+        exec = FakeExecutor.new
+        @c.executor = exec
+        @c.execute!(['a'])
+        exec.called.should eql(['a'])
+      end
     end
   end
 end

data/spec/choosy/dsl/argument_builder_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helpers'
+require 'choosy/dsl/argument_builder'
+
+module Choosy::DSL
+  describe ArgumentBuilder do
+    before :each do
+      @builder = ArgumentBuilder.new
+      @argument = @builder.argument
+    end
+
+    describe :required do
+      it "should set the argument" do
+        @builder.required
+        @argument.required?.should be(true)
+      end
+
+      it "should set the argument on non-nil/non-true" do
+        @builder.required 1
+        @argument.required?.should be(false)
+      end
+
+      it "should set the argument on false" do
+        @builder.required false
+        @argument.required?.should be(false)
+      end
+    end#required
+
+    describe :metaname do
+      it "should be able to set the name of the metaname" do
+        @builder.metaname 'PARAM'
+        @argument.metaname.should eql('PARAM')
+      end
+
+      it "should set the arity on STD+ to 1+" do
+        @builder.metaname 'STD+'
+        @argument.arity.should eql(1..1000)
+      end
+
+      it "should set the arity on STD to 1" do
+        @builder.metaname 'STD'
+        @argument.arity.should eql(1..1)
+      end
+    end#metaname
+
+    describe :count do
+      describe "when welformed" do
+        it "should set :at_least the right arity" do
+          @builder.count :at_least => 32
+          @argument.arity.should eql(32..1000)
+        end
+
+        it "should set :at_most the right arity" do
+          @builder.count :at_most => 31
+          @argument.arity.should eql(1..31)
+        end
+
+        it "should set :once to the right arity" do
+          @builder.count :once
+          @argument.arity.should eql(1..1)
+        end
+
+        it "should set :zero to the right arity" do
+          @builder.count :zero
+          @argument.arity.should eql(0..0)
+        end
+
+        it "should set :none to the right arity" do
+          @builder.count :none
+          @argument.arity.should eql(0..0)
+        end
+
+        it "should set a number exactly" do
+          @builder.count 3
+          @argument.arity.should eql(3..3)
+        end
+
+        it "should allow for a range" do
+          @builder.count 1..2
+          @argument.arity.should eql(1..2)
+        end
+      end
+
+      describe "when malformed" do
+        it "should fail when the :exactly isn't a number" do
+          attempting {
+            @builder.count :exactly => 'p'
+          }.should raise_error(Choosy::ConfigurationError, /number/)
+        end
+
+        it "should fail when the :at_most isn't a number" do
+          attempting {
+            @builder.count :at_most => 'p'
+          }.should raise_error(Choosy::ConfigurationError, /number/)
+        end
+
+        it "should fail when the :at_least isn't a number" do
+          attempting {
+            @builder.count :at_least => 'p'
+          }.should raise_error(Choosy::ConfigurationError, /number/)
+        end
+
+        it "should fail when the :count isn't a number" do
+          attempting {
+            @builder.count 'p'
+          }.should raise_error(Choosy::ConfigurationError, /number/)
+        end
+
+        it "should fail when the :at_least is greater than :at_most" do
+          attempting {
+            @builder.count :at_least => 3, :at_most => 2
+          }.should raise_error(Choosy::ConfigurationError, /lower bound/)
+        end
+      end
+    end#count
+
+    describe :cast do
+      it "should allow symbol casts" do
+        @builder.cast :int
+        @argument.cast_to.should eql(:integer)
+      end
+  
+      class CustomConverter
+        def convert(value)
+        end
+      end
+
+      it "should allow for custom conversions" do
+        conv = CustomConverter.new
+        @builder.cast conv
+        @argument.cast_to.should be(conv)
+      end
+
+      it "should fail if it doesn't know about a Type" do
+        attempting {
+          @builder.cast Choosy::Error
+        }.should raise_error(Choosy::ConfigurationError, /Unknown conversion/)
+      end
+
+      it "should fail if it doesn't know about a symbol" do
+        attempting {
+          @builder.cast :unknown_type
+        }.should raise_error(Choosy::ConfigurationError, /Unknown conversion/)
+      end
+    end#cast
+
+    describe :die do
+      it "should fail with a specific error" do
+        attempting {
+          @builder.die("Malformed argument")
+        }.should raise_error(Choosy::ValidationError, /argument error: Malformed/)
+      end
+    end
+
+    describe :validate do
+      it "should save the context of the validation in a Proc to call later" do
+        @builder.validate do
+          puts "Hi!"
+        end
+        @argument.validation_step.should be_a(Proc)
+      end
+      
+      it "should have access to the larger context when called" do
+        value = nil
+        @builder.validate do
+          value = 'here'
+        end
+        @argument.validation_step.call
+        value.should eql('here')
+      end
+    end#validate
+
+    describe :finalize! do
+      it "should set the arity if not already set" do
+        @builder.finalize!
+        @argument.arity.should eql(0..0)
+      end
+    end#finalize!
+  end
+end
+