executable 1.1.0 → 1.2.0

data/lib/executable/parser.rb

@@ -0,0 +1,208 @@
+module Executable
+
+  # The Parser class does all the heavy lifting for Executable.
+  #
+  class Parser
+
+    # 
+    # @param [Executable] cli_class
+    #   An executabe class.
+    #
+    def initialize(cli_class)
+      @cli_class = cli_class
+    end
+
+    attr :cli_class
+
+    # Parse command-line.
+    #
+    # @param argv [Array,String] command-line arguments
+    #
+    def parse(argv=ARGV)
+      # duplicate to make sure ARGV stay intact.
+      argv = argv.dup
+      argv = parse_shellwords(argv)
+
+      cmd, argv = parse_subcommand(argv)
+      cli  = cmd.new
+      args = parse_arguments(cli, argv)
+
+      return cli, args
+    end
+
+    # Make sure arguments are an array. If argv is a String,
+    # then parse using Shellwords module.
+    #
+    # @param argv [Array,String] commmand-line arguments
+    def parse_shellwords(argv)
+      if String === argv
+        require 'shellwords'
+        argv = Shellwords.shellwords(argv)
+      end
+      argv.to_a
+    end
+
+    #
+    #
+    #
+    def parse_subcommand(argv)
+      cmd = cli_class
+      arg = argv.first
+
+      while c = cmd.subcommands[arg]
+        cmd = c
+        argv.shift
+        arg = argv.first
+      end
+
+      return cmd, argv
+    end
+
+    #
+    # Parse command line options based on given object.
+    #
+    # @param obj [Object] basis for command-line parsing
+    # @param argv [Array,String] command-line arguments
+    # @param args [Array] pre-seeded arguments to add to
+    #
+    # @return [Array] parsed arguments
+    #
+    def parse_arguments(obj, argv, args=[])
+      case argv
+      when String
+        require 'shellwords'
+        argv = Shellwords.shellwords(argv)
+      #else
+      #  argv = argv.dup
+      end
+
+      #subc = nil
+      #@args = []  #opts, i = {}, 0
+
+      while argv.size > 0
+        case arg = argv.shift
+        when /=/
+          parse_equal(obj, arg, argv, args)
+        when /^--/
+          parse_long(obj, arg, argv, args)
+        when /^-/
+          parse_flags(obj, arg, argv, args)
+        else
+          #if Executable === obj
+          #  if cmd_class = obj.class.subcommands[arg]
+          #    cmd  = cmd_class.new(obj)
+          #    subc = cmd
+          #    parse(cmd, argv, args)
+          #  else
+              args << arg
+          #  end
+          #end
+        end
+      end
+     
+      return args
+    end
+
+    #
+    # Parse equal setting comman-line option.
+    #
+    def parse_equal(obj, opt, argv, args)
+      if md = /^[-]*(.*?)=(.*?)$/.match(opt)
+        x, v = md[1], md[2]
+      else
+        raise ArgumentError, "#{x}"
+      end
+      if obj.respond_to?("#{x}=")
+        v = true  if v == 'true'   # yes or on  ?
+        v = false if v == 'false'  # no  or off ?
+        obj.send("#{x}=", v)
+      else
+        obj.__send__(:option_missing, x, v) # argv?
+      end
+    end
+
+    #
+    # Parse double-dash command-line option.
+    #
+    def parse_long(obj, opt, argv, args)
+      x = opt.sub(/^\-+/, '') # remove '--'
+      if obj.respond_to?("#{x}=")
+        m = obj.method("#{x}=")
+        if obj.respond_to?("#{x}?")
+          m.call(true)
+        else
+          invoke(obj, m, argv)
+        end
+      elsif obj.respond_to?("#{x}!")
+        invoke(obj, "#{x}!", argv)
+      else
+        # call even if private method
+        obj.__send__(:option_missing, x, argv)
+      end
+    end
+
+    # TODO: parse_flags needs some thought concerning character
+    # spliting and arguments.
+
+    #
+    # Parse single-dash command-line option.
+    #
+    def parse_flags(obj, opt, argv, args)
+      x = opt[1..-1]
+      c = 0
+      x.split(//).each do |k|
+        if obj.respond_to?("#{k}=")
+          m = obj.method("#{k}=")
+          if obj.respond_to?("#{x}?")
+            m.call(true)
+          else
+            invoke(obj, m, argv) #m.call(argv.shift)
+          end
+        elsif obj.respond_to?("#{k}!")
+          invoke(obj, "#{k}!", argv)
+        else
+          long = find_long_option(obj, k)
+          if long
+            if long.end_with?('=') && obj.respond_to?(long.chomp('=')+'?')
+              invoke(obj, long, [true])
+            else
+              invoke(obj, long, argv)
+            end
+          else
+            obj.__send__(:option_missing, x, argv)
+          end
+        end
+      end
+    end
+
+    #
+    #
+    # @todo Sort alphabetically?
+    #
+    def find_long_option(obj, char)
+      meths = obj.methods.map{ |m| m.to_s }
+      meths = meths.select do |m|
+        m.start_with?(char) and (m.end_with?('=') or m.end_with?('!'))
+      end
+      meths.first
+    end
+
+    #
+    #
+    def invoke(obj, meth, argv)
+      m = (Method === meth ? meth : obj.method(meth))
+      a = []
+      m.arity.abs.times{ a << argv.shift }
+      m.call(*a)
+    end
+
+    # Index of subcommands.
+    #
+    # @return [Hash] name mapped to subcommnd class
+    def subcommands
+      @cli_class.subcommands
+    end
+
+  end
+
+end

data/lib/executable/utils.rb

@@ -0,0 +1,41 @@
+module Executable
+
+  # Some handy-dandy CLI utility methods.
+  #
+  module Utils
+    extend self
+
+    # TODO: Maybe #ask chould serve all purposes depending on degfault?
+    # e.g. `ask?("ok?", default=>true)`, would be same as `yes?("ok?")`.
+
+    # Strings to interprest as boolean values.
+    BOOLEAN_MAP = {"y"=>true, "yes"=>true, "n"=>false, "no"=>false}
+
+    # Query the user for a yes/no answer, defaulting to yes.
+    def yes?(question, options={})
+      print "#{question} [Y/n] "
+      input  = STDIN.readline.chomp.downcase
+      BOOLEAN_MAP[input] || true
+    end
+
+    # Query the user for a yes/no answer, defaulting to no.
+    def no?(question, options={})
+      print "#{question} [y/N] "
+      input  = STDIN.readline.chomp.downcase
+      BOOLEAN_MAP[input] || false
+    end
+
+    # Query the user for an answer.
+    def ask(question, options={})
+      print "#{question} [default: #{options[:default]}] "
+      reply = STDIN.readline.chomp
+      if reply.empty?
+        options[:default]
+      else
+        reply
+      end
+    end
+
+  end
+
+end

data/lib/executable/version.rb

@@ -0,0 +1,23 @@
+module Exectuable
+
+  #
+  DIRECTORY = File.dirname(__FILE__)
+
+  #
+  def self.version
+    @package ||= (
+      require 'yaml'
+      YAML.load(File.new(DIRECTORY + '/version.yml'))
+    )
+  end
+
+  #
+  def self.const_missing(name)
+    version[name.to_s.downcase] || super(name)
+  end
+
+  # because Ruby 1.8~ gets in the way
+  remove_const(:VERSION) if const_defined?(:VERSION)
+
+end
+

data/meta/authors

@@ -0,0 +1,2 @@
+---
+- 7rans <transfire@gmail.com>

data/meta/copyrights

@@ -0,0 +1,3 @@
+---
+- (c) 2008 Rubyworks (BSD-2-Clause)
+

data/meta/created

@@ -0,0 +1 @@
+2008-08-08

data/meta/description

@@ -0,0 +1,6 @@
+Think of Executable as a *COM*, a Commandline Object Mapper,
+in much the same way that ActiveRecord is an ORM,
+an Object Relational Mapper. A class utilizing Executable
+can define a complete command line tool using nothing more
+than Ruby's own method definitions.
+

data/meta/name

@@ -0,0 +1 @@
+executable

data/meta/organization

@@ -0,0 +1 @@
+rubyworks

data/meta/repositories

@@ -0,0 +1,2 @@
+---
+upstream: git://github.com/rubyworks/executable.git

data/meta/requirements

@@ -0,0 +1,6 @@
+---
+- qed       (test)
+- ae        (test)
+- detroit   (build)
+- simplecov (build)
+

data/meta/resources

@@ -0,0 +1,7 @@
+---
+home: http://rubyworks.github.com/executable
+code: http://github.com/rubyworks/executable
+bugs: http://github.com/rubyworks/executable/issues
+mail: http://groups.google.com/rubyworks-mailinglist
+chat: irc://chat.us.freenode.net#rubyworks
+

data/meta/summary

@@ -0,0 +1 @@
+Commandline Object Mapper

data/meta/version

@@ -0,0 +1 @@
+1.2.0

data/test/test_executable.rb

@@ -1,38 +1,59 @@
+$:.unshift(File.dirname(__FILE__)+'/../lib')
+
+require 'microtest'
+require 'ae'
+
 require 'executable'
 
-class TestExecutable < Test::Unit::TestCase
+class ExecutableTestCase < MicroTest::TestCase
 
-  class SampleCli
+  class MyCommand 
     include Executable
 
-    attr :result
+    attr_reader :size, :quiet, :file
 
     def initialize
-      @result = []
+      @file = 'hey.txt' # default
+    end
+
+    def quiet=(bool)
+      @quiet = bool
+    end
+
+    def quiet?
+      @quiet  
     end
 
-    def output=(value)
-      @result << "output: #{value}"
+    def size=(integer)
+      @size = integer.to_i
     end
 
-    def jump
-      @result << "jump"
+    def file=(fname)
+      @file = fname
+    end
+
+    def call(*args)
+      @args = args
     end
   end
 
-  #
-  def test_parse_without_option
-    s = SampleCli.new
-    s.execute!("jump")
-    assert_equal(s.result, ["jump"])
+  def test_boolean_optiion
+    mc = MyCommand.execute('--quiet')
+    mc.assert.quiet?
   end
 
-  #
-  def test_parse_with_option
-    s = SampleCli.new
-    s.execute!("jump --output=home")
-    assert_equal(s.result, ['output: home', 'jump'])
+  def test_integer_optiion
+    mc = MyCommand.execute('--size=4')
+    mc.size.assert == 4
   end
 
-end
+  def test_default_value
+    mc = MyCommand.execute('')
+    mc.file.assert == 'hey.txt'
+  end
+
+  #def usage_output
+  #  MyCommand.help.usage.assert == "{$0} [options] [subcommand]"
+  #end
 
+end

metadata

@@ -1,90 +1,146 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: executable
-version: !ruby/object:Gem::Version 
-  hash: 19
-  prerelease: false
-  segments: 
-  - 1
-  - 1
-  - 0
-  version: 1.1.0
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+  prerelease: 
 platform: ruby
-authors: 
-- Thomas Sawyer
+authors:
+- 7rans
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-21 00:00:00 -04:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: turn
+date: 2012-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: &16160360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: *16160360
+- !ruby/object:Gem::Dependency
+  name: ae
+  requirement: &16158800 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-description: The Executable mixin is a very quick and and easy way to make almost any class usable via a command line interface. It simply uses writer methods as option setters, and the first command line argument as the method to call, with the subsequent arguments passed to the method.
-email: ""
-executables: []
+  prerelease: false
+  version_requirements: *16158800
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &16156720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16156720
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &16155820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16155820
+description: ! 'Think of Executable as a *COM*, a Commandline Object Mapper,
 
-extensions: []
+  in much the same way that ActiveRecord is an ORM,
+
+  an Object Relational Mapper. A class utilizing Executable
+
+  can define a complete command line tool using nothing more
 
-extra_rdoc_files: 
+  than Ruby''s own method definitions.'
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- HISTORY.rdoc
+- DEMO.rdoc
 - README.rdoc
-files: 
+- COPYING.rdoc
+files:
+- .ruby
+- .yardopts
+- demo/00_introduction.rdoc
+- demo/01_single_command.rdoc
+- demo/02_multiple_commands.rdoc
+- demo/03_help_text.rdoc
+- demo/04_manpage.rdoc
+- demo/05_optparse_example.rdoc
+- demo/06_delegate_example.rdoc
+- demo/07_command_methods.rdoc
+- demo/08_dispatach.rdoc
+- demo/applique/ae.rb
+- demo/applique/compare.rb
+- demo/applique/exec.rb
+- demo/samples/bin/hello
+- demo/samples/man/hello.1
+- demo/samples/man/hello.1.html
+- demo/samples/man/hello.1.ronn
+- lib/executable/core_ext.rb
+- lib/executable/dispatch.rb
+- lib/executable/domain.rb
+- lib/executable/errors.rb
+- lib/executable/help.rb
+- lib/executable/parser.rb
+- lib/executable/utils.rb
+- lib/executable/version.rb
 - lib/executable.rb
-- meta/license/Apache2.txt
+- meta/authors
+- meta/copyrights
+- meta/created
+- meta/description
+- meta/name
+- meta/organization
+- meta/repositories
+- meta/requirements
+- meta/resources
+- meta/summary
+- meta/version
 - test/test_executable.rb
-- Profile
+- HISTORY.rdoc
+- DEMO.rdoc
+- Schedule.reap
 - README.rdoc
-- History.rdoc
-- Version
-- NOTICE.rdoc
-has_rdoc: true
+- COPYING.rdoc
 homepage: http://rubyworks.github.com/executable
-licenses: 
-- Apache 2.0
+licenses:
+- BSD-2-Clause
 post_install_message: 
-rdoc_options: 
-- --title
-- Executable API
-- --main
-- README.rdoc
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: executable
-rubygems_version: 1.3.7
+rubyforge_project: 
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: Any class, a command-line interface.
-test_files: 
-- test/test_executable.rb
+summary: Commandline Object Mapper
+test_files: []