iolite 0.0.3 → 2.0.0

data/lib/iolite/refinements/object_with_to_lazy.rb

@@ -1,9 +0,0 @@
-require "iolite/adaptor/to_lazy"
-
-module Iolite module Refinements
-	module ObjectWithToLazy
-		refine Object do
-			include Iolite::Adaptor::ToLazy
-		end
-	end
-end end

data/lib/iolite/refinements/proc.rb

@@ -1,9 +0,0 @@
-require "iolite/adaptor/all"
-
-module Iolite module Refinements
-	module Proc
-		refine ::Proc do
-			include Iolite::Adaptor::All
-		end
-	end
-end end

data/lib/iolite/refinements/string.rb

@@ -1,26 +0,0 @@
-require "iolite/adaptor/all"
-require "iolite/functinal/invoke"
-
-module Iolite module Refinements
-	module String
-		refine ::String do
-			include Iolite::Adaptor::ToProc
-			include Iolite::Adaptor::Callable
-			def call *args
-				result = self.clone
-				args.each_with_index { |it, i|
-					result.gsub! Iolite::Placeholders.const_get("ARG#{i+1}").to_s, it.to_s
-				}
-				result
-			end
-
-			def to_call_by_eval binding = nil
-				Iolite.lambda { |*args|
-					gsub(/#{'#{(.*?)}'}/) {
-						eval($1, binding).call(*args)
-					}
-				}
-			end
-		end
-	end
-end end

data/lib/iolite/refinements.rb

@@ -1,6 +0,0 @@
-require "iolite/refinements/object_with_to_lazy"
-# require "iolite/refinements/array"
-# require "iolite/refinements/hash"
-# require "iolite/refinements/proc"
-# require "iolite/refinements/string"
-

data/lib/iolite/statement/if.rb

@@ -1,50 +0,0 @@
-require "iolite/lazy"
-require "iolite/functinal"
-
-module Iolite module Statement
-
-	class IfThenElse
-		def initialize cond, then_
-			@cond = cond
-			@then_ = then_
-		end
-
-		def [](*else_)
-			Iolite.lazy { |*args|
-				if Iolite::Functinal.invoke(@cond, *args)
-					Iolite::Functinal.invoke_a(@then_, *args).last
-				else
-					Iolite::Functinal.invoke_a(else_, *args).last
-				end
-			}
-		end
-	end
-
-	class If
-		def initialize cond
-			@cond = cond
-		end
-
-		def [](*then_)
-			if_then = Iolite::Lazy.new { |*args|
-				if Iolite::Functinal.invoke(@cond, *args)
-					Iolite::Functinal.invoke_a(then_, *args).last
-				end
-			}
-			cond = @cond
-			(class << if_then; self; end).class_eval {
-				define_method(:else_) {
-					IfThenElse.new cond, then_
-				}
-			}
-			if_then
-		end
-	end
-
-	def if_ cond
-		If.new cond
-	end
-
-	module_function :if_
-
-end end

data/lib/iolite/statement/if_else.rb

@@ -1,12 +0,0 @@
-module Iolite module Statement
-	def if_else cond, then_, else_
-		Lazy.new { |*args|
-			if Functinal.invoke(cond, *args)
-				Functinal.invoke(then_, *args)
-			else
-				Functinal.invoke(else_, *args)
-			end
-		}
-	end
-	module_function :if_else
-end end

data/lib/iolite/statement.rb

@@ -1,3 +0,0 @@
-require "iolite/statement/if"
-require "iolite/statement/if_else"
-

data/lib/iolite/version.rb

@@ -1,3 +0,0 @@
-module Iolite
-  VERSION = "0.0.3"
-end

data/lib/iolite.rb

@@ -1,14 +0,0 @@
-require "iolite/version"
-require "iolite/adaptor"
-require "iolite/functinal"
-require "iolite/lazy"
-require "iolite/placeholders"
-require "iolite/statement"
-
-# Not support 1.9.x
-require "iolite/refinements" if RUBY_VERSION.to_f > 2.0
-
-module Iolite
-	include Functinal
-	include Statement
-end

data/spec/iolite_adaptored_spec.rb

