its-it 1.1.0 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f1f6a4b053ef34ba91f453a9ca02fb417c272ff809388495a7305ffa0df48d32
+  data.tar.gz: 494832c699a13a34401757bc915e62eaf94e3c147d29e8fe5517448b4696e8e2
+SHA512:
+  metadata.gz: 3e40f49a07ecb80ea873b3bf78d415bd96b357f6e3c1f478f3f306adfda1b326c71a99fd07874fb34d2871a2a50309f43b4efe22c99de1e3ffb9126a751e6a18
+  data.tar.gz: 9d7889759739aa30597012fbb23aac386f404df0ed9f256f518fc9f3c2f8347c9964c8bcb152924e55911318b645a8ce6cfcb9def0e2767017f420bab1ab1c76

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.1.9
+  - 2.2.5
+  - 2.3.1
+
+before_install: gem install bundler -v ">= 1.10.0" --conservative

data/README.md

@@ -0,0 +1,151 @@
+# 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.
+
+When performing a list comprehension ruby, you can use a block argument:
+
+
+```ruby
+users.map{ |user| user.contact }
+```
+
+Or, to avoid needing the block and and extra parameter, you can use the `Symbol#to_proc` shortcut:
+
+```ruby
+users.map &:contact
+```
+
+But if you want to chain several methods, such as:
+
+```ruby
+users.map{ |user| user.contact.last_name.capitalize }
+```
+
+The `Symbol#to_proc` shortcut doesn't help much.  At best, if you're willing to accept intermediate arrays, you can do:
+
+```ruby
+users.map(&:contact).map(&:last_name).map(&:capitalize)
+```
+
+To improve the situation, this gem provides a Kernel method `its`, which lets you get the same shortcut advantages as `Symbol#to_proc` but supports chaining:
+
+```ruby
+users.map &its.contact.last_name.capitalize
+```
+
+Also, `its` supports arguments and blocks, allowing you to do things like
+
+```ruby
+users.map &its.contact.last_name[0,3].capitalize
+users.select &its.contact.last_name.length > 10
+users.select(&its.addresses.any? { |address| airline.flies_to address.city })
+```
+
+As a syntactic sugar, `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
+```
+
+### Hash comprehensions
+
+When used with hash comprehensions, the `|key, val|` pair of arguments are presented to `its` as a tuple that can be accessed array-like via `[0]` or `[1]` and/or struct-like via `#key` and `#value` methods.  E.g.
+
+```ruby
+{dogs: 1, cats: 2, goats:3}.select &its.key =~ /^c/ # => {cats: 2}
+{dogs: 1, cats: 2, goats:3}.select &its.value.even? # => {cats: 2}
+{dogs: 1, cats: 2, goats:3}.select &its[1].even? # => {cats: 2}
+```
+
+## Case statements
+
+`its` and `it` similarly extend Ruby's `case` mechanism to support testing
+arbitrary methods, minimizing the need to create temporary variables.  That is, instead of:
+
+```ruby
+maxlen = arrays.map(&size).max
+case
+when maxlen > 10000 then "too big"
+when maxlen < 10    then "too small"
+else                     "okay"
+end
+```
+
+You can use `it`:
+
+```ruby
+case arrays.map(&size).max
+when it > 1000 then "too big"
+when it < 10   then "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 `it` method creates an instance of the `ItsIt::It` class, which uses `method_missing` to capture and queue up all
+methods and their arguments except for `: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 2.7.1
+
+(MRI ruby 1.9.3, 2.1.9, 2.2.5, and 2.3.1 were supported up through version 1.3.0)
+
+(MRI ruby 1.8.7 was supported up through version 1.1.1)
+
+## History
+
+Release Notes
+
+* 2.0.0 Switch to Ruby 2.7 keyword syntax.  No other breaking changes.
+* 1.3.0 Add `#key` and `#value` for Hash comprehensions; plus minor internal cleanup.
+* 1.2.1 Don't leak all of ItsIt into main, just ItsIt::Kernel.  Thanks to [klg](https://github.com/kjg)
+* 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 made available on [rubygems.org](http://rubygems.org), and updated over the years.
+

data/Rakefile

@@ -1,43 +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 'rake/rdoctask'
+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,9 +23,9 @@ for ruby 1.9 and gemspec compatibility and adding the case statement functionali
 }
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
   ]
 
