choosy 0.1.0 → 0.2.0

data/lib/choosy/base_command.rb

@@ -1,27 +1,42 @@
 require 'choosy/errors'
+require 'tsort'
 
 module Choosy
+  class OptionBuilderHash < Hash
+    include TSort
+    alias tsort_each_node each_key
+
+    def tsort_each_child(node, &block)
+      deps = fetch(node).option.dependent_options
+      deps.each(&block) unless deps.nil?
+    end
+  end
+
   class BaseCommand
-    attr_accessor :name, :summary, :description, :printer
+    attr_accessor :name, :summary, :printer
     attr_reader :builder, :listing, :option_builders
     
-    def initialize(name)
+    def initialize(name, &block)
       @name = name
       @listing = []
-      @option_builders = {}
+      @option_builders = OptionBuilderHash.new
 
       @builder = create_builder
-      yield @builder if block_given?
+      if block_given?
+        @builder.instance_eval(&block)
+      end
       @builder.finalize!
     end
 
     def alter(&block)
-      yield @builder if block_given?
+      if block_given?
+        @builder.instance_eval(&block)
+      end
       @builder.finalize!
     end
 
     def options
-      @option_builders.values.map {|b| b.option}
+      @option_builders.tsort.map {|key| @option_builders[key].option }
     end
 
     def parse!(args, propagate=false)
@@ -30,7 +45,7 @@ module Choosy
       else
         begin
           return parse(args)
-        rescue Choosy::ValidationError, Choosy::ConversionError, Choosy::ParseError => e
+        rescue Choosy::ValidationError, Choosy::ConversionError, Choosy::ParseError, Choosy::SuperParseError => e
           $stderr << "#{@name}: #{e.message}\n"
           exit 1
         rescue Choosy::HelpCalled => e

data/lib/choosy/command.rb

@@ -6,12 +6,16 @@ require 'choosy/verifier'
 
 module Choosy
   class Command < BaseCommand
-    attr_accessor :executor, :argument_validation
+    attr_accessor :executor, :arguments
     
     def execute!(args)
       raise Choosy::ConfigurationError.new("No executor given for: #{name}") unless executor
       result = parse!(args)
-      executor.call(result.options, result.args)
+      if executor.is_a?(Proc)
+        executor.call(result.args, result.options)
+      else
+        executor.execute!(result.args, result.options)
+      end
     end
 
     protected
@@ -20,13 +24,17 @@ module Choosy
     end
 
     def handle_help(hc)
-      printer.print!(self)
+      puts printer.print!(self)
     end
 
     def parse(args)
       parser = Parser.new(self)
       result = parser.parse!(args)
-      result.verify!
+
+      verifier = Verifier.new
+      verifier.verify!(result)
+    
+      result
     end
   end
 end

data/lib/choosy/dsl/argument_builder.rb

@@ -0,0 +1,88 @@
+require 'choosy/errors'
+require 'choosy/argument'
+require 'choosy/converter'
+
+module Choosy::DSL
+  class ArgumentBuilder
+    def initialize
+      @count_called = false
+    end
+
+    def argument
+      @argument ||= Choosy::Argument.new
+    end
+    
+    def required(value=nil)
+      argument.required = if value.nil? || value == true
+                          true
+                        else 
+                          false
+                        end
+    end
+
+    def metaname(meta)
+      return if meta.nil?
+      argument.metaname = meta
+      return if @count_called
+      
+      if meta =~ /\+$/
+        argument.multiple!
+      else
+        argument.single!
+      end
+    end
+
+    def count(restriction)
+      @count_called = true
+      if restriction.is_a?(Hash)
+        lower_bound = restriction[:at_least] || restriction[:exactly] || 1
+        upper_bound = restriction[:at_most] || restriction[:exactly] || 1000
+
+        check_count(lower_bound)
+        check_count(upper_bound)
+        if lower_bound > upper_bound
+          raise Choosy::ConfigurationError.new("The upper bound (#{upper_bound}) is less than the lower bound (#{lower_bound}).")
+        end
+        
+        argument.arity = (lower_bound .. upper_bound)
+      elsif restriction.is_a?(Range)
+        argument.arity = restriction
+      elsif restriction == :zero || restriction == :none
+        argument.boolean!
+      elsif restriction == :once
+        argument.single!
+      else
+        check_count(restriction)
+        argument.arity = (restriction .. restriction)
+      end
+    end
+
+    def cast(ty)
+      argument.cast_to = Choosy::Converter.for(ty)
+      if argument.cast_to.nil?
+        raise Choosy::ConfigurationError.new("Unknown conversion cast: #{ty}")
+      end
+    end
+    
+    def validate(&block)
+      argument.validation_step = block
+    end
+    
+    def die(msg)
+      raise Choosy::ValidationError.new("argument error: #{msg}")
+    end
+
+    def finalize!
+      if argument.arity.nil?
+        argument.boolean!
+      end
+    end
+
+    protected
+    def check_count(count)
+      if !count.is_a?(Integer)
+        raise Choosy::ConfigurationError.new("Expected a number to count, got '#{count}'")
+      end
+    end
+  end
+end

