options 1.0.0

data/README

@@ -0,0 +1,151 @@
+NAME
+  options.rb
+
+DESCRIPTION
+  options.rb simplifies the common idiom of dealing with keyword options in
+  ruby functions.  it also deals correctly with symbol vs string keywords and
+  prevents many subtle programming errors that can arise from doing so
+  incorrectly.  options.rb doesn't hack ruby's core with one exception: the
+  method Array#options.
+
+SYNOPSIS
+  require 'options'
+
+  def method(*args, &block)
+    args, options = Options.parse(args)
+
+    a = args.shift
+    b = args.shift
+
+    force = options.getopt(:force, default = false)
+    verbose = options.getopt([:verbose, :VERBOSE])
+    foo, bar = options.getopt(:foo, :bar)
+  end
+
+INSTALL
+  gem install options
+
+SAMPLES
+  
+  <========< samples/a.rb >========>
+
+  ~ > cat samples/a.rb
+
+    require 'options'
+    
+    # options.rb makes is super easy to deal with keyword options in a safe and
+    # easy way.
+    #
+    
+      def method(*args)
+        args, options = Options.parse(args)
+    
+        force = options.getopt(:force, default=false)
+        p force
+      end
+    
+      method(:foo, :bar, :force => true)
+      method('force' => true)
+
+  ~ > ruby samples/a.rb
+
+    true
+    true
+
+
+  <========< samples/b.rb >========>
+
+  ~ > cat samples/b.rb
+
+    require 'options'
+    
+    # options.rb avoids common mistakes made handling keyword arguments
+    #
+    
+      def broken(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        if options[:force]
+          puts 'forcing'
+        else
+          puts 'broken'
+        end
+      end
+    
+      def nonbroken(*args)
+        args, options = Options.parse(args)
+        if options.getopt(:force)
+          puts 'nonbroken'
+        end
+      end
+    
+      broken('force' => true)
+      nonbroken('force' => true)
+    
+    
+    
+      def fubar(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        verbose = options[:verbose] || true
+        if verbose 
+          if options[:verbose]
+            puts 'verbosely'
+          else
+            puts 'fubar'
+          end
+        end
+      end
+    
+      def nonfubar(*args)
+        args, options = Options.parse(args)
+        verbose = options.getopt(:verbose)
+        if verbose 
+          puts 'verbosely'
+        else
+          puts 'nonfubar'
+        end
+      end
+    
+      fubar(:verbose => false)
+      nonfubar(:verbose => false)
+
+  ~ > ruby samples/b.rb
+
+    broken
+    nonbroken
+    fubar
+    nonfubar
+
+
+  <========< samples/c.rb >========>
+
+  ~ > cat samples/c.rb
+
+    require 'options'
+    
+    # options.rb hacks ruby core in exactly one way - the method Array#options
+    #
+    
+      def method(*args)
+        options = args.options
+        p :args => args
+        p :options => options
+      end
+    
+      method(:a, :b, :k => :v)
+    
+      def method2(*args)
+        options = args.options.pop
+        p :args => args
+        p :options => options
+      end
+    
+      method2(:a, :b, :k => :v)
+
+  ~ > ruby samples/c.rb
+
+    {:args=>[:a, :b, {:k=>:v}]}
+    {:options=>{:k=>:v}}
+    {:args=>[:a, :b]}
+    {:options=>{:k=>:v}}
+
+

data/README.rb

@@ -0,0 +1,80 @@
+#! /usr/bin/env ruby
+
+template = <<-__
+  NAME
+    options.rb
+
+  DESCRIPTION
+    options.rb simplifies the common idiom of dealing with keyword options in
+    ruby functions.  it also deals correctly with symbol vs string keywords and
+    prevents many subtle programming errors that can arise from doing so
+    incorrectly.  options.rb doesn't hack ruby's core with one exception: the
+    method Array#options.
+
+  SYNOPSIS
+    require 'options'
+
+    def method(*args, &block)
+      args, options = Options.parse(args)
+
+      a = args.shift
+      b = args.shift
+
+      force = options.getopt(:force, default = false)
+      verbose = options.getopt([:verbose, :VERBOSE])
+      foo, bar = options.getopt(:foo, :bar)
+    end
+
+  INSTALL
+    gem install options
+
+  SAMPLES
+    <%= samples %>
+__
+
+
+require 'erb'
+require 'pathname'
+
+$VERBOSE=nil
+
+def indent(s, n = 2)
+  s = unindent(s)
+  ws = ' ' * n
+  s.gsub(%r/^/, ws)
+end
+
+def unindent(s)
+  indent = nil
+  s.each do |line|
+    next if line =~ %r/^\s*$/
+    indent = line[%r/^\s*/] and break
+  end
+  indent ? s.gsub(%r/^#{ indent }/, "") : s
+end
+
+samples = ''
+prompt = '~ > '
+
+Dir.chdir(File.dirname(__FILE__))
+
+Dir['sample*/*'].sort.each do |sample|
+  samples << "\n" << "  <========< #{ sample } >========>" << "\n\n"
+
+  cmd = "cat #{ sample }" 
+  samples << indent(prompt + cmd, 2) << "\n\n" 
+  samples << indent(`#{ cmd }`, 4) << "\n" 
+
+  cmd = "ruby #{ sample }" 
+  samples << indent(prompt + cmd, 2) << "\n\n" 
+
+  cmd = "ruby -e'STDOUT.sync=true; exec %(ruby -Ilib #{ sample })'" 
+  #cmd = "ruby -Ilib #{ sample }" 
+  samples << indent(`#{ cmd } 2>&1`, 4) << "\n" 
+end
+
+erb = ERB.new(unindent(template))
+result = erb.result(binding)
+#open('README', 'w'){|fd| fd.write result}
+#puts unindent(result)
+puts result

data/gemspec.rb

@@ -0,0 +1,62 @@
+#! /usr/bin/env ruby
+
+lib, version, *ignored = ARGV
+
+unless lib
+  lib = File.basename(Dir.pwd)
+end
+
+unless version
+  mod = lib.capitalize
+  require "./lib/#{ lib }"
+  version = eval(mod).send(:version)
+end
+
+abort('no lib') unless lib
+abort('no version') unless version
+
+puts "### gemspec: #{ lib }-#{ version }"
+
+$VERBOSE = nil
+
+shiteless = lambda{|list| list.delete_if{|file| file =~ %r/\.(git|svn|tmp|sw.|bak)$/}}
+
+files       = shiteless[Dir::glob("**/**")]
+executables = shiteless[Dir::glob("bin/*")].map{|exe| File.basename(exe)}
+has_rdoc    = true #File.exist?('doc')
+test_files  = "test/#{ lib }.rb" if File.file?("test/#{ lib }.rb")
+
+extensions = []
+%w( Makefile configure extconf.rb rakefile Rakefile mkrf_conf ).each do |ext|
+  extensions << ext if File.exists?(ext)
+end
+
+template = <<-__
+
+  Gem::Specification::new do |spec|
+    spec.name = #{ lib.inspect }
+    spec.version = #{ version.inspect }
+    spec.platform = Gem::Platform::RUBY
+    spec.summary = #{ lib.inspect }
+
+    spec.files = #{ files.inspect }
+    spec.executables = #{ executables.inspect }
+    
+    spec.require_path = "lib"
+
+    spec.has_rdoc = #{ has_rdoc.inspect }
+    spec.test_files = #{ test_files.inspect }
+    #spec.add_dependency 'lib', '>= version'
+    #spec.add_dependency 'fattr'
+
+    spec.extensions.push(*#{ extensions.inspect })
+
+    spec.rubyforge_project = 'codeforpeople'
+    spec.author = "Ara T. Howard"
+    spec.email = "ara.t.howard@gmail.com"
+    spec.homepage = "http://github.com/ahoward/#{ lib }/tree/master"
+  end
+
+__
+
+puts template

data/lib/options.rb

@@ -0,0 +1,192 @@
+module Options
+  VERSION = '1.0.0'
+
+  class << Options
+    def version
+      Options::VERSION
+    end
+
+    def normalize!(hash)
+      hash.keys.each{|key| hash[key.to_s.to_sym] = hash.delete(key) unless Symbol===key}
+      hash
+    end
+    alias_method 'to_options!', 'normalize!'
+
+    def normalize(hash)
+      normalize!(hash.dup)
+    end
+    alias_method 'to_options', 'normalize'
+
+    def stringify!(hash)
+      hash.keys.each{|key| hash[key.to_s] = hash.delete(key) unless String===key}
+      hash
+    end
+    alias_method 'stringified!', 'stringify!'
+
+    def stringify(hash)
+      stringify!(hash)
+    end
+    alias_method 'stringified', 'stringify'
+
+    def for(hash)
+      hash =
+        case hash
+          when Hash
+            hash
+          when Array
+            Hash[*hash.flatten]
+          when String, Symbol
+            {hash => true}
+          else
+            hash.to_hash
+        end
+      normalize!(hash)
+    ensure
+      hash.extend(Options) unless hash.is_a?(Options)
+    end
+
+    def parse(args)
+      args.extend(Arguments) unless args.is_a?(Arguments)
+      [args, args.options.pop]
+    end
+  end
+
+  def to_options!
+    replace to_options
+  end
+
+  def to_options
+    keys.inject(Hash.new){|h,k| h.update k.to_s.to_sym => fetch(k)}
+  end
+        
+  def getopt key, default = nil
+    [ key ].flatten.each do |key|
+      return fetch(key) if has_key?(key)
+      key = key.to_s
+      return fetch(key) if has_key?(key)
+      key = key.to_sym
+      return fetch(key) if has_key?(key)
+    end
+    default
+  end
+
+  def getopts *args
+    args.flatten.map{|arg| getopt arg}
+  end
+
+  def hasopt key, default = nil
+    [ key ].flatten.each do |key|
+      return true if has_key?(key)
+      key = key.to_s
+      return true if has_key?(key)
+      key = key.to_sym
+      return true if has_key?(key)
+    end
+    default
+  end
+  alias_method 'hasopt?', 'hasopt'
+
+  def hasopts *args
+    args.flatten.map{|arg| hasopt arg}
+  end
+  alias_method 'hasopts?', 'hasopts'
+
+  def delopt key, default = nil
+    [ key ].flatten.each do |key|
+      return delete(key) if has_key?(key)
+      key = key.to_s
+      return delete(key) if has_key?(key)
+      key = key.to_sym
+      return delete(key) if has_key?(key)
+    end
+    default
+  end
+
+  def delopts *args
+    args.flatten.map{|arg| delopt arg}
+  end
+
+  def setopt key, value = nil
+    [ key ].flatten.each do |key|
+      return self[key]=value if has_key?(key)
+      key = key.to_s
+      return self[key]=value if has_key?(key)
+      key = key.to_sym
+      return self[key]=value if has_key?(key)
+    end
+    return self[key]=value
+  end
+  alias_method 'setopt!', 'setopt'
+
+  def setopts opts 
+    opts.each{|key, value| setopt key, value}
+    opts
+  end
+  alias_method 'setopts!', 'setopts'
+
+  def select! *a, &b
+    replace select(*a, &b).to_hash
+  end
+
+  def normalize!
+    Options.normalize!(self)
+  end
+  alias_method 'normalized!', 'normalized!'
+  alias_method 'to_options!', 'normalize!'
+
+  def normalize
+    Options.normalize(self)
+  end
+  alias_method 'normalized', 'normalized'
+  alias_method 'to_options', 'normalize'
+
+  def stringify!
+    Options.stringify!(self)
+  end
+  alias_method 'stringified!', 'stringify!'
+
+  def stringify
+    Options.stringify(self)
+  end
+  alias_method 'stringified', 'stringify'
+
+  attr_accessor :arguments
+  def pop
+    pop! unless popped?
+    self
+  end
+
+  def popped?
+    defined?(@popped) and @popped
+  end
+
+  def pop!
+    @popped = arguments.pop
+  end
+end
+
+module Arguments
+  def options
+    @options ||= Options.for(last.is_a?(Hash) ? last : {})
+  ensure
+    @options.arguments = self
+  end
+
+  class << Arguments
+    def for(args)
+      args.extend(Arguments) unless args.is_a?(Arguments)
+      args
+    end
+
+    def parse(args)
+      Options.parse(args)
+    end
+  end
+end
+
+class Array
+  def options
+    extend(Arguments) unless is_a?(Arguments)
+    options
+  end
+end

data/options.gemspec

@@ -0,0 +1,26 @@
+### gemspec: options-1.0.0
+
+  Gem::Specification::new do |spec|
+    spec.name = "options"
+    spec.version = "1.0.0"
+    spec.platform = Gem::Platform::RUBY
+    spec.summary = "options"
+
+    spec.files = ["gemspec.rb", "lib", "lib/options.rb", "options.gemspec", "README", "README.rb", "samples", "samples/a.rb", "samples/b.rb", "samples/c.rb"]
+    spec.executables = []
+    
+    spec.require_path = "lib"
+
+    spec.has_rdoc = true
+    spec.test_files = nil
+    #spec.add_dependency 'lib', '>= version'
+    #spec.add_dependency 'fattr'
+
+    spec.extensions.push(*[])
+
+    spec.rubyforge_project = 'codeforpeople'
+    spec.author = "Ara T. Howard"
+    spec.email = "ara.t.howard@gmail.com"
+    spec.homepage = "http://github.com/ahoward/options/tree/master"
+  end
+

data/samples/a.rb

@@ -0,0 +1,15 @@
+require 'options'
+
+# options.rb makes is super easy to deal with keyword options in a safe and
+# easy way.
+#
+
+  def method(*args)
+    args, options = Options.parse(args)
+
+    force = options.getopt(:force, default=false)
+    p force
+  end
+
+  method(:foo, :bar, :force => true)
+  method('force' => true)

data/samples/b.rb

@@ -0,0 +1,50 @@
+require 'options'
+
+# options.rb avoids common mistakes made handling keyword arguments
+#
+
+  def broken(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    if options[:force]
+      puts 'forcing'
+    else
+      puts 'broken'
+    end
+  end
+
+  def nonbroken(*args)
+    args, options = Options.parse(args)
+    if options.getopt(:force)
+      puts 'nonbroken'
+    end
+  end
+
+  broken('force' => true)
+  nonbroken('force' => true)
+
+
+
+  def fubar(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    verbose = options[:verbose] || true
+    if verbose 
+      if options[:verbose]
+        puts 'verbosely'
+      else
+        puts 'fubar'
+      end
+    end
+  end
+
+  def nonfubar(*args)
+    args, options = Options.parse(args)
+    verbose = options.getopt(:verbose)
+    if verbose 
+      puts 'verbosely'
+    else
+      puts 'nonfubar'
+    end
+  end
+
+  fubar(:verbose => false)
+  nonfubar(:verbose => false)

data/samples/c.rb

@@ -0,0 +1,20 @@
+require 'options'
+
+# options.rb hacks ruby core in exactly one way - the method Array#options
+#
+
+  def method(*args)
+    options = args.options
+    p :args => args
+    p :options => options
+  end
+
+  method(:a, :b, :k => :v)
+
+  def method2(*args)
+    options = args.options.pop
+    p :args => args
+    p :options => options
+  end
+
+  method2(:a, :b, :k => :v)

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: options
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Ara T. Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-31 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: 
+email: ara.t.howard@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- gemspec.rb
+- lib
+- lib/options.rb
+- options.gemspec
+- README
+- README.rb
+- samples
+- samples/a.rb
+- samples/b.rb
+- samples/c.rb
+has_rdoc: true
+homepage: http://github.com/ahoward/options/tree/master
+post_install_message: 
+rdoc_options: []
+
+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: codeforpeople
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: options
+test_files: []
+