+  s.required_ruby_version = '~> 2.7'
   s.required_rubygems_version = Gem::Requirement.new('>= 1.3.7')
   s.rubygems_version = '1.3.7'
   s.specification_version = 3
@@ -35,10 +35,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_runtime_dependency 'blankslate'
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rdoc'
+  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.rb

@@ -4,5 +4,4 @@ require 'its-it/it'
 require 'its-it/kernel'
 require 'its-it/version'
 
-include ItsIt
 include ItsIt::Kernel

data/lib/its-it/it.rb

@@ -1,5 +1,3 @@
-require 'blankslate'
-
 # This module contains an It class which queues any methods called on it
 # and can be converted into a Proc. The Proc it generates executes the queued
 # methods in the order received on the argument passed to the block, allowing
@@ -8,38 +6,46 @@ require 'blankslate'
 #   (1..10).select &it % 2 == 0
 # 
 module ItsIt
-  
+
   # The class instantiated by the <code>it</code> and <code>its</code> kernel methods.
-  class It < BlankSlate
+  class It < BasicObject
+
+    instance_methods.map(&:to_s).each do |method|
+      undef_method method unless method.start_with? "__"
+    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])
+    def method_missing(method, *args, **kw, &block)
+      @queue << [method, args, kw, block] unless method == :respond_to? and [:to_proc, :===].include?(args.first.to_sym)
       self
     end
-  
+
+    module KeyValAccessors
+      def key
+        self[0]
+      end
+      def value
+        self[1]
+      end
+    end
+
     def to_proc
-      lambda do |obj|
-        @methods.inject(obj) do |current,(args,block)|
-          current.send(*args, &block)
+      Kernel.send :proc do |*obj|
+        case obj.size
+        when 1 then obj = obj.shift     # array comprehension, gets one arg
+        when 2 then obj.extend(KeyValAccessors) # hash comprehension, gets two args
         end
+        @queue.inject(obj) { |chain,(method, args, kw, block)| chain.send(method, *args, **kw, &block) }
       end
     end
 
     def ===(obj)
-      to_proc.call(obj)
+      self.to_proc.call(obj)
     end
 
-    # Used for testing.  This method is hidden but can be revealed using
-    #   ItsIt::It.reveal(:method_queue)
-    def method_queue
-      @methods
-    end
-    hide(:method_queue)
-    
   end
   
 end

data/lib/its-it/version.rb

@@ -1,3 +1,3 @@
 module ItsIt
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

data/spec/it_spec.rb

@@ -1,75 +1,91 @@
 require File.dirname(__FILE__) + "/spec_helper"
 
-describe "An It instance" do
-
-  before :all do
-    ItsIt::It.reveal(:method_queue)
-  end
-  
-  before:each do
-    @it = ItsIt::It.new
-  end
-  
-  it "should queue a single simple method" do
-    @it.foo
-    queue = @it.method_queue
-    queue.size.should == 1
-    queue.first.size.should == 2
-    queue.first.last.should be_nil # No block, ergo nil
-  end
-  
-  it "should store arguments" do
-    @it.bar(:qaz, :qwerty)
-    @it.method_queue.first.should == [[:bar, :qaz, :qwerty], nil]
-  end
-  
-  it "should store a block" do
-    @it.map { }
-    @it.method_queue.first.last.should be_kind_of(Proc)
-  end
-  
-  it "should allow chaining blocks" do
-    @it.map {}.inject {}.select {}.sexypants {}
-    blocks = @it.method_queue.map { |x| x.last }
-    blocks.size.should == 4
-    blocks.each do |block|
-      block.should be_kind_of(Proc)
-    end
+describe ItsIt::It do
+
+  TestString = "This is a test"
+
+  it "should start with identity via to_proc" do
+    expect(it.to_proc.call(TestString)).to eq(TestString)
+  end
+
+  it "should start with identity via ===" do
+    expect(it === TestString).to eq(TestString)
+  end
+
+  it "should work with a simple method via to_proc" do
+    expect((it.length).to_proc.call(TestString)).to eq(TestString.length)
+  end
+
+  it "should work with a simple method using ===" do
+    expect((it.length) === TestString).to eq(TestString.length)
+  end
+
+  it "should work with arguments" do
+    expect((it.sub(/test/, 'kumquat')).call(TestString)).to eq('This is a kumquat')
+  end
+
+  it "should work with keyword arguments" do
+    expect((it.lines(chomp:true)).call(TestString + "\n")).to eq([TestString])
+  end
+
+  it "should work with a block" do
+    expect((it.sub(/test/) {"balloon"}).to_proc.call(TestString)).to eq('This is a balloon')
   end
