choosy 0.1.0

data/lib/choosy/parser.rb

@@ -0,0 +1,184 @@
+require 'choosy/errors'
+require 'choosy/parse_result'
+require 'choosy/dsl/option_builder'
+
+module Choosy
+  class Parser
+    attr_reader :flags, :terminals, :command
+
+    def initialize(command, lazy=nil, terminals=nil)
+      @command = command
+      @lazy = lazy || false
+      @terminals = terminals || []
+
+      @flags = {}
+      return if command.options.nil?
+      command.options.each do |o|
+        verify_option(o)
+      end
+    end
+    
+    def parse!(argv, result=nil)
+      index = 0
+      result ||= ParseResult.new(@command)
+
+      while index < argv.length
+        case argv[index]
+        when '-'
+          if lazy?
+            result.unparsed << '-'
+            index += 1
+          else
+            raise Choosy::ParseError.new("Unfinished option '-'")
+          end
+        when '--'
+          result.unparsed << '--' if lazy?
+          index = parse_rest(argv, index, result)
+        when /^-/
+          index = parse_option(argv, index, result)
+        else
+          index = parse_arg(argv, index, result)
+        end
+      end
+
+      result
+    end
+
+    def lazy?
+      @lazy
+    end
+
+    private
+    def verify_option(option)
+      verify_flag(option, option.short_flag)
+      verify_flag(option, option.long_flag)
+    end
+
+    def verify_flag(option, flag)
+      return nil if flag.nil?
+      if @flags[flag]
+        raise Choosy::ConfigurationError.new("Duplicate option: '#{flag}'")
+      end
+      @flags[flag] = option
+    end
+
+    def parse_option(argv, index, result)
+      current = argv[index]
+      flag, arg = current.split("=", 2)
+      option = @flags[flag]
+
+      if option.nil?
+        if lazy?
+          result.unparsed << current
+          return index + 1
+        else
+          raise Choosy::ParseError.new("Unrecognized option: '#{flag}'")
+        end
+      end
+
+      if option.arity == Choosy::DSL::OptionBuilder::ZERO_ARITY
+        parse_boolean_option(result, option, index, arg, current)
+      elsif option.arity == Choosy::DSL::OptionBuilder::ONE_ARITY
+        parse_single_option(result, option, index, argv, flag, arg)
+      else # Vararg
+        parse_multiple_option(result, option, index, argv, flag, arg)
+      end
+    end
+
+    def parse_boolean_option(result, option, index, arg, current)
+        raise Choosy::ParseError.new("Argument given to boolean flag: '#{current}'") if arg
+        result.options[option.name] = !option.default_value 
+        index + 1
+    end
+
+    def parse_single_option(result, option, index, argv, flag, arg)
+      if arg
+        result.options[option.name] = arg
+        index += 1
+      else
+        current, index = read_arg(argv, index + 1, result)
+        if current.nil?
+          raise Choosy::ParseError.new("Argument missing for option: '#{flag}'")
+        else
+          result.options[option.name] = current
+        end
+      end
+
+      index
+    end
+
+    def parse_multiple_option(result, option, index, argv, flag, arg)
+      if arg
+        if option.arity.min > 1
+          raise Choosy::ParseError.new("The '#{flag}' flag requires at least #{option.arity.min} arguments")
+        end
+        result.options[option.name] = arg
+        return index + 1
+      end
+
+      index += 1
+      min = index + option.arity.min
+      max = index + option.arity.max
+      args = []
+
+      while index < min
+        current, index = read_arg(argv, index, result)
+        if current.nil?
+          raise Choosy::ParseError.new("The '#{flag}' flag requires at least #{option.arity.min} arguments")
+        end
+        args << current
+      end
+
+      while index < max && index < argv.length
+        current, index = read_arg(argv, index, result)
+        break if current.nil?
+        args << current
+      end
+
+      if index < argv.length && argv[index] == '-'
+        index += 1
+      end
+
+      result.options[option.name] = args
+      index
+    end
+
+    def parse_arg(argv, index, result)
+      while index < argv.length
+        current, index = read_arg(argv, index, result)
+        break if current.nil?
+        if lazy?
+          result.unparsed << current
+        else
+          result.args << current
+        end
+      end
+      index
+    end
+
+    def read_arg(argv, index, result)
+      return [nil, index] if index >= argv.length
+
+      current = argv[index]
+      return [nil, index] if current[0] == '-'
+      if @terminals.include? current
+        result.unparsed.push(*argv[index, argv.length])
+        return [nil, argv.length]
+      end
+      [current, index + 1]
+    end
+
+    def parse_rest(argv, index, result)
+      index += 1
+      while index < argv.length
+        if lazy?
+          result.unparsed << argv[index]
+        else
+          result.args << argv[index]
+        end
+        index += 1
+      end
+      index
+    end
+  end
+end

