choosy 0.1.0 → 0.2.0

data/lib/choosy/dsl/super_command_builder.rb

@@ -4,30 +4,58 @@ require 'choosy/command'
 
 module Choosy::DSL
   class SuperCommandBuilder < BaseCommandBuilder
-    def command(cmd)
+    HELP = :help
+    SUPER = :__SUPER_COMMAND__
+
+    def command(cmd, &block)
       subcommand = if cmd.is_a?(Choosy::Command)
                      cmd
                    else
                      Choosy::Command.new(cmd)
                    end
-      yield subcommand.builder if block_given?
+
+      if block_given?
+        subcommand.builder.instance_eval(&block)
+      end
       finalize_subcommand(subcommand)
     end
 
+    def parsimonious
+      @command.parsimonious = true
+    end
+
+    def metaname(meta)
+      @command.metaname = meta
+    end
+
     def help(msg=nil)
       msg ||= "Show the info for a command, or this message"
-      help = Choosy::Command.new :help do |help|
+      help_command = 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)
+        help.arguments do
+          count 0..1
+          validate do |args, options|
+            if args.nil?
+              raise Choosy::HelpCalled.new(SUPER)
+            elsif args.is_a?(Array)
+              if args.length == 0
+                raise Choosy::HelpCalled.new(SUPER)
+              else
+                raise Choosy::HelpCalled.new(args[0].to_sym)
+              end
+            else
+              raise Choosy::HelpCalled.new(args.to_sym)
+            end
           end
         end
       end
-      finalize_subcommand(help)
+      finalize_subcommand(help_command)
+    end
+
+    def finalize!
+      super
+      @command.metaname ||= 'COMMAND'
     end
 
     private

data/lib/choosy/option.rb

@@ -1,22 +1,24 @@
+require 'choosy/argument'
+
 module Choosy
-  class Option
+  class Option < Argument
     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 :short_flag, :long_flag
+    attr_accessor :default_value
     attr_accessor :dependent_options
+    attr_accessor :negation
 
     def initialize(name)
+      super()
       @name = name
-      @required = false
     end
-    
-    def required=(req)
-      @required = req
+
+    def negated?
+      !negation.nil?
     end
-    def required?
-      @required == true
+
+    def negated
+      @negated ||= long_flag.gsub(/^--/, "--#{negation}-")
     end
   end
 end

data/lib/choosy/parse_result.rb

@@ -4,11 +4,11 @@ module Choosy
   class BaseParseResult
     attr_reader :command, :options, :unparsed
 
-    def initialize(command)
+    def initialize(command, subresult)
       @command = command
       @options = {}
       @unparsed = []
-      @verified = false
+      @subresult = subresult
     end 
 
     def [](opt)
@@ -19,46 +19,27 @@ module Choosy
       @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
+    def subresult?
+      @subresult
     end
   end
 
   class ParseResult < BaseParseResult
     attr_reader :args
 
-    def initialize(command)
-      super(command)
+    def initialize(command, subresult)
+      super(command, subresult)
       @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)
+      super(command, false)
       @subresults = []
     end
+
   end
 end

data/lib/choosy/parser.rb

@@ -20,7 +20,7 @@ module Choosy
     
     def parse!(argv, result=nil)
       index = 0
-      result ||= ParseResult.new(@command)
+      result ||= ParseResult.new(@command, false)
 
       while index < argv.length
         case argv[index]
@@ -52,6 +52,9 @@ module Choosy
     def verify_option(option)
       verify_flag(option, option.short_flag)
       verify_flag(option, option.long_flag)
+      if option.negated?
+        verify_flag(option, option.negated)
+      end
     end
 
     def verify_flag(option, flag)
@@ -76,19 +79,23 @@ module Choosy
         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
+      if option.boolean?
+        parse_boolean_option(result, option, index, arg, current, flag)
+      elsif option.single?
         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
+    def parse_boolean_option(result, option, index, arg, current, flag)
+      raise Choosy::ParseError.new("Argument given to boolean flag: '#{current}'") if arg
+      if option.negated? && flag == option.negated
+        result.options[option.name] = option.default_value
+      else
         result.options[option.name] = !option.default_value 
