choosy 0.1.0

data/lib/choosy/converter.rb

@@ -0,0 +1,115 @@
+require 'choosy/errors'
+require 'time'
+require 'date'
+require 'yaml'
+
+module Choosy
+  class Converter
+    CONVERSIONS = {
+      :integer => nil,
+      :int     => :integer,
+      :float   => nil,
+      :symbol  => nil,
+      :file    => nil,  # Succeeds only if a file is present
+      :yaml    => nil,  # Loads a YAML file, if present
+      :date    => nil,
+      :time    => nil,
+      :datetime => nil,
+      :string  => nil,
+      :boolean => nil,
+      :bool    => :boolean
+    }
+
+    def self.for(ty)
+      if ty.is_a?(Symbol) && CONVERSIONS.has_key?(ty)
+        val = CONVERSIONS[ty]
+        if val
+          return val 
+        else
+          return ty
+        end
+      elsif ty.respond_to?(:convert)
+        return ty
+      end
+
+      nil
+    end
+
+    def self.convert(ty, value)
+      if CONVERSIONS.has_key?(ty)
+        send(ty, value)
+      else
+        ty.convert(value)
+      end
+    end
+
+    def self.boolean(value)
+      value # already set
+    end
+
+    def self.string(value)
+      value # already set
+    end
+
+    def self.integer(value)
+      begin
+        return Integer(value)
+      rescue ArgumentError
+        raise Choosy::ConversionError.new("Unable to convert '#{value}' into an integer")
+      end
+    end
+
+    def self.float(value)
+      begin
+        return Float(value)
+      rescue ArgumentError
+        raise Choosy::ConversionError.new("Unable to convert '#{value}' into a float")
+      end
+    end
+
+    def self.symbol(value)
+      value.to_sym
+    end
+
+    def self.file(value)
+      if File.exist?(value)
+        File.new(value)
+      else
+        raise Choosy::ValidationError.new("Unable to locate file: '#{value}'")
+      end
+    end
+
+    def self.yaml(value)
+      fd = file(value)
+      begin
+        return YAML::load_file(fd.path)
+      rescue Error
+        raise Choosy::ConversionError.new("Unable to load YAML from file: '#{value}'")
+      end
+    end
+
+    def self.date(value)
+      begin
+        return Date.parse(value)
+      rescue ArgumentError
+        raise Choosy::ConversionError.new("Unable to convert '#{value}' into a date")
+      end
+    end
+
+    def self.time(value)
+      begin
+        return Time.parse(value)
+      rescue ArgumentError
+        raise Choosy::ConversionError.new("Unable to convert '#{value}' into a time")
+      end
+    end
+
+    def self.datetime(value)
+      begin
+        return DateTime.parse(value)
+      rescue ArgumentError
+        raise Choosy::ConversionError.new("Unable to convert '#{value}' into datetime")
+      end
+    end
+  end
+end

data/lib/choosy/dsl/base_command_builder.rb

