hirobumi-argument_sensei 0.1.0

data/README.rdoc

@@ -0,0 +1,57 @@
+= ArgumentSensei
+
+ArgumentSensei is yet another command-line argument parser with a minimal set of features.
+
+== Installation
+
+	sudo gem install hirobumi-argument_sensei -s http://gems.github.com --no-ri --no-rdoc
+
+== Usage
+
+	require 'rubygems'
+	require 'argument_sensei'
+	
+	commands = ArgumentSensei.define do
+	
+		option 'help', :short => 'h' do
+			arguments 0
+			describe 'show this message'
+			action do
+				# commands to run when -h or --help is given.
+			end # action do
+		end # option 'help', :short => 'h' do
+
+		default 'help'
+
+	end 
+	
+	# ...
+	
+	# in the place you want to run the codes...
+	commands.run!
+	
+
+== License
+
+Copyright (c) 2009 Hirobumi Hama
+
+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/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+require 'lib/argument_sensei/version'
+
+task :default => :test
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'argument_sensei'
+  s.version          = ArgumentSensei::Version.to_s
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w(README.rdoc)
+  s.rdoc_options     = %w(--main README.rdoc)
+  s.summary          = "ArgumentSensei is yet another command-line argument parser with a minimal set of features."
+  s.author           = 'Hirobumi Hama'
+  s.email            = 'hama@yoidore.org'
+  s.homepage         = 'http://yoidore.org/argument_sensei'
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{lib,test}/**/*")
+  # s.executables    = ['argument_sensei']
+  
+  # s.add_dependency('gem_name', '~> 0.0.1')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+desc 'Generate the gemspec to serve this Gem from Github'
+task :github do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, 'w') {|f| f << spec.to_ruby }
+  puts "Created gemspec: #{file}"
+end

data/lib/argument_sensei/commands.rb