data/lib/choosy/printing/color.rb

@@ -0,0 +1,101 @@
+require 'choosy/errors'
+
+module Choosy::Printing
+  class Color
+    # Extrapolated from:
+    # http://kpumuk.info/ruby-on-rails/colorizing-console-ruby-script-output/
+    COLORS = {
+      :black   => 0,
+      :red     => 1,
+      :green   => 2,
+      :yellow  => 3,
+      :blue    => 4,
+      :magenta => 5, 
+      :cyan    => 6,
+      :white   => 7,
+    }
+
+    EFFECTS = {
+      :reset     => 0,
+      :bright    => 1,
+      :underline => 4,
+      :blink     => 5,
+      :exchange  => 7,
+      :hide      => 8
+    }
+
+    FOREGROUND = 30
+    BACKGROUND = 40
+
+    def initialize
+      begin
+        require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
+        @disabled = false
+      rescue LoadError
+        # STDERR.puts "You must gem install win32console to use color on Windows"
+        disable!
+      end
+    end
+
+    def disabled?
+      @disabled
+    end
+
+    def disable!
+      @disabled = true
+    end
+
+    def color?(color)
+      COLORS.has_key?(color.to_sym)
+    end
+
+    def effect?(effect)
+      EFFECTS.has_key?(effect.to_sym)
+    end
+
+    def respond_to?(method)
+      color?(method) || effect?(method)
+    end
+
+    # Dynamically handle colors and effects
+    def method_missing(method, *args, &block)
+      str, offset = unpack_args(method, args)
+      return str || "" if disabled?
+
+      if color?(method)
+        bedazzle(COLORS[method] + offset, str)
+      elsif effect?(method)
+        bedazzle(EFFECTS[method], str)
+      else
+        raise NoMethodError.new("undefined method '#{method}' for Color")
+      end
+    end
+
+    private
+    def unpack_args(method, args)
+      case args.length
+      when 0
+        [nil, FOREGROUND]
+      when 1
+        [args[0], FOREGROUND]
+      when 2
+        case args[1]
+        when :foreground then [args[0], FOREGROUND]
+        when :background then [args[0], BACKGROUND]
+        else raise ArgumentError.new("unrecognized state for Color##{method}, :foreground or :background only")
+        end
+      else
+        raise ArgumentError.new("too many arguments to Color##{method} (max 2)")
+      end
+    end
+
+    def bedazzle(number, str)
+      prefix = "e#{number}[m"
+      if str.nil?
+        prefix
+      else
+        "#{prefix}#{str}e0[m"
+      end
+    end
+  end
+end

data/lib/choosy/printing/erb_printer.rb

@@ -0,0 +1,23 @@
+require 'choosy/errors'
+require 'choosy/printing/help_printer'
+require 'erb'
+
+module Choosy::Printing
+  class ERBPrinter < HelpPrinter
+    attr_reader :command
+    attr_accessor :template
+
+    def print!(command)
+      @command = command
+      contents = nil
+      File.open(template, 'r') {|f| contents = f.read }
+      erb = ERB.new contents
+
+      erb.run(self)
+    end
+
+    def erb_binding
+      binding
+    end
+  end
+end

data/lib/choosy/printing/help_printer.rb

