slop 0.1.0 → 0.1.4

data/README.md

@@ -1,9 +1,9 @@
 Slop
 ====
 
-Slop is a simple option parser with an easy to remember syntax and friendly API.
+Slop is a simple option collector with an easy to remember syntax and friendly API.
 
-**NOTE** This software is still in beta, it contains bugs and lacks core
+**NOTE** This software is still unstable, it contains bugs and lacks core
 features
 
 Installation
@@ -24,28 +24,30 @@ Usage
 -----
 
     s = Slop.parse(ARGV) do
-      option :v, :verbose, "Enable verbose mode", :default => false
-      option :n, :name, "Your name", true # compulsory argument
-      option :c, :country, "Your country", argument => true # the same thing
+      option(:v, :verbose, "Enable verbose mode", :default => false)
+      option(:n, :name, "Your name", true) # compulsory argument
+      option(:c, :country, "Your country", argument => true) # the same thing
 
-      option :a, :age, "Your age", true, :optional => true # optional argument
-      option :address, "Your address", :optional => true # the same
+      option(:a, :age, "Your age", true, :optional => true) # optional argument
+      option(:address, "Your address", :optional => true)   # the same
 
       # shortcut option aliases
-      opt :height, "Your height"
-      o :weight, "Your weight
+      opt(:height, "Your height")
+      o(:weight, "Your weight)
     end
 
     # using `--name Lee -a 100`
     s.options_hash #=> {:verbose=>false, :name=>"Lee", :age=>"100", :address=>nil}
     s.value_for(:name) #=> "Lee"
+
+    # or grab the Option object directly
     option = s.option_for(:name)
     option.description #=> "Your name"
 
     # You can also use switch values to set options according to arguments
     s = Slop.parse(ARGV) do
-      option :v, :verbose, :default => false, :switch => true
-      option :applicable_age, :default => 10, :switch => 20
+      option(:v, :verbose, :default => false, :switch => true)
+      option(:applicable_age, :default => 10, :switch => 20)
     end
 
     # without `-v`
@@ -57,6 +59,22 @@ Usage
     # using `--applicable_age`
     s.value_for(:applicable_age) #=> 20
 
+Callbacks
+---------
+
+If you'd like to trigger an event when an option is used, you can pass a
+block to your option. Here's how:
+
+    Slop.parse(ARGV) do
+      opt(:v, :version, "Display the version") do
+        puts "Version 1.0.1"
+        exit
+      end
+    end
+
+Now when using the `--version` option on the command line, the trigger will
+be called and its contents executed.
+
 Casting
 -------
 
@@ -64,7 +82,7 @@ If you want to return values of specific types, for example a Symbol or Integer
 you can pass the `:as` attribute to your option.
 
     s = Slop.parse("--age 20") do
-      opt :age, true, :as => Integer # :int/:integer both also work
+      opt(:age, true, :as => Integer) # :int/:integer both also work
     end
     s.value_for(:age) #=> 20 # not "20"
 
@@ -72,7 +90,7 @@ Slop will also check your default attributes type to see if it can cast the new
 value to the same type.
 
     s = Slop.parse("--port 110") do
-      opt :port, true, :default => 80
+      opt(port, true, :default => 80)
     end
     s.value_for(:port) #=> 110
 
@@ -82,14 +100,14 @@ Lists
 You can of course also parse lists into options. Here's how:
 
     s = Slop.parse("--people lee,injekt") do
-      opt :people, true, :as => Array
+      opt(:people, true, :as => Array)
     end
     s.value_for(:people) #=> ["lee", "injekt"]
 
 You can also change both the split delimiter and limit
 
     s = Slop.parse("--people lee:injekt:bob") do
-      opt :people, true, :as => Array, :delimiter => ':', :limit => 2
+      opt(:people, true, :as => Array, :delimiter => ':', :limit => 2)
     end
     s.value_for(:people) #=> ["lee", "injekt:bob"]
 

data/lib/slop.rb

@@ -3,13 +3,15 @@ require 'set'
 require 'slop/option'
 
 class Slop
-  VERSION = '0.1.0'
+  VERSION = '0.1.4'
 
+  # Raised when an option expects an argument and none is given
   class MissingArgumentError < ArgumentError; end
 
   # @return [Set]
   attr_reader :options
 
+  # Sugar for new(..).parse(stuff)
   def self.parse(values=[], &blk)
     new(&blk).parse(values)
   end
@@ -40,7 +42,7 @@ class Slop
     options = Hash[attributes.zip(args)]
     options.merge!(opts)
     options[:as] = options[:default].class if options.key?(:default)
-    yield options if block_given?
+    options[:callback] = blk if block_given?
 
     @options << Option.new(options)
   end
@@ -67,9 +69,8 @@ class Slop
         next unless option = option_for(opt) # skip unknown values for now
         index = values.index(value)
 
-        if option.has_switch?
-          option.switch_argument_value
-        end
+        option.execute_callback if option.has_callback?
+        option.switch_argument_value if option.has_switch?
 
         if option.requires_argument?
           value = values.at(index + 1)
@@ -93,11 +94,6 @@ class Slop
     self
   end
 
-  # traverse options
-  def each_option
-    @options.each {|o| yield o }
-  end
-
   # A simple Hash of options with option labels or flags as keys
   # and option values as.. values.
   #
@@ -112,12 +108,13 @@ class Slop
     out
   end
   alias :to_hash :options_hash
+  alias :to_h :options_hash
 
   # Find an option using its flag or label
   #
   # @example
   #   s = Slop.new do
-  #     option :n, :name, "Your name"
+  #     option(:n, :name, "Your name")
   #   end
   #
   #   s.option_for(:name).description #=> "Your name"
@@ -134,7 +131,7 @@ class Slop
   #
   # @example When passing --name Lee
   #   s = Slop.new do
-  #     option :n, :name, true
+  #     option(:n, :name, true)
   #   end
   #
   #   s.value_for(:name) #=> "Lee"
@@ -144,4 +141,5 @@ class Slop
     return unless option = option_for(flag)
     option.argument_value
   end
+  alias :[] :value_for
 end

data/lib/slop/option.rb

@@ -6,6 +6,7 @@ class Slop
     attr_reader :description
     attr_reader :argument_value
     attr_reader :default
+    attr_reader :callback
 
     def initialize(options={}, &blk)
       @options = options
@@ -17,6 +18,7 @@ class Slop
       @argument ||= @optional
       @default = options[:default]
       @as = options[:as]
+      @callback = options[:callback]
 
       # Array properties
       @delimiter = options[:delimiter] || ','
@@ -68,6 +70,16 @@ class Slop
       !!@options[:switch]
     end
 
+    # @return [Boolean] true if the option has a callback
+    def has_callback?
+      !!@callback
+    end
+
+    # execute this options callback
+    def execute_callback
+      @callback.call if has_callback?
+    end
+
     # does the option require an argument?
     # @return [Boolean]
     def requires_argument?
@@ -80,6 +92,11 @@ class Slop
       @options[:optional]
     end
 
+    # @return
+    def [](key)
+      @options[key]
+    end
+
     # Replace options argument value with the switch value supplied, used
     # when supplying the `switch` option making switch flags easy to alter
     #

data/spec/slop_spec.rb

@@ -14,21 +14,20 @@ describe Slop do
       end.should be_kind_of(Slop::Option)
     end
 
-    it "adds an option with a block to alter option attributes" do
-      s = Slop.new do
-        option :n, :name, "Set your name!", true do |o|
-          o[:default] = "Lee"
-        end
-      end
-      s.option_for(:name).default.should == "Lee"
-    end
-
     it "takes no more than 4 arguments" do
       lambda do
         Slop.new { option :a, :b, :c, :d, :e }
       end.should raise_error(ArgumentError, "Argument size must be no more than 4")
     end
 
+    it "accepts a block which assigns an option callback" do
+      s = Slop.parse("-v") do
+        opt(:v, :version, "Display version") { "Version 1" }
+      end
+      s.option_for(:version).callback.should be_kind_of(Proc)
+      s.option_for(:version).callback.call.should == "Version 1"
+    end
+
     it "does not parse option values unless option.argument is true" do
       Slop.parse("--name Lee") { opt :name }.value_for(:name).should be_nil
       Slop.parse("--name Lee") { opt :name, true }.value_for(:name).should == "Lee"
@@ -46,7 +45,7 @@ describe Slop do
     end
   end
 
-  describe "value_for" do
+  describe "value_for/[]" do
     it "returns the value of an option" do
       s = Slop.parse("--name Lee") do
         opt :n, :name, "Your name", true
@@ -56,6 +55,7 @@ describe Slop do
 
     it "returns a default option if none is given" do
       Slop.new { opt :name, true, :default => "Lee" }.value_for(:name).should == "Lee"
+      Slop.new { opt :name, true, :default => "Lee" }[:name].should == "Lee"
     end
 
     it "returns nil if an option does not exist" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Lee Jarvis
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-26 00:00:00 +00:00
+date: 2010-11-30 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -80,6 +80,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Option parsing made easy
+summary: Option gathering made easy
 test_files: []