synoption 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fe1c709d5995beaa457aa686b213cce88234b0a1
+  data.tar.gz: 59c59d6d95786ce9e750c0e42418c4665400b229
+SHA512:
+  metadata.gz: 25ac687f69df1bccc08f29136f807af33401fc3643050f6b4959cecd6675608399071d0b25e6a574b7ebcb459cf7ae005292c67e9787e3176ffcf615c24f24d6
+  data.tar.gz: 7d1af4a7d5dea65241177b5eff102fc9de53cd0d3fbae9c865a8efaa7e301a3df11aab09c928d438391c4abbe85dc357da7bcaf5f17d9e73d8ee0946915fdd59

data/lib/synoption/base_option.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubygems'
+require 'logue/loggable'
+require 'synoption/doc'
+require 'synoption/match'
+require 'synoption/matchers'
+
+module Synoption
+  class BaseOption
+    include Logue::Loggable
+
+    # for as_cmdline_option:
+    NO_CMDLINE_OPTION = Object.new
+    
+    attr_reader :name
+    attr_reader :tag
+    attr_reader :description
+    attr_reader :default
+
+    attr_reader :negate
+    attr_reader :regexp
+
+    def initialize name, tag, description, default, options = Hash.new
+      @name = name
+      @tag = tag
+      @description = description
+
+      @value = @default = default
+
+      @matchers = Matchers.new @tag, @name, options[:negate], options[:regexp]
+
+      @negate = options[:negate]
+      @regexp = options[:regexp]
+      
+      if options.include? :as_cmdline_option
+        if options[:as_cmdline_option].nil?
+          @as_cmdline_option = NO_CMDLINE_OPTION
+        else
+          @as_cmdline_option = options[:as_cmdline_option]
+        end
+      else
+        @as_cmdline_option = nil
+      end
+
+      @unsets = options[:unsets]
+    end
+
+    def takes_value?
+      true
+    end
+
+    def to_command_line
+      return nil unless value
+      
+      if @as_cmdline_option
+        @as_cmdline_option == NO_CMDLINE_OPTION ? nil : @as_cmdline_option
+      else
+        [ tag, value ]
+      end
+    end
+
+    def to_s
+      [ @name, @tag ].join(", ")
+    end
+
+    def exact_match? arg
+      @matchers.exact.match? arg
+    end
+
+    def negative_match? arg
+      @matchers.negative and @matchers.negative.match? arg
+    end
+
+    def regexp_match? arg
+      @matchers.regexp and @matchers.regexp.match? arg
+    end
+
+    def unset
+      @value = nil
+    end
+
+    def set_value val
+      @value = val
+    end
+
+    def value
+      @value
+    end
+      
+    def to_doc io
+      doc = Doc.new self
+      doc.to_doc io
+    end
+
+    def next_argument args
+      raise "ERROR: option #{name} expecting following argument" if args.empty?
+      args.shift
+    end
+
+    def process args
+      if @matchers.exact.match? args[0]
+        args.shift
+        val = takes_value? ? next_argument(args) : true
+        set_value val
+        true
+      elsif @matchers.negative && @matchers.negative.match?(args[0])
+        arg = args.shift
+        set_value false
+        true
+      elsif @matchers.regexp && (md = @matchers.regexp.match?(args[0]))
+        arg = args.shift
+        set_value md[0]
+        true
+      else
+        false
+      end
+    end
+
+    def post_process option_set, unprocessed
+      resolve_value option_set, unprocessed
+
+      if @unsets
+        option_set.unset @unsets
+      end
+    end
+
+    def resolve_value option_set, unprocessed
+    end
+  end
+end

data/lib/synoption/boolean_option.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'synoption/option'
+
+module Synoption
+  # a boolean option maps to a single tag, not a tag and value. For example,
+  # "-v" (verbose) is a boolean option, but "-r 3444" (revision) is a option
+  # with a value.
+  class BooleanOption < Option
+    def takes_value?
+      false
+    end
+
+    def to_command_line
+      super && [ tag ]
+    end
+  end
+end