@@ -0,0 +1,174 @@
+require 'choosy/errors'
+require 'choosy/printing/color'
+
+module Choosy::Printing
+  class HelpPrinter
+    DEFAULT_LINE_COUNT = 25
+    DEFAULT_COLUMN_COUNT = 80
+
+    attr_reader :color
+
+    def initialize
+      @color = Color.new
+    end
+  
+    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 colored=(val)
+      @color.disable! unless val
+    end
+
+    def print!(command)
+      print_usage(command)
+      print_summary(command.summary) if command.summary
+      print_description(command.description) if command.description
+      command.listing.each do |l|
+        if l.is_a?(String)
+          print_separator(l)
+        elsif l.is_a?(Choosy::Option)
+          print_option(l)
+        else
+          print_command(l)
+        end
+      end
+    end
+
+    # FIXME: hideously ugly
+    def print_usage(command)
+      args = if command.respond_to?(:argument_validation) && command.argument_validation
+               " [ARGS]"
+             else
+               ""
+             end
+      cmds = if command.respond_to?(:commands) 
+               " [COMMANDS]"
+             else
+               ""
+             end
+      options = if command.option_builders.length == 0
+                  ""
+                else
+                  " [OPTIONS]"
+                end
+      $stdout << "USAGE: #{command.name}#{cmds}#{options}#{args}\n"
+    end
+
+    def print_summary(summary)
+      write_lines(summary, '  ')
+    end
+
+    def print_description(desc)
+      print_separator("DESCRIPTION")
+      write_lines(desc, "  ")
+    end
+
+    def print_separator(sep)
+      $stdout << "\n#{sep}\n"
+    end
+
+    def print_option(option)
+      $stdout << "  "
+      if option.short_flag
+        $stdout << option.short_flag
+        if option.long_flag
+          $stdout << ", "
+        end
+      end
+
+      if option.long_flag
+        $stdout << option.long_flag
+      end
+
+      if option.flag_parameter
+        $stdout << " "
+        $stdout << option.flag_parameter
+      end
+
+      $stdout << "\n"
+      write_lines(option.description, "       ")
+    end
+
+    def print_command(command)
+      write_lines("#{command.name}\t#{command.summary}", "  ")
+    end
+
+    protected
+    def write_lines(str, prefix)
+      str.split("\n").each do |line|
+        if line.length == 0
+          $stdout << "\n"
+        else
+          wrap_long_lines(line, prefix)
+        end
+      end
+    end
+
+    # FIXME: not exactly pretty, but it works, mostly
+    MAX_BACKTRACK = 25
+    def wrap_long_lines(line, prefix)
+      index = 0
+      while index < line.length
+        segment_size = line.length - index
+        if segment_size >= columns
+          i = columns + index - prefix.length
+          while i > columns - MAX_BACKTRACK
+            if line[i] == ' '
+              indent_line(line[index, i - index], prefix)
+              index = i + 1
+              break
+            else
+              i -= 1
+            end
+          end
+        else
+          indent_line(line[index, line.length], prefix)
+          index += segment_size
+        end
+      end
+    end
+
+    def indent_line(line, prefix)
+      $stdout << prefix
+      $stdout << line
+      $stdout << "\n"
+    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
+
+    # directly from hirb
+    def command_exists?(command)
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? {|d| File.exists? File.join(d, command) }
+    end
+  end
+end

data/lib/choosy/super_command.rb

@@ -0,0 +1,77 @@
+require 'choosy/errors'
+require 'choosy/parser'
+require 'choosy/base_command'
+require 'choosy/super_parser'
+require 'choosy/dsl/super_command_builder'
+
+module Choosy
+  class SuperCommand < BaseCommand
+    attr_reader :command_builders
+
+    def command_builders
+      @command_builders ||= {}
+    end
+
+    def commands
+      @command_builders.values.map {|b| b.command }
+    end
+
+    def parsimonious=(value)
+      @parsimonious = value
+    end
+
+    def parsimonious?
+      @parsimonous ||= false
+    end
+
+    def execute!(args)
+      super_result = parse!(args)
+      super_result.subresults.each do |result|
+        cmd = result.command
+        if cmd.executor.nil?
+          raise Choosy::ConfigurationError.new("No executor given for: #{cmd.name}")
+        end
+      end
+
+      super_result.subresults.each do |result|
+        cmd = result.command
+        cmd.executor.call(result.options, result.args)
+      end
+    end
+
+    protected
+    def create_builder
+      Choosy::DSL::SuperCommandBuilder.new(self)
+    end
+
+    def parse(args)
+      parser = SuperParser.new(self)
+      parser.parse!(args)
+    end
+
+    def handle_help(hc)
+      command_name = hc.message
+
+      if command_name.to_s == @name.to_s
+        printer.print!(self)
+      else
+        builder = command_builders[command_name]
+        if builder
+          printer.print!(builder.command)
+        else
+          $stdout << "#{@name}: #{format_help(command_name)}\n"
+          exit 1
+        end
+      end
+    end
+
+    def format_help(command)
+      help = if command_builders[:help]
+               "See '#{@name} help'."
+             else
+               ""
+             end
+      "'#{command}' is not a standard command. #{help}"
+    end
+  end
+end

