totally_lazy 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d920f02851d9aa5f7b31c4fb981d27f6de1c4c94
-  data.tar.gz: 7abffac7838c3b7438e6fdbb630f1215d9469a1c
+  metadata.gz: eaad07a76c011ba5573c34c69bf011a0a6c83dcf
+  data.tar.gz: 0d6623c562462a5e936b60bcee8d43ea919fa4bf
 SHA512:
-  metadata.gz: 78c04354b86df09c0530d05aa0f79447f5d14616114ba52d078bb2f46de87ce130a906a1486762113245210152b577fdf1f2c616cb6d1cb16320cad7094f14cd
-  data.tar.gz: 9499dc81048c8cda73e8d2de55704d6e6a55e9486cf235fb86403799b230fbdb86123bc185f52b0de9eab84c70e50ad030a83df753dc2558f8f2d1d9e0b24a87
+  metadata.gz: 9000dde503c5754b186847d11e300de5cc53ea8c48f5a0806ecd3847b3f565870cce50e3f7a330df184a0e2af4fd534bc06dfce1abbcfc5d38571128b87e122d
+  data.tar.gz: 8dc151abd744dbb82190bc7774d431f868cabd9b856a62e275475601e7416cefe053f9e4fb71e50c4f7f6a87c32587a5091481632d244a038b63da84cfea97a4

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/lib/option.rb

@@ -22,6 +22,8 @@ module Option
       raise(Exception, 'some cannot be nil') if @content.nil?
     end
 
+
+
     def <=>(object)
       self.state <=> object.state
     end
@@ -58,8 +60,8 @@ module Option
       blank? ? nil : @content
     end
 
-    def get_or_throw(exception,message='')
-      blank? ? raise(exception,message) : @content
+    def get_or_throw(exception, message='')
+      blank? ? raise(exception, message) : @content
     end
 
     def to_seq
@@ -71,13 +73,63 @@ module Option
     end
 
     def exists?(predicate)
-     value
+      value
     end
 
     def join(target_sequence)
       sequence(value) << target_sequence
     end
 
+    def map(predicate=nil, &block)
+      sequence(@content).map(predicate, &block).head_option
+    end
+
+    alias collect map
+
+    def select(predicate=nil, &block)
+      sequence(@content).select(predicate, &block).head_option
+    end
+
+    alias find_all select
+    alias filter select
+
+    def reject(predicate=nil, &block)
+      sequence(@content).reject(predicate, &block).head_option
+    end
+
+    alias unfilter reject
+
+    def grep(pattern)
+      sequence(@content).grep(pattern).head_option
+    end
+
+    def drop(n)
+      sequence(@content).drop(n).head_option
+    end
+
+    def drop_while(&block)
+      sequence(@content).drop_while(&block).head_option
+    end
+
+    def take(n)
+      sequence(@content).take(n).head_option
+    end
+
+    def take_while(&block)
+      sequence(@content).take_while(&block).head_option
+    end
+
+    def flat_map(&block)
+      sequence(@content).flat_map(&block).head_option
+    end
+
+    alias collect_concat flat_map
+
+    # TODO - fix me
+    # def zip(*args, &block)
+    #   sequence(@content).zip(*args,&block).head_option
+    # end
+
     alias + join
     alias << join
 
@@ -127,19 +179,19 @@ module Option
     end
 
     def defined?
-     false
+      false
     end
 
     def get_or_else(item)
-     item
+      item
     end
 
     def get_or_nil
       nil
     end
 
-    def get_or_throw(exception,message='')
-      raise(exception,message)
+    def get_or_throw(exception, message='')
+      raise(exception, message)
     end
 
     def to_seq
@@ -147,7 +199,7 @@ module Option
     end
 
     def contains(item)
-     false
+      false
     end
 
     def exists?(predicate)
@@ -161,6 +213,51 @@ module Option
     alias + join
     alias << join
 
+    def map(predicate=nil, &block)
+          sequence(@content).map(predicate, &block).head_option
+        end
+
+        alias collect map
+
+        def select(predicate=nil, &block)
+         none
+        end
+
+        alias find_all select
+        alias filter select
+
+        def reject(predicate=nil, &block)
+          none
+        end
+
+        alias unfilter reject
+
+        def grep(pattern)
+          none
+        end
+
+        def drop(n)
+          none
+        end
+
+        def drop_while(&block)
+          none
+        end
+
+        def take(n)
+          none
+        end
+
+        def take_while(&block)
+          none
+        end
+
+        def flat_map(&block)
+          none
+        end
+
+        alias collect_concat flat_map
+
     protected
 
     def state

data/lib/sequence.rb

@@ -349,6 +349,10 @@ module Sequences
       end)
     end
 
+    def to_map(symbolize=true)
+      Maps.merge(to_maps(symbolize))
+    end
+
     def from_pairs
       Sequence.new(Sequence::Generator.new do |g|
         self.entries.map { |e| Type.check(e, Pair::Pair); [e.key, e.value] }.flatten.each { |i| g.yield i }
@@ -460,6 +464,17 @@ module Sequences
       blank?(sequence[index]) ? raise(exception, message) : sequence[index]
     end
 
+
+    def get_by(pair_key)
+      item = self.filter{|e| e.first == pair_key}.head_option
+      item.is_some? ? item.get.value : none
+    end
+
+    def into_hash
+      raise(Exception.new, 'The sequence must contain pairs') unless self.head.kind_of?(Pair::Pair)
+      Maps.merge(self.map{|p| {p.key => p.value}})
+    end
+
     def drop_nil
       Sequence.new(Sequence::Generator.new do |g|
         self.reject { |e| e.nil? }.each { |i| g.yield i }

data/spec/option_spec.rb

@@ -115,6 +115,56 @@ describe 'Option' do
     expect(option(1).is_some?).to be(true)
   end
 
+  it 'should support select' do
+    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(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(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(some('apple'))
+    expect(option(nil).grep(/p/)).to eq(none)
+  end
+
+  it 'should support drop' do
+    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(1).drop_while { |n| n < 5 }).to eq(none)
+    expect(option(nil).drop_while { |n| n < 5 }).to eq(none)
+  end
+
+  it 'should support take' do
+    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(none)
+  end
 
+  it 'should support flat_map' do
+    expect(option(nil).flat_map{|v| v.first}).to eq(none)
+  end
 
 end

data/spec/sequence_spec.rb

@@ -212,6 +212,14 @@ describe 'Sequence' do
     expect(sequence(5,2,3,1,4).sorting).to eq(sequence(1,2,3,4,5))
   end
 
+  it 'should convert sequence to a map' do
+    expect(sequence(oops('apple',1,'pear',2)).to_map).to eq({apple:1,pear:2})
+  end
+
+  def oops(*values)
+    values
+  end
+
 
 
 end

data/totally_lazy.gemspec

@@ -6,7 +6,7 @@
 
 Gem::Specification.new do |s|
   s.name = "totally_lazy"
-  s.version = "0.0.7"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: totally_lazy
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Kingsley Hendrickse