pickled_optparse 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.rspec

@@ -0,0 +1 @@
+--color

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Mike Bethany
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,35 @@
+= pickled_optparse
+
+Allows a programmer to easily add required switches to a Ruby app using the built-in OptionParser class.
+
+To make a switch required simple add the symbol :required anywhere in the list of options like so:
+  
+  opts.on("-f [foo]", String, :required, "Required option") do |option|
+    @options[:foo] = option
+  end
+
+Then at the end of your OptionParser block add something like this:
+  
+  if opts.missing_switches?
+    puts opts.missing_switches
+    puts opts
+    exit
+  end
+
+You of course need to require the "pickled_optparse" gem but that's it. You don't need to require the opt_parse file because that's already handled for you.
+
+For a complete usage example see the lib/example.rb file.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Mike Bethany. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.required_ruby_version = '~> 1.9.2' # Everyone should upgrade, now!
+    gem.name = "pickled_optparse"
+    gem.summary = %Q{Adds required switches to the OptionParser class}
+    gem.description = %Q{Adds the ability to easily specify and test for required switches in Ruby's built-in OptionParser class}
+    gem.email = "picklepumpers@gmail.com"
+    gem.homepage = "http://github.com/PicklePumpers/pickled_optparse"
+    gem.authors = ["Mike Bethany"]
+    gem.add_development_dependency "rspec", ">= 2.0.1"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t| 
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"] 
+  t.pattern = 'spec/*/*_spec.rb' 
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov_opts =  %q[--exclude "spec"]
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pickled_optparse #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery {"rspec2"}

data/lib/example.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require_relative 'pickled_optparse'
+
+# Configure options based on command line options
+@options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: test [options] in_file[.srt] out_file[.srt]"
+  
+  # Note that :required can be anywhere in the parameters
+  
+  # Also note that OptionParser is bugged and will only check 
+  # for required parameters on the last option, not my bug.
+   
+  # required switch, required parameter
+  opts.on("-s Short", String, :required, "a required switch with just a short") do |operation|
+    @options[:operation] = operation
+  end
+
+  # required switch, optional parameter
+  opts.on(:required, "--long [Long]", String, "a required switch with just a long") do |operation|
+    @options[:operation] = operation
+  end
+
+  # required switch, required parameter
+  opts.on("-b", "--both ShortAndLong", String, "a required switch with short and long", :required) do |operation|
+    @options[:operation] = operation
+  end
+
+  # optional switch, optional parameter
+  opts.on("-o", "--optional [Whatever]", String, "an optional switch with short and long") do |operation|
+    @options[:operation] = operation
+  end
+
+  # Now we can see if there are any missing required 
+  # switches so we can alert the user to what they 
+  # missed and how to use the program properly.
+  if opts.missing_switches?
+    puts opts.missing_switches
+    puts opts
+    exit
+  end
+
+end.parse!

data/lib/pickled_optparse.rb

@@ -0,0 +1,156 @@
+require 'optparse'
+
+# Add the ability to specify switches as required to OptionParser
+class OptionParser
+  
+  # An array of messages describing any missing required switches
+  attr_reader :missing_switches
+  
+  # Convenience method to test if we're missing any required switches
+  def missing_switches?
+    !@missing_switches.nil?
+  end
+
+  def make_switch(opts, block = nil)
+    short, long, nolong, style, pattern, conv, not_pattern, not_conv, not_style = [], [], []
+    ldesc, sdesc, desc, arg = [], [], []
+    default_style = Switch::NoArgument
+    default_pattern = nil
+    klass = nil
+    n, q, a = nil
+
+    # Check for required switches
+    required = opts.delete(:required)
+
+    opts.each do |o|
+      
+      # argument class
+      next if search(:atype, o) do |pat, c|
+        klass = notwice(o, klass, 'type')
+        if not_style and not_style != Switch::NoArgument
+          not_pattern, not_conv = pat, c
+        else
+          default_pattern, conv = pat, c
+        end
+      end
+
+      # directly specified pattern(any object possible to match)
+      if (!(String === o || Symbol === o)) and o.respond_to?(:match)
+        pattern = notwice(o, pattern, 'pattern')
+        if pattern.respond_to?(:convert)
+          conv = pattern.method(:convert).to_proc
+        else
+          conv = SPLAT_PROC
+        end
+        next
+      end
+
+      # anything others
+      case o
+        when Proc, Method
+          block = notwice(o, block, 'block')
+        when Array, Hash
+          case pattern
+            when CompletingHash
+            when nil
+              pattern = CompletingHash.new
+              conv = pattern.method(:convert).to_proc if pattern.respond_to?(:convert)
+            else
+              raise ArgumentError, "argument pattern given twice"
+          end
+          o.each {|pat, *v| pattern[pat] = v.fetch(0) {pat}}
+        when Module
+          raise ArgumentError, "unsupported argument type: #{o}", ParseError.filter_backtrace(caller(4))
+        when *ArgumentStyle.keys
+          style = notwice(ArgumentStyle[o], style, 'style')
+        when /^--no-([^\[\]=\s]*)(.+)?/
+          q, a = $1, $2
+          o = notwice(a ? Object : TrueClass, klass, 'type')
+          not_pattern, not_conv = search(:atype, o) unless not_style
+          not_style = (not_style || default_style).guess(arg = a) if a
+          default_style = Switch::NoArgument
+          default_pattern, conv = search(:atype, FalseClass) unless default_pattern
+          ldesc << "--no-#{q}"
+          long << 'no-' + (q = q.downcase)
+          nolong << q
+        when /^--\[no-\]([^\[\]=\s]*)(.+)?/
+          q, a = $1, $2
+          o = notwice(a ? Object : TrueClass, klass, 'type')
+          if a
+            default_style = default_style.guess(arg = a)
+            default_pattern, conv = search(:atype, o) unless default_pattern
+          end
+          ldesc << "--[no-]#{q}"
+          long << (o = q.downcase)
+          not_pattern, not_conv = search(:atype, FalseClass) unless not_style
+          not_style = Switch::NoArgument
+          nolong << 'no-' + o
+        when /^--([^\[\]=\s]*)(.+)?/
+          q, a = $1, $2
+          if a
+            o = notwice(NilClass, klass, 'type')
+            default_style = default_style.guess(arg = a)
+            default_pattern, conv = search(:atype, o) unless default_pattern
+          end
+          ldesc << "--#{q}"
+          long << (o = q.downcase)
+        when /^-(\[\^?\]?(?:[^\\\]]|\\.)*\])(.+)?/
+          q, a = $1, $2
+          o = notwice(Object, klass, 'type')
+          if a
+            default_style = default_style.guess(arg = a)
+            default_pattern, conv = search(:atype, o) unless default_pattern
+          end
+          sdesc << "-#{q}"
+          short << Regexp.new(q)
+        when /^-(.)(.+)?/
+          q, a = $1, $2
+          if a
+            o = notwice(NilClass, klass, 'type')
+            default_style = default_style.guess(arg = a)
+            default_pattern, conv = search(:atype, o) unless default_pattern
+          end
+          sdesc << "-#{q}"
+          short << q
+        when /^=/
+          style = notwice(default_style.guess(arg = o), style, 'style')
+          default_pattern, conv = search(:atype, Object) unless default_pattern
+        else
+          desc.push(o)
+      end
+    
+    end
+    
+    default_pattern, conv = search(:atype, default_style.pattern) unless default_pattern
+    if !(short.empty? and long.empty?)
+      s = (style || default_style).new(pattern || default_pattern, conv, sdesc, ldesc, arg, desc, block)
+    elsif !block
+      if style or pattern
+        raise ArgumentError, "no switch given", ParseError.filter_backtrace(caller)
+      end
+      s = desc
+    else
+      short << pattern
+      s = (style || default_style).new(pattern, conv, nil, nil, arg, desc, block)
+    end
+
+    # Make sure required switches are given
+    if required && !(default_argv.include?("-#{short[0]}") || default_argv.include?("--#{long[0]}"))
+        @missing_switches ||= [] # Should be placed in initialize if incorporated into Ruby proper
+        
+        # This is ugly, long, and not very DRY but it is easy to understand
+        #missing = "-#{short[0]}" if !short.empty?
+        #missing = "#{missing} or " if !short.empty? && !long.empty?
+        #missing = "#{missing}--#{long[0]}" if !long.empty?
+        
+        # This is even uglier, and really hard to read, but it is shorter and 
+        # as DRY as I could figure out how to make it... but it still stinks.
+        @missing_switches << "Missing switch: #{"-#{short[0]}" if !short.empty?}#{" or " if !short.empty? && !long.empty?}#{"--#{long[0]}" if !long.empty?}"
+    end
+    
+    return s, short, long,
+      (not_style.new(not_pattern, not_conv, sdesc, ldesc, nil, desc, block) if not_style),
+      nolong
+  end
+  
+end

