remi-optparse-simple 0.1.0

data/README.rdoc

@@ -0,0 +1,27 @@
+= optparse-simple
+
+A partial pre-implementation of OptionParser, in particular that actual parsing part:
+
+  opts = OptionParser.new do |opts|
+    opts.in('-f', '--foo'){ ... }
+  end
+
+  opts.parse! args
+
+I really love optparse but:
+
+- I don't care about separators / banners / etc, I use other gems/libraries for that stuff
+- optparse is a PITA to extend and the source code is <b>1,791</b> lines long!
+
+This is a re-implementation of the part of optparse that actually parses.
+
+This is <b>not</b> trying to be a whole framework for creating CLI applications. 
+There are already numerous great tools out there.  Unfortunately, many of them 
+re-implement OptionParser, themselves, because there's no library out there (that 
+I know of) that <b>just</b> does the parsing part.
+
+Our libraries need to be more UNIX-y!  "Write programs that do one thing and do it well."
+
+== install
+
+<b>NOT YET COMPLETE</b>

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rake'
+require 'rubygems'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = "optparse-simple"
+    s.summary     = "a partial reimplementation of OptionParser"
+    s.email       = "remi@remitaylor.com"
+    s.homepage    = "http://github.com/remi/optparse-simple"
+    s.description = "a partial reimplementation of OptionParser"
+    s.authors     = %w( remi )
+    s.files       = FileList["[A-Z]*", "{bin,lib,spec,examples,rails_generators}/**/*"] 
+    s.add_dependency 'remi-indifferent-variable-hash' 
+    # s.executables = "optparse-simple"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'optparse-simple'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Confirm that gemspec is $SAFE'
+task :safe do
+  require 'yaml'
+  require 'rubygems/specification'
+  data = File.read('optparse-simple.gemspec')
+  spec = nil
+  if data !~ %r{!ruby/object:Gem::Specification}
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  else
+    spec = YAML.load(data)
+  end
+  spec.validate
+  puts spec
+  puts "OK"
+end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 1

data/lib/optparse-simple.rb

@@ -0,0 +1,161 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'indifferent-variable-hash'
+
+class OptParseSimple
+  extend IndifferentVariableHash
+
+  # an Array of Options
+  attr_accessor :options
+
+  # DEFAULT configuration values
+  OptParseSimple.compatibility_mode = false # whether or not OptParseSimple acts like OptionParser
+
+  def initialize &block
+    block.call self
+  end
+
+  def parse args
+    check_for_invalid_options(args) if OptParseSimple.compatibility_mode
+    options.each {|option| option.parse(args) }
+  end
+
+  def parse! args
+    check_for_invalid_options(args) if OptParseSimple.compatibility_mode
+    options.each {|option| option.parse!(args) }
+  end
+
+  #:nodoc:
+  def options
+    @options ||= []
+  end
+
+  def on *args, &block
+    options << Option.new(*args, &block)
+  end
+
+  private
+
+  def check_for_invalid_options args
+    args_clone = args.clone
+    options.each {|option| option.match! args_clone }
+    raise "invalid option: #{ args_clone.first }" unless args_clone.empty?
+  end
+
+end
+
+class OptParseSimple #:nodoc:
+
+  # 
+  # represents a single option, eg. its matchers (-f, --foo) 
+  # and its block of logic to call, if matched
+  #
+  class Option
+    attr_accessor :short_string, :long_string, :accepts_argument, :proc
+
+    def initialize *args, &block
+      set_defaults
+
+      @proc = block
+
+      # take arguments (eg. '-f' or '--f' or '--f [foo]')
+      # and set #short_string, #long_string, and #accepts_argument
+      args.each do |arg|
+        case arg
+        when /^-(\w)/
+          @short_string = $1 
+        when /^--(\w+)/
+          @long_string = $1
+        else
+          raise "Don't know how to handle argument: #{ arg.inspect }"
+        end
+
+        @accepts_argument = true if arg =~ /\[.*\]$/
+      end
+    end
+
+    def short_string_with_dash
+      (short_string) ? "-#{ short_string }" : ''
+    end
+
+    def long_string_with_dashes
+      (long_string) ? "--#{ long_string }" : ''
+    end
+
+    def parse *args
+      args = args.first if args.first.is_a?(Array) and args.length == 1
+      do_parsing args, :run => true, :destructive => false
+    end
+    
+    def parse! *args
+      args = args.first if args.first.is_a?(Array) and args.length == 1
+      do_parsing args, :run => true, :destructive => true
+    end
+
+    def match *args
+      args = args.first if args.first.is_a?(Array) and args.length == 1
+      do_parsing args, :run => false, :destructive => false
+    end
+
+    def match! *args
+      args = args.first if args.first.is_a?(Array) and args.length == 1
+      do_parsing args, :run => false, :destructive => true
+    end
+
+    alias accept_argument?   accepts_argument
+    alias accept_arguments?  accepts_argument
+    alias accepts_argument?  accepts_argument
+    alias accepts_arguments? accepts_argument
+
+    private
+
+    def do_parsing args, options = { }
+      options = { :run => false, :destructive => false }.merge(options)
+      
+      if accepts_arguments?
+        match_with_arguments args, options
+      else
+        match_without_arguments args, options
+      end
+    end
+
+    def match_without_arguments args, options
+      args.each do |arg|
+        if arg == short_string_with_dash || arg == long_string_with_dashes
+          args.delete arg if options[:destructive]
+          @proc.call if options[:run] and @proc.respond_to?(:call)
+          return true
+        end
+      end
+      return false
+    end
+
+    def match_with_arguments args, options
+      indexes_that_match = [] # indexes that match either the short or long string
+      args.each_with_index do |arg, index|
+        indexes_that_match << index if arg == short_string_with_dash || arg == long_string_with_dashes
+        if indexes_that_match.include?( index - 1 )
+          unless arg.start_with?('-')
+            this_argument = arg
+            if options[:destructive]
+              args.delete_at index - 1 # delete the last matching index
+              args.delete_at index - 1 # delete this index (-1 because we deleted matching)
+            end
+            if options[:run] and @proc.respond_to?(:call)
+              @proc.call this_argument
+            end
+
+            return true
+          end
+        end
+      end
+      return false
+    end
+
+    def set_defaults
+      @accepts_argument = false
+    end
+  end
+
+end