@@ -0,0 +1,172 @@
+require 'choosy/errors'
+require 'choosy/dsl/option_builder'
+require 'choosy/printing/erb_printer'
+
+module Choosy::DSL
+  class BaseCommandBuilder
+    attr_reader :command
+
+    def initialize(command)
+      @command = command
+    end
+
+    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
+
+      if p.respond_to?(:color) && options && options.has_key?(:color)
+        p.color.disable! if !options[:color]
+      end
+
+      @command.printer = p
+    end
+
+    def desc(msg)
+      @command.description = msg
+    end
+
+    def separator(msg=nil)
+      @command.listing << (msg.nil? ? "" : msg)
+    end
+
+    def option(arg)
+      raise Choosy::ConfigurationError.new("The option name was nil") if arg.nil?
+      
+      builder = nil
+
+      if arg.is_a?(Hash)
+        raise Choosy::ConfigurationError.new("Malformed option hash") if arg.count != 1
+        name = arg.keys[0]
+        builder = OptionBuilder.new(name)
+
+        to_process = arg[name]
+        if to_process.is_a?(Array)
+          builder.dependencies to_process
+        elsif to_process.is_a?(Hash)
+          builder.from_hash to_process
+        else
+          raise Choosy::ConfigurationError.new("Unable to process option hash")
+        end
+      else
+        builder = OptionBuilder.new(arg)
+        raise Choosy::ConfigurationError.new("No configuration block was given") if !block_given?
+      end
+
+      yield builder if block_given?
+      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
+
+        plural = "#{method}s".to_sym
+        define_method plural do |sym, desc, config=nil, &block|
+          simple_option(sym, desc, true, :many, method, config, &block)
+        end
+
+        underscore = "#{method}_"
+        define_method underscore do |sym, desc, config=nil, &block|
+          simple_option(sym, desc, false, :one, method, 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
+      end
+    end
+
+    create_conversions
+    alias :single :string
+    alias :single_ :string_
+
+    alias :multiple :strings
+    alias :multiple_ :strings_
+
+    def boolean(sym, desc, config=nil, &block)
+      simple_option(sym, desc, true, :zero, :boolean, config, &block)
+    end
+    def boolean_(sym, desc, config=nil, &block)
+      simple_option(sym, desc, false, :zero, :boolean, config, &block)
+    end
+    alias :bool :boolean
+    alias :bool_ :boolean_
+
+    def version(msg)
+      v = OptionBuilder.new(OptionBuilder::VERSION)
+      v.long '--version'
+      v.desc "The version number"
+
+      v.validate do
+        raise Choosy::VersionCalled.new(msg)
+      end
+
+      yield v if block_given?
+      finalize_option_builder v
+    end
+
+    def finalize!
+      if @command.printer.nil?
+        printer :standard
+      end
+    end
+
+    protected
+    def finalize_option_builder(option_builder)
+      option_builder.finalize!
+      @command.option_builders[option_builder.option.name] = option_builder
+      @command.listing << option_builder.option
+
+      option_builder.option
+    end
+
+    private
+    def simple_option(sym, desc, allow_short, param, cast, config, &block)
+      name = sym.to_s
+      builder = OptionBuilder.new sym
+      builder.desc desc
+      builder.short "-#{name[0]}" if allow_short
+      builder.long "--#{name.downcase.gsub(/_/, '-')}"
+      builder.param format_param(name, param)
+      builder.cast cast
+      builder.from_hash config if config
+
+      yield builder if block_given?
+      finalize_option_builder builder
+    end
+
+    def format_param(name, count)
+      case count
+      when :zero then nil
+      when :one then name.upcase
+      when :many then "#{name.upcase}+"
+      end
+    end
+  end
+end

data/lib/choosy/dsl/command_builder.rb

@@ -0,0 +1,43 @@
+require 'choosy/errors'
+require 'choosy/dsl/base_command_builder'
+require 'choosy/dsl/option_builder'
+require 'choosy/printing/help_printer'
+
+module Choosy::DSL
+  class CommandBuilder < BaseCommandBuilder
+    def executor(exec=nil, &block)
+      if exec.nil? 
+        if block_given?
+          @command.executor = block
+        else
+          raise Choosy::ConfigurationError.new("The executor was nil")
+        end
+      else
+        if !exec.respond_to?(:execute!)
+          raise Choosy::ConfigurationError.new("Execution class doesn't implement 'execute!'")
+        end
+        @command.executor = exec
+      end
+    end
+
+    def help(msg=nil)
+      h = OptionBuilder.new(OptionBuilder::HELP)
+      h.short '-h'
+      h.long '--help'
+      msg ||= "Show this help message"
+      h.desc msg
+
+      h.validate do
+        raise Choosy::HelpCalled.new(@name)
+      end 
+
+      finalize_option_builder h
+    end
+
+    def arguments(&block)
+      raise Choosy::ConfigurationError.new("No block to arguments call") if !block_given?
+
+      command.argument_validation = block
+    end
+  end
+end

data/lib/choosy/dsl/option_builder.rb

@@ -0,0 +1,155 @@
+require 'choosy/option'
+require 'choosy/errors'
+require 'choosy/converter'
+
+module Choosy::DSL
+  class OptionBuilder
+    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
+    end
+
+    def short(flag, param=nil)
+      option.short_flag = flag
+      param(param)
+    end
+
+    def long(flag, param=nil)
+      option.long_flag = flag
+      param(param)
+    end
+
+    def flags(shorter, longer=nil, parameter=nil)
+      short(shorter)
+      long(longer) if longer
+      param(parameter) if parameter
+    end
+
+    def desc(description)
+      option.description = description
+    end
+
+    def default(value)
+      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 
+      else
+        option.arity = ONE_ARITY
+      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
+    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
+    end
+    
+    def validate(&block)
+      option.validation_step = block
+    end
+    
+    def fail(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}"
+                   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
+    end
+
+    def from_hash(hash)
+      raise Choosy::ConfigurationError.new("Only hash arguments allowed") if !hash.is_a?(Hash)
+
+      hash.each do |k, v|
+        if respond_to?(k)
+          if v.is_a?(Array)
+            self.send(k, *v)
+          else
+            self.send(k, v)
+          end
+        else
+          raise Choosy::ConfigurationError.new("Not a recognized option: #{k}")
+        end
+      end
+    end
+    
+    def finalize!
+      if option.arity.nil?
+        option.arity = ZERO_ARITY
+      end
+
+      if option.cast_to.nil?
+        if option.arity == ZERO_ARITY
+          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}'")
+      end
+    end
+  end
+end

