give4each 0.0.3 → 0.1.0

data/README.rdoc

@@ -3,43 +3,32 @@
 
 https://github.com/pasberth/give4each
 
-== install
+== installation
 
   $ gem install give4each
   
 == description
 
-(1..5).map { |i| i ** 2 } を (1..5).map &:**.with(2) とか書けるようにする
+Can write the oneliner as block like the Symbol#to_proc
 
-== usage
+== examples
 
-  (1..5).map { |i| i ** 2 }
+  require 'give4each'
 
-だからこう書けるようにした
-  
+  # (1..5).map { |i| i ** 2 }
   (1..5).map &:**.with(2) # => [1, 4, 9, 16, 25]
 
-ああああああ
-こういうのももう嫌だ!!!
-
-  def initialize
-    @stack = []
-  end
-
-  def foo *xs
-    xs.each { |x| @stack.push x  }
-  end
-
-だからこう書けるように(ry
-
-  xs.each &:push.to(@array)
-
-
-こういうのも(ry
+  # %w[c++ lisp].map { |lang| (lang + "er").upcase }
+  %w[c++ lisp].map &:upcase.of(:+, "er") # => ["C++ER", "LISPER"]
 
-  f = "hello %s world"
-  %w[ruby python].map { |a| f % a }
+  # %w[c++ lisp].map { |lang| lang.upcase + "er" }
+  %w[c++ lisp].map &:upcase.and(:+, "er") # => ["C++er", "LISPer"]
 
-だからこう(ry
+  # stack = []
+  # (1..5).each { |item| stack.push item }
+  stack = []
+  (1..5).each &:push.to(stack)
+  stack # => [1, 2, 3, 4, 5]
 
-  %w[ruby python].map &:%.in("hello %s world")
+  # %w[ruby python].map { |lang| "hello %s world" % lang }
+  %w[ruby python].map &:%.in("hello %s world") # => ["hello ruby world", "hello python world"]

data/Rakefile

@@ -1,9 +0,0 @@
-require './lib/give4each'
-require 'hoe'
-
-Hoe.spec 'give4each' do
-  self.developer 'pasberth', 'pasberth@gmail.com'
-  self.rubyforge_name = self.name
-  self.readme_file = 'README.rdoc'
-  self.version = Give4Each::VERSION
-end

data/examples/example.rb

@@ -1,20 +1,20 @@
-begin
-  require 'give4each'
-rescue LoadError
-  require './' + File.dirname(__FILE__) + '/../lib/give4each'
-end
+require 'rubygems'
+require 'give4each'
 
-# (1..5).map do |i|
-#   i ** 2
-# end
-p (1..5).map &:**.with(2) # => [1, 4, 9, 16, 25]
-  
-# %w[c++ lisp].map do |a|
-#   a.concat("er").upcase
-# end
-p %w[c++ lisp].map &:upcase.of_concat.with("er") # => ["C++ER", "LISPER"]
+# (1..5).map { |i| i ** 2 }
+(1..5).map &:**.with(2) # => [1, 4, 9, 16, 25]
 
-# %w[c++ lisp].map do |a|
-#   a.upcase.concat("er")
-# end
-p %w[c++ lisp].map &:upcase.and_concat.with("er") # => ["C++er", "LISPer"]
+# %w[c++ lisp].map { |lang| (lang + "er").upcase }
+%w[c++ lisp].map &:upcase.of(:+, "er") # => ["C++ER", "LISPER"]
+
+# %w[c++ lisp].map { |lang| lang.upcase + "er" }
+%w[c++ lisp].map &:upcase.and(:+, "er") # => ["C++er", "LISPer"]
+
+# stack = []
+# (1..5).each { |item| stack.push item }
+stack = []
+(1..5).each &:push.to(stack)
+stack # => [1, 2, 3, 4, 5]
+
+# %w[ruby python].map { |lang| "hello %s world" % lang }
+%w[ruby python].map &:%.in("hello %s world") # => ["hello ruby world", "hello python world"]

data/lib/give4each.rb

@@ -1,7 +1,4 @@
-$:.unshift File.dirname(__FILE__)
-
 module Give4Each
-  VERSION = "0.0.3"
 end
 
 require "give4each/private_helpers"

data/lib/give4each/method_chain.rb

@@ -9,17 +9,17 @@ class Give4Each::MethodChain
   #   Give4Eeach::MethodChain.new :any, *args, &block
   # as the:
   #   :any.with *args, &block
-  def initialize method, *args, &block
+  def initialize method, *args, &block # :nodoc:
     raise TypeError, "#{self.class} need to the symbol of the method." unless method.respond_to? :to_sym
     @current = natural method, *args, &block
     @callings = [@current]
   end
-
+  
   # Examples::
   # *of_\**:
-  #   %w[c++ lisp].map &:upcase.of_concat.with("er") # => ["C++ER", "LISPER"]
+  #   %w[c++ lisp].map &:upcase.of_concat("er") # => ["C++ER", "LISPER"]
   # *and_\**:
-  #   %w[c++ lisp].map &:upcase.and_concat.with("er") # => ["C++er", "LISPer"]
+  #   %w[c++ lisp].map &:upcase.and_concat("er") # => ["C++er", "LISPer"]
   # You can do the same as +with+ if you pass the +args+.
   #   %w[c++ lisp].map &:upcase.and_concat("er") # => ["C++er", "LISPer"]
   def method_missing method, *args, &block
@@ -35,6 +35,10 @@ class Give4Each::MethodChain
     super
   end
   
+  def respond_to? f
+    super or Proc.instance_methods.include? f.to_sym
+  end
+  
   def natural method, *args, &block
     HasArgs.new method.to_sym, args, block, lambda { |o, has| o.send has.method, *has.args, &has.block }
   end
@@ -51,21 +55,23 @@ class Give4Each::MethodChain
     self
   end
   
-  # Wrong :( %w[c++ lisp].map &:upcase.of_+("er")
-  # Right :) %w[c++ lisp].map &:upcase.of(:+, "er")
+  # Wrong :(
+  #   %w[c++ lisp].map &:upcase.of_+("er")
+  # Right :)
+  #   %w[c++ lisp].map &:upcase.of(:+, "er")
   def and method, *args, &block
     @current = natural method, *args, &block
     @callings.push @current
     return self
   end
 
+  # For example, I expect the nil is replaced by 0:
+  #
   #    [
   #      [1, 2],
   #      [3],
   #      []
-  #    ].map &:first # => [1, 2, nil]
-  #
-  # I expect the nil is replaced by 0.
+  #    ].map &:first # => [1, 3, nil]
   #
   # But this is needlessly long!:
   #
@@ -73,7 +79,7 @@ class Give4Each::MethodChain
   #     [1, 2],
   #     [3],
   #     []
-  #    ].map { |a| a.first or 0 }
+  #   ].map { |a| a.first or 0 } # => [1, 3, 0]
   #
   # I think I write:
   #
@@ -81,7 +87,7 @@ class Give4Each::MethodChain
   #     [1, 2],
   #     [3],
   #     []
-  #    ].map &:first.or(0)
+  #   ].map &:first.or(0) # => [1, 3, 0]
   #
   def or default_value
     old = @current.callback
@@ -91,7 +97,7 @@ class Give4Each::MethodChain
     self
   end
 
-  # example:
+  # *example*:
   #   # (1..5).map do |i|
   #   #   i ** 2
   #   # end
@@ -106,6 +112,18 @@ class Give4Each::MethodChain
   #   #   a.upcase.concat("er")
   #   # end
   #   p %w[c++ lisp].map &:upcase.and_concat.with("er") # => ["C++er", "LISPer"]
+  #
+  # the 'a', 'an', and 'the' are aliases for this.
+  #
+  # This is strange in English, is not you?
+  #
+  #   char = 'l'
+  #   %w[hello world].map &:count.with(char) # => [2, 1]
+  #
+  # If you want to use, let's choose what you like.
+  #
+  #   %w[hello world].map &:count.a(char)
+  #   %w[hello world].map &:count.the('l')
   def with *args, &block
     @current.args = args
     @current.block = block
@@ -133,8 +151,10 @@ class Give4Each::MethodChain
   # *example*:
   #   receiver = "hello %s world"
   #   %w[ruby python].map &:%.in(receiver) # => ["hello ruby world", "hello python world"] 
+  #
   # *method chain*:
   #   %w[ruby python].map &:%.in(receiver).and_upcase # => ["HELLO RUBY WORLD", "HELLO PYTHON WORLD"]
+  #
   # You should not use #to for that.
   #   receiver = "hello %s world"
   #   %w[ruby python].map &:%.to(receiver) # => ["ruby", "python"]
@@ -144,13 +164,9 @@ class Give4Each::MethodChain
     end
     self
   end
-  
-  def to_sym
-    @method
-  end
 
   def to_proc
-    lambda do |o, &b|
+    lambda do |o|
       @callings.inject o do |o, has|
         has.callback.call o, has
       end

data/spec/enumerable_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe "when using for Enumerable" do
+  
+  let(:langs) { %w[c++ lisp] }
+  let(:suffix) { "er" }
+  
+  describe "Symbol#of" do
+  
+    context "langs.map &:upcase.of(:+, suffix)" do
+      let(:result) { langs.map &:upcase.of(:+, suffix) }
+      let(:expected_result) { langs.map { |lang| (lang + suffix).upcase } }
+      subject { result }
+      it { should == expected_result }
+    end
+
+    context "langs.map &:upcase.of(:+, suffix).and(:+, 's')" do
+      let(:result) { langs.map &:upcase.of(:+, suffix).and(:+, 's') }
+      let(:expected_result) { langs.map { |lang| (lang + suffix).upcase + 's' } }
+      subject { result }
+      it { should == expected_result }
+    end
+  end
+
+  describe "Symbol#and" do
+
+    context "langs.map &:upcase.and(:+, suffix)" do
+      let(:result) { langs.map &:upcase.and(:+, suffix) }
+      let(:expected_result) { langs.map { |lang| lang.upcase + suffix } }
+      subject { result }
+      it { should == expected_result }
+    end
+  end
+  
+  describe "Symbol#to" do
+  
+    context "langs.map &:push.to(*receivers)" do
+      let(:receivers) { Array.new(3) { [] } }
+      let(:destructed_receivers) { Array.new(3) { langs } }
+      let(:result) { langs.map &:push.to(*receivers) }
+      let(:expected_result) { langs }
+      before { result }
+
+      describe "receivers" do
+        subject { receivers }
+        it { should == destructed_receivers }
+      end
+    
+      describe "result" do
+        subject { result }
+        it { should == expected_result }
+      end
+    end
+
+    context "langs.map &:capitalize.and_push.to(*receivers)" do
+      let(:receivers) { Array.new(3) { [] } }
+      let(:destructed_receivers) { Array.new(3) { langs.map { |lang| lang.capitalize } } }
+      let(:result) { langs.map &:capitalize.and_push.to(*receivers) }
+      let(:expected_result) { langs.map &:capitalize }
+      before { result }
+    
+      describe "receivers" do
+        subject { receivers }
+        it { should == destructed_receivers }
+      end
+    
+      describe "result" do
+        subject { result }
+        it { should == expected_result }
+      end
+    end
+
+    context "langs.map &:capitalize.of_push.to(*receivers)" do
+      let(:receivers) { Array.new(3) { [] } }
+      let(:destructed_receivers) { Array.new(3) { langs } }
+      let(:result) { langs.map &:capitalize.of_push.to(*receivers) }
+      let(:expected_result) { langs.map &:capitalize }
+      before { result }
+    
+      describe "receivers" do
+        subject { receivers }
+        it { should == destructed_receivers }
+      end
+    
+      describe "result" do
+        subject { result }
+        it { should == expected_result }
+      end
+    end
+  end
+
+  describe "Symbol#in" do
+
+    context "langs.map &:+.in(receiver)" do
+      let(:receiver) { "The " }
+      let(:result) { langs.map &:+.in(receiver) }
+      let(:expected_result) { langs.map { |lang| receiver + lang } }
+      subject { result }
+      it { should == expected_result }
+    end
+
+    context "langs.map &:capitalize.and(:+).in(receiver)" do
+      let(:receiver) { "The " }
+      let(:result) { langs.map &:capitalize.and(:+).in(receiver) }
+      let(:expected_result) { langs.map { |lang| receiver + lang.capitalize } }
+      subject { result }
+      it { should == expected_result }
+    end
+
+    context "langs.map &:capitalize.of(:+).in(receiver)" do
+      let(:receiver) { "The " }
+      let(:result) { langs.map &:capitalize.of(:+).in(receiver) }
+      let(:expected_result) { langs.map { |lang| (receiver + lang).capitalize } }
+      subject { result }
+      it { should == expected_result }
+    end
+  end
+  
+  describe "Symbol#or" do
+    
+    context "(0..5).map &:at.in(langs).or(default_value)" do
+      let(:default_value) { "none" }
+      let(:result) { (0..5).map &:at.in(langs).or(default_value) }
+      let(:expected_result) { (0..5).map { |i| langs.at(i) or default_value } }
+      subject { result }
+      it { should == expected_result }
+    end
+
+    context "(0..5).map &:at.in(langs).or(default_value).and_capitalize" do
+      let(:default_value) { "none" }
+      let(:result) { (0..5).map &:at.in(langs).or(default_value).and_capitalize }
+      let(:expected_result) { (0..5).map { |i| (langs.at(i) or default_value).capitalize } }
+      subject { result }
+      it { should == expected_result }
+    end
+  end
+end

data/spec/give4each/method_chain_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Give4Each::MethodChain do
+
+  let(:to_s_method) { Give4Each::MethodChain.new :to_s }
+  subject { to_s_method }
+  
+  # # Maybe this is passed each time.
+  # Proc.instance_methods.each do |proc_method|
+  #   it { should respond_to proc_method }
+  # end
+  
+  describe "#to_proc" do
+    let(:receiver) { "hello world" }
+    let(:result) { to_s_method.to_proc.call receiver }
+    subject { result }
+    it { should == "hello world" }
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/../lib/give4each"

data/spec/symbol_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Symbol do
+
+  describe "#to_proc" do
+    let(:receiver) { Array }
+    let(:args) { [2] }
+    let(:result) { :new.to_proc.call(receiver, *args) }
+    subject { result }
+
+    it { should == [nil, nil] }
+  end
+  
+  describe "#of" do
+    let(:receiver) { "ruby" }
+    let(:args) { ["ist"] }
+    let(:result) { :upcase.of(:+, *args).to_proc.call(receiver) }
+    subject { result }
+    it { should == "RUBYIST" }
+  end
+  
+  describe "#and" do
+    let(:receiver) { "ruby" }
+    let(:args) { ["ist"] }
+    let(:result) { :upcase.and(:+, *args).to_proc.call(receiver) }
+    subject { result }
+    it { should == "RUBYist" }
+  end
+  
+  describe "#of_*" do
+    let(:receiver) { "ruby" }
+    let(:args) { ["ist"] }
+    let(:result) { :upcase.of_concat(*args).to_proc.call(receiver) }
+    subject { result }
+    it { should == "RUBYIST" }
+  end
+  
+  describe "#and_*" do
+    let(:receiver) { "ruby" }
+    let(:args) { ["ist"] }
+    let(:result) { :upcase.and_concat(*args).to_proc.call(receiver) }
+    subject { result }
+    it { should == "RUBYist" }
+  end
+  
+  describe "#with" do
+    let(:receiver) { Array }
+    let(:args) { [2] }
+    let(:result) { :new.with(*args).to_proc.call(receiver) }
+    subject { result }
+    it { should == [nil, nil] }
+  end
+  
+  describe "#to" do
+    let(:receiver) { ["hello"] }
+    let(:args) { [["world"]] }
+    let(:result) { :concat.to(receiver).to_proc.call(*args) }
+    before { result }
+    
+    describe "receiver" do
+      subject { receiver }
+      it { should == ["hello", "world"] }
+    end
+    
+    describe "result" do
+      subject { result }
+      it { should == ["world"] }
+    end
+  end
+
+  describe "#in" do
+    let(:receiver) { ["hello"] }
+    let(:args) { [["world"]] }
+    let(:result) { :concat.in(receiver).to_proc.call(*args) }
+    before { result }
+    
+    describe "receiver" do
+      subject { receiver }
+      it { should == ["hello", "world"] }
+    end
+    
+    describe "result" do
+      subject { result }
+      it { should == ["hello", "world"] }
+    end
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: give4each
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,56 +9,53 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-24 00:00:00.000000000 Z
+date: 2012-02-28 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: &70353993100060 !ruby/object:Gem::Requirement
+  name: rake
+  requirement: &70142495229960 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70353993100060
+  version_requirements: *70142495229960
 - !ruby/object:Gem::Dependency
-  name: hoe
-  requirement: &70353993099640 !ruby/object:Gem::Requirement
+  name: rspec
+  requirement: &70142495229080 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70353993099640
-description: (1..5).map { |i| i ** 2 } を (1..5).map &:**.with(2) とか書けるようにする
-email:
-- pasberth@gmail.com
+  version_requirements: *70142495229080
+description: Can write the oneliner as block like the Symbol#to_proc
+email: pasberth@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- History.txt
+- README.rdoc
 files:
+- README.rdoc
+- Rakefile
+- examples/example.rb
 - lib/give4each.rb
 - lib/give4each/core_ext.rb
 - lib/give4each/method_chain.rb
 - lib/give4each/private_helpers.rb
-- History.txt
-- README.rdoc
-- Rakefile
-- examples/and.rb
-- examples/example.rb
-- examples/of.rb
-- examples/with.rb
-- .gemtest
-homepage: https://github.com/pasberth/give4each
+- spec/enumerable_spec.rb
+- spec/give4each/method_chain_spec.rb
+- spec/spec_helper.rb
+- spec/symbol_spec.rb
+homepage: http://github.com/pasberth/give4each
 licenses: []
 post_install_message: 
 rdoc_options:
-- --main
-- README.rdoc
+- --charset=UTF-8
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -74,9 +71,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: give4each
+rubyforge_project: 
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: (1..5).map { |i| i ** 2 } を (1..5).map &:**.with(2) とか書けるようにする
-test_files: []
+summary: Can write the oneliner as block like the Symbol#to_proc
+test_files:
+- spec/enumerable_spec.rb
+- spec/give4each/method_chain_spec.rb
+- spec/spec_helper.rb
+- spec/symbol_spec.rb
+has_rdoc: 

data/History.txt

@@ -1,4 +0,0 @@
-=== 0.0.3 / 2012-2-24
-* added Symbol#or
-* added Symbol#and
-* added Symbol#of

data/examples/and.rb

@@ -1,5 +0,0 @@
-require 'give4each'
-# %w[c++ lisp].map do |a|
-#   a.upcase.concat("er")
-# end
-%w[c++ lisp].map &:upcase.and_concat.with("er") # => ["C++er", "LISPer"]

data/examples/of.rb

@@ -1,6 +0,0 @@
-require 'give4each'
-
-# %w[c++ lisp].map do |a|
-#   a.concat("er").upcase
-# end
-%w[c++ lisp].map &:upcase.of_concat.with("er") # => ["C++ER", "LISPER"]

data/examples/with.rb

@@ -1,5 +0,0 @@
-require 'give4each'
-# (1..5).map do |i|
-#    i ** 2
-# end
-(1..5).map &:**.with(2) # => [1, 4, 9, 16, 25]