data/spec/option_spec.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe OptParseSimple::Option do
+
+  before :all do
+    ::Option = OptParseSimple::Option
+  end
+
+  it "should hold onto the block it's initalized with" do
+    option = Option.new('-f'){ "hello from block" }
+    option.proc.should respond_to(:call)
+    option.proc.call.should == "hello from block"
+
+    option.accepts_arguments?.should be_false
+  end
+
+  it 'should have a short string' do
+    option = Option.new('-f')
+    option.short_string.should == 'f'
+    option.long_string.should be_nil
+
+    option.accepts_arguments?.should be_false
+  end
+
+  it 'should have a long string' do
+    option = Option.new('--foo')
+    option.long_string.should == 'foo'
+    option.short_string.should be_nil
+
+    option.accepts_arguments?.should be_false
+  end
+
+  it 'should have a short string and a long string' do
+    option = Option.new('-f', '--foo')
+    option.short_string.should == 'f'
+    option.long_string.should == 'foo'
+
+    # order shouldn't matter
+    option2 = Option.new('--foo', '-f')
+    option2.short_string.should == 'f'
+    option2.long_string.should == 'foo'
+
+    option.accepts_arguments?.should be_false
+  end
+
+  it 'should be able to accept an argument' do
+    Option.new('-f [x]').accepts_arguments?.should be_true    
+    Option.new('--foo [abc]').accepts_arguments?.should be_true    
+    Option.new('-f', '--f [123]').accepts_arguments?.should be_true    
+    Option.new('-f [x]', '--f').accepts_arguments?.should be_true    
+    Option.new('-f []', '--f').accepts_arguments?.should be_true    
+  end
+
+  it 'should be able to determine if it #match a set of args' do
+    Option.new('-f').match(['-f']).should be_true
+    Option.new('-f').match(['-d']).should be_false
+    Option.new('-f').match(['-a', 'hi', '1', '-f', '-g']).should be_true
+
+    Option.new('-f [x]').match(['-f']).should be_false
+    Option.new('-f [x]').match(['-f', '-g']).should be_false
+    Option.new('-f [x]').match(['hi', '-f']).should be_false
+    Option.new('-f [x]').match(['hi', '-f', '5']).should be_true
+    Option.new('-f [x]').match(['hi', '-f', 'hi there']).should be_true
+
+    # should *not* run procs
+    Option.new('-f'){ @foo = 'w00t' }.match(['-f']).should be_true
+    @foo.should be_nil
+  end
+
+  it 'should be able to #parse args (and run proc)' do
+    @foo = nil
+    Option.new('-f'){ @foo = 'w00t' }.parse(['-x']).should be_false
+    @foo.should be_nil
+    Option.new('-f'){ @foo = 'w00t' }.parse(['-f']).should be_true
+    @foo.should == 'w00t'
+
+    # also shouldn't alter args
+    args = ['-x', '-f', '-g']
+    Option.new('-f'){ @foo = 'w00t again' }.parse(args).should be_true
+    @foo.should == 'w00t again'
+    args.should == ['-x', '-f', '-g']
+  end
+
+  it 'should be able to #parse! (destructively) args (and run proc)' do
+    # should alter args
+    @foo = nil
+    args = ['-x', '-f', '-g']
+    Option.new('-f'){ @foo = 'w00t' }.parse!(args).should be_true
+    @foo.should == 'w00t'
+    args.should == ['-x', '-g']
+  end
+
+  it "should pass arguments to proc when #parse[!]'d (if accepts_arguments)" do
+    # should not modify
+    args = %w(-x -f 5 -y)
+    Option.new('-f [x]'){|x| @foo = "it is #{x}" }.parse(args).should be_true
+    @foo.should == "it is 5"
+    args.should == %w(-x -f 5 -y)
+
+    # should modify
+    args = %w(-x -f 8 -y)
+    Option.new('-f [x]'){|x| @foo = "it is #{x}" }.parse!(args).should be_true
+    @foo.should == "it is 8"
+    args.should == %w(-x -y)
+  end
+
+end