data/lib/synoption/doc.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubygems'
+require 'logue/loggable'
+
+module Synoption
+  # documentation for an option.
+  class Doc
+    include Logue::Loggable
+
+    def initialize option
+      @option = option
+    end
+
+    def to_doc_tag
+      tagline = "#{@option.tag} [--#{@option.name}]"
+      if @option.takes_value?
+        tagline << " ARG"
+      end
+      tagline
+    end
+
+    # returns an option regexp as a 'cleaner' string
+    def re_to_string re
+      re.source.gsub(%r{\\d\+?}, 'N').gsub(%r{[\^\?\$\\\(\)]}, '')
+    end
+
+    def to_doc_negate
+      doc = nil
+      @option.negate.each do |neg|
+        str = if neg.kind_of? Regexp
+                str = re_to_string neg
+              else
+                str = neg
+              end
+
+        if doc
+          doc << " [#{str}]"
+        else
+          doc = str
+        end
+      end
+      doc
+    end
+
+    #   -g [--use-merge-history] : use/display additional information from merge
+    # 01234567890123456789012345678901234567890123456789012345678901234567890123456789
+    # 0         1         2         3         4         5         6         
+
+    def to_doc_line lhs, rhs, sep = ""
+      fmt = "  %-24s %1s %s"
+      sprintf fmt, lhs, sep, rhs
+    end
+      
+    def to_doc io
+      # wrap optdesc?
+
+      [ @option.description ].flatten.each_with_index do |descline, idx|
+        lhs = idx == 0 ? to_doc_tag :  ""
+        io.puts to_doc_line lhs, descline, idx == 0 ? ":" : ""
+      end
+
+      if defval = @option.default
+        io.puts to_doc_line "", "  default: #{defval}"
+      end
+
+      if re = @option.regexp
+        io.puts to_doc_line re_to_string(re), "same as above", ":"
+      end
+
+      if @option.negate
+        lhs = to_doc_negate
+        io.puts to_doc_line lhs, "", ""
+      end
+    end
+  end
+end

data/lib/synoption/exception.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Synoption
+  class OptionException < RuntimeError
+  end
+end

data/lib/synoption/fixnum_option.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'synoption/option'
+
+module Synoption
+  # An option that has a fixnum (integer) as its value.
+  class FixnumOption < Option
+    def set_value val
+      super(val && val.to_i)
+    end
+  end
+end

data/lib/synoption/list.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module Synoption
+  class OptionList    
+    attr_reader :options
+    
+    def initialize options = Array.new
+      @options = options
+    end
+
+    def inspect
+      @options.collect { |opt| opt.inspect }.join("\n")
+    end
+
+    def find_by_name name
+      @options.find { |opt| opt.name == name }
+    end
+
+    def has_option? name
+      find_by_name name
+    end
+
+    def to_command_line
+      cmdline = Array.new
+      @options.each do |opt|
+        if cl = opt.to_command_line
+          cmdline.concat cl
+        end
+      end
+      cmdline
+    end
+
+    def << option
+      add option
+    end
+
+    def add option
+      @options << option
+      option
+    end
+  end
+end

data/lib/synoption/match.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubygems'
+require 'logue/loggable'
+
+module Synoption
+  class OptionMatch
+    include Logue::Loggable
+
+    def match? arg
+      raise "not implemented"
+    end
+  end
+
+  class OptionExactMatch < OptionMatch
+    def initialize tag, name
+      @tag = tag
+      @name = name
+    end
+
+    def match? arg
+      arg == @tag || arg == '--' + @name.to_s
+    end
+  end
+
+  class OptionNegativeMatch < OptionMatch
+    def initialize *negopts
+      # in case this gets passed an array as an element:
+      @negopts = Array.new(negopts).flatten
+    end
+
+    def match? arg
+      arg && @negopts.select { |x| arg.index x }.size > 0
+    end
+  end
+
+  class OptionRegexpMatch < OptionMatch
+    def initialize regexp
+      @regexp = regexp
+    end
+
+    def match? arg
+      arg && @regexp.match(arg)
+    end
+  end
+end

data/lib/synoption/matchers.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubygems'
+require 'logue/loggable'
+require 'synoption/match'
+
+module Synoption
+  class Matchers
+    include Logue::Loggable
+
+    attr_reader :exact
+    attr_reader :negative
+    attr_reader :regexp
+
+    def initialize tag, name, negate, regexp
+      @exact = OptionExactMatch.new tag, name
+      @negative = negate && OptionNegativeMatch.new(negate)
+      @regexp = regexp && OptionRegexpMatch.new(regexp)
+    end
+  end
+end