-        index + 1
+      end
+      index + 1
     end
 
     def parse_single_option(result, option, index, argv, flag, arg)
@@ -160,7 +167,7 @@ module Choosy
       return [nil, index] if index >= argv.length
 
       current = argv[index]
-      return [nil, index] if current[0] == '-'
+      return [nil, index] if current =~ /^-/
       if @terminals.include? current
         result.unparsed.push(*argv[index, argv.length])
         return [nil, argv.length]
@@ -170,15 +177,12 @@ module Choosy
 
     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
+      if lazy?
+        result.unparsed.push(*argv[index, argv.length])
+      else
+        result.args.push(*argv[index, argv.length])
       end
-      index
+      argv.length
     end
   end
 end

data/lib/choosy/printing/color.rb

@@ -18,10 +18,13 @@ module Choosy::Printing
     EFFECTS = {
       :reset     => 0,
       :bright    => 1,
+      :bold      => 1,
       :underline => 4,
       :blink     => 5,
       :exchange  => 7,
-      :hide      => 8
+      :hide      => 8,
+      :primary   => 10,
+      :normal    => 22
     }
 
     FOREGROUND = 30
@@ -53,48 +56,63 @@ module Choosy::Printing
       EFFECTS.has_key?(effect.to_sym)
     end
 
+    def multiple(str, styles)
+      return str if styles.nil? || styles.empty? || disabled?
+
+      styles.each do |style|
+        if color?(style)
+          str = bedazzle(COLORS[style] + FOREGROUND, str)
+        elsif effect?(style)
+          str = bedazzle(EFFECTS[style], str)
+        end
+      end
+      str
+    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?
+    def method_missing(method, *args, &block)  
+      if disabled?
+        return args[0] || "" 
+      end
 
       if color?(method)
-        bedazzle(COLORS[method] + offset, str)
+        raise ArgumentError.new("too many arguments to Color##{method} (max 2)") if args.length > 2
+        offset = find_state(method, args[1])
+        bedazzle(COLORS[method] + offset, args[0])
       elsif effect?(method)
-        bedazzle(EFFECTS[method], str)
+        raise ArgumentError.new("too many arguments to Color##{method} (max 1)") if args.length > 1
+        bedazzle(EFFECTS[method], args[0])
       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
+    def find_state(method, state)
+      case state
+      when nil
+        FOREGROUND
+      when :foreground
+        FOREGROUND
+      when :background
+        BACKGROUND
       else
-        raise ArgumentError.new("too many arguments to Color##{method} (max 2)")
+        raise ArgumentError.new("unrecognized state for Color##{method}, :foreground or :background only")
       end
     end
 
     def bedazzle(number, str)
-      prefix = "e#{number}[m"
+      prefix = "\e[#{number}m"
       if str.nil?
         prefix
