iolite 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f8bdc1d07b8278aae627184301b8ccbdca18c586
+  data.tar.gz: 7988f1205a24e40ed0a4ab0943d74775464a21c7
+SHA512:
+  metadata.gz: 0c81d0be5cbda84687152fd2c1d58148bea44a1e0049e0a4efd43025786fb8813a9a50f339ec0b4d3e848ec8bb69898fdef8005976ef46d2505119cff0854044
+  data.tar.gz: 2f94fba7d27a8e0e2e998b5fb8ddfdc1575468cebe04b37051afa70d89db273190581386f861a2b394c1f486b5dc34d81e78cd16e7b29730f56a720c0782cb24

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+test
+_lib

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in iolite.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 manga_osyo
+
+MIT License
+
+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.md

@@ -0,0 +1,70 @@
+[![Build Status](https://travis-ci.org/osyo-manga/gem-iolite.svg?branch=master)](https://travis-ci.org/osyo-manga/gem-iolite)
+
+# Iolite
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'iolite'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install iolite
+
+## Usage
+
+```ruby
+require "iolite"
+
+
+#######################################
+# Using block
+#######################################
+
+p (1..5).map { |it| it + 3 }
+# => [4, 5, 6, 7, 8]
+
+p (1..5).inject { |memo, item| memo + item }
+# => 15
+
+p ["homu", "mami", "an"].inject(0) { |memo, item| memo + item.length }
+# => 10
+
+p [{name: :homu}, {name: :mami}].map { |it| it[:name] }
+# => [:homu, :mami]
+
+
+#######################################
+# Using iolite
+#######################################
+
+# using arg1, arg2...
+include Iolite::Placeholders
+
+p (1..5).map &arg1 + 3
+# => [4, 5, 6, 7, 8]
+
+p (1..5).inject &arg1 + arg2
+# => 15
+
+p ["homu", "mami", "an"].inject 0, &arg1 + arg2.length
+# => 10
+
+p [{name: :homu}, {name: :mami}].map &arg1[:name]
+# => [:homu, :mami]
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/osyo-manga/gem-iolite )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/docs/iolite.md

@@ -0,0 +1,278 @@
+# iotelite
+
+## これは何？
+
+式を遅延評価するためのライブラリです。  
+ブロックで行う処理を抽象化し、コードを簡略化することを目的としています。  
+ちなみにライブラリ名である iolite（アイオライト）は菫青石から取っています。
+
+## イントロダクション
+
+さて、Ruby ではブロック付きメソッド呼び出しを行うことが多いです。
+
+```ruby
+["homu", "mami", "mado"].map { |it| it.capitalize }
+# => ["Homu", "Mami", "Mado"]
+```
+
+しかし、上記のようにブロックを使用すると it を2回書く必要が出てきてちょっと手間ですね。  
+これは 以下のように Symbol#to_proc を利用するように書き換える事が可能です。
+
+```ruby
+["homu", "mami", "mado"].map &:capitalize
+# => ["Homu", "Mami", "Mado"]
+```
+
+これでブロックを記述することなく map を使用する事ができました。  
+では、次のようなコードはどうでしょうか。
+
+```ruby
+["homu", "mami", "mado"].select{ |it| it =~ /^m/ }
+# => ["mami", "mado"]
+
+[{ name: "homu" }, { name: "mami" }, { name: "mado" }].map { |it| it[:name] }
+# => ["homu", "mami", "mado"]
+```
+
+上記のように呼び出したいメソッドに対して引数を渡したい場合はどうしてもブロックで記述する必要が出てきます。  
+このような場合に iolite を使用することですっきりとした記述をすることができます。
+
+```ruby
+# iolite を使って書いてみる
+# arg1 は第一引数に置き換わり評価される
+["homu", "mami", "mado"].select &arg1 =~ /^m/
+# => ["mami", "mado"]
+
+[{ name: "homu" }, { name: "mami" }, { name: "mado" }].map &arg1[:name]
+# => ["homu", "mami", "mado"]
+```
+
+## 導入
+
+#### install
+
+```shell
+$ gem install iolite
+```
+
+#### require
+
+```ruby
+require "iolite"
+```
+
+## 簡単な使い方
+
+iolite ではプレースホルダを使用して、式から遅延評価を行うオブジェクトを定義します。  
+プレースホルダは arg1, arg2, ...argN と定義されており、それぞれの引数番目の値に置き換わり評価されます。
+
+```ruby
+# プレースホルダは module Iolite::Placeholders で定義されている
+include Iolite::Placeholders
+
+# arg1 は第一引数を返す
+arg1.call(1, 2)
+# => 1
+
+# arg1 は第二引数を返す
+arg2.call(1, 2)
+# => 2
+```
+
+このプレースホルダからメソッドを呼び出すと、そのメソッドを遅延評価するオブジェクトを返します。
+
+```ruby
+# 第一引数に対して #capitalize メソッドを呼び出すオブジェクトを返す
+capitalize_ = arg1.capitalize
+
+capitalize_.call("homu")
+# => "Homu"
+capitalize_.call("an")
+# => "An"
+
+# メソッドの引数に対してプレースホルダを渡すこともできる
+plus = arg1 + arg2
+# plus = arg1.+(arg2)
+
+plus.call(1, 2)
+# => 3
+```
+
+次のようにメソッドチェーンやネストしてプレースホルダを使用することもできます。
+
+```ruby
+# 連続してメソッドを呼び出すこともできる
+length_ = arg1.to_s(4).length
+length_.call(:homu)
+# => 4
+length_.call(42)
+# => 2
+
+# ネストして呼び出すことも可能
+f = arg1[arg2].length + arg1[arg3]
+f.call({ :name => "homu", :age => 13 }, :name, :age)
+# => 17
+```
+
+
+### ブロックに渡す
+
+& をつけることでブロックに渡すことができます。
+
+```ruby
+["homu", "mami", "mado"].select &arg1 =~ /^m/
+# => ["mami", "mado"]
+[:homu, :mami, :mado].inject 0, &arg1 + arg2.to_s.length
+# => 12
+```
+
+
+## Iolite::Lazy < BasicObject (class)
+
+Iolite::Lazy は遅延評価を行うためのオブジェクトです。
+プレースホルダなどはこのオブジェクトのラッパになります。
+
+```ruby
+f = Iolite::Lazy.new { |a, b| a + b }
+p f.call(1, 2)
+# => 10
+```
+
+これは次のようにメソッド呼び出しを遅延評価する事ができます。
+
+```ruby
+twice = Iolite::Lazy.new { |a| a + a }
+twice.call(2)
+# => 4
+
+# 演算子を遅延評価
+twice_plus3 = (twice + 3)
+twice_plus3.call(1) # to twice.call(1) + 3
+# => 5
+
+# メソッド呼び出しを遅延評価
+upcase_ = twice.upcase
+upcase_.call("homu") # to twice.call("homu").upcase
+# => "HOMUHOMU"
+```
+
+また、このクラスは BasicObject を継承していることに注意してください。
+
+#### Iolite::Lazy#initialize &block
+
+遅延評価を行うブロックを渡してオブジェクトを作成します。
+このブロックは `#call` の呼び出し時に評価されます。
+
+#### Iolite::Lazy#call(*args)
+
+初期化時に渡したブロックを評価します。
+
+
+#### Iolite::Lazy#send(name, *args)
+
+name という名前のメソッドを遅延評価します。  
+遅延評価した結果に対して `#send(name, *args)` を呼び出す Iolite::Lazy を返します。
+
+```ruby
+it = Iolite::Lazy.new { |it| it }
+it.send(:length).call("homu") # to { |it| it }.call("homu").length
+```
+
+#### Iolite::Lazy#method_missing(name, *args)
+
+`Iolite::Lazy#send(name, *args)` を返します。  
+Iolite::Lazy で定義されていないメソッドであれば `#send` を使用することなくメソッドを遅延評価することができます。
+
+#### Iolite::Lazy#to_proc
+
+`#call` を呼び出す Proc を返します。  
+これにより & を着けてブロックに渡すことができます。
+
+```ruby
+it = Iolite::Lazy.new { |it| it }
+["homu", "mami", "mado"].map &it.capitalize
+# => ["Homu", "Mami", "Mado"]
+
+["homu", "mami", "mado"].select &it =~ /^m/
+# => ["mami", "mado"]
+```
+
+## プレースホルダ
+
+プレースホルダは任意の引数値に対して遅延評価を行うために使用します。  
+プレースホルダは arg1 〜 arg10 まで定義されており、argN 番目の引数に対応します。  
+これは module Iolite::Placeholders で定義されています。
+
+```ruby
+include Iolite::Placeholders
+
+arg1.call(1, 2)
+# => 1
+
+arg2.call(1, 2)
+# => 1
+```
+
+このプレースホルダは Iolite::Lazy オブジェクトなので Iolite::Lazy と同様に遅延評価を行うことができます。
+
+
+```ruby
+include Iolite::Placeholders
+
+(arg1 + arg2).call(1, 2)
+# => 3
+
+arg1.to_s.length.call(:homu)
+# => 4
+
+["homu", "mami", "mado"].select(&arg1 =~ /^m/).map &arg1.capitalize
+# => ["Mami", "Mado"]
+
+(1..5).map &arg1.to_s(2)
+# => ["1", "10", "11", "100", "101"]
+
+[:homu, :mami, :an].select &arg1.to_s.length > 3
+# => [:homu, :mami]
+```
+
+## Object#to_lazy
+
+`Object#to_lazy` は自身を遅延評価するオブジェクト（Iolite::Lazy オブジェクト）として返すメソッドです。
+`Object#to_lazy` を使用したい場合は refinements が使える環境であれば、
+
+```ruby
+using Iolite::Refinements::ObjectWithToLazy
+```
+
+refinements が使えない、もしくは直接 Object を拡張したい場合は
+
+```ruby
+require "iolite/adaptored/object_with_to_lazy"
+```
+
+することで利用することができます。
+
+
+#### Example
+
+```ruby
+# (1..Float::INFINITY) を遅延評価する
+lazy_list = (1..Float::INFINITY).to_lazy
+twice_list = lazy_list.first(arg1).map(&arg1 * 2)
+
+p twice_list.call(5)
+# => [2, 4, 6, 8, 10]
+p twice_list.call(10)
+# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
+
+["homu", "mami", "mado"].each &to_lazy.printf("%s:%s, ", arg1, arg1)
+# => homu:homu, mami:mami, mado:mado,
+
+a = { :name => "mami", :age => 13 }
+b = { :name => "mami" }
+a.reject &arg2 == b.to_lazy[arg1]
+# => { :age => 13 }
+```
+
+
+

data/example/array.rb

@@ -0,0 +1,17 @@
+require "iolite"
+
+# Use require
+# define Array#to_proc
+require "iolite/adaptored/array"
+
+include Iolite::Placeholders
+
+p [1, arg1, 2, arg1 + arg2].to_proc.call(1, 2)
+# => [1, 1, 2, 3]
+
+p [1, 2, 3].map &[arg1, arg1 ,arg1]
+# => [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
+
+p [1, 2, 3].map &((1..3).map &arg1.to_l + 3)
+# => [[4, 4, 4], [5, 5, 5], [6, 6, 6]]
+