data/lib/synoption/option.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'synoption/base_option'
+
+module Synoption
+  class Option < BaseOption
+  end
+end

data/lib/synoption/set.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'rubygems'
+require 'logue/loggable'
+require 'synoption/option'
+require 'synoption/exception'
+require 'synoption/list'
+
+module Synoption
+  class OptionSet < OptionList
+    include Logue::Loggable
+
+    # maps from the option set class to the valid options for that class.
+    @@options_for_class = Hash.new { |h, k| h[k] = Array.new }
+
+    attr_reader :unprocessed
+
+    def self.has_option name, optcls, optargs = Hash.new
+      @@options_for_class[self] << { :name => name, :class => optcls, :args => optargs }
+
+      define_method name do
+        instance_eval do
+          opt = instance_variable_get '@' + name.to_s          
+          opt.value
+        end
+      end
+    end
+
+    attr_reader :options
+    
+    def initialize options = Array.new
+      super 
+
+      cls = self.class
+      while cls != OptionSet
+        add_options_for_class cls
+        cls = cls.superclass
+      end
+    end
+
+    def add_options_for_class cls
+      opts = @@options_for_class[cls]
+
+      opts.each do |option|
+        name = option[:name]
+        cls = option[:class]
+        args = option[:args]
+        opt = cls.new(*args)
+        
+        add opt
+        instance_variable_set '@' + name.to_s, opt
+      end
+    end
+
+    def unset key
+      opt = find_by_name key
+      opt && opt.unset
+    end
+
+    def process args
+      options_processed = Array.new
+
+      @unprocessed = args
+
+      aborted = false
+      
+      while !@unprocessed.empty?
+        if @unprocessed[0] == '--'
+          @unprocessed.delete_at 0
+          aborted = true
+          break
+        end
+
+        processed = false
+
+        options.each do |opt|
+          if opt.process @unprocessed
+            processed = true
+            options_processed << opt
+          end
+        end
+
+        break unless processed
+      end
+
+      unless aborted
+        check_for_valid_options 
+      end
+
+      post_process_all options_processed
+    end
+
+    def check_for_valid_options 
+      @unprocessed.each do |opt|
+        if opt.start_with? '-'
+          raise OptionException.new "error: option: #{opt} invalid for #{name}"
+        end
+      end
+    end
+
+    def post_process_all options_processed
+      options_processed.each do |opt|
+        opt.post_process self, @unprocessed
+      end
+    end
+  end
+end

data/test/synoption/base_option_test.rb