data/lib/choosy/super_parser.rb

@@ -0,0 +1,81 @@
+require 'choosy/errors'
+require 'choosy/parser'
+require 'choosy/parse_result'
+
+module Choosy
+  class SuperParser
+    attr_reader :terminals
+
+    def initialize(super_command, parsimonious=nil)
+      @super_command = super_command
+      @parsimonious = parsimonious || false
+      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
+    end
+
+    private
+    def generate_terminals
+      @terminals = []
+      if parsimonious?
+        @super_command.commands.each do |c|
+          @terminals << c.name.to_s
+        end
+      end
+    end
+
+    def parse_globals(args)
+      result = SuperParseResult.new(@super_command)
+      parser = Parser.new(@super_command, true)
+      parser.parse!(args, result)
+      result.verify!
+
+      # 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)
+        else
+          raise Choosy::SuperParseError.new("requires a command")
+        end
+      end
+
+      result
+    end
+
+    def parse_command(args, terminals)
+      command_name = args.shift
+      command_builder = @super_command.command_builders[command_name.to_sym]
+      if command_builder.nil?
+        if command_name =~ /^-/
+          raise Choosy::SuperParseError.new("unrecognized option: '#{command_name}'")
+        else
+          raise Choosy::SuperParseError.new("unrecognized command: '#{command_name}'")
+        end
+      end
+
+      command = command_builder.command
+      parser = Parser.new(command, false, terminals)
+      command_result = parser.parse!(args)
+
+      command_result.verify!
+    end
+  end
+end
+

data/lib/choosy/verifier.rb

@@ -0,0 +1,62 @@
+require 'choosy/errors'
+require 'choosy/dsl/option_builder'
+
+module Choosy
+  class Verifier
+    def verify_options!(result)
+      result.command.options.each do |option|
+        required?(option, result)
+        populate!(option, result)
+        convert!(option, result)
+        validate!(option, result)
+      end
+    end
+
+    def verify_arguments!(result)
+      if result.command.respond_to?(:argument_validation) && result.command.argument_validation
+        result.command.argument_validation.call(result.args)
+      end
+    end
+
+    def required?(option, result)
+      if option.required? && result[option.name].nil?
+        raise ValidationError.new("Required option '#{option.long_flag}' missing.")
+      end
+    end
+    
+    def populate!(option, result)
+      return if option.name == Choosy::DSL::OptionBuilder::HELP || option.name == Choosy::DSL::OptionBuilder::VERSION
+
+      if !result.options.has_key?(option.name) # Not already set
+        if !option.default_value.nil? # Has default?
+          result[option.name] = option.default_value
+        elsif option.cast_to == :boolean
+          result[option.name] = false
+        elsif option.arity.max > 1
+          result[option.name] = []
+        else
+          result[option.name] = nil
+        end
+      end
+    end
+
+    def convert!(option, result)
+      value = result[option.name]
+      if exists? value
+        result[option.name] = Converter.convert(option.cast_to, value)
+      end
+    end
+
+    def validate!(option, result)
+      value = result[option.name]
+      if option.validation_step && exists?(value)
+        option.validation_step.call(value)
+      end
+    end
+
+    private
+    def exists?(value)
+      value && value != []
+    end
+  end
+end

data/lib/choosy/version.rb

@@ -0,0 +1,12 @@
+require 'scanf'
+
+module Choosy
+  class Version
+    CURRENT = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
+    MAJOR, MINOR, TINY = CURRENT.scanf('%d.%d.%d')
+
+    def self.to_s
+      CURRENT
+    end
+  end
+end