executable 1.0.0 → 1.1.0

data/History.rdoc

@@ -0,0 +1,35 @@
+= RELEASE HISTORY
+
+== 1.1.0 / 2011-04-21
+
+This release simplifies Exectuable, removing the #option_missing method
+and using the standard #method_missing callback instead. Along with this
+the special error class, +NoOptionError+, has been removed. This release
+also fixes an issue with inconsistant arguments being passed to the callback.
+Finally it renames the #execute_command method to simple #execute!.
+
+Changes:
+
+* Name Changes
+
+  * Renamed `#execute_command` method to `#execute!`.
+
+* Deprecations
+
+  * Rely on #method_missing callback instead of special #option_missing method.
+  * The +NoOptionError+ exceotion class is no longer needed because of above.
+
+* Bug Fixes
+
+  * The #method_missing callback takes the value of the option being set.
+
+
+== 1.0.0 / 2011-04-15
+
+This is the initialize release of Executable (as a stand alone project).
+Executable is a mixin that can turn any class into an commandline interface.
+
+* 1 Major Enhancement
+
+  * Birthday!
+

data/NOTICE.rdoc

@@ -0,0 +1,23 @@
+= COPYRIGHT NOTICES
+
+== Executable
+
+Copyright (c) 2009 Thomas Sawyer
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this program except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+---
+
+You can find the full text of all cited licenses in the `meta/license`
+directory distributed with this program.
+

data/{README → README.rdoc}

@@ -1,9 +1,5 @@
 = Executable
 
-* http://rubyworks.github.com/executable
-* http://github.com/rubyworks/executable
-
-
 == DESCRIPTION
 
 The Executable mixin is a very quick and and easy
@@ -17,10 +13,16 @@ passed to the method.
 == FEATURES
 
 * Super easy to use, just mixin.
-* Public writters become CLI options.
+* Public writers become options.
 * Public methods become subcommands.
 
 
+== RESOURCES
+
+* http://rubyworks.github.com/executable
+* http://github.com/rubyworks/executable
+
+
 == RELEASE NOTES
 
 Please see HISTORY file.
@@ -32,29 +34,44 @@ Simply mixin Executable, then call #execute_command.
 
   class X
     include Executable
+
     attr_accessor :quiet
+
+    attr_accessor :size
+
     def bread(*args)
-      ["BREAD", quiet, *args]
+      ["bread", quiet, size, *args]
     end
+
     def butter(*args)
-      ["BUTTER", quiet, *args]
+      ["butter", quiet, size, *args]
     end
   end
 
   x = X.new
 
-  x.execute_command("butter yum")
-  => ["BUTTER", nil, "yum"]
+  x.execute!("butter yum")
+  => ["butter", nil, nil, "yum"]
 
-  x.execute_command("bread --quiet")
-  => ["BREAD", true]
+  x.execute!("bread --quiet --size=big")
+  => ["bread", true, "big"]
 
-See RDocs for more information.
+
+Notice that Executable requires an equal-sign (<code>=</code>) be used
+when specifying values for non-boolean attributes.
+
+To make the command available on the command line, add an executable
+to your project passing ARGV to the #execute_command method.
+
+  #!usr/bin/env ruby
+  require 'x'
+  x = X.new
+  x.execute_command(ARGV)
 
 
 == INSTALL
 
-  $ sudo gem install executable
+  $ gem install executable
 
 
 == LEGAL

data/Version

@@ -0,0 +1 @@
+1.1.0

data/lib/executable.rb

@@ -1,90 +1,71 @@
 # = Executable Mixin
 #
-# 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.
+# 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 a
+# method to call with the subsequent arguments passed to the method.
 #
-# The only limitation of this approach (besides the weak
-# control of the process) is that required options must
-# be specified with the key=value notation.
+# The only limitation of this approach is that non-boolean options must
+# be specified with `key=value` notation.
 #
-#   class X
+#   class Example
 #     include Executable
 #
 #     attr_accessor :quiet
 #
 #     def bread(*args)