@@ -1,105 +0,0 @@
-load 'spec_helper.rb'
-require "iolite"
-require "iolite/adaptored/array"
-require "iolite/adaptored/hash"
-require "iolite/adaptored/proc"
-require "iolite/adaptored/string"
-require "iolite/adaptored/object_with_to_lazy"
-
-describe "Iolite Adaptored" do
-	include Iolite::Placeholders
-
-	describe "Array" do
-		it "call" do
-			expect([arg1, arg1, arg1].call(1)).to eq([1, 1, 1])
-		end
-		it "call with value" do
-			expect([arg1, 3, arg1].call(1)).to eq([1, 3, 1])
-		end
-		it "bind" do
-			expect([arg1, arg1, arg1].bind(arg2).call(1, 2)).to eq([2, 2, 2])
-		end
-		it "call invoke" do
-			expect(Iolite::Functinal.invoke([arg1, arg1, arg1], 1)).to eq([1, 1, 1])
-		end
-		it "nest" do
-			expect([arg1, [arg2, arg3]].call(1, 2, 3)).to eq([1, [2, 3]])
-		end
-		it "nest binding" do
-			expect([arg1, [arg1, arg2].bind(arg3, arg2)].call(1, 2, 3)).to eq([1, [3, 2]])
-		end
-	end
-
-	describe "Hash" do
-		it "call" do
-			expect({ arg1 => arg2 }.call(:name, :homu)).to eq({ name: :homu })
-		end
-		it "call key" do
-			expect({ arg1 => :mami }.call(:name, :homu)).to eq({ name: :mami })
-		end
-		it "call value" do
-			expect({ :mami => arg1 }.call(:name, :homu)).to eq({ mami: :name })
-		end
-		it "calls" do
-			expect({ arg1 => arg2, arg1 => arg3 }.call(:name, :homu, :mado)).to eq({ name: :homu, name: :mado })
-		end
-		it "bind" do
-			expect({ arg1 => arg3, arg2 => arg4 }.bind(arg1, arg1, arg2, arg3).call(:name, :homu, :mado)).to eq({ name: :homu, name: :mado })
-		end
-	end
-
-	describe "Proc" do
-		describe "operator" do
-			it "proc" do
-				expect((proc { 10 } + 20).call()).to eq(30)
-			end
-			it "lambda" do
-				expect((lambda { 10 } + 20).call()).to eq(30)
-			end
-		end
-		describe "bind" do
-			it "proc" do
-				expect(proc { |a, b| a + b }.bind(arg1, 2).call(1)).to eq(3)
-			end
-			it "lambda" do
-				expect(proc { |a, b| a - b }.bind(2, arg1).call(1)).to eq(1)
-			end
-		end
-		describe "Symbol" do
-			it "#to_proc" do
-				expect((arg1.to_s + :to_s.to_proc).call(42)).to eq("4242")
-			end
-		end
-	end
-
-	describe "String" do
-		it "call" do
-			expect("value:#{arg1}:#{arg2}".call(1, 2)).to eq("value:1:2")
-		end
-		it "#to_call_by_eval" do
-			expect('value:#{ Iolite::Placeholders.arg1 }:#{ Iolite::Placeholders.arg2 }'.to_call_by_eval.call(1, 2)).to eq("value:1:2")
-		end
-		it "#to_call_by_eval binding" do
-			var = 10
-			expect('value:#{ arg1 + arg2 * var }:#{ arg2 - arg1 }'.to_call_by_eval(binding).call(1, 2)).to eq("value:21:1")
-		end
-	end
-
-	describe "Object" do
-		describe "#to_lazy" do
-			it "lazy" do
-				expect(1.to_lazy.call()).to eq(1)
-			end
-			it "operator" do
-				expect((1.to_lazy + 2).call()).to eq(3)
-			end
-			it "operator with placeholder" do
-				expect((1.to_lazy + arg1).call(2)).to eq(3)
-			end
-			it "call method" do
-				expect(((1..10).to_lazy.first arg1).call(3)).to eq([1, 2, 3])
-			end
-		end
-	end
-end
-

data/spec/iolite_functinal_spec.rb

