proc_to_lambda 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac8537308f2b72d03b641f01eb23ea614deac38e
+  data.tar.gz: 4a35226dac5a19098a37d90b3fa1222f3aa13bd4
+SHA512:
+  metadata.gz: 384049eb6093f34955be10590eec890b17089e4336d78de6121488efaa2bfde0ae527367ada93cd56adea2a7522c14d73ad4f5ad9d3eb2d5d8c564e97d4bafd3
+  data.tar.gz: 4983898ebfd9e63e899586336097fa86f9f781cc6b3a6d554043aa66933f4a2dd2a30ebbbe57313fbd38b4b6a8748969290dfa646432f796b5f7d66b17b61e31

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+*.gem
+
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+  - jruby-19mode
+  - rbx-19mode
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,88 @@
+## Proc To Lambda
+
+[![Build Status](https://travis-ci.org/schneems/proc_to_lambda.png)](https://travis-ci.org/schneems/proc_to_lambda)
+
+Convert your procs to lambdas for all the Rubies.
+
+## Why?
+
+I love anonomyous functions ( lambdas & procs <3 ). I also love "confident" style ruby functions that have early returns:
+
+```ruby
+def foo(num)
+  return false if num.nil?
+  # ...
+```
+
+Unfortunately procs do not play nice with early returns:
+
+```ruby
+def bar(num, &block)
+  block.call(num)
+end
+
+bar(nil) do |num|
+  return false if num.nil?
+  # ...
+end
+LocalJumpError: unexpected return
+  from (irb):25:in `block in irb_binding'
+  from (irb):21:in `call'
+  from (irb):21:in `bar'
+  from (irb):24
+  from /Users/schneems/.rbenv/versions/2.0.0-p247/bin/irb:12:in `<main>'
+```
+
+But lambdas do:
+
+```ruby
+bar(nil, &lambda {|num|
+  return false if num.nil?
+  # ...
+})
+# => false
+```
+
+What I want is the pretty syntax of using a proc, but with the flexibility of explicit returns of a lambda. Enter: ProcToLambda
+
+
+## Can't you do this in Ruby already?
+
+Yes, but the implementation is not standard across all the rubies :(
+
+## Install
+
+In your `Gemfile`:
+
+```rb
+gem 'proc_to_lambda'
+```
+
+## Use
+
+In your code, call `ProcToLambda.to_lambda()` and pass in a block:
+
+```ruby
+def bar(num, &block)
+  block = ProcToLambda.to_lambda(block)
+  block.call(num)
+end
+```
+
+If you're risky you can extend the `Proc` class directly:
+
+```ruby
+Proc.extend(ProcToLambda)
+```
+
+Then you can call `Proc.to_lambda`:
+
+```ruby
+def bar(num, &block)
+  block.to_lambda.call(num)
+end
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test]
+
+test_task = Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end

data/lib/proc_to_lambda.rb

@@ -0,0 +1,15 @@
+module ProcToLambda
+  def to_lambda
+    ProcToLambda.to_lambda(self)
+  end
+
+  def self.to_lambda(block)
+    if RUBY_ENGINE && RUBY_ENGINE == "jruby"
+      return lambda(&block)
+    else
+      obj = Object.new
+      obj.define_singleton_method(:_, &block)
+      return obj.method(:_).to_proc
+    end
+  end
+end

data/lib/proc_to_lambda/version.rb

@@ -0,0 +1,3 @@
+module ProcToLambda
+  VERSION = "1.0.0"
+end

data/proc_to_lambda.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'proc_to_lambda/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "proc_to_lambda"
+  gem.version       = ProcToLambda::VERSION
+  gem.authors       = ["Richard Schneeman"]
+  gem.email         = ["richard.schneeman+rubygems@gmail.com"]
+  gem.description   = %q{ Turn your procs to lambdas in no time }
+  gem.summary       = %q{ Turn your procs to lambdas in less time than you can read this sentence. }
+  gem.homepage      = "https://github.com/schneems/proc_to_lambda"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake"
+end
+

data/test/proc_to_lambda_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+def pass_to_block(pass, &block)
+  block.call(pass)
+end
+
+def pass_to_block_with_convert(pass, &block)
+  block = ProcToLambda.to_lambda(block)
+  pass_to_block(pass, &block)
+end
+
+def pass_to_block_with_include(pass, &block)
+  pass_to_block(pass, block.to_lambda)
+end
+
+class ProcToLambdaTest < Test::Unit::TestCase
+  def test_raises
+    assert_raise do
+      pass_to_block(nil) do |num|
+        return false if num.nil?
+      end
+    end
+  end
+
+  def test_module_method_works
+    pass_to_block_with_convert(nil) do |num|
+      return false if num.nil?
+    end
+  end
+
+  def test_include
+    Proc.extend ProcToLambda
+    pass_to_block(nil) do |num|
+      return false if num.nil?
+    end
+    assert Proc.new.to_lambda
+    Proc.send(:undef_method, :to_lambda)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+Bundler.require
+
+require 'test/unit'
+require 'proc_to_lambda'

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: proc_to_lambda
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Richard Schneeman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ' Turn your procs to lambdas in no time '
+email:
+- richard.schneeman+rubygems@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- lib/proc_to_lambda.rb
+- lib/proc_to_lambda/version.rb
+- proc_to_lambda.gemspec
+- test/proc_to_lambda_test.rb
+- test/test_helper.rb
+homepage: https://github.com/schneems/proc_to_lambda
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Turn your procs to lambdas in less time than you can read this sentence.
+test_files:
+- test/proc_to_lambda_test.rb
+- test/test_helper.rb