totally_lazy 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76f6d260b177c8aa5b64578b0091377494ce839b
-  data.tar.gz: 312fa25893fa88b9d4cdc32222da221c57151e1d
+  metadata.gz: 359852636f3453d43e493fb7294d4ff1aae3c290
+  data.tar.gz: e90a9cb5312f5bb6f96233ba6b7ede106a265ef6
 SHA512:
-  metadata.gz: b70457704551cdc3892eb34f9a02fb089d5fa4c0f39e2d5f10705536db1cf03f3bd2a080b52e31ef02ab9d2413342764a61fba413da77fdb86cee6b7de2e4370
-  data.tar.gz: 518b3ef257b1825686154c90e6a541ef207012fba8443b2fd18b42805c3be849891aba64924a885126a388b47c343cc565b268dd2a7932053696882c568b217f
+  metadata.gz: dc8fa64092c0487056ab2074188daffcb1ebe44da6554cc18a65f12c8efb0c95f5f200e08cb7d9dde54b526c3711ff2c5b01a3067d5a6cf2a218c298c00e7399
+  data.tar.gz: 788d696acf110d53defb2095567e7d2a78121111e1d817ba2c4d7cf12803fdf454d4564970c42506497416aa1017614a3824d80e3b0dafa1e2403e8f37534e2e

data/VERSION

@@ -1 +1 @@
-0.0.15
+0.0.16

data/lib/option.rb

@@ -85,49 +85,49 @@ module Option
 
     def each(&block)
       @content.each(&block)
-     end
+    end
 
     def map(predicate=nil, &block)
-      sequence(@content).map(predicate, &block)
+      as_option(sequence(@content).map(predicate, &block))
     end
 
     alias collect map
 
     def select(predicate=nil, &block)
-      sequence(@content).select(predicate, &block)
+      as_option(sequence(@content).select(predicate, &block))
     end
 
     alias find_all select
     alias filter select
 
     def reject(predicate=nil, &block)
-      sequence(@content).reject(predicate, &block)
+      as_option(sequence(@content).reject(predicate, &block))
     end
 
     alias unfilter reject
 
     def grep(pattern)
-      sequence(@content).grep(pattern)
+      as_option(sequence(@content).grep(pattern))
     end
 
     def drop(n)
-      sequence(@content).drop(n)
+      as_option(sequence(@content).drop(n))
     end
 
     def drop_while(&block)
-      @content.drop_while(&block)
+      as_option(@content.drop_while(&block))
     end
 
     def take(n)
-      sequence(@content).take(n)
+      as_option(sequence(@content).take(n))
     end
 
     def take_while(&block)
-      sequence(@content).take_while(&block)
+      as_option(@content.take_while(&block))
     end
 
     def flat_map(&block)
-      sequence(@content).flat_map(&block)
+      as_option(sequence(@content).flat_map(&block))
     end
 
     alias collect_concat flat_map
@@ -233,46 +233,46 @@ module Option
     alias << join
 
     def map(predicate=nil, &block)
-      empty
+      none
     end
 
     alias collect map
 
     def select(predicate=nil, &block)
-      empty
+      none
     end
 
     alias find_all select
     alias filter select
 
     def reject(predicate=nil, &block)
-      empty
+      none
     end
 
     alias unfilter reject
 
     def grep(pattern)
-      empty
+      none
     end
 
     def drop(n)
-      empty
+      none
     end
 
     def drop_while(&block)
-      empty
+      none
     end
 
     def take(n)
-      empty
+      none
     end
 
     def take_while(&block)
-      empty
+      none
     end
 
     def flat_map(&block)
-      empty
+      none
     end
 
     alias collect_concat flat_map

data/spec/option_spec.rb

@@ -64,7 +64,7 @@ describe 'Option' do
   end
 
   it 'should convert to sequence' do
-    expect(option(1).to_seq.to_a).to eq(sequence(1).to_a)
+    expect(option(1).to_seq).to eq(sequence(1))
     expect(none.to_seq).to eq(empty)
   end
 
@@ -127,57 +127,58 @@ describe 'Option' do
   end
 
   it 'should support select' do
-    expect(option(2).filter(even)).to eq(sequence(2))
-    expect(option(2).find_all(even)).to eq(sequence(2))
-    expect(option(2).select(even)).to eq(sequence(2))
-    expect(option(2).filter(&:even?)).to eq(sequence(2))
-    expect(option(2).filter{|v| v == 2}).to eq(sequence(2))
-    expect(option(nil).filter(even)).to eq(empty)
+    expect(option(2).filter(even)).to eq(some(2))
+    expect(option(2).find_all(even)).to eq(some(2))
+    expect(option(2).select(even)).to eq(some(2))
+    expect(option(2).filter(&:even?)).to eq(some(2))
+    expect(option(2).filter{|v| v == 2}).to eq(some(2))
+    expect(option(nil).filter(even)).to eq(none)
   end
 
   it 'should support map' do