-#       ["BREAD", quiet, *args]
+#       ["bread", quiet, *args]
 #     end
 #
 #     def butter(*args)
-#       ["BUTTER", quiet, *args]
+#       ["butter", quiet, *args]
 #     end
 #   end
 #
-#   x = X.new
+#   ex = Example.new
 #
-#   x.execute_command("butter yum")
-#   => ["BUTTER", nil, "yum"]
+#   ex.execute!("butter yum")
+#   => ["butter", nil, "yum"]
 #
-#   x.execute_command("bread --quiet")
-#   => ["BUTTER", true]
+#   ex.execute!("bread --quiet")
+#   => ["butter", true]
 #
-# Executable also defines #command_missing and #option_missing,
-# which you can override to provide suitable results.
-#
-# TODO: Maybe command_missing is redundant, and method_missing would suffice?
+# Executable also provides #option_missing, which you can overriden to provide
+# suitable results when a given command line option has no corresponding 
+# writer method.
 #
 module Executable
 
-  class NoCommandError < NameError
-  end
-
-  class NoOptionError < ArgumentError
-  end
-
-  # Used to invoke the command.
-  def execute_command(argv=ARGV)
-    Executable.run(self, argv)
+  # Used the #excute! method to invoke the command.
+  def execute!(argv=ARGV)
+    Executable.execute(self, argv)
   end
 
-  # This is the fallback subcommand. Override this to provide
-  # a fallback when no command is given on the commandline.
-  def command_missing
-    raise NoCommandError
-  end
-
-  # Override option_missing if needed.
-  # This receives the name of the option and
-  # the remaining arguments list. It must consume
-  # any argument it uses from the (begining of)
-  # the list.
-  def option_missing(opt, *argv)
-    raise NoOptionError, opt
-  end
+  ## When no attribute write exists for an option that has been given on
+  ## the command line #option_missing is called. Override #option_missing
+  ## to handle these cases, if needed. Otherwise a NoMethodArgument will be
+  ## raised. This callback method receives the name and value of the option.
+  #def option_missing(opt, arg)
+  #  raise NoMethodError, "undefined option `#{opt}=' for #{self}"
+  #end
 
   class << self
 
-    def run(obj, argv=ARGV)
-      args = parse(obj, argv)
-      subcmd = args.shift
+    # Process the arguments as an exectuable against the given object.
+    def execute(obj, argv=ARGV)
+      args   = parse(obj, argv)
+      subcmd = args.first
       if subcmd && !obj.respond_to?("#{subcmd}=")
-        obj.send(subcmd, *args)
+        obj.send(*args)
       else
-        obj.command_missing
+        obj.method_missing(*args)
       end
     end
 
-    #def run(obj)
-    #  methname, args = *parse(obj)
-    #  meth = obj.method(methname)
-    #  meth.call(*args)
-    #end
+    # The original name for #execute.
+    alias_method :run, :execute
 
-    #
+    # Parse command line with respect to +obj+.
     def parse(obj, argv)
       case argv
       when String
@@ -111,84 +92,52 @@ module Executable
       return args
     end
 
-    #
+    # Parse a setting option.
     def parse_equal(obj, opt, argv)
       if md = /^[-]*(.*?)=(.*?)$/.match(opt)
         x, v = md[1], md[2]
       else
         raise ArgumentError, "#{x}"
       end
-      if obj.respond_to?("#{x}=")
-        # TODO: to_b if 'true' or 'false' ?
-        obj.send("#{x}=",v)
-      else
-        obj.option_missing(x, v) # argv?
-      end
+      # TODO: to_b if 'true' or 'false' ?
+      #if obj.respond_to?("#{x}=")
+        obj.send("#{x}=", v)
+      #else
+      #  obj.option_missing(x, v)
+      #end
     end
 
-    #
+    # Parse a named boolean option.
     def parse_option(obj, opt, argv)
-      x = opt[2..-1]
-      if obj.respond_to?("#{x}=")
-        obj.send("#{x}=",true)
-      else
-        obj.option_missing(x, argv)
-      end
+      x = opt.sub(/^--/, '')
+      #if obj.respond_to?("#{x}=")
+        obj.send("#{x}=", true)
+      #else
+      #  obj.option_missing(x, true)
+      #end
     end
 