+      elsif str =~ /\e\[0m$/
+        "#{prefix}#{str}"
       else
-        "#{prefix}#{str}e0[m"
+        "#{prefix}#{str}\e[0m"
       end
     end
   end

data/lib/choosy/printing/erb_printer.rb

@@ -4,8 +4,17 @@ require 'erb'
 
 module Choosy::Printing
   class ERBPrinter < HelpPrinter
-    attr_reader :command
-    attr_accessor :template
+    attr_reader :command, :template
+
+    def initialize(options)
+      super(options)
+      if 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
+      @template = options[:template]
+    end
 
     def print!(command)
       @command = command
@@ -13,7 +22,7 @@ module Choosy::Printing
       File.open(template, 'r') {|f| contents = f.read }
       erb = ERB.new contents
 
-      erb.run(self)
+      erb.result(self)
     end
 
     def erb_binding

data/lib/choosy/printing/formatting_element.rb

@@ -0,0 +1,17 @@
+require 'choosy/errors'
+
+module Choosy::Printing
+  class FormattingElement
+    attr_reader :value, :styles, :kind
+
+    def initialize(kind, value, styles)
+      @value = value
+      @kind = kind
+      @styles = styles
+    end
+
+    def header?
+      @kind == :header
+    end
+  end
+end

data/lib/choosy/printing/help_printer.rb

@@ -1,174 +1,261 @@
 require 'choosy/errors'
-require 'choosy/printing/color'
+require 'choosy/printing/terminal'
 
 module Choosy::Printing
   class HelpPrinter
-    DEFAULT_LINE_COUNT = 25
-    DEFAULT_COLUMN_COUNT = 80
+    include Terminal
 
-    attr_reader :color
+    attr_reader :header_styles, :indent, :offset, :buffer, :usage
 
-    def initialize
-      @color = Color.new
-    end
-  
-    def lines
-      @lines ||= find_terminal_size('LINES', 'lines', 0) || DEFAULT_LINE_COUNT
-    end
+    def initialize(options)
+      @indent = options[:indent] || '  '
+      @offset = options[:offset] || '  '
+      @header_styles = options[:header_styles] || [:bold, :blue]
+      @buffer = options[:buffer] || ""
+      @usage = options[:usage] || 'Usage:'
 
-    def lines=(value)
-      @lines = value
+      if options[:color] == false
+        color.disable!
+      end
+      if options[:max_width]
+        self.columns = options[:max_width]
+      end
     end
 
-    def columns
-      @columns ||= find_terminal_size('COLUMNS', 'cols', 1) || DEFAULT_COLUMN_COUNT
-    end
+    def print!(command)
+      print_usage(command)
 
-    def columns=(value)
-      @columns = value
-    end
+      cmd_indent, option_indent, prefixes = retrieve_formatting_info(command)
 
-    def colored=(val)
-      @color.disable! unless val
+      command.listing.each_with_index do |item, i|
+        case item
+        when Choosy::Option
+          print_option(item, prefixes[i], option_indent)
+        when Choosy::Command
+          print_command(item, prefixes[i], cmd_indent)
+        when Choosy::Printing::FormattingElement
+          print_element(item)
+        end
+      end
+
+      @buffer
     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)
+    def print_usage(command)
+      print_header(@usage)
+      @buffer << ' '
+      @buffer << command.name.to_s
+      return if command.options.empty?
+
+      width = starting_width = 8 + command.name.to_s.length # So far
+      command.listing.each do |option|
+        if option.is_a?(Choosy::Option)
+          formatted = usage_option(option)
+          width += formatted.length
+          if width > columns
+            @buffer << "\n"
+            @buffer << ' ' * starting_width
+            @buffer << formatted
+            width = starting_width + formatted.length
+          else
+            @buffer << ' '
+            @buffer << formatted
+            width += 1
+          end
+        end
+      end
+
+      case command
+      when Choosy::Command
+        if command.arguments
+          @buffer << ' '
+          @buffer << command.arguments.metaname
         end
+      when Choosy::SuperCommand
+        @buffer << ' '
+        @buffer << command.metaname
       end
+
+      @buffer << "\n"
     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"
+    def print_header(str, styles=nil)
+      return if str.nil?
+      if styles && !styles.empty?
+        @buffer << color.multiple(str, styles)
+      else
+        @buffer << color.multiple(str, header_styles)
+      end
     end
 
-    def print_summary(summary)
-      write_lines(summary, '  ')
+    def print_element(element)
+      if element.header?
+        @buffer << "\n"
+        print_header(element.value, element.styles)
+        @buffer << "\n"
+      else
+        @buffer << "\n"
+        write_lines(element.value, indent, true)
+      end
     end
 
-    def print_description(desc)
-      print_separator("DESCRIPTION")
-      write_lines(desc, "  ")
+    def print_option(option, formatted_prefix, opt_indent)
+      write_prefix(formatted_prefix, opt_indent)
+      write_lines(option.description, opt_indent, false)
     end
 
-    def print_separator(sep)
-      $stdout << "\n#{sep}\n"
+    def print_command(command, formatted_prefix, cmd_indent)
+      write_prefix(formatted_prefix, cmd_indent)
+      write_lines(command.summary, cmd_indent, false)
     end
 
-    def print_option(option)
-      $stdout << "  "
+    def usage_option(option, value=nil)
+      value ||= ""
+      value << "["
       if option.short_flag
-        $stdout << option.short_flag
+        value << option.short_flag
         if option.long_flag
