gli_aziz_light 2.8.1

data/lib/gli/gli_option_parser.rb

@@ -0,0 +1,156 @@
+module GLI
+  # Parses the command-line options using an actual +OptionParser+
+  class GLIOptionParser
+    def initialize(commands,flags,switches,accepts,default_command = nil,subcommand_option_handling_strategy=:legacy)
+       command_finder       = CommandFinder.new(commands,default_command || "help")
+      @global_option_parser = GlobalOptionParser.new(OptionParserFactory.new(flags,switches,accepts),command_finder)
+      @accepts              = accepts
+      @subcommand_option_handling_strategy = subcommand_option_handling_strategy
+    end
+
+    # Given the command-line argument array, returns an OptionParsingResult
+    def parse_options(args) # :nodoc:
+      option_parser_class = self.class.const_get("#{@subcommand_option_handling_strategy.to_s.capitalize}CommandOptionParser")
+      OptionParsingResult.new.tap { |parsing_result|
+        parsing_result.arguments = args
+        parsing_result = @global_option_parser.parse!(parsing_result)
+        parsing_result.cli_options = @global_option_parser.cli_options
+        option_parser_class.new(@accepts).parse!(parsing_result)
+      }
+    end
+
+  private
+
+    class GlobalOptionParser
+      attr_reader :cli_options
+
+      def initialize(option_parser_factory,command_finder)
+        @option_parser_factory = option_parser_factory
+        @command_finder        = command_finder
+      end
+
+      def parse!(parsing_result)
+        parsing_result.arguments      = GLIOptionBlockParser.new(@option_parser_factory,UnknownGlobalArgument).parse!(parsing_result.arguments)
+        @cli_options = { :global => @option_parser_factory.options_hash.dup, "commands" => {} }
+        parsing_result.global_options = @option_parser_factory.options_hash_with_defaults_set!
+        command_name = if parsing_result.global_options[:help]
+                         "help"
+                       else
+                         parsing_result.arguments.shift
+                       end
+        parsing_result.command        = @command_finder.find_command(command_name)
+        parsing_result
+      end
+    end
+
+    class NormalCommandOptionParser
+      attr_accessor :cli_options
+
+      def initialize(accepts)
+        @accepts = accepts
+      end
+
+      def error_handler
+        lambda { |message,extra_error_context| 
+          raise UnknownCommandArgument.new(message,extra_error_context)
+        }
+      end
+
+      def parse!(parsing_result)
+        parsed_command_options = {}
+        command = parsing_result.command
+        arguments = nil
+
+        loop do
+          option_parser_factory       = OptionParserFactory.for_command(command,@accepts)
+          option_block_parser         = CommandOptionBlockParser.new(option_parser_factory, self.error_handler)
+          option_block_parser.command = command
+          arguments                   = parsing_result.arguments
+
+          arguments = option_block_parser.parse!(arguments)
+
+          parsing_result.cli_options["commands"][command.name] = option_parser_factory.options_hash.dup
+          parsed_command_options[command] = option_parser_factory.options_hash_with_defaults_set!
+          command_finder                  = CommandFinder.new(command.commands,command.get_default_command)
+          next_command_name               = arguments.shift
+
+          begin
+            command = command_finder.find_command(next_command_name)
+          rescue AmbiguousCommand
+            arguments.unshift(next_command_name)
+            break
+          rescue UnknownCommand
+            arguments.unshift(next_command_name)
+            # Although command finder could certainy know if it should use
+            # the default command, it has no way to put the "unknown command"
+            # back into the argument stack.  UGH.
+            unless command.get_default_command.nil?
+              command = command_finder.find_command(command.get_default_command)
+            end
+            break
+          end
+        end
+        parsed_command_options[command] ||= {}
+        command_options = parsed_command_options[command]
+
+        this_command          = command.parent
+        child_command_options = command_options
+
+        while this_command.kind_of?(command.class)
+          this_command_options = parsed_command_options[this_command] || {}
+          child_command_options[GLI::Command::PARENT] = this_command_options
+          this_command = this_command.parent
+          child_command_options = this_command_options
+        end
+
+        parsing_result.command_options = command_options
+        parsing_result.command = command
+        parsing_result.arguments = Array(arguments.compact)
+        parsing_result
+      end
+    end
+
+    class LegacyCommandOptionParser < NormalCommandOptionParser
+      def parse!(parsing_result)
+        command                     = parsing_result.command
+        option_parser_factory       = OptionParserFactory.for_command(command,@accepts)
+        option_block_parser         = LegacyCommandOptionBlockParser.new(option_parser_factory, self.error_handler)
+        option_block_parser.command = command
+
+        parsing_result.arguments       = option_block_parser.parse!(parsing_result.arguments)
+        parsing_result.cli_options["commands"][command.name] = option_parser_factory.options_hash.dup
+        parsing_result.command_options = option_parser_factory.options_hash_with_defaults_set!
+
+        subcommand,args                = find_subcommand(command,parsing_result.arguments)
+        parsing_result.command         = subcommand
+        parsing_result.arguments       = args
+      end
+
+    private
+
+      def find_subcommand(command,arguments)
+        arguments = Array(arguments)
+        command_name = if arguments.empty?
+                         nil
+                       else
+                         arguments.first
+                       end
+
+        default_command = command.get_default_command
+        finder = CommandFinder.new(command.commands,default_command.to_s)
+
+        begin
+          results = [finder.find_command(command_name),arguments[1..-1]]
+          find_subcommand(results[0],results[1])
+        rescue UnknownCommand, AmbiguousCommand
+          begin
+            results = [finder.find_command(default_command.to_s),arguments]
+            find_subcommand(results[0],results[1])
+          rescue UnknownCommand, AmbiguousCommand
+            [command,arguments]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gli/option_parser_factory.rb