@@ -1,87 +0,0 @@
-load 'spec_helper.rb'
-require "iolite/functinal"
-
-
-describe "Iolite::Functinal" do
-	include Iolite::Functinal
-	class Callable
-		def iolite_functinal_invoke_call a, b
-			a + b
-		end
-	end
-	class Uncallable
-		def call x
-			x + x
-		end
-	end
-
-	class First
-		def iolite_functinal_invoke_call *args
-			args[0]
-		end
-		def call *args
-			args[0]
-		end
-	end
-	first = First.new
-
-	describe ".invoke" do
-		it "callable" do
-			expect(invoke(Callable.new, 1, 2)).to eq(3)
-		end
-		it "uncallable" do
-			expect(invoke(3, 1)).to eq(3)
-		end
-		it "uncallable call" do
-			expect(invoke(Uncallable.new, 1).class).to eq(Uncallable)
-		end
-		#it "uncallable proc" do
-		#	expect(invoke(proc { |a, b| a + b }, 1, 2).class).to eq(Proc)
-		#end
-	end
-
-	describe ".invoke_a" do
-		it "callable" do
-			expect(invoke_a([Callable.new, Callable.new], 1, 2)).to eq([3, 3])
-		end
-		it "uncallable" do
-			expect(invoke_a([1, 2], 1)).to eq([1, 2])
-		end
-	end
-
-	describe ".send" do
-		it "send callable" do
-			expect(send(4, :+, Callable.new).call(1, 2)).to eq(7)
-		end
-		it "send callable" do
-			expect(send(Callable.new, :+, Callable.new).call(1, 2)).to eq(6)
-		end
-		it "send with block" do
-			expect(send(first, :select){ |it| it > 1 }.call([1, 2, 3])).to eq([2, 3])
-		end
-	end
-
-	describe ".bind" do
-#		it "bind callable" do
-#			expect(bind(-> a, b { a + b }, 1, First.new).call(1, 2)).to eq(2)
-#		end
-#		it "bind method" do
-#			expect(bind(:+.to_proc, 1, First.new).call(2)).to eq(3)
-#		end
-#		it "bind next" do
-#			expect(bind(-> a, b { a + b }, bind(-> a, b { a + b }, First.new, First.new), First.new).call(3)).to eq(9)
-#		end
-		it "apply first" do
-			expect(bind(First.new, 1, 2).call(-> a, b { a + b })).to eq(3)
-		end
-	end
-
-#	describe ".apply" do
-#		it "call first" do
-#			expect(apply(-> a { -> b { a + b} }, 1).call(2)).to eq(3)
-#		end
-#		it "NoMethodError" do
-#			expect{ apply(-> a { 10 }, 1).call(2) }.to raise_error(NoMethodError)
-#		end
-#	end
-end

data/spec/iolite_lazy_spec.rb

@@ -1,92 +0,0 @@
-load 'spec_helper.rb'
-require "iolite/lazy"
-
-
-describe "Iolite lazy" do
-	describe "Iolite::lazy" do
-		include Iolite
-		arg1 = Iolite.lazy { |*args| args[0] }
-		arg2 = Iolite.lazy { |*args| args[1] }
-
-		describe "#class" do
-			it "#class by Obejct#class" do
-				expect(lazy { |a, b| a + b }.class).to eq(Iolite::Lazy)
-			end
-		end
-
-		describe "#call" do
-			it "call" do
-				expect(lazy { |a, b| a + b }.call(1, 2)).to eq(3)
-			end
-		end
-
-		describe "#bind" do
-			it "bind argument" do
-				expect(lazy { |a, b| a + b }.bind(1, 2).call()).to eq(3)
-			end
-			it "bind placeholders" do
-				expect(lazy { |a, b| a + b }.bind(arg2, 2).call(2, 1)).to eq(3)
-			end
-			it "bind by placeholders" do
-				expect((arg1 - arg2).bind(arg2, 2).call(1, 1)).to eq(-1)
-			end
-		end
-
-		describe "#send" do
-			it "send method" do
-				expect(arg1.send(:length).call("homu")).to eq(4)
-			end
-			it "send Object method" do
-				expect(arg1.send(:class).call("homu")).to eq(String)
-			end
-		end
-
-		describe "#method_missing" do
-			it "send method" do
-				expect(arg1.length.call("homu")).to eq(4)
-			end
-			it "send Object method" do
-				expect(arg1.class).to eq(arg1.__send__(:class))
-			end
-		end
-
-		describe "#apply" do
-			it "apply lazy" do
-				expect(arg1.apply(1, 2).call(arg1 + arg2)).to eq(3)
-			end
-		end
-
-		describe "#+" do
-			it "call lazy" do
-				expect((lazy { |a, b| a + b } + 3).call(1, 2)).to eq(6)
-			end
-		end
-
-		describe "#==" do
-			it "call" do
-				expect((arg1 == 3).call(3)).to eq(true)
-			end
-		end
-
-		describe "#===" do
-			it "call" do
-				expect((arg1 === arg2).call(/^m/, "mami")).to eq(true)
-			end
-		end
-
-		describe "#to_s" do
-			it "Symbol#to_s" do
-				expect(arg1.to_s.call(:mami)).to eq("mami")
-			end
-			it "Fixnum#to_s" do
-				expect(arg1.to_s.call(42)).to eq("42")
-			end
-		end
-
-		describe "#class" do
-			it "Symbol#class" do
-				expect(arg1.class.call(:mami)).to eq(Symbol)
-			end
-		end
-	end
-end