-          $stdout << ", "
+          value << "|"
+        end
+      end
+      if option.long_flag
+        value << option.long_flag
+      end
+      if option.negated?
+        value << '|'
+        value << option.negated
+      end
+      if option.metaname
+        if option.arity.max > 1
+          value << ' '
+          value << option.metaname
+        else
+          value << '='
+          value << option.metaname
         end
       end
+      value << ']'
+    end
+
+    def regular_option(option, value=nil)
+      value ||= ""
+      if option.short_flag
+        value << option.short_flag
+        if option.long_flag
+          value << ', '
+        end
+      else
+        value << '    '
+      end
 
       if option.long_flag
-        $stdout << option.long_flag
+        if option.negated?
+          value << '--['
+          value << option.negation
+          value << '-]'
+          value << option.long_flag.gsub(/^--/, '')
+        else
+          value << option.long_flag
+        end
       end
 
-      if option.flag_parameter
-        $stdout << " "
-        $stdout << option.flag_parameter
+      if option.metaname
+        value << ' '
+        value << option.metaname
       end
+      value
+    end
+
+    protected
+    def retrieve_formatting_info(command)
+      cmdlen = 0
+      optionlen = 0
+      prefixes = []
 
-      $stdout << "\n"
-      write_lines(option.description, "       ")
+      command.listing.each do |item|
+        case item
+        when Choosy::Option
+          opt = regular_option(item)
+          if opt.length > optionlen
+            optionlen = opt.length
+          end
+          prefixes << opt
+        when Choosy::Command
+          name = item.name.to_s
+          if name.length > cmdlen
+            cmdlen = name.length
+          end
+          prefixes << name
+        else
+          prefixes << nil
+        end
+      end
+
+      option_indent = ' ' * (optionlen + indent.length + offset.length)
+      cmd_indent = ' ' * (cmdlen + indent.length + offset.length)
+      [cmd_indent, option_indent, prefixes]
     end
 
-    def print_command(command)
-      write_lines("#{command.name}\t#{command.summary}", "  ")
+    def write_prefix(prefix, after_indent)
+      len = after_indent.length - prefix.length - indent.length
+      @buffer << indent
+      @buffer << prefix
+      @buffer << ' ' * len
     end
 
-    protected
-    def write_lines(str, prefix)
+    def write_lines(str, prefix, indent_first)
       str.split("\n").each do |line|
         if line.length == 0
-          $stdout << "\n"
+          @buffer << "\n"
         else
-          wrap_long_lines(line, prefix)
+          index = 0
+
+          while index < line.length
+            index = write_line(line, prefix, index, indent_first)
+            indent_first = true
+          end
         end
       end
     end
 
-    # FIXME: not exactly pretty, but it works, mostly
+    # Line:
+    #    index                          char
+    # ----|---------------|--------------|--------------------|
+    #                  length?                             length?
+    # 
+    # Printing:
+    #  offset                                          columns
+    # --|-------------------------------------------------|
+    #
     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
+    def write_line(line, prefix, index, indent_first)
+      if indent_first
+        @buffer << prefix
       end
-    end
 
-    def indent_line(line, prefix)
-      $stdout << prefix
-      $stdout << line
-      $stdout << "\n"
-    end
+      max_line_length = columns - prefix.length # How much can we print?
+      char = index + max_line_length # Where are we within the line, looking at the max length
 
-    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
+      if char > line.length # There's not a lot of line left to print
+        return write_rest(line, index)
+      end
+
+      char.downto(char - MAX_BACKTRACK) do |i| # Only go back a fixed line segment
+        if line[i, 1] == ' '
+          @buffer << line[index, i - index]
+          @buffer << "\n"
+          return i + 1
         end
-      rescue
-        nil
       end
+
+      # We didn't succeed in writing the line. so just bail and write the rest.
+      write_rest(line, index)
     end
 
-    # directly from hirb
-    def command_exists?(command)
-      ENV['PATH'].split(File::PATH_SEPARATOR).any? {|d| File.exists? File.join(d, command) }
+    def write_rest(line, index)
+      @buffer << line[index, line.length]
+      @buffer << "\n"
+      line.length
     end
   end
 end