data/spec/optparse_simple_spec.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe OptParseSimple, 'parsing' do
+
+  before do
+    ARGV.clear
+
+    # make OptParseSimple act exactly like OptionParser
+    OptParseSimple.compatibility_mode = true
+  end
+
+  it 'parse -f (compatibility mode)' do
+    [ OptionParser, OptParseSimple ].each do |parser|
+      @args = ['-a', '-f', '-x']
+      @foo = nil
+
+      opts = parser.new do |opts|
+        opts.on('-f'){ puts "-f block CALLED!"; @foo = 'w00t' }
+      end
+
+      @foo.should be_nil
+
+      lambda { opts.parse @args }.should raise_error(/invalid option: -a/)
+
+      # @foo.should  == 'w00t'
+      # @args.should == ['-a', '-f', '-x']
+    end
+  end
+
+  it 'parse! -f (compatibility mode)' do
+    [ OptionParser, OptParseSimple ].each do |parser|
+      @args = ['-a', '-f', '-x']
+      @foo = nil
+
+      opts = parser.new do |opts|
+        opts.on('-f'){ puts "-f block CALLED!"; @foo = 'w00t' }
+      end
+
+      @foo.should be_nil
+
+      lambda { opts.parse! @args }.should raise_error(/invalid option: -a/)
+
+      # @foo.should  == 'w00t'
+      # @args.should == ['-a', '-x']
+    end
+  end
+
+  it 'parse -f' do
+    OptParseSimple.compatibility_mode = false
+
+    @args = ['-a', '-f', '-x']
+    @foo = nil
+
+    opts = OptParseSimple.new do |opts|
+      opts.on('-f'){ puts "-f block CALLED!"; @foo = 'w00t' }
+    end
+
+    @foo.should be_nil
+
+    opts.parse @args
+
+    @foo.should  == 'w00t'
+    @args.should == ['-a', '-f', '-x']
+  end
+
+  it 'parse! -f' do
+    OptParseSimple.compatibility_mode = false
+
+    @args = ['-a', '-f', '-x']
+    @foo = nil
+
+    opts = OptParseSimple.new do |opts|
+      opts.on('-f'){ puts "-f block CALLED!"; @foo = 'w00t' }
+    end
+
+    @foo.should be_nil
+
+    opts.parse! @args
+
+    @foo.should  == 'w00t'
+    @args.should == ['-a', '-x']
+  end
+
+  it '--foo'
+
+  it '-f, --foo'
+
+  it '-f X'
+
+  # TODO i think OptionParser supports the -f=X / --foo=X syntaxes ... i need to add support!
+  it '-f=X'
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/optparse-simple'

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: remi-optparse-simple
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- remi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-02 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: remi-indifferent-variable-hash
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: a partial reimplementation of OptionParser
+email: remi@remitaylor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- VERSION.yml
+- README.rdoc
+- lib/optparse-simple.rb
+- spec/option_spec.rb
+- spec/spec_helper.rb
+- spec/optparse_simple_spec.rb
+has_rdoc: true
+homepage: http://github.com/remi/optparse-simple
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: a partial reimplementation of OptionParser
+test_files: []
+