@@ -0,0 +1,180 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'synoption/base_option'
+require 'stringio'
+
+module Synoption
+  class BaseOptionTestCase < TestCase    
+    def test_init_minimal
+      opt = BaseOption.new :limit, '-l', "the number of log entries", nil
+      assert_equal :limit, opt.name
+      assert_equal '-l', opt.tag
+      assert_equal "the number of log entries", opt.description
+    end
+
+    def test_init_default_value
+      opt = BaseOption.new :nombre, '-x', " one two three", 133
+      assert_equal 133, opt.value
+    end
+
+    def test_init_negate
+      opt = BaseOption.new :limit, '-l', "the number of log entries", nil, :negate => [ %r{^--no-?limit} ]
+      assert_equal [ %r{^--no-?limit} ], opt.negate
+    end
+
+    def test_to_doc
+      opt = BaseOption.new :limit, '-l', "the number of log entries", 777, :negate => [ %r{^--no-?limit} ]
+      sio = StringIO.new
+      opt.to_doc sio
+      exp = String.new
+      exp << "  -l [--limit] ARG         : the number of log entries\n"
+      exp << "                               default: 777\n"
+      exp << "  --no-limit                 \n"
+      assert_equal exp, sio.string
+    end
+
+    def assert_exact_match exp, opt, val
+      assert_equal exp, opt.exact_match?(val), "value: '" + val + "'"
+    end
+
+    def test_exact_match
+      opt = BaseOption.new :limit, '-l', "the number of log entries", 3
+      [ '-l', '--limit' ].each do |val|
+        assert_exact_match true, opt, val
+      end
+
+      [ '-L', '-x', '--lim', '--liMit' ].each do |val|
+        assert_exact_match false, opt, val
+      end
+    end
+
+    def assert_negative_match exp, opt, val
+      md = opt.negative_match? val
+      assert_equal exp, !!md, "value: '" + val + "'"
+    end
+
+    def test_negative_match
+      opt = BaseOption.new :limit, '-l', "the number of log entries", 777, :negate => [ '-L', %r{^--no-?limit} ]
+      [ '-L', '--no-limit', '--nolimit' ].each do |val|
+        assert_negative_match true, opt, val
+      end
+
+      [ '-l', '-x', '-nolimit', '  --nolimit' ].each do |val|
+        assert_negative_match false, opt, val
+      end
+    end
+
+    def assert_regexp_match exp, opt, val
+      md = opt.regexp_match? val
+      assert_equal exp, !!md, "value: '" + val + "'"
+    end
+
+    def test_regexp_match
+      opt = BaseOption.new :revision, '-r', "the revision", nil, :regexp => Regexp.new('^[\-\+]\d+$')
+      [ '-1', '-123', '+99', '+443' ].each do |val|
+        assert_regexp_match true, opt, val
+      end
+
+      [ '-x', '123', '+-x', 'word' ].each do |val|
+        assert_regexp_match false, opt, val
+      end
+    end
+
+    def assert_to_command_line exp, opt
+      assert_equal exp, opt.to_command_line
+    end
+
+    def make_xyz_option options = Hash.new
+      BaseOption.new :xyz, '-x', "the blah blah blah", nil, options
+    end
+
+    def test_to_command_line_no_cmdline_option
+      opt = make_xyz_option
+      assert_to_command_line nil, opt
+      opt.set_value 1
+      assert_to_command_line [ '-x', 1 ], opt
+    end
+
+    def test_to_command_line_cmdline_option_string
+      opt = make_xyz_option :as_cmdline_option => '--xray'
+      assert_to_command_line nil, opt
+      opt.set_value 1
+      assert_to_command_line '--xray', opt
+    end
+
+    def test_to_command_line_cmdline_option_nil
+      opt = make_xyz_option :as_cmdline_option => nil
+      assert_to_command_line nil, opt
+      opt.set_value 1
+      assert_to_command_line nil, opt
+    end
+
+    def test_takes_value
+      opt = make_xyz_option
+      assert opt.takes_value?
+    end
+
+    def assert_process exp_process, exp_value, exp_remaining_args, opt, args
+      pr = opt.process args
+      assert_equal exp_process, pr
+      assert_equal exp_value, opt.value
+      assert_equal exp_remaining_args, args
+    end
+
+    def test_process_exact_no_match
+      opt = make_xyz_option
+      args = %w{ --baz foo }
+      assert_process false, nil, %w{ --baz foo }, opt, args
+    end
+
+    def test_process_exact_takes_argument
+      opt = make_xyz_option
+      args = %w{ --xyz foo }
+      assert_process true, 'foo', %w{ }, opt, args
+
+      opt = make_xyz_option
+      args = %w{ --xyz foo bar }
+      assert_process true, 'foo', %w{ bar }, opt, args
+    end
+
+    def test_process_exact_takes_missing_argument
+      opt = make_xyz_option
+      args = %w{ --xyz }
+      assert_raises(RuntimeError) do 
+        assert_process true, 'foo', %w{ }, opt, args
+      end
+    end
+
+    def test_process_negative
+      options = { :negate => [ '-X', %r{^--no-?xyz} ] }
+      %w{ -X --no-xyz --noxyz }.each do |arg|
+        opt = make_xyz_option options
+        args = [ arg ]
+        assert_process true, false, %w{ }, opt, args
+      end
+
+      %w{ -X --no-xyz --noxyz }.each do |arg|
+        opt = make_xyz_option options
+        args = [ arg, '--abc' ]
+        assert_process true, false, %w{ --abc }, opt, args
+      end
+    end
+
+    def test_process_regexp
+      options = { :regexp => Regexp.new('^[\-\+]\d+$') }
+      %w{ -1 +123 }.each do |arg|
+        opt = make_xyz_option options
+        args = [ arg ]
+        assert_process true, arg, %w{ }, opt, args
+      end
+
+      %w{ -1 +123 }.each do |arg|
+        opt = make_xyz_option options
+        args = [ arg, '--foo' ]
+        assert_process true, arg, %w{ --foo }, opt, args
+      end
+    end
+  end
+end