data/lib/choosy/dsl/base_command_builder.rb

@@ -1,6 +1,7 @@
 require 'choosy/errors'
 require 'choosy/dsl/option_builder'
 require 'choosy/printing/erb_printer'
+require 'choosy/printing/formatting_element'
 
 module Choosy::DSL
   class BaseCommandBuilder
@@ -10,46 +11,37 @@ module Choosy::DSL
       @command = command
     end
 
+    # Generic setup
+
     def summary(msg)
       @command.summary = msg
     end
 
-    def printer(kind, options=nil)
-      return if kind.nil?
-
-      p = nil
-      if kind == :standard
-        p = Choosy::Printing::HelpPrinter.new
-      elsif kind == :erb
-        p = Choosy::Printing::ERBPrinter.new
-        if options.nil? || options[:template].nil?
-          raise Choosy::ConfigurationError.new("no template file given to ERBPrinter")
-        elsif !File.exist?(options[:template])
-          raise Choosy::ConfigurationError.new("the template file doesn't exist: #{options[:template]}")
-        end
-        p.template = options[:template]
-      elsif kind.respond_to?(:print!)
-        p = kind
-      else
-        raise Choosy::ConfigurationError.new("Unknown printing method for help: #{kind}")
-      end
+    def printer(kind, options={})
+      @command.printer =  if kind == :standard
+                            Choosy::Printing::HelpPrinter.new(options)
+                          elsif kind == :erb
+                            Choosy::Printing::ERBPrinter.new(options)
+                          elsif kind.respond_to?(:print!)
+                            kind
+                          else
+                            raise Choosy::ConfigurationError.new("Unknown printing method for help: #{kind}")
+                          end
+    end
 
-      if p.respond_to?(:color) && options && options.has_key?(:color)
-        p.color.disable! if !options[:color]
-      end
+    # Formatting
 
-      @command.printer = p
+    def header(msg, *styles)
+      @command.listing << Choosy::Printing::FormattingElement.new(:header, msg, styles)
     end
 
-    def desc(msg)
-      @command.description = msg
+    def para(msg=nil, *styles)
+      @command.listing << Choosy::Printing::FormattingElement.new(:para, msg, styles)
     end
 
-    def separator(msg=nil)
-      @command.listing << (msg.nil? ? "" : msg)
-    end
+    # Options
 
-    def option(arg)
+    def option(arg, &block)
       raise Choosy::ConfigurationError.new("The option name was nil") if arg.nil?
       
       builder = nil
@@ -61,7 +53,7 @@ module Choosy::DSL
 
         to_process = arg[name]
         if to_process.is_a?(Array)
-          builder.dependencies to_process
+          builder.depends_on to_process
         elsif to_process.is_a?(Hash)
           builder.from_hash to_process
         else
@@ -72,33 +64,33 @@ module Choosy::DSL
         raise Choosy::ConfigurationError.new("No configuration block was given") if !block_given?
       end
 
-      yield builder if block_given?
+      if block_given?
+        builder.instance_eval(&block)
+      end
       finalize_option_builder builder
     end
 
-    # Option types
     def self.create_conversions
       Choosy::Converter::CONVERSIONS.keys.each do |method|
         next if method == :boolean || method == :bool
 