data/lib/choosy/dsl/super_command_builder.rb

@@ -0,0 +1,41 @@
+require 'choosy/errors'
+require 'choosy/dsl/base_command_builder'
+require 'choosy/command'
+
+module Choosy::DSL
+  class SuperCommandBuilder < BaseCommandBuilder
+    def command(cmd)
+      subcommand = if cmd.is_a?(Choosy::Command)
+                     cmd
+                   else
+                     Choosy::Command.new(cmd)
+                   end
+      yield subcommand.builder if block_given?
+      finalize_subcommand(subcommand)
+    end
+
+    def help(msg=nil)
+      msg ||= "Show the info for a command, or this message"
+      help = Choosy::Command.new :help do |help|
+        help.summary msg
+
+        help.arguments do |args|
+          if args.nil? || args.length == 0
+            raise Choosy::HelpCalled.new(@command.name)
+          else
+            raise Choosy::HelpCalled.new(args[0].to_sym)
+          end
+        end
+      end
+      finalize_subcommand(help)
+    end
+
+    private
+    def finalize_subcommand(subcommand)
+      subcommand.builder.finalize!
+      @command.command_builders[subcommand.name] = subcommand.builder
+      @command.listing << subcommand
+      subcommand
+    end
+  end
+end

data/lib/choosy/errors.rb

@@ -0,0 +1,11 @@
+module Choosy
+  Error = Class.new(RuntimeError)
+
+  ConfigurationError = Class.new(Choosy::Error)
+  ValidationError    = Class.new(Choosy::Error)
+  HelpCalled         = Class.new(Choosy::Error)
+  VersionCalled      = Class.new(Choosy::Error)
+  ConversionError    = Class.new(Choosy::Error)
+  ParseError         = Class.new(Choosy::Error)
+  SuperParseError    = Class.new(Choosy::Error)
+end

data/lib/choosy/option.rb

@@ -0,0 +1,22 @@
+module Choosy
+  class Option
+    attr_accessor :name, :description
+    attr_accessor :short_flag, :long_flag, :flag_parameter
+    attr_accessor :cast_to,  :default_value
+    attr_accessor :validation_step
+    attr_accessor :arity
+    attr_accessor :dependent_options
+
+    def initialize(name)
+      @name = name
+      @required = false
+    end
+    
+    def required=(req)
+      @required = req
+    end
+    def required?
+      @required == true
+    end
+  end
+end

data/lib/choosy/parse_result.rb

@@ -0,0 +1,64 @@
+require 'choosy/verifier'
+
+module Choosy
+  class BaseParseResult
+    attr_reader :command, :options, :unparsed
+
+    def initialize(command)
+      @command = command
+      @options = {}
+      @unparsed = []
+      @verified = false
+    end 
+
+    def [](opt)
+      @options[opt]
+    end
+
+    def []=(opt, val)
+      @options[opt] = val
+    end
+
+    def verified?
+      @verified
+    end
+
+    def verify!
+      basic_verification
+    end
+
+    protected
+    def basic_verification(&block)
+      verifier = Verifier.new
+      verifier.verify_options!(self)
+      yield verifier if block_given?
+      @verified = true
+      self
+    end
+  end
+
+  class ParseResult < BaseParseResult
+    attr_reader :args
+
+    def initialize(command)
+      super(command)
+      @args = []
+    end
+
+    def verify!
+      return self if verified?
+      basic_verification do |verifier|
+        verifier.verify_arguments!(self)
+      end
+    end
+  end
+
+  class SuperParseResult < BaseParseResult
+    attr_reader :subresults
+
+    def initialize(command)
+      super(command)
+      @subresults = []
+    end
+  end
+end