data/test/synoption/match_test.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'synoption/match'
+
+module Synoption
+  class MatchTestCase < TestCase
+    def assert_match exp, matcher, arg
+      assert_equal exp, matcher.match?(arg), "arg: #{arg}"
+    end
+
+    def assert_matches exp, matcher, *args
+      args.each do |arg|
+        assert_match exp, matcher, arg
+      end
+    end
+
+    def test_exact
+      matcher = OptionExactMatch.new '-t', 'tagname'
+      assert_matches true,  matcher, '-t', '--tagname'
+      assert_matches false, matcher, '-T', '--tag-name', '--no-tagname', '--notagname'
+    end
+
+    def test_negative_string
+      matcher = OptionNegativeMatch.new '-T'
+      assert_matches true,  matcher, '-T'
+      assert_matches false, matcher, '-t'
+    end
+
+    def test_negative_regexp
+      matcher = OptionNegativeMatch.new %r{^\-\-no\-?tagname$}
+      assert_matches true,  matcher, '--no-tagname', '--notagname'
+      assert_matches false, matcher, '-t', '--non-tagname' '--nontagname'
+    end
+
+    def test_negative_multiple
+      matcher = OptionNegativeMatch.new %r{^\-\-no\-?tagname$}, '-T'
+      assert_matches true,  matcher, '-T', '--no-tagname', '--notagname'
+      assert_matches false, matcher, '-t', '--tagname'
+    end
+
+    def assert_match_not_nil matcher, arg
+      assert_not_nil matcher.match?(arg), "arg: #{arg}"
+    end
+
+    def assert_matches_not_nil matcher, *args
+      args.each do |arg|
+        assert_match_not_nil matcher, arg
+      end
+    end
+
+    def test_regexp_match
+      matcher = OptionRegexpMatch.new %r{^--tag-?name$}
+      assert_matches_not_nil matcher, '--tagname', '--tag-name'
+      assert_matches nil,    matcher, '--tagnames' '--tag--name'
+    end
+  end
+end

data/test/synoption/option_test.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'synoption/option'
+require 'stringio'
+
+module Synoption
+  class OptionTestCase < TestCase
+    def test_nothing_yet
+    end
+  end
+end

data/test/synoption/set_test.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'tc'
+require 'synoption/set'
+require 'synoption/base_option'
+
+module Synoption
+  class SetTestCase < TestCase
+    class TestOptionSet < OptionSet
+      def name
+        'test'
+      end
+    end
+
+    def setup
+      @xyz = BaseOption.new :xyz, '-x', "blah blah xyz",    nil
+      @abc = BaseOption.new :abc, '-a', "abc yadda yadda",  nil
+      @tnt = BaseOption.new :tnt, '-t', "tnt and so forth", nil
+      
+      @optset = TestOptionSet.new [ @xyz, @abc, @tnt ]
+    end
+
+    def test_find_by_name
+      assert_not_nil @optset.find_by_name(:xyz)
+      assert_nil @optset.find_by_name(:bfd)
+    end
+
+    def test_process_set
+      @optset.process %w{ -x foo }
+      
+      assert_equal 'foo', @xyz.value
+    end
+
+    def test_process_not_set
+      @optset.process %w{ -x foo }
+      
+      assert_nil @abc.value
+      assert_nil @tnt.value
+    end
+
+    def test_bad_option
+      assert_raises(OptionException) do
+        @optset.process %w{ -y foo }
+      end
+    end
+
+    def test_stop_on_double_dash
+      @optset.process %w{ -- -x foo }
+      
+      assert_nil @xyz.value
+      assert_nil @abc.value
+      assert_nil @tnt.value
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: synoption
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Jeff Pace
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: Another implementation of an option processor.
+email: jeugenepace@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/synoption/base_option.rb
+- lib/synoption/boolean_option.rb
+- lib/synoption/doc.rb
+- lib/synoption/exception.rb
+- lib/synoption/fixnum_option.rb
+- lib/synoption/list.rb
+- lib/synoption/match.rb
+- lib/synoption/matchers.rb
+- lib/synoption/option.rb
+- lib/synoption/set.rb
+- test/synoption/base_option_test.rb
+- test/synoption/match_test.rb
+- test/synoption/option_test.rb
+- test/synoption/set_test.rb
+homepage: http://www.incava.org/projects/synoption
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Yet another getopt-like library.
+test_files:
+- test/synoption/base_option_test.rb
+- test/synoption/match_test.rb
+- test/synoption/option_test.rb
+- test/synoption/set_test.rb