named_proc 1.0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2011 Jan Lelis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,95 @@
+= MultiBlock
+
+MultiBlock is a mini framework for passing multiple blocks to methods. It uses "named procs" to accomplish this in a nice way. The receiving method can either yield all blocks, or just call specific ones, identified by order or name.
+
+These gem was build during a codebrawl contest. You might also take a look at the other entries: http://codebrawl.com/contests/methods-taking-multiple-blocks
+
+== Setup
+
+    gem install multi_block
+
+== Named Procs
+A named proc acts like a normal proc, but has got a name attribute. You can create it by calling a method with the desired name on +proc+:
+
+    >> a = proc.even?{ |e| e.even? }
+    => #<NamedProc:0x00000001ffc340@(irb):1>
+    >> a.name
+    => :even?
+    >> a[42]
+    => false
+
+In the same way, you can create lambdas:
+
+    >> b = lambda.doubler{ |e| e * 2 }
+    => #<NamedProc:0x000000020685e0@(irb):7 (lambda)>
+    >> b.name
+    => :doubler
+    >> b[21]
+    => 42
+    >> b.lambda?
+    => true
+
+== MultiBlock Usage
+=== Defining methods that use multiple blocks
+
+The first argument given to yield always defines the desired block(s). The other arguments get directly passed to the block(s). So these are example calls to the block:
+
+    yield                                            # calls all given procs without args
+    yield :success                                   # calls :success proc without args
+    yield :success, "Code Brawl!"                    # calls :success proc with message
+    yield 1                                          # calls first proc (:success in this case)
+    yield [:success, :bonus]                         # calls :success and :bonus without args
+    yield [:success, :bonus], "Code Brawl!"          # calls both procs with same arg
+    yield success: "Code Brawl!",                    # calls each keyed proc,
+          error:   [500, "Internal Brawl Error"]     #       values are the args
+
+Consider these two example methods:
+
+    def ajax
+      yield rand(6) != 0 ? :success : :error # calls the :success block if everything worked well
+    end
+
+    def dice
+      random_number = rand(6)
+      yield random_number, random_number + 1 # calls the n-th block
+    end
+
+=== Calling methods with multiple blocks
+
+It's done by calling the +blocks+ helper method:
+
+    ajax &blocks[
+      proc.success do puts "Yeah!" end,
+      proc.error   do puts "Error..." end,
+    ]
+
+The dice method could, for example, be called in this way:
+
+    dice &blocks[
+      proc{ ":(" },
+      proc{ ":/" },
+      proc{ ":O" },
+      proc{ ":b" },
+      proc{ ":P" },
+      proc{ rand(42) != 0 ? ":)"  : ":D"},
+    ]
+
+== Bonus sugar: Array extension
+
+If you like the slim <tt>&to_proc</tt> operator, you can further optimize the syntax by calling:
+
+    Array.send :include, MultiBlock::Array
+
+Now, it's getting real hot:
+
+    do_something, some_argument, &[
+      proc.easy_way do
+        # do it the easy way
+      end,
+      
+      proc.complex_way do
+        # use complex heuristics, etc.
+      end,
+    ]
+
+== J-_-L

data/lib/named_proc.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+# Class for a proc that's got a name
+class NamedProc < Proc
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+    super
+  end
+  
+  # create one from a given proc/lambda object
+  def self.create(name, block, lambda = false)
+    name = name.to_sym
+    # sorry for this ugly hack, is there a better way to lambdafy?
+    block = Module.new.send(:define_method, name.to_sym, &block) if lambda
+    
+    new(name, &block)
+  end
+  
+  # Proxy object to ease named proc initialization
+  module Proxy
+    Proc = BasicObject.new
+    def Proc.method_missing(name, &block)   NamedProc.create(name, block) end
+
+    Lambda = BasicObject.new
+    def Lambda.method_missing(name, &block) NamedProc.create(name, block, true) end
+  end
+  
+  # Mixing in low level method "links"
+  module Object
+    private
+  
+    # create a proc with name if given
+    def proc
+      if block_given?
+        super
+      else
+        NamedProc::Proxy::Proc
+      end
+    end
+    
+    # same for lambda
+    def lambda
+      if block_given?
+        super
+      else
+        NamedProc::Proxy::Lambda
+      end
+    end
+  end
+  
+  ::Object.send :include, NamedProc::Object
+end

data/named_proc.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems' unless defined? Gem
+ 
+Gem::Specification.new do |s|
+  s.name        = "named_proc"
+  s.version     = 1.0
+  s.authors     = ["Jan Lelis"]
+  s.email       = "mail@janlelis.de"
+  s.homepage    = "https://gist.github.com/4b2f5fd0b45118e46d0f"
+  s.summary     = "NamedProc: Like anonymous procs, but have a name."
+  s.description = "NamedProc: Like anonymous procs, but have a name. Example: lambda.codebrawl {} # creates an empty lambda with the name :codebrawl"
+  s.required_ruby_version     = '>= 1.9.2'
+  s.files = Dir.glob %w{named_proc.gemspec lib/named_proc.rb spec/named_proc_spec.rb}
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
+  s.license = 'MIT'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec-core'
+end

data/spec/named_proc_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require_relative '../lib/named_proc'
+
+describe "proc" do
+  it "creates a new proc as usual when called with a block" do
+    a = proc{}
+    a.should be_instance_of Proc
+    a.lambda?.should == false
+  end
+  
+  it "creates a named proc when a method gets called on it" do
+    a = proc.brawl{}
+    a.should be_a Proc
+    a.should be_instance_of NamedProc
+    a.lambda?.should == false
+    a.name == :brawl
+  end
+end
+
+describe "lambda" do
+  it "creates a new lambda as usual when called with a block" do
+    a = lambda{}
+    a.should be_instance_of Proc
+    a.lambda?.should == true
+  end
+  
+  it "creates a named lambda when a method gets called on it" do
+    a = lambda.brawl{}
+    a.should be_a Proc
+    a.should be_instance_of NamedProc
+    a.lambda?.should == true
+    a.name == :brawl
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: named_proc
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- Jan Lelis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-24 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &9105880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9105880
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: &9105320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9105320
+description: ! 'NamedProc: Like anonymous procs, but have a name. Example: lambda.codebrawl
+  {} # creates an empty lambda with the name :codebrawl'
+email: mail@janlelis.de
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- LICENSE.txt
+files:
+- named_proc.gemspec
+- lib/named_proc.rb
+- spec/named_proc_spec.rb
+- README.rdoc
+- LICENSE.txt
+homepage: https://gist.github.com/4b2f5fd0b45118e46d0f
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: ! 'NamedProc: Like anonymous procs, but have a name.'
+test_files: []