-        define_method method do |sym, desc, config=nil, &block|
-          simple_option(sym, desc, true, :one, method, config, &block)
-        end
+        self.class_eval <<-EOF
+          def #{method}(sym, desc, config=nil, &block)
+            simple_option(sym, desc, true, :one, :#{method}, nil, config, &block)
+          end
 
-        plural = "#{method}s".to_sym
-        define_method plural do |sym, desc, config=nil, &block|
-          simple_option(sym, desc, true, :many, method, config, &block)
-        end
+          def #{method}s(sym, desc, config=nil, &block)
+            simple_option(sym, desc, true, :many, :#{method}, nil, config, &block)
+          end
 
-        underscore = "#{method}_"
-        define_method underscore do |sym, desc, config=nil, &block|
-          simple_option(sym, desc, false, :one, method, config, &block)
-        end
+          def #{method}_(sym, desc, config=nil, &block)
+            simple_option(sym, desc, false, :one, :#{method}, nil, config, &block)
+          end
 
-        plural_underscore = "#{plural}_".to_sym
-        define_method plural_underscore do |sym, desc, config=nil, &block|
-          simple_option(sym, desc, false, :many, method, config, &block)
-        end
+          def #{method}s_(sym, desc, config=nil, &block)
+            simple_option(sym, desc, false, :many, :#{method}, nil, config, &block)
+          end
+        EOF
       end
     end
 
@@ -110,15 +102,24 @@ module Choosy::DSL
     alias :multiple_ :strings_
 
     def boolean(sym, desc, config=nil, &block)
-      simple_option(sym, desc, true, :zero, :boolean, config, &block)
+      simple_option(sym, desc, true, :zero, :boolean, nil, config, &block)
     end
     def boolean_(sym, desc, config=nil, &block)
-      simple_option(sym, desc, false, :zero, :boolean, config, &block)
+      simple_option(sym, desc, false, :zero, :boolean, nil, config, &block)
     end
     alias :bool :boolean
     alias :bool_ :boolean_
 
-    def version(msg)
+    def enum(sym, allowed, desc, config=nil, &block)
+      simple_option(sym, desc, true, :one, :symbol, allowed, config, &block)
+    end
+
+    def enum_(sym, allowed, desc, config=nil, &block)
+      simple_option(sym, desc, false, :one, :symbol, allowed, config, &block)
+    end
+    # Additional helpers
+
+    def version(msg, &block)
       v = OptionBuilder.new(OptionBuilder::VERSION)
       v.long '--version'
       v.desc "The version number"
@@ -127,7 +128,9 @@ module Choosy::DSL
         raise Choosy::VersionCalled.new(msg)
       end
 
-      yield v if block_given?
+      if block_given?
+        v.instance_eval(&block)
+      end
       finalize_option_builder v
     end
 
@@ -147,21 +150,33 @@ module Choosy::DSL
     end
 
     private
-    def simple_option(sym, desc, allow_short, param, cast, config, &block)
+    def simple_option(sym, desc, allow_short, meta, cast, allowed, config, &block)
       name = sym.to_s
       builder = OptionBuilder.new sym
       builder.desc desc
-      builder.short "-#{name[0]}" if allow_short
+      short = case name[0]
+              when Fixnum
+                name[0].chr
+              else
+                name[0]
+              end
+
+      builder.short "-#{short}" if allow_short
       builder.long "--#{name.downcase.gsub(/_/, '-')}"
-      builder.param format_param(name, param)
+      builder.metaname format_meta(name, meta)
       builder.cast cast
+      if allowed
+        builder.only(*allowed)
+      end
       builder.from_hash config if config
 
-      yield builder if block_given?
+      if block_given?
+        builder.instance_eval(&block)
+      end
       finalize_option_builder builder
     end
 
-    def format_param(name, count)
+    def format_meta(name, count)
       case count
       when :zero then nil
       when :one then name.upcase

data/lib/choosy/dsl/command_builder.rb

@@ -1,6 +1,7 @@
 require 'choosy/errors'
 require 'choosy/dsl/base_command_builder'
 require 'choosy/dsl/option_builder'
+require 'choosy/dsl/argument_builder'
 require 'choosy/printing/help_printer'
 
 module Choosy::DSL
@@ -35,9 +36,20 @@ module Choosy::DSL
     end
 
     def arguments(&block)
-      raise Choosy::ConfigurationError.new("No block to arguments call") if !block_given?
+      builder = ArgumentBuilder.new
+      # Set multiple by default
+      builder.argument.multiple!
 
-      command.argument_validation = block
+      if block_given?
+        builder.instance_eval(&block)
+      end
+      
+      builder.finalize!
+      if builder.argument.metaname.nil?
+        builder.metaname 'ARGS+'
+      end
+
+      command.arguments = builder.argument
     end
   end
 end

data/lib/choosy/dsl/option_builder.rb

@@ -1,37 +1,38 @@
 require 'choosy/option'
 require 'choosy/errors'
 require 'choosy/converter'
+require 'choosy/dsl/argument_builder'
 
 module Choosy::DSL
-  class OptionBuilder
+  class OptionBuilder < ArgumentBuilder
     HELP = :__help__
     VERSION = :__version__
 
-    ZERO_ARITY     = (0 .. 0)
-    ONE_ARITY      = (1 .. 1)
-    MANY_ARITY     = (1 .. 1000)
-    
-    attr_reader :option
-    
     def initialize(name)
-      @option = Choosy::Option.new(name)
-      @count_called = false
+      super()
+      @name = name
+    end
+
+    def option
+      @argument ||= Choosy::Option.new(@name)
     end
 
-    def short(flag, param=nil)
+    alias :argument :option
+
+    def short(flag, meta=nil)
       option.short_flag = flag
-      param(param)
+      metaname(meta)
     end
 
-    def long(flag, param=nil)
+    def long(flag, meta=nil)
       option.long_flag = flag
-      param(param)
+      metaname(meta)
     end
 
-    def flags(shorter, longer=nil, parameter=nil)
+    def flags(shorter, longer=nil, meta=nil)
       short(shorter)
       long(longer) if longer
-      param(parameter) if parameter
+      metaname(meta) if meta
     end
 
     def desc(description)
@@ -42,77 +43,32 @@ module Choosy::DSL
       option.default_value = value
     end
 
-    def required(value=nil)
-      option.required = if value.nil? || value == true
-                          true
-                        else 
-                          false
-                        end
-    end
-
-    def param(param)
-      return if param.nil?
-      option.flag_parameter = param
-      return if @count_called
-      
-      if param =~ /\+$/
-        option.arity = MANY_ARITY 
+    def depends_on(*args)
+      if args.count == 1 && args[0].is_a?(Array)
+        option.dependent_options = args[0]
       else
-        option.arity = ONE_ARITY
+        option.dependent_options = args
       end
     end
 
-    def count(restriction)
-      @count_called = true
-      if restriction.is_a?(Hash)
-        lower_bound = restriction[:at_least] || restriction[:exactly] || 1
-        upper_bound = restriction[:at_most] || restriction[:exactly] || 1000
-
-        check_count(lower_bound)
-        check_count(upper_bound)
-        if lower_bound > upper_bound
-          raise Choosy::ConfigurationError.new("The upper bound (#{upper_bound}) is less than the lower bound (#{lower_bound}).")
-        end
-        
-        option.arity = (lower_bound .. upper_bound)
-      elsif restriction == :zero || restriction == :none
-        option.arity = ZERO_ARITY
-      elsif restriction == :once
-        option.arity = ONE_ARITY
-      else
-        check_count(restriction)
-        option.arity = (restriction .. restriction)
-      end
+    def only(*args)
+      option.allowable_values = args
     end
 
-    def cast(ty)
-      option.cast_to = Choosy::Converter.for(ty)
-      if option.cast_to.nil?
-        raise Choosy::ConfigurationError.new("Unknown conversion cast: #{ty}")
-      end
+    def negate(prefix=nil)
+      prefix ||= 'no'
+      option.negation = prefix
     end
-    
-    def validate(&block)
-      option.validation_step = block
-    end
-    
-    def fail(msg)
+
+    def die(msg)
       flag_fmt = if option.short_flag && option.long_flag
                    "#{option.short_flag}/#{option.long_flag}"
                  end
       flag_fmt ||= option.short_flag || option.long_flag
-      flag_param = if option.flag_parameter
-                     " #{option.flag_parameter}"
+      flag_meta = if option.metaname
+                     " #{option.metaname}"
                    end
-      raise Choosy::ValidationError.new("#{flag_fmt}#{flag_param}: #{msg}")
-    end
-
-    def dependencies(*args)
-      if args.count == 1 && args[0].is_a?(Array)
-        option.dependent_options = args[0]
-      else
-        option.dependent_options = args
-      end
+      raise Choosy::ValidationError.new("#{flag_fmt}#{flag_meta}: #{msg}")
     end
 
     def from_hash(hash)
@@ -132,23 +88,27 @@ module Choosy::DSL
     end
     
     def finalize!
-      if option.arity.nil?
-        option.arity = ZERO_ARITY
-      end
+      super
 
       if option.cast_to.nil?
-        if option.arity == ZERO_ARITY
+        if option.boolean?
           option.cast_to = :boolean
         else
           option.cast_to = :string
         end
       end
-    end
 
-    private
-    def check_count(count)
-      if !count.is_a?(Integer)
-        raise Choosy::ConfigurationError.new("Expected a number to count, got '#{count}'")
+      if option.boolean?
+        if option.restricted?
+          raise Choosy::ConfigurationError.new("Options cannot be both boolean and restricted to certain arguments: #{option.name}")
+        elsif option.negated? && option.long_flag.nil?
+          raise Choosy::ConfigurationError.new("The long flag is required for negation: #{option.name}")
+        end
+        option.default_value ||= false
+      else
+        if option.negated?
+          raise Choosy::ConfigurationError.new("Unable to negate a non-boolean option: #{option.name}")
+        end
       end
     end
   end