-    expect(option([{apple:1,pear:2},{melon:3}]).map{|h| h}).to eq([{apple:1,pear:2},{melon:3}])
-    expect(option(1).map(as_string)).to eq(sequence('1'))
-    expect(option(1).collect(as_string)).to eq(sequence('1'))
-    expect(option(sequence(1, 2, 3)).map { |s| s.entries }.to_a).to eq([[1, 2, 3]])
-    expect(option(1).map{|v| v+1}).to eq(sequence(2))
-    expect(option(nil).map(as_string)).to eq(empty)
+    expect(option([{apple:1,pear:2},{melon:3}]).map{|h| h}).to eq(some([{apple:1,pear:2},{melon:3}]))
+    expect(option({apple:1,pear:2})).to eq(some({apple:1,pear:2}))
+    expect(option(1).map(as_string)).to eq(some('1'))
+    expect(option(1).collect(as_string)).to eq(some('1'))
+    expect(option(sequence(1, 2, 3)).map { |s| s.entries }).to eq(some([1, 2, 3]))
+    expect(option(nil).map(as_string)).to eq(none)
   end
 
   it 'should support reject' do
-    expect(option(2).reject(odd)).to eq(sequence(2))
-    expect(option(2).unfilter(odd)).to eq(sequence(2))
-    expect(option(2).reject(&:odd?)).to eq(sequence(2))
-    expect(option(2).reject{|v| v == 1}).to eq(sequence(2))
-    expect(option(nil).reject(odd)).to eq(empty)
+    expect(option(2).reject(odd)).to eq(some(2))
+    expect(option(2).unfilter(odd)).to eq(some(2))
+    expect(option(2).reject(&:odd?)).to eq(some(2))
+    expect(option(2).reject{|v| v == 1}).to eq(some(2))
+    expect(option(nil).reject(odd)).to eq(none)
   end
 
   it 'should support grep' do
-    expect(option('apple').grep(/p/)).to eq(sequence('apple'))
-    expect(option(nil).grep(/p/)).to eq(empty)
+    expect(option('apple').grep(/p/)).to eq(some('apple'))
+    expect(option(nil).grep(/p/)).to eq(none)
   end
 
   it 'should support drop' do
-    expect(option(1).drop(1)).to eq(empty)
-    expect(option(nil).drop(1)).to eq(empty)
+    expect(option(1).drop(1)).to eq(none)
+    expect(option(nil).drop(1)).to eq(none)
   end
 
   it 'should support drop_while' do
-    expect(option(sequence(1,7)).drop_while { |n| n < 5 }).to eq(sequence(7))
-    expect(option(nil).drop_while { |n| n < 5 }).to eq(empty)
+    expect(option(sequence(1,7)).drop_while { |n| n < 5 }).to eq(some(1))
+    expect(option(nil).drop_while { |n| n < 5 }).to eq(none)
   end
 
   it 'should support take' do
-    expect(option(1).take(2)).to eq(sequence(1))
-    expect(option(nil).take(2)).to eq(empty)
+    expect(option(1).take(2)).to eq(some(1))
+    expect(option(nil).take(2)).to eq(none)
   end
 
   it 'should support take_while' do
-    expect(option(nil).take_while { |n| n < 5 }).to eq(empty)
+    expect(option(sequence(1,7)).take_while { |n| n < 5 }).to eq(some(1))
+    expect(option(nil).take_while { |n| n < 5 }).to eq(none)
   end
 
   it 'should support flat_map' do
-    expect(option(nil).flat_map{|v| v.first}).to eq(empty)
+    expect(option(nil).flat_map{|v| v.first}).to eq(none)
   end
 
 end

data/totally_lazy.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: totally_lazy 0.0.15 ruby lib
+# stub: totally_lazy 0.0.16 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "totally_lazy"
-  s.version = "0.0.15"
+  s.version = "0.0.16"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Kingsley Hendrickse"]
-  s.date = "2015-11-01"
+  s.date = "2015-11-03"
   s.description = "Port of java functional library totally lazy to ruby"
   s.email = "kingsleyhendrickse@me.com"
   s.extra_rdoc_files = [
@@ -59,7 +59,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/kingsleyh/totally_lazy"
   s.licenses = ["MIT"]
-  s.rubygems_version = "2.2.2"
+  s.rubygems_version = "2.4.5.1"
   s.summary = "Port of java functional library totally lazy to ruby"
 
   if s.respond_to? :specification_version then

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: totally_lazy
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Kingsley Hendrickse
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-01 00:00:00.000000000 Z
+date: 2015-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -201,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Port of java functional library totally lazy to ruby