keyword_params 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1,7 @@
+
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/ruby-1.9.2-p0@keyword_params" ]] ; then
+  \. "${rvm_path:-$HOME/.rvm}/environments/ruby-1.9.2-p0@keyword_params"
+else
+  rvm --create  "ruby-1.9.2-p0@keyword_params"
+fi

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in keyword_params.gemspec
+gemspec

data/README

@@ -0,0 +1 @@
+Please see example.rb!

data/Rakefile

@@ -0,0 +1,42 @@
+require 'English'
+require 'bundler'
+
+LIB_PATH     = File.expand_path("lib", File.dirname(__FILE__))
+EXAMPLE_FILE = File.expand_path("example.rb", File.dirname(__FILE__))
+
+Bundler::GemHelper.install_tasks
+
+task "load_path" do
+  $LOAD_PATH.unshift(File.expand_path("lib", File.dirname(__FILE__)))
+end
+
+desc "Run the tests"
+task "test" => %w[load_path] do
+  require 'rcodetools/xmpfilter'
+  require 'rcodetools/options'
+  include Rcodetools
+  example_file = EXAMPLE_FILE
+  example_code = File.read(example_file)
+  xmp_options = {
+    include_paths: [LIB_PATH]
+  }
+  output = ::XMPFilter.run(example_code,xmp_options)
+  diff   = IO.popen("diff #{example_file} -", "r+")
+  diff.write(output)
+  diff.close_write
+  results = diff.read
+  diff.close_read
+  if $CHILD_STATUS.success?
+    puts "Green!"
+    exit 0
+  else
+    puts results
+    exit 1
+  end
+end
+
+desc "Run the examples"
+task "example" do
+  $LOAD_PATH.unshift(LIB_PATH)
+  load EXAMPLE_FILE
+end

data/example.rb

@@ -0,0 +1,77 @@
+# Ruby doesn't have keyword arguments, but it fakes them pretty well.
+
+def explain(options={})
+  "the #{options[:the]} says #{options[:says]}"
+end
+
+explain the: "pig", says: "oink"    # => "the pig says oink"
+explain the: "frog", says: "ribbit" # => "the frog says ribbit"
+
+# Which is fine, but it isn't as declarative (and therefore not as
+# self-documenting) as proper keyword arguments.
+
+# Also, when using keywords to construct English-like DSLs, as we are
+# above, we often would like to assign different names to the
+# parameters which are passed by keyword.
+
+def explain2(options={})
+  animal = options[:the]
+  sound  = options[:says]
+  "the #{animal} says #{sound}"
+end
+
+# And then there's defaulting for missing paramters...
+
+def explain3(options={})
+  animal = options.fetch(:the) { "cow" }
+  sound  = options.fetch(:says){ "moo" }
+  "the #{animal} says #{sound}"
+end
+
+explain3 # => "the cow says moo"
+
+# Of course, it might be nice to offer a positional-argument version
+# as well.
+
+def explain4(*args)
+  options = args.last.is_a?(Hash) ? args.pop : {}
+  animal  = args[0] || options.fetch(:the) { "cow" }
+  sound   = args[1] || options.fetch(:says){ "moo" }
+  "the #{animal} says #{sound}"
+end
+
+explain4 "horse", "neigh"        # => "the horse says neigh"
+explain4 "duck", says: "quack"   # => "the duck says quack"
+explain4 the: "donkey", :says => "hee-haw" # => "the donkey says hee-haw"
+
+# Once we've written all this parameter-munging machinery, we then
+# repeat it in the method's documentation. (Assuming we document it at
+# all). This seems a bit un-DRY.
+
+# Let's see if we can improve on the situation.
+
+require 'keyword_params'
+
+class BarnYard
+  extend KeywordParams
+
+  keyword(:the)  { "cow" }
+  keyword(:says) { "moo" }
+  def explain(animal, sound)
+    "the #{animal} says #{sound}"
+  end
+end
+
+b = BarnYard.new
+
+b.explain "horse", "neigh"                  # => "the horse says neigh"
+b.explain "duck", says: "quack"             # => "the duck says quack"
+b.explain the: "donkey", :says => "hee-haw" # => "the donkey says hee-haw"
+b.explain the: "cat"                        # => "the cat says moo"
+b.explain                                   # => "the cow says moo"
+
+# Improvement? Well, I'll leave that for you to judge. Certainly
+# specifying part of the method's  signature above the method
+# definition proper has a nasty "old-style C" feel to it. But I feel
+# like it's a lot more self-documenting than doing the keyword
+# processing inside the method.

data/keyword_params.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "keyword_params/version"
+
+Gem::Specification.new do |s|
+  s.name        = "keyword_params"
+  s.version     = KeywordParams::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Avdi Grimm"]
+  s.email       = ["avdi@avdi.org"]
+  s.homepage    = ""
+  s.summary     = %q{Declarative keyword arguments for methods}
+  s.description = %q{Declarative keyword arguments for methods}
+
+  s.rubyforge_project = "keyword_params"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rcodetools'
+end

data/lib/keyword_params.rb

@@ -0,0 +1,42 @@
+require 'ostruct'
+module KeywordParams
+  class KeywordList
+    def initialize
+      @keywords = []
+    end
+
+    def add_keyword(name, default_block)
+      @keywords << OpenStruct.new(name: name, default_block: default_block)
+    end
+    
+    def values(options={})
+      @keywords.map {|keyword|
+        options.fetch(keyword.name, &keyword.default_block)
+      }
+    end
+  end
+  
+  def keyword(name, &default_block)
+    @keyword_list ||= KeywordList.new
+    @keyword_list.add_keyword(name, default_block)
+  end
+
+  def method_added(name)
+    # Avoid crazy stack recursion
+    return if Thread.current[:in_keyword_params_method_added]
+    Thread.current[:in_keyword_params_method_added] = true
+    original_method = instance_method(name)
+    keyword_list = @keyword_list
+    @keyword_list = nil
+    define_method(name) do |*args|
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      keyword_args = keyword_list.values(options)
+      # We only need keyword arg values for as many positional args
+      # as are NOT supplied.
+      needed_keyword_args = keyword_args[(args.size..-1)]
+      original_method.bind(self).call(*(args + needed_keyword_args))
+    end
+    super
+    Thread.current[:in_keyword_params_method_added] = false
+  end
+end

data/lib/keyword_params/version.rb

@@ -0,0 +1,3 @@
+module KeywordParams
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: keyword_params
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Avdi Grimm
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-29 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rcodetools
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Declarative keyword arguments for methods
+email: 
+- avdi@avdi.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- README
+- Rakefile
+- example.rb
+- keyword_params.gemspec
+- lib/keyword_params.rb
+- lib/keyword_params/version.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: keyword_params
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Declarative keyword arguments for methods
+test_files: []
+