@@ -0,0 +1,81 @@
+module GLI
+  # Factory for creating an OptionParser based on app configuration and DSL calls
+  class OptionParserFactory
+
+    # Create an option parser factory for a command.  This has the added
+    # feature of setting up -h and --help on the command if those
+    # options aren't otherwise configured, e.g. to allow todo add --help as an
+    # alternate to todo help add
+    def self.for_command(command,accepts)
+      self.new(command.flags,command.switches,accepts).tap { |factory|
+        add_help_switches_to_command(factory.option_parser,command)
+      }
+    end
+
+    # Create an OptionParserFactory for the given
+    # flags, switches, and accepts
+    def initialize(flags,switches,accepts)
+      @flags = flags
+      @switches = switches
+      @options_hash = {}
+      @option_parser = OptionParser.new do |opts|
+        self.class.setup_accepts(opts,accepts)
+        self.class.setup_options(opts,@switches,@options_hash)
+        self.class.setup_options(opts,@flags,@options_hash)
+      end
+    end
+
+    attr_reader :option_parser
+    attr_reader :options_hash
+
+    def options_hash_with_defaults_set!
+      set_defaults(@flags,@options_hash)
+      set_defaults(@switches,@options_hash)
+      @options_hash
+    end
+
+  private
+
+    def set_defaults(options_by_name,options_hash)
+      options_by_name.values.each do |option|
+        option.names_and_aliases.each do |option_name|
+          [option_name,option_name.to_sym].each do |name|
+            options_hash[name] = option.default_value if options_hash[name].nil?
+          end
+        end
+      end
+    end
+
+    def self.setup_accepts(opts,accepts)
+      accepts.each do |object,block|
+        opts.accept(object) do |arg_as_string|
+          block.call(arg_as_string)
+        end
+      end
+    end
+
+    def self.setup_options(opts,tokens,options)
+      tokens.each do |ignore,token|
+        opts.on(*token.arguments_for_option_parser) do |arg|
+          token.names_and_aliases.each do |name|
+            options[name] = arg
+            options[name.to_sym] = arg
+          end
+        end
+      end
+    end
+
+    def self.add_help_switches_to_command(option_parser,command)
+      help_args = %w(-h --help).reject { |_| command.has_option?(_) }
+
+      unless help_args.empty?
+        help_args << "Get help for #{command.name}"
+        option_parser.on(*help_args) do
+          raise CommandException.new(nil,command,0)
+        end
+      end
+    end
+
+
+  end
+end

data/lib/gli/option_parsing_result.rb

@@ -0,0 +1,21 @@
+module GLI
+  class OptionParsingResult
+    attr_accessor :global_options
+    attr_accessor :command
+    attr_accessor :command_options
+    attr_accessor :arguments
+
+    attr_accessor :cli_options
+
+    def convert_to_openstruct!
+      @global_options  = Options.new(@global_options)
+      @command_options = Options.new(@command_options)
+      self
+    end
+
+    # Allows us to splat this object into blocks and methods expecting parameters in this order
+    def to_a
+      [@global_options,@command,@command_options,@arguments]
+    end
+  end
+end

data/lib/gli/options.rb

@@ -0,0 +1,23 @@
+require 'ostruct'
+
+module GLI
+  # Subclass of +OpenStruct+ that provides hash-like methods for #[] and #[]=.  Note that is is *not* a Hash.
+  # By using GLI::App#use_openstruct, your options will be coerced into one of these.
+  class Options < OpenStruct
+
+    # Return the value of an attribute
+    def[](k)
+      @table[k.to_sym]
+    end
+
+    # Set the value of an attribute
+    def[]=(k, v)
+      @table[k.to_sym] = v
+    end
+
+    def map(&block)
+      @table.map(&block)
+    end
+  end
+end
+

data/lib/gli/switch.rb

@@ -0,0 +1,35 @@
+require 'gli/command_line_option.rb'
+
+module GLI
+  # Defines a command line switch
+  class Switch < CommandLineOption #:nodoc:
+
+    attr_accessor :default_value
+    attr_reader :negatable
+
+    # Creates a new switch
+    #
+    # names - Array of symbols or strings representing the names of this switch
+    # options - hash of options:
+    #           :desc - the short description
+    #           :long_desc - the long description
+    #           :negatable - true or false if this switch is negatable; defaults to true
+    #           :default_value - default value if the switch is omitted
+    def initialize(names,options = {})
+      super(names,options)
+      @default_value = false if options[:default_value].nil?
+      @negatable = options[:negatable].nil? ? true : options[:negatable]
+      if @default_value != false && @negatable == false
+        raise "A switch with default #{@default_value} that isn't negatable is useless"
+      end
+    end
+
+    def arguments_for_option_parser
+      all_forms_a
+    end
+
+    def negatable?
+      @negatable
+    end
+  end
+end