+    # Parse flags. Each character of a flag set is treated as a separate option.
+    # For example:
+    #
+    #   $ foo -abc
+    #
+    # Would be parsed the same as:
+    #
+    #   $ foo -a -b -c
     #
     def parse_flags(obj, opt, args)
-      x = opt[1..-1]
-      c = 0
+      x = opt.sub(/^-/, '')
+      #c = 0
       x.split(//).each do |k|
-        if obj.respond_to?("#{k}=")
-          obj.send("#{k}=",true)
-        else
-          obj.option_missing(x, argv)
-        end
+        #if obj.respond_to?("#{k}=")
+          obj.send("#{k}=", true)
+        #else
+        #  obj.option_missing(x, true)
+        #end
       end
     end
 
   end #class << self
 
 end
-
-
-=begin SPEC
-
-class X
-  include Executable
-
-  attr_accessor :file
-  attr_accessor :quiet
-
-  attr :cmd
-
-  #
-  def bread(*args)
-    @cmd = "BREAD"
-  end
-
-  #
-  def butter(*args)
-    @cmd = "BUTTER"
-  end
-end
-
-Respect.spec "Executable" do
-
-  it "first command runs" do
-    x = X.new
-    x.execute_command("bread")
-    x.cmd.assert == "BREAD"
-  end
-
-  it "second command runs" do
-    x = X.new
-    x.execute_command("butter")
-    x.cmd.assert == "BUTTER"
-  end
-end
-
-=end
-

data/{LICENSE → meta/license/Apache2.txt}

@@ -1,4 +1,4 @@
-.
+
                              Apache License
                         Version 2.0, January 2004
                      http://www.apache.org/licenses/
@@ -175,30 +175,3 @@
       of your accepting any such warranty or additional liability.
 
    END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-

data/test/test_executable.rb

@@ -23,14 +23,14 @@ class TestExecutable < Test::Unit::TestCase
   #
   def test_parse_without_option
     s = SampleCli.new
-    s.execute_command("jump")
+    s.execute!("jump")
     assert_equal(s.result, ["jump"])
   end
 
   #
   def test_parse_with_option
     s = SampleCli.new
-    s.execute_command("jump --output=home")
+    s.execute!("jump --output=home")
     assert_equal(s.result, ['output: home', 'jump'])
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: executable
 version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: 
+  hash: 19
+  prerelease: false
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Thomas Sawyer
@@ -15,7 +15,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-15 00:00:00 Z
+date: 2011-04-21 00:00:00 -04:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: turn
@@ -38,15 +39,17 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README
+- README.rdoc
 files: 
 - lib/executable.rb
+- meta/license/Apache2.txt
 - test/test_executable.rb
-- Rakefile
-- PROFILE
-- LICENSE
-- README
-- HISTORY
+- Profile
+- README.rdoc
+- History.rdoc
+- Version
+- NOTICE.rdoc
+has_rdoc: true
 homepage: http://rubyworks.github.com/executable
 licenses: 
 - Apache 2.0
@@ -55,7 +58,7 @@ rdoc_options:
 - --title
 - Executable API
 - --main
-- README
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -79,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: executable
-rubygems_version: 1.7.2
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Any class, a command-line interface.

data/HISTORY

@@ -1,11 +0,0 @@
-= HISTORY
-
-== 1.0.0 / 2009-06-25
-
-This is the initialize release of Cliable (as a stand alone project).
-Cliable is a mixin that can turn any class into an commandline interface.
-
-* 1 Major Enhancement
-
-  * Birthday!
-

data/Rakefile

@@ -1,11 +0,0 @@
-task :default => [:test]
-
-desc "run tests"
-task :test do
-  sh "ruby -rtest/unit -Ilib test/*.rb"
-end
-
-desc "run tests with turn"
-task :turn do
-  sh "turn -T -Ilib test/*.rb"
-end