data/spec/iolite_spec.rb

@@ -1,212 +0,0 @@
-load 'spec_helper.rb'
-
-describe Iolite do
-	it 'has a version number' do
-		expect(Iolite::VERSION).not_to be nil
-	end
-
-	describe "Iolite" do
-		it "::lazy" do
-			expect(Iolite.lazy { |a, b| a + b }.class).to eq(Iolite::Lazy)
-		end
-#		it "::wrap" do
-#			expect((Iolite.wrap lambda { |a, b| a + b }).call(1, 2).class).to eq(Proc)
-#		end
-	end
-
-	describe "Iolite::Lazy" do
-		first = Iolite::lazy { |x| x }
-		plus = Iolite::lazy { |a, b| a + b }
-		describe "#call" do
-			it "call" do
-				expect(first.call(10)).to eq(10)
-			end
-
-			it "()" do
-				expect(first.(10)).to eq(10)
-			end
-
-			it "call multi arguments" do
-				expect(first.call(10, 2)).to eq(10)
-				expect(plus.call(10, 2)).to eq(12)
-			end
-		end
-
-		describe "#bind" do
-			include Iolite::Placeholders
-			f = Iolite::lazy { |a, b| a + b }
-			it "argument" do
-				expect(f.bind(-3, 1).call()).to eq(-2)
-			end
-			it "argument" do
-				expect(f.bind(arg2, arg1).call(-1, 3)).to eq(2)
-			end
-			it "operator" do
-				expect(Iolite::lazy(&:+).bind(arg2, arg1).call(-1, 3)).to eq(2)
-			end
-		end
-
-		describe "#send" do
-			it "call method" do
-				expect(first.send(:to_s).call(10).class).to eq(String)
-			end
-			it "call method with args" do
-				expect(first.send(:+, 1).call(2)).to eq(3)
-			end
-			include Iolite::Placeholders
-			it "call method with placeholders" do
-				expect(first.send(:+, arg2).call(2, -2)).to eq(0)
-			end
-		end
-
-		describe "#apply" do
-			include Iolite::Placeholders
-			it "call lambda" do
-				expect(arg1.apply(1, 2).call(lambda { |a ,b| a + b })).to eq(3)
-			end
-			it "call Iolite::Lazy" do
-				expect(arg1.apply(1, 2).call(Iolite::lazy { |a ,b| a + b })).to eq(3)
-			end
-		end
-
-		describe "operators" do
-			it "a + b" do
-				expect((first + first).call(1)).to eq(2)
-			end
-			it "a - b" do
-				expect((plus - first).call(2, 3)).to eq(3)
-			end
-			it "a * b" do
-				expect((first * first).call(2)).to eq(4)
-			end
-			it "a[b]" do
-				expect((first[:name]).call({name: :homu})).to eq(:homu)
-			end
-			it "a + {value}" do
-				expect((first + 3).call(4)).to eq(7)
-			end
-			it "==" do
-				expect([1, 2, 3].any? &first == 3).to eq(true)
-			end
-			it "=~" do
-				expect(["homu", "123", "mami"].any? &first =~ /\d+/).to eq(true)
-			end
-			it "!" do
-				expect([1, nil, 6].find_index &!first).to eq(1)
-			end
-		end
-
-		describe "#method_missing" do
-			it "call #length method" do
-				expect(first.length.call("homu")).to eq(4)
-			end
-			it "call #to_s method" do
-				expect(first.to_i.call("1").class).to eq(Fixnum)
-			end
-			it "call Object#*" do
-				# not call method_missing
-				expect(first.class).to eq(Iolite::Lazy)
-			end
-			it "call Object#* from #send" do
-				expect(first.send(:class).call("homu")).to eq(String)
-			end
-		end
-
-		describe "Array block" do
-			it "#map by" do
-				expect((1..3).map &(first + 3)).to eq([4, 5, 6])
-			end
-			it "#inject by" do
-				expect((2..4).inject &(plus)).to eq(9)
-			end
-		end
-	end
-
-	describe "Iolite::Placeholders" do
-		include Iolite::Placeholders
-		it "arg1" do
-			expect(arg1.call(1, 2)).to eq(1)
-		end
-		it "arg1 + arg2" do
-			expect((arg1 + arg2).call(1, 2)).to eq(3)
-		end
-		it "arg1[arg2]" do
-			expect((arg1[arg2]).call([1, 2, 3], 2)).to eq(3)
-		end
-		it "args" do
-			expect((args[arg2]).call(1, 3, 2, 4)).to eq(4)
-		end
-		it "bind" do
-			# expect(arg1.bind(10).call(Iolite.lambda { |x| x + x})).to eq(20)
-		end
-		it "alias _1, arg1" do
-			expect((_1 + _2).call(1, 2)).to eq(3)
-		end
-	end
-
-	describe "Iolite::adaptor" do
-		describe "Adapt callable" do
-			include Iolite::Placeholders
-			class UnCallableFromIolite
-			end
-			it "not callable" do
-				# UnCallableFromIolite.new.class
-				expect(arg1.send(:class).bind(UnCallableFromIolite.new).call(10)).to eq(UnCallableFromIolite)
-			end
-			class CallableFromIolite
-				include Iolite::Adaptor::Callable
-				def call n
-					n
-				end
-			end
-			it "callable" do
-				# CallableFromIolite.new.call("homu")
-				expect(arg1.send(:class).bind(CallableFromIolite.new).call("homu")).to eq(String)
-			end
-			it "wrap" do
-				# expect(arg1.send(:class).bind(Iolite.wrap CallableFromIolite.new).call("homu")).to eq(CallableFromIolite)
-			end
-		end
-	end
-
-	describe "Iolite::Statement" do
-		describe "if_else" do
-			include Iolite::Statement
-			include Iolite::Placeholders
-			it "call then" do
-				f = if_else(arg1 > 0, arg2, nil)
-				expect(f.(10, "yes")).to eq("yes")
-			end
-			it "call else" do
-				f = if_else(arg1 > 0, arg2, nil)
-				expect(f.(-10, "yes")).to eq(nil)
-			end
-		end
-		describe "if_" do
-			describe "if then" do
-				include Iolite::Statement
-				include Iolite::Placeholders
-				it "call then" do
-					f = if_(arg1 > 0)[ arg1, arg1 + arg1 ]
-					expect(f.(10)).to eq(20)
-				end
-				it "call else" do
-					f = if_(arg1 > 0)[ arg1, arg1 + arg1 ]
-					expect(f.(0)).to eq(nil)
-				end
-			end
-			describe "if then else" do
-				include Iolite::Statement
-				include Iolite::Placeholders
-				it "call then" do
-					f = if_(arg1 > 0)[ arg1, arg1 + arg1 ].else_[ arg1, arg1 - arg1 ]
-					expect(f.(10)).to eq(20)
-				end
-				it "call else" do
-					f = if_(arg1 > 0)[ arg1, arg1 + arg1 ].else_[ arg1, arg1 - arg1 ]
-					expect(f.(-10)).to eq(0)
-				end
-			end
-		end
-	end
-end

data/spec/spec_helper.rb

@@ -1,2 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require 'iolite'