data/lib/gli/terminal.rb

@@ -0,0 +1,101 @@
+module GLI
+  # Class to encapsulate stuff about the terminal. This is useful to application developers
+  # as a canonical means to get information about the user's current terminal configuraiton.
+  # GLI uses this to determine the number of columns to use when printing to the screen.
+  #
+  # To access it, use Terminal.instance.  This is a singleton mostly to facilitate testing, but
+  # it seems reasonable enough, since there's only one terminal in effect
+  #
+  # Example:
+  #
+  #     Terminal.instance.size[0] # => columns in the terminal
+  #     Terminal.default_size = [128,24] # => change default when we can't figure it out
+  #     raise "no ls?!?!?" unless Terminal.instance.command_exists?("ls")
+  #
+  class Terminal
+
+    @@default_size = [80,24]
+
+    # Get the default size of the terminal when we can't figure it out
+    # 
+    # Returns an array of int [cols,rows]
+    def self.default_size
+      @@default_size
+    end
+
+    # Set the default size of the terminal to use when we can't figure it out
+    #
+    # +size+:: array of two int [cols,rows]
+    def self.default_size=(size)
+      @@default_size = size
+    end
+
+    # Provide access to the shared instance.  
+    def self.instance; @@instance ||= Terminal.new; end
+
+    # Call this to cause methods to throw exceptions rather than return a sane default.  You
+    # probably don't want to call this unless you are writing tests
+    def make_unsafe! #:nodoc:
+      @unsafe = true
+    end
+
+    # Returns true if the given command exists on this system
+    #
+    # +command+:: The command, as a String, to check for, without any path information.
+    def self.command_exists?(command)
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? {|dir| File.exists? File.join(dir, command) }
+    end
+
+    def command_exists?(command)
+      self.class.command_exists?(command)
+    end
+
+    SIZE_DETERMINERS = [
+      [
+        lambda { (ENV['COLUMNS'] =~ /^\d+$/) && (ENV['LINES'] =~ /^\d+$/) },
+        lambda { [ENV['COLUMNS'].to_i, ENV['LINES'].to_i] }
+      ],
+      [
+        lambda { (jruby? || (!STDIN.tty? && ENV['TERM'])) && command_exists?('tput') },
+        lambda { [run_command('tput cols').to_i, run_command('tput lines').to_i] }
+      ],
+      [
+        lambda { (solaris? && STDIN.tty? && command_exists?('stty')) },
+        lambda { run_command('stty').split("\n")[1].scan(/\d+/)[0..1].map { |size_element| size_element.to_i }.reverse }
+      ],
+      [ 
+        lambda { STDIN.tty? && command_exists?('stty') },
+        lambda { run_command('stty size').scan(/\d+/).map { |size_element| size_element.to_i }.reverse }
+      ],
+      [
+        lambda { true },
+        lambda { Terminal.default_size },
+      ],
+    ]
+
+    # Get the size of the current terminal.
+    # Ripped from hirb[https://github.com/cldwalker/hirb/blob/master/lib/hirb/util.rb]
+    #
+    # Returns an Array of size two Ints representing the terminal width and height
+    def size
+      SIZE_DETERMINERS.select { |(predicate,ignore)| predicate.call }.first[1].call
+    rescue Exception => ex
+      raise ex if @unsafe
+      Terminal.default_size
+    end
+
+    private
+
+    # Runs a command using backticks.  Extracted to allow for testing
+    def self.run_command(command)
+      `#{command}`
+    end
+
+    # True if we are JRuby; exposed to allow for testing
+    def self.jruby?; RUBY_PLATFORM =~ /java/; end
+
+    # True if this is running under Solaris Sparc
+    def self.solaris?; RUBY_PLATFORM =~ /solaris/; end
+
+  end
+end

data/lib/gli/version.rb

@@ -0,0 +1,5 @@
+module GLI
+  unless const_defined? :VERSION
+    VERSION = '2.8.1'
+  end
+end

data/test/apps/README.md

@@ -0,0 +1,2 @@
+Special-built applications for use in tests that will hopefully reveal
+various features and edge cases

data/test/apps/todo/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/test/apps/todo/README.rdoc

@@ -0,0 +1,6 @@
+= todo
+
+Describe your project here
+
+:include:todo.rdoc
+

data/test/apps/todo/Rakefile

@@ -0,0 +1,23 @@
+require 'rake/clean'
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+  rd.title = 'Your application title'
+end
+
+spec = eval(File.read('todo.gemspec'))
+
+Rake::GemPackageTask.new(spec) do |pkg|
+end
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/tc_*.rb']
+end
+
+task :default => :test