data/spec/pickled_optparse/pickled_optparse_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../spec_helper'
+
+describe "Pickled OptionParse" do
+
+  before do
+    @op = OptionParser.new
+  end
+  
+  describe "added properites" do
+    it "should have a missing_switches? parameter to indicate there are missing ones" do
+      @op.should respond_to(:missing_switches?)
+    end 
+    
+    it "should have a missing_switches parameter to describe the missing switches" do
+      @op.should respond_to(:missing_switches)
+    end
+  end # added properites
+
+  describe "no required switches missing" do
+  
+    it "should not have :missing_switches? set to true" do
+      ARGV << "-r"
+      op = OptionParser.new
+      op.on("-r", "--required_switch", String, :required, "a required switch")
+      op.parse!
+      op.missing_switches?.should_not == true
+    end
+
+  end # no required switches missing
+
+  describe "required switches are missing" do
+    before do
+      @op.on("-r", "--required_switch", String, :required, "a required switch")
+      @op.on("-s pickle_type", String, :required, "a required switch")
+      @op.on("--third_required_switch [blah]", String, :required, "a required switch")
+      @op.parse!
+    end
+    
+    it "should have :missing_switches? set to true" do
+      @op.missing_switches?.should == true
+    end
+  
+    it "should store information about the missing switches" do
+      @op.missing_switches.to_s.downcase.should include('missing switch', 
+                                                        '-r', '--required_switch', 
+                                                        '-s', 
+                                                        '--third_required_switch')
+    end
+    
+  end # required switches are missing
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+require 'rspec'
+require 'pickled_optparse'
+
+

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: pickled_optparse
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mike Bethany
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-30 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id001
+description: Adds the ability to easily specify and test for required switches in Ruby's built-in OptionParser class
+email: picklepumpers@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .rspec
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- autotest/discover.rb
+- lib/example.rb
+- lib/pickled_optparse.rb
+- spec/pickled_optparse/pickled_optparse_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/PicklePumpers/pickled_optparse
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      - 2
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Adds required switches to the OptionParser class
+test_files: 
+- spec/pickled_optparse/pickled_optparse_spec.rb
+- spec/spec_helper.rb