its-it 1.1.1 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0940411f44c31b8869ba17e8efa1505c63c01c97
+  data.tar.gz: 3a0b78717605b167e8017b4d9108f6cb08a3b680
+SHA512:
+  metadata.gz: f0a011722987ec5ac5a566c23e54c869a9faadec3a036cf3f207e9b92a32078527a25a06409668941706e490dfdfa011a5d2d8111603fe385bde91b7e2b3a4d0
+  data.tar.gz: a386fe0ed1440033d01c5a794ff447892225bcdf98e610c66d14a7324085e42458741809107f7d00c6b7a1d6bd116363c11a1c94c9d483bbd454767f6639501d

data/.rspec

@@ -1 +1,2 @@
 --color
+--format d

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.2.3

data/README.md

@@ -0,0 +1,148 @@
+# its-it
+
+
+## Overview
+
+This gem defines kernel methods `its` and `it` that queue and defer method
+calls. This is handy for list comprehension and case statements.
+
+[![Gem Version](https://badge.fury.io/rb/its-it.png)](http://badge.fury.io/rb/its-it)
+[![Build Status](https://secure.travis-ci.org/ronen/its-it.png)](http://travis-ci.org/ronen/its-it)
+[![Dependency Status](https://gemnasium.com/ronen/its-it.png)](https://gemnasium.com/ronen/its-it)
+
+## List Comprehension
+
+`its` and `it` extend the Symbol#to_proc idiom to support chaining multiple
+methods.
+
+The pure Ruby way to chain methods when iterating through a list would be:
+
+```ruby
+users.map{|user| user.contact}.map{|contact| contact.last_name}.map{|name| name.capitalize}
+```
+
+Using `Symbol#to_proc`, this becomes simpler (at the cost of generating intermediate arrays):
+
+```ruby
+users.map(&:contact).map(&:last_name).map(&:capitalize)
+```
+
+And using `its`, this becomes becomes simpler still:
+
+```ruby
+users.map(&its.contact.last_name.capitalize)
+```
+
+Note that `its` captures arguments and blocks, allowing you to do things like
+
+```ruby
+users.map(&its.contact.last_name[0,3].capitalize)
+```
+
+or
+
+```ruby
+users.select(&its.addresses.any? { |address| airline.flies_to address.city })
+```
+
+
+`it` is an alias for `its`, to use with methods that describe actions rather
+than posessives. For example:
+
+```ruby
+items.map(&it.to_s.capitalize)
+```
+
+When used with hash comprehensions, the `|key, val|` pair of arguments are presented to `its` as an array.  E.g.
+
+```ruby
+{dogs: 1, cats: 2, goats:3}.select &it[1].even? # => {cats: 2}
+```
+
+## Case statements
+
+`its` and `it` likewise extend Ruby's `case` statement to support testing
+arbitrary methods, minimizing the need to create temporary variables and use
+`if-elsif` constructs.
+
+In pure Ruby, doing comparisons on computed values would be done something
+like this:
+
+```ruby
+maxlen = arrays.map(&size).max
+if maxlen > 10000
+    "too big"
+elsif maxlen < 10
+    "too small"
+else
+    "okay"
+end
+```
+
+But using `it` this becomes:
+
+```ruby
+case arrays.map(&size).max
+when it > 1000
+    "too big"
+when it < 10
+    "too small"
+else
+    "okay"
+end
+```
+
+Of course method chanining can be used here too:
+
+```ruby
+case users.first
+when its.name == "Gimme Cookie" then ...
+when its.name.length > 10 then ...
+else ...
+end
+```
+
+## Under the hood
+
+The `ItsIt::It` class uses `method_missing` to capture and queue up all
+methods and their arguments, with the exception of `:to_proc` and `:===` (and
+also excepting `:respond_to? :to_proc` and `:respond_to? :===`).
+
+`:to_proc` returns a proc that will evaluate the method queue on a given
+argument.  `:===` takes an argument and evaluates that proc, returning the
+result.
+
+## Installation
+
+Install as usual from http://rubygems.org via
+
+```bash
+$ gem install "its-it"
+```
+
+or in a Gemfile
+
+```ruby
+gem "its-it"
+```
+
+## Compatibility
+
+Tested on MRI ruby 1.9.3, 2.0.0 and 2.2.3
+
+(MRI ruby 1.8.7 was supported up through version 1.1.1)
+
+## History
+
+Release Notes
+
+* 1.2.0 Add support for Hash comprehensions; drop support for ruby 1.8.7
+* 1.1.1 Remove dependency on BlankSlate
+
+This gem is orignally based on Jay Philips'
+[methodphitamine](https://github.com/jicksta/methodphitamine) gem. It has been
+updated to be compatible with ruby 1.9 and gemspec, added case statement
+support, renamed its-it, and installed on [rubygems.org](http://rubygems.org).
+ Unlike methodphitamine, this gem includes only `its` and `it`, not the
+"maybe" monad.
+

data/Rakefile

@@ -1,44 +1,20 @@
 require 'rubygems'
-
-begin
-  require 'bundler'
-rescue LoadError
-  $stderr.puts "You must install bundler - run `gem install bundler`"
-end
-
-begin
-  Bundler.setup
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-require 'bueller'
-Bueller::Tasks.new
+require "bundler/gem_tasks"
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.rspec_opts = '-Ispec'
 end
 
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.rspec_opts = '-Ispec'
-  spec.rcov = true
-end
-
 task :default => :spec
 
-require "rdoc/task"
-
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   version = File.exist?('VERSION') ? File.read('VERSION') : ""
 
   rdoc.main = 'README.rdoc'
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "its-it #{version}"
+  rdoc.title = "enumerable_hashify #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
-

data/its-it.gemspec

@@ -23,7 +23,6 @@ for ruby 1.9 and gemspec compatibility and adding the case statement functionali
 }
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
   ]
 
   s.required_rubygems_version = Gem::Requirement.new('>= 1.3.7')
@@ -35,10 +34,10 @@ for ruby 1.9 and gemspec compatibility and adding the case statement functionali
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 
+  s.add_development_dependency 'rake'
   s.add_development_dependency 'rdoc'
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', "~> 3.0"
   s.add_development_dependency 'bundler'
-  s.add_development_dependency 'bueller'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'simplecov-gem-adapter'
 

data/lib/its-it/it.rb

@@ -17,20 +17,18 @@ module ItsIt
     end
   
     def initialize #:nodoc:
-      @methods = []
+      @queue = []
     end
     
-    def method_missing(*args, &block)
-      @methods << [args, block] unless args.first == :respond_to? and [:to_proc, :===].include?(args[1].to_sym)
+    def method_missing(method, *args, &block)
+      @queue << [method, args, block] unless method == :respond_to? and [:to_proc, :===].include?(args.first.to_sym)
       self
     end
 
     def to_proc
-      Kernel.send :lambda do |obj|
-        ret = @methods.inject(obj) do |current,(args,block)|
-          current.send(*args, &block)
-        end
-        ret
+      Kernel.send :proc do |*obj|
+        obj = obj.shift if obj.size == 1
+        @queue.inject(obj) { |chain,(method, args,block)| chain.send(method, *args, &block) }
       end
     end
 

data/lib/its-it/version.rb

@@ -1,3 +1,3 @@
 module ItsIt
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/spec/it_spec.rb

@@ -1,74 +1,76 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe "An It instance" do
+describe ItsIt::It do
 
-  before (:each) do
-    it = ItsIt::It.new
-    @string = "This is a test"
-  end
+  TestString = "This is a test"
 
   it "should start with identity via to_proc" do
-    it.to_proc.call(@string).should == @string
+    expect(it.to_proc.call(TestString)).to eq(TestString)
   end
 
   it "should start with identity via ===" do
-    (it === @string).should == @string
+    expect(it === TestString).to eq(TestString)
   end
 
   it "should work with a simple method via to_proc" do
-    (it.length).to_proc.call(@string).should == @string.length
+    expect((it.length).to_proc.call(TestString)).to eq(TestString.length)
   end
 
-  it "should work with a simple methoud using ===" do
-    ((it.length) === @string).should == @string.length
+  it "should work with a simple method using ===" do
+    expect((it.length) === TestString).to eq(TestString.length)
   end
   
   it "should work with arguments" do
-    (it.sub(/test/, 'kumquat')).call(@string).should == 'This is a kumquat'
+    expect((it.sub(/test/, 'kumquat')).call(TestString)).to eq('This is a kumquat')
   end
   
   it "should work with a block" do
-    (it.sub(/test/) {"balloon"}).to_proc.call(@string).should == 'This is a balloon'
+    expect((it.sub(/test/) {"balloon"}).to_proc.call(TestString)).to eq('This is a balloon')
   end
   
   it "should chain methods" do
-    it.reverse.swapcase.succ.should == "TSET A SI SIHu"
+    expect(it.reverse.swapcase.succ).to eq("TSET A SI SIHu")
   end
   
   it "should respond to to_proc()" do
-    it.should respond_to(:to_proc)
+    expect(it).to respond_to(:to_proc)
   end
 
   it "should respond to ===" do
-    it.should respond_to(:===)
+    expect(it).to respond_to(:===)
   end
 
   it "should work with numbers" do
-    ((it < 1) === 0).should be_true
-    ((it < 1) === 1).should be_false
-    ((it < 1) === 2).should be_false
+    expect((it < 1) === 0).to be_truthy
+    expect((it < 1) === 1).to be_falsey
+    expect((it < 1) === 2).to be_falsey
+  end
+
+  it "should work with hashes (multiple args)" do
+    expect({a: 1, b:2}.select &it[1] == 2).to eq({b:2})
   end
 
+
   it "should work in a case statement" do
     [0,1,2].each do |i|
       case i
-      when it < 1 then i.should == 0
-      when it == 1 then i.should == 1
-      else i.should == 2
+      when it < 1 then expect(i).to eq(0)
+      when it == 1 then expect(i).to eq(1)
+      else expect(i).to eq(2)
       end
     end
   end
   
   it "should not queue the method respond_to? when given :to_proc as an arg" do
-    (it.respond_to? :to_proc).should be_true
+    expect(it.respond_to? :to_proc).to be_true
   end
 
   it "should not queue the method respond_to? when given :=== as an arg" do
-    (it.respond_to? :===).should be_true
+    expect(it.respond_to? :===).to be_true
   end
 
   it "should queue the method respond_to? when given generic arg" do
-    (it.respond_to? :size).to_proc.call(@string).should be_true
+    expect((it.respond_to? :size).to_proc.call(TestString)).to be_truthy
   end
-  
+
 end

data/spec/rspec_compatibility_spec.rb

@@ -1,20 +1,18 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe "The ItsIt's RSpec compatibility" do
+describe "RSpec compatibility" do
   
   # Surprisingly, RSpec's it() method isn't even defined within the context
   # of each expectation block. Man, that's some crazy voodoo.
   
   it "should make available the it and its methods" do
-    should respond_to(:it)
-    should respond_to(:its)
-    method(:it).should == method(:its) # Ensure it's not RSpec's it() method
-    lambda do
+    expect(method(:it)).to eq method(:its) # Ensure it's not RSpec's it() method
+    expect {
       it.should be_kind_of(ItsIt::It)
-    end.should_not raise_error
+    }.to_not raise_error
   end
   
-  it "should work with RSpec's assertion methods" do
+  it "should work with RSpec's old :should syntax" do
     [1,2,3].each &it.should(be_kind_of(Fixnum))
   end
 end

data/spec/spec_helper.rb

@@ -14,5 +14,7 @@ require 'its-it'
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
-  
+    config.expect_with(:rspec) do |c|
+      c.syntax = [:expect, :should]
+    end
 end

metadata

@@ -1,115 +1,123 @@
 --- !ruby/object:Gem::Specification
 name: its-it
 version: !ruby/object:Gem::Version
-  version: 1.1.1
-  prerelease: 
+  version: 1.2.0
 platform: ruby
 authors:
 - Ronen Barzel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-04-26 00:00:00.000000000Z
+date: 2011-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: &70172872051900 !ruby/object:Gem::Requirement
-    none: false
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70172872051900
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &70172872051440 !ruby/object:Gem::Requirement
-    none: false
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70172872051440
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &70172872050980 !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
   prerelease: false
-  version_requirements: *70172872050980
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: bueller
-  requirement: &70172872044640 !ruby/object:Gem::Requirement
-    none: false
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70172872044640
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &70172872044220 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70172872044220
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov-gem-adapter
-  requirement: &70172872043800 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70172872043800
-description: ! '
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
 
   This gem defines the Kernel method "it" that queue and defer method calls.
-
   This extends the Symbol#to_proc idiom to support chaining multiple methods.
-
   For example, items.collect(&it.to_s.capitalize).  This also allows
-
   conditionals in case statements, such as: case ... when it > 3 then [etc.].
-
   The method is also aliased as "its", for methods that describe possessives
-
   rather than actions, such as items.collect(&its.name.capitalize)
 
-
-  [This gem is an extension of Jay Philips'' "methodphitamine" gem, updated
-
+  [This gem is an extension of Jay Philips' "methodphitamine" gem, updated
   for ruby 1.9 and gemspec compatibility and adding the case statement functionality.]
-
-'
 email: ronen@barzel.org
 executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
 files:
-- .document
-- .gitignore
-- .rspec
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - its-it.gemspec
 - lib/its-it.rb
@@ -121,28 +129,24 @@ files:
 - spec/spec_helper.rb
 homepage: http://github.com/ronen/its-it
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4170040046291894423
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.7
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 3
 summary: Defines its() and it() method-chain proxies.

data/README.rdoc

@@ -1,110 +0,0 @@
-= its-it
-
-== Overview
-
-This gem defines kernel methods <code>its</code> and <code>it</code> that
-queue and defer method calls. This is handy for list enumeration and case
-statements.
-
-== List Enumeration
-
-<code>its</code> and <code>it</code> extend the Symbol#to_proc idiom to
-support chaining multiple methods.
-
-The pure Ruby way to chain methods when enumerating a list would be:
-
-        users.collect{|user| user.contact}.collect{|contact| contact.last_name}.collect{|name| name.capitalize}
-
-Using <code>Symbol#to_proc</code>, this becomes simpler:
-
-        users.collect(&:contact).collect(&:last_name).collect(&:capitalize)
-
-And using <code>its</code>, this becomes becomes simpler still:
-
-        users.collect(&its.contact.last_name.capitalize)
-
-Note that <code>its</code> captures arguments and blocks, allowing constructs like this,
-which will select users whose names include any non-hyphenated word that's more than 10
-letters long:
-        users.select(&its.name.split(/ /).reject{|word| word =~ /-/}.collect(&:length).max > 10)
-
-<code>it</code> is an alias for <code>its</code>, to use with methods that
-describe actions rather than posessives. For example:
-
-        items.collect(&it.to_s.capitalize)
-
-== Case statements
-
-<code>its</code> and <code>it</code> likewise extend Ruby's
-<code>code</code> statement to support testing arbitrary methods,
-minimizing the need to create temporary variables and use
-<code>if-elsif</code> constructs.
-
-In pure Ruby, doing comparisons on computed values would be done something
-like this:
-
-        maxlen = arrays.collect(&size).max
-        if maxlen > 10000
-            "too big"
-        elsif maxlen < 10
-            "too small"
-        else
-            "okay"
-        end
-
-But using <code>it</code> this becomes:
-
-        case arrays.collect(&size).max
-        when it > 1000
-            "too big"
-        when it < 10
-            "too small"
-        else
-            "okay"
-        end
-
-Of course method chanining can be used here too:
-
-        case users.first
-        when its.name == "Gimme Cookie" then ...
-        when its.name.length > 10 then ...
-        else ...
-        end
-
-== Under the hood
-
-The <code>ItsIt::It</code> class starts from <code>BlankSlate</code>, and
-uses <code>method_missing</code> to capture and queue up all methods and
-their arguments, with the exception of <code>:to_proc</code> and <code>:===</code>
-(and also excepting <code>:respond_to? :to_proc</code> and
-<code>:respond_to? :===</code>).
-
-<code>:to_proc</code> returns a proc that will evaluate the method queue on
-a given argument.  <code>:===</code> takes an argument and evaluates that
-proc, returning the result.
-
-== Installation
-
-Install from http://rubygems.org via
-
-        $ gem install "its-it"
-
-or in a Gemfile
-
-        gem "its-it"
-
-== Compatibility
-
-Works with MRI ruby 1.8.7, 1.9.2, 1.9.3
-
-== History
-
-This gem is orignally based on Jay Philips'
-methodphitamine[https://github.com/jicksta/methodphitamine] gem. It has
-been updated to be compatible with ruby 1.9 and gemspec, added case
-statement support, renamed its-it, and installed on
-rubygems.org[http://rubygems.org].  Unlike methodphitamine, this gem
-includes only <code>its</code> and <code>it</code>, not the "maybe" monad.
-
-Release Notes
-* 1.1.1 Remove dependency on BlankSlate