-  
-  it "should queue many methods in the right order" do
-    @it.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z
-    queue = @it.method_queue
-    queue.size.should == 26
-    queue.map { |x| x.first.first.to_s }.should == ('a'..'z').to_a
+
+  it "should chain methods" do
+    expect((it.reverse.swapcase.succ).to_proc.call(TestString)).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
+    expect((it < 1) === 0).to be_truthy
+    expect((it < 1) === 1).to be_falsey
+    expect((it < 1) === 2).to be_falsey
+  end
+
+  context "hash comprehension" do
+    it "presents `key` accessor" do
+      expect({a: 1, b:2}.select(&(it.key == :b))).to eq({b:2})
+    end
+
+    it "presents `value` accessor" do
+      expect({a: 1, b:2}.select(&(it.value == 2))).to eq({b:2})
+    end
+
+    it "presents as an array" do
+      expect({a: 1, b:2}.select(&(it[1] == 2))).to eq({b:2})
+    end
+
   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
-    @it.method_queue.should be_empty
+    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? :to_proc
-    @it.method_queue.should be_empty
+    expect(it.respond_to? :===).to be_true
+  end
+
+  it "should queue the method respond_to? when given generic arg" do
+    expect((it.respond_to? :size).to_proc.call(TestString)).to be_truthy
   end
-  
+
 end

data/spec/main_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Object do
+  it "doesn't get ItsIt's version" do
+    expect(defined?(::VERSION)).to be_nil
+  end
+
+  it "does't get the It class" do
+    expect(defined?(::It)).to be_nil
+  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
-    [1,2,3].each &it.should(be_kind_of(Fixnum))
+  it "should work with RSpec's old :should syntax" do
+    [1,2,3].each &it.should(be_kind_of(Integer))
   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,108 +1,123 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: its-it
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 1.1.0
+version: !ruby/object:Gem::Version
+  version: 2.0.0
 platform: ruby
-authors: 
+authors:
 - Ronen Barzel
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2011-04-26 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: blankslate
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+date: 2011-04-26 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: :runtime
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: bundler
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !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: *id003
-- !ruby/object:Gem::Dependency 
-  name: bueller
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: simplecov-gem-adapter
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id006
-description: "\n\
-  This gem defines the Kernel method \"it\" that queue and defer method calls.\n\
-  This extends the Symbol#to_proc idiom to support chaining multiple methods.\n\
-  For example, items.collect(&it.to_s.capitalize).  This also allows\n\
-  conditionals in case statements, such as: case ... when it > 3 then [etc.].\n\
-  The method is also aliased as \"its\", for methods that describe possessives\n\
-  rather than actions, such as items.collect(&its.name.capitalize)\n\n\
-  [This gem is an extension of Jay Philips' \"methodphitamine\" gem, updated\n\
-  for ruby 1.9 and gemspec compatibility and adding the case statement functionality.]\n"
+  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
+  for ruby 1.9 and gemspec compatibility and adding the case statement functionality.]
 email: ronen@barzel.org
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
-files: 
-- .document
-- .gitignore
-- .rspec
+files:
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - its-it.gemspec
 - lib/its-it.rb
@@ -110,40 +125,33 @@ files:
 - lib/its-it/kernel.rb
 - lib/its-it/version.rb
 - spec/it_spec.rb
+- spec/main_spec.rb
 - spec/rspec_compatibility_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/ronen/its-it
 licenses: []
-
-post_install_message: 
+metadata: {}
+post_install_message:
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: -664830529632804485
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
+    - !ruby/object:Gem::Version
       version: 1.3.7
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.6.2
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 3
 summary: Defines its() and it() method-chain proxies.
-test_files: 
+test_files:
 - spec/it_spec.rb
+- spec/main_spec.rb
 - spec/rspec_compatibility_spec.rb
 - spec/spec_helper.rb

data/README.rdoc

@@ -1,107 +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
-
-Tested with <b>ruby 1.8.7</b> and <b>ruby 1.9.2</b>
-
-== 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.2 and gemspec, 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.