@@ -0,0 +1,259 @@
+module ArgumentSensei
+  
+  class Commands
+
+    include Enumerable
+
+    def initialize(opts = {})
+      @arguments = opts[:arguments] || ARGV || []
+      @options = opts[:options] || []
+      @queue = {}
+      @default = nil
+    end # def initialize(opts = {})
+
+    attr_reader :arguments, :options
+
+    def method_missing(method_name, *args, &block)
+      if @options.respond_to?(method_name)
+        @options.send(method_name, *args, &block)
+      else
+        raise(NameError.new("undefined local variable or method '#{method_name}' for both #{inspect} and its @options"))
+      end
+    end
+
+    # parses and runs actions if necessary, returns a hash of command-line options
+    def run!
+      count = 0
+
+      h = parse
+      keys = h.keys
+
+      opts = @options.select { |o| o[:priority] == :option && (keys.include?(o[:long]) || keys.include?(o[:short])) } || []
+      runs = @options.select { |o| o[:priority] == :runner && (keys.include?(o[:long]) || keys.include?(o[:short])) } || []
+
+      # TODO: Exception message can be more informative.
+      raise(RuntimeError.new(runs.map { |o| "--#{o[:long]}/-#{o[:short]}" }.join(' ') + ' cannot be ran at the same time')) if runs.length > 1
+
+      (opts + runs).each do |o|
+        next unless o[:action]
+        if h.keys.include?(o[:short]) || h.keys.include?(o[:long])
+          o[:action].call(h[o[:short] || o[:long]])
+          count += 1
+        end
+      end # @options.each do |o|
+
+      if count == 0 && !@default.nil? # runs default if given
+        definition(@default)[:action].call(nil)
+      end # if count == 0
+
+    end # def run!
+
+    # returns a hash of command-line options
+    def parse
+      arr = []
+      for_arguments = false
+      temp = []
+
+      # splits grouped booelean short options
+      @arguments.collect! do |x|
+        unless x =~ /^-\w{2,}/
+          x
+        else
+          x.gsub(/^-/, '').split(//).map do |y|
+            raise(ArgumentError.new("option #{y} (which takes #{definition(y)[:arguments]}) should not be combined (#{x})")) if definition(y) && definition(y)[:arguments] != 0
+            '-' + y
+          end # x.gsub(/^-/, '').split(//).map do |y|
+        end
+      end.flatten! # @arguments.collect! do |x|
+
+      @arguments.each do |x|
+
+        if for_arguments && ((argument_length(temp[0]) != :all && temp.length - 1 >= argument_length(temp[0])) || x =~ /^-+/)
+          arr << temp
+          for_arguments = false
+          temp = []
+        end # if for_arguments && temp.length - 1 >= argument_length(temp[0])
+
+        if x =~ /^-+/
+          unless option_defined?(x)
+            arr << x
+          else
+            for_arguments = true
+            temp << x
+          end
+        elsif for_arguments # if x =~ /^-+/
+          temp << x
+        else # elsif for_arguments if x =~ /^-+/
+          arr << x
+        end # end elsif for_arguments if x =~ /^-+/
+
+      end # each do |x|
+
+      arr << temp if temp.length > 0
+
+      hash = {}
+      hash[:orphans] = arr.select { |a| !a.is_a?(Array) }
+      (arr - hash[:orphans]).each do |a|
+        gsubbed = a[0].gsub(/^-+/, '')
+        if argument_length(gsubbed) == 0
+          hash[gsubbed] = true
+        else
+          hash[gsubbed] = a[1..-1]
+        end
+      end # (arr - hash[:orphans]).each do |a|
+
+      # make sure both :short and :long are filled if they are provided
+      each do |c|
+        short, long = [c[:short], c[:long]].map { |n| (n || '').gsub(/^-+/, '') }
+        next if short == '' || long == ''
+
+        if hash[short] || hash[long]
+          next if hash[short] == hash[long]
+          if hash[short].nil?
+            hash[short] = hash[long]
+          else
+            hash[long] = hash[short]
+          end
+        end
+
+      end # each do |c|
+
+      hash # returns
+    end # def parse
+
+    # finds a detailed option for given name
+    def definition(name)
+      n = name.gsub(/^-+/, '')
+      select { |h| h[:short] == n || h[:long] == n }[0] # can be nil
+    end
+
+    def option_defined?(name)
+      !!definition(name)
+    end # def defined?(name)
+
+    def argument_length(name)
+      definition(name)[:arguments]
+    end # def arguments(name)
+
+    def value(name)
+      definition(name)[:value]
+    end # def value(name)
+
+    def set_value(name, given_value)
+      hash = select { |h| h[:short] == name || h[:long] == name }[0]
+      raise(ArgumentError.new("option with #{name} could not be found")) if hash.nil?
+      @options[index(hash)] = hash.merge(:value => given_value) # [index(hash)]= gives you a syntax error
+    end # def set_value(name, given_value)
+
+    # shows help message to STDOUT
+    def help
+      STDERR.puts("USAGE: #{$0}")
+
+      @options.each do |o|
+
+        temp = ''
+
+        o[:short] ? temp << "-#{o[:short]}" : temp << "\t" 
+        temp.length > 0 ? temp << ", " : temp << "\t"
+        o[:long] ? temp << "--#{o[:long]}" : temp << "\t" 
+
+        temp << "\t\t"
+        temp << o[:description]
+
+        if o[:description]
+          temp << ' '
+        end
+
+        case o[:arguments]
+        when :all
+          temp << "(multiple arguments)"
+        when 0
+          temp << "(boolean)"
+        when 1
+          temp << "(1 argument)"
+        else
+          temp << "(#{o[:arguments]} arguments)"
+        end
+        puts temp
+
+      end # @options.each do |o|
+
+      nil
+    end # def help
+
+    def option(name, opts = {}, &block)
+      @queue = {
+        :short => opts[:short], # without hyphens
+        :long => opts[:long], # this too
+        :description => '',
+        :arguments => :all, # Integer, :all
+        :action => nil, # a Proc object, rarity should be :arguments, use *args if :all.
+        :priority => :option # priority, :option first then :runner. only one :runner should be called at a time.
+      } # defaults
+
+      if name.length > 1
+        @queue[:long] = name
+      else
+        @queue[:short] = name
+      end
+
+      instance_eval(&block) if block_given?
+
+      flush!
+    end
+
+    private
+
+    # flushes @queue into @commands array, used to implement DSL.
+    def flush!
+      return nil if @queue.empty?
+
+      self << @queue
+      @queue = {}
+      self[-1]
+    end  
+
+    def describe(desc = '', opts = {})
+      @queue[:description] = desc
+    end
+
+    # Integer or :all (= default), defaults are set in #option method
+    def arguments(n, opts = {})    
+      @queue[:arguments] = n
+    end
+
+    def action(opts = {}, &block)
+      @queue[:action] = block
+    end
+
+    # sets priority for the option, default is :option.
+    def priority(type)
+      raise(ArgumentError.new("priority must be :option or :runner but :#{type} given.")) unless [:option, :runner].include?(type)
+      @queue[:priority] = type
+    end # def priority(type)
+
+    def default(name)
+      @default = name
+    end
+
+    class << self
+
+      # Commands.define do
+      #   option 'run', :short => 'S' do
+      #     action do ||
+      #   end
+      # end
+      def define(opts = {}, &block)
+        raise(ArgumentError.new('no block given')) unless block_given?
+
+        c = Commands.new(opts)
+        c.instance_eval(&block)
+
+        c
+      end
+
+    end
+
+  end # class Commands
+  
+end # module ArgumentSensei

data/lib/argument_sensei/version.rb

@@ -0,0 +1,13 @@
+module ArgumentSensei
+  module Version
+    
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    
+    def self.to_s # :nodoc:
+      [MAJOR, MINOR, TINY].join('.')
+    end
+    
+  end
+end

data/lib/argument_sensei.rb

@@ -0,0 +1,7 @@
+$:.unshift File.dirname(__FILE__)
+
+module ArgumentSensei
+end # module ArgumentSensei
+
+require 'argument_sensei/version'
+require 'argument_sensei/commands'

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+# http://sneaq.net/textmate-wtf
+$:.reject! { |e| e.include? 'TextMate' }
+
+require 'rubygems'
+require 'test/unit'
+gem 'thoughtbot-shoulda', '>= 2.10.1'
+require 'shoulda'
+
+require File.dirname(__FILE__) + '/../lib/argument_sensei'

data/test/unit/argument_sensei_test.rb

@@ -0,0 +1,202 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ArgumentSenseiTest < Test::Unit::TestCase
+
+  Commands = ArgumentSensei::Commands
+
+  context 'Commands' do
+    
+    should 'parses accordingly with defined options' do
+      
+      c = Commands.define(:arguments => %w(orphan1 -S short1 short2 orphan2 --long1 long1 long2 long3 --long2 long4 long5 orphan3 --boolean)) do
+        option 'S' do
+          arguments 2
+        end
+        option 'long1'
+        option 'long2', :short => 'L' do
+          arguments 2
+          describe 'takes long4 and long5 then leaves orphan3'
+        end
+        option 'boolean' do
+          arguments 0
+        end
+      end # c = Commands.define do
+      
+      assert_equal({
+        :orphans => %w(orphan1 orphan2 orphan3),
+        'S' => %w(short1 short2),
+        'long1' => %w(long1 long2 long3),
+        'long2' => %w(long4 long5),
+        'L' => %w(long4 long5),
+        'boolean' => true
+      }, c.parse)
+      
+      c = Commands.define(:arguments => %w(--what if there --are nothing defined)) do
+      end
+      
+      assert_nothing_raised { c.parse.inspect }
+      
+    end
+
+    should 'parses combined short boolean switches' do
+      # -abcDEF => -a -b -c -D -E -F, as long as they are boolean.
+      # if non-booleans included, returns error,
+      # unknowns will just be ignored.
+      c = Commands.define(:arguments => %w(-aBC -A forA)) do
+        option 'a' do
+          arguments 0
+        end
+        option 'B' do
+          arguments 0
+        end
+        option 'C' do
+          arguments 0
+        end
+        option 'A' do
+          arguments 1
+        end
+      end.parse # c = Commands.define(:arguments => %w()) do
+      assert(c['a'])
+      assert(c['B'])
+      assert(c['C'])
+      assert_equal(['forA'], c['A'])
+      
+      # non boolean should not be combined.
+      assert_raise(ArgumentError) do
+        c = Commands.define(:arguments => %w(-aB)) do
+          option 'a' do
+            arguments 0
+          end
+          option 'B' do
+            arguments :all
+          end
+        end.parse
+      end
+    end
+    
+    should 'runs given actions' do
+      done = false
+      should_not_do = true
+      Commands.define(:arguments => %w(--do)) do
+        option 'do' do
+          action do
+            done = true
+          end
+        end
+        option 'do not' do
+          action do
+            should_not_do = false
+          end
+        end
+      end.run! # c = Commands.define do
+      assert(done, 'action were not called')
+      assert(should_not_do, 'even other action got run')
+    end
+    
+    should 'runs default action' do
+      done = false
+      Commands.define do
+        option 'D' do
+          action do
+            done = true
+          end
+        end
+        default 'D'
+      end.run!
+      assert(done, 'default action was not called')
+    end
+    
+    should 'should not raise any error for undefined options' do
+      assert_nothing_raised(Exception) do
+        Commands.define(:arguments => %w(-these -commands --are not defined --yet)) do
+          option 't' do
+            arguments 0
+          end
+          option 'o' do
+            arguments 0
+          end
+        end
+      end
+    end
+    
+    context 'Prioritization' do
+      
+      should 'should be defined as option' do
+        assert_equal(:option, Commands.define { option('-t') { priority :option } }.options[0][:priority])
+      end
+      
+      should 'should be defined as runner' do
+        assert_equal(:runner, Commands.define { option('-t') { priority :runner } }.options[0][:priority])
+      end
+      
+      should 'runs options first then a runner' do
+        first = false; last = false
+        was_first_last = false
+        was_last_first = false
+        
+        assert_nothing_raised(Exception) do
+          Commands.define(:arguments => %w(-l -f)) do
+            option 'l' do
+              priority :runner
+              action do
+                
+                last = true
+                was_last_first = true unless first
+                
+              end
+            end
+            option 'f' do
+              priority :option
+              action do
+                
+                first = true
+                was_first_last = true if last
+                
+              end
+            end
+          end.run!
+        end
+        
+        assert(!was_last_first, 'Runner ran first.')
+        assert(!was_first_last, 'Option ran last.')
+        
+      end
+      
+      should 'should not accept multiple runners at a time' do
+        shouldnotrun1 = false
+        shouldnotrun2 = false
+        assert_raise(RuntimeError) do
+          Commands.define(:arguments => %w(-a -b)) do
+            option 'a' do
+              priority :runner
+              action do
+                shouldnotrun1 = true
+              end
+            end
+            option 'b' do
+              priority :runner
+              action do
+                shouldnotrun2 = true
+              end
+            end
+          end.run!
+        end
+        assert(!shouldnotrun1)
+        assert(!shouldnotrun2)
+      end
+      
+    end # context 'Priority' do
+    
+  end # context 'Commands' do
+  
+  context 'ArgumentSensei' do
+    
+    context 'Class' do
+    end # Class
+    
+    context 'Instance' do
+    end # Instance
+    
+  end # ArgumentSensei
+
+end # class ArgumentSenseiTest < Test::Unit::TestCase

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: hirobumi-argument_sensei
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Hirobumi Hama
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-10 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: hama@yoidore.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/argument_sensei
+- lib/argument_sensei/commands.rb
+- lib/argument_sensei/version.rb
+- lib/argument_sensei.rb
+- test/test_helper.rb
+- test/unit
+- test/unit/argument_sensei_test.rb
+has_rdoc: true
+homepage: http://yoidore.org/argument_sensei
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+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: ArgumentSensei is yet another command-line argument parser with a minimal set of features.
+test_files: []
+