opt 0.1.0

data/lib/opt/option.rb

@@ -0,0 +1,198 @@
+module Opt
+  #
+  # A command line option consisting of multiple switches,
+  # possibly arguments and options about allowed numbers etc.
+  #
+  # @api private
+  #
+  class Option
+    #
+    # Option's name.
+    #
+    # @return [String] Frozen name string.
+    #
+    attr_reader :name
+
+    # Set of switches triggering this option.
+    #
+    # Avoid direct manipulation.
+    #
+    # @return [Set<Switch>] Set of switches.
+    #
+    attr_reader :switches
+
+    # Options passed to {#initialize}.
+    #
+    # @return [Hash] Option hash.
+    #
+    attr_reader :options
+
+    # Option default value.
+    #
+    # @return [Object] Default value.
+    #
+    attr_reader :default
+
+    # Option value returned if switch is given.
+    #
+    # Will be ignored if option takes arguments.
+    #
+    # @return [Object] Option value.
+    #
+    attr_reader :value
+
+    # Number of arguments as a range.
+    #
+    # @return [Range] Argument number range.
+    #
+    attr_reader :nargs
+
+    def initialize(definition, options = {})
+      @options  = options
+      @default  = options.fetch(:default, nil)
+      @value    = options.fetch(:value, true)
+      @nargs    = Option.parse_nargs options.fetch(:nargs, 0)
+
+      if definition.to_s =~ /\A[[:word:]]+\z/
+        @switches = Set.new
+        @name     = options.fetch(:name, definition).to_s.freeze
+
+        unless nargs.first > 0 || nargs.size > 1
+          raise 'A text option must consist of at least one argument.'
+        end
+      else
+        @switches = Switch.parse(definition)
+        @name     = options.fetch(:name, switches.first.name).to_s.freeze
+      end
+    end
+
+    # Check if option is triggered by at least on CLI switch.
+    #
+    def switch?
+      switches.any?
+    end
+
+    # Check if option is a free-text option.
+    #
+    def text?
+      !switch?
+    end
+
+    def collide?(option)
+      name == option.name || !switches.disjoint?(option.switches)
+    end
+
+    def parse!(argv, result)
+      if text?
+        parse_text!(argv, result)
+      else
+        parse_switches!(argv, result)
+      end
+    end
+
+    def parse_text!(argv, result)
+      return false unless argv.first.text?
+
+      parse_args!(argv, result)
+      true
+    end
+
+    def parse_switches!(argv, result)
+      switches.each do |switch|
+        next unless switch.match!(argv)
+
+        parse_args!(argv, result)
+        return true
+      end
+
+      false
+    end
+
+    def parse_args!(argv, result)
+      if nargs.first == 0 && nargs.last == 0
+        result[name] = value
+      else
+        args = []
+        if argv.any? && argv.first.text?
+          while argv.any? && argv.first.text? && args.size < nargs.last
+            args << argv.shift.value
+          end
+        elsif argv.any? && argv.first.short?
+          args << argv.shift.value
+        end
+
+        if nargs.include?(args.size)
+          if nargs.first == 1 && nargs.last == 1
+            result[name] = args.first
+          else
+            result[name] = args
+          end
+        else
+          # raise Opt::MissingArgument
+          raise "wrong number of arguments (#{args.size} for #{nargs})"
+        end
+      end
+    end
+
+    class << self
+      def parse_nargs(num)
+        case num
+          when Range
+            parse_nargs_range(num)
+          when Array
+            parse_nargs_array(num)
+          else
+            parse_nargs_obj(num)
+        end
+      end
+
+      def parse_nargs_obj(obj)
+        case obj.to_s.downcase
+          when '+'
+            1..Float::INFINITY
+          when '*', 'inf', 'infinity'
+            0..Float::INFINITY
+          else
+            i = Integer(obj.to_s)
+            parse_nargs_range i..i
+        end
+      end
+
+      def parse_nargs_range(range)
+        if range.first > range.last
+          if range.exclude_end?
+            range = Range.new(range.last + 1, range.first)
+          else
+            range = Range.new(range.last, range.first)
+          end
+        end
+
+        if range.first < 0
+          raise RuntimeError.new 'Argument number must not be less than zero.'
+        end
+
+        range
+      end
+
+      def parse_nargs_array(obj)
+        if obj.size == 2
+          parse_nargs_range Range.new(parse_nargs_array_obj(obj[0]),
+                                      parse_nargs_array_obj(obj[1]))
+        else
+
+          raise ArgumentError.new \
+            'Argument number array count must be exactly two.'
+        end
+      end
+
+      def parse_nargs_array_obj(obj)
+        case obj.to_s.downcase
+          when '*', 'inf', 'infinity'
+            Float::INFINITY
+          else
+            Integer(obj.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/opt/program.rb

@@ -0,0 +1,9 @@
+module Opt
+  #
+  class Program < Command
+
+    def initialize(options = {})
+      super nil, options
+    end
+  end
+end

data/lib/opt/switch.rb

@@ -0,0 +1,119 @@
+require 'set'
+
+module Opt
+  #
+  # A single command line switch.
+  #
+  class Switch
+    class << self
+      #
+      # Parse an object or string into a Set of switches.
+      #
+      # @example
+      #   Opt::Switch.parse '-h, --help'
+      #   #=> Set{<Switch: -h>, <Switch: --help>}
+      #
+      def parse(object)
+        if object.is_a?(self)
+          object
+        else
+          if object.respond_to?(:to_str)
+            parse_str object.to_str
+          else
+            parse_str object.to_s
+          end
+        end
+      end
+
+      # Create new command line switch.
+      #
+      # If a Switch object is given it will be returned instead.
+      #
+      # @see #initialize
+      #
+      def new(object)
+        if object.is_a?(self)
+          object
+        else
+          super object
+        end
+      end
+
+      private
+
+      def parse_str(str)
+        Set.new str.split(/\s*,\s*/).map{|s| new s }
+      end
+    end
+
+    # Switch name.
+    #
+    attr_reader :name
+
+    # Regular expression matching an accepted command line switch
+    REGEXP = /\A(?<dash>--?)(?<name>[[:word:]]+([[[:word:]]-]*[[:word:]])?)\z/
+
+    def initialize(str)
+      match = REGEXP.match(str)
+      raise "Invalid command line switch: #{str.inspect}" unless match
+
+      @name  = match[:name].freeze
+
+      case match[:dash].to_s.size
+        when 0
+          @short = name.size == 1
+        when 1
+          @short = true
+        else
+          @short = false
+      end
+    end
+
+    def short?
+      @short
+    end
+
+    def long?
+      !short?
+    end
+
+    def eql?(object)
+      if object.is_a?(self.class)
+        name == object.name
+      else
+        super
+      end
+    end
+
+    def hash
+      name.hash
+    end
+
+    def match?(argv)
+      case (arg = argv.first).type
+        when :long
+          long? && arg.value.split('=')[0] == name
+        when :short
+          short? && arg.value[0] == name[0]
+        else
+          false
+      end
+    end
+
+    def match!(argv)
+      return false unless match?(argv)
+
+      if short? && argv.first.value.size > 1
+        argv.first.value.slice!(0, 1)
+      else
+        arg = argv.shift
+
+        if arg.value.include?('=')
+          argv.unshift Command::Token.new(:text, arg.value.split('=', 2)[1])
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/opt/types/io.rb

@@ -0,0 +1,4 @@
+module Opt::Types
+  class IO < Base
+  end
+end

data/lib/opt/version.rb

@@ -0,0 +1,3 @@
+module Opt
+  VERSION = "0.1.0"
+end

data/opt.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'opt/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'opt'
+  spec.version       = Opt::VERSION
+  spec.authors       = ['Jan Graichen']
+  spec.email         = ['jg@altimos.de']
+  spec.summary       = %q(An option parsing library.)
+  spec.description   = %q(An option parsing library. Optional.)
+  spec.homepage      = ''
+  spec.license       = 'LGPLv3'
+
+  spec.files         = Dir['**/*'].grep(%r{^((bin|lib|test|spec|features)/|.*\.gemspec|.*LICENSE.*|.*README.*|.*CHANGELOG.*)})
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+end

data/spec/opt/flag_spec.rb

@@ -0,0 +1,100 @@
+# require 'spec_helper'
+
+# describe Opt::Flag do
+#   shared_examples 'defined flag' do
+#     it 'should match short code' do
+#       ret = option.parse %w(-v)
+#       expect(ret).to eq [true]
+#     end
+
+#     it 'should match long code' do
+#       ret = option.parse %w(--verbose)
+#       expect(ret).to eq [true]
+#     end
+
+#     it 'should match negated long code' do
+#       ret = option.parse %w(--no-verbose)
+#       expect(ret).to eq [false]
+#     end
+
+#     it 'should not match something else' do
+#       ret = option.parse %w(--fuu)
+#       expect(ret).to be_false
+#     end
+#   end
+
+#   context 'as simple flag' do
+#     let(:option) { Opt::Flag.new :name, '-v, --verbose' }
+
+#     it_should_behave_like 'defined flag'
+#   end
+
+#   context 'with undashed flag' do
+#     let(:option) { Opt::Flag.new :name, 'v, verbose' }
+
+#     it_should_behave_like 'defined flag'
+#   end
+
+#   context 'with multiple flags' do
+#     let(:option) { Opt::Flag.new :name, 'v, verbose, a, ausführlich' }
+
+#     it_should_behave_like 'defined flag'
+
+#     it 'should match second short code' do
+#       ret = option.parse %w(-a)
+#       expect(ret).to eq [true]
+#     end
+
+#     it 'should match second long code' do
+#       ret = option.parse %w(--ausführlich)
+#       expect(ret).to eq [true]
+#     end
+
+#     it 'should match second negated long code' do
+#       ret = option.parse %w(--no-ausführlich)
+#       expect(ret).to eq [false]
+#     end
+#   end
+
+#   context 'with single-dash long flag' do
+#     let(:option) { Opt::Flag.new :name, '-with-recommended' }
+
+#     it 'should match code' do
+#       ret = option.parse %w(-with-recommended)
+#       expect(ret).to eq [true]
+#     end
+
+#     it 'should negated code' do
+#       ret = option.parse %w(-without-recommended)
+#       expect(ret).to eq [false]
+#     end
+#   end
+
+#   context 'with already negated flag' do
+#     let(:option) { Opt::Flag.new :name, '--without-recommended' }
+
+#     it 'should match code' do
+#       ret = option.parse %w(--with-recommended)
+#       expect(ret).to eq [false]
+#     end
+
+#     it 'should negated code' do
+#       ret = option.parse %w(--without-recommended)
+#       expect(ret).to eq [true]
+#     end
+
+#     context 'with default: false' do
+#       let(:option) { Opt::Flag.new :name, '--without-recommended', default: false }
+
+#       it 'should match code' do
+#         ret = option.parse %w(--with-recommended)
+#         expect(ret).to eq [true]
+#       end
+
+#       it 'should negated code' do
+#         ret = option.parse %w(--without-recommended)
+#         expect(ret).to eq [false]
+#       end
+#     end
+#   end
+# end