totally_lazy 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef27c17e829a30f3c3efd0bacdb6023066e85326
-  data.tar.gz: d583a528661e3c190245c64ffce9cf9b8093d55a
+  metadata.gz: 07387e8a468855a7da2085b260925debed565e11
+  data.tar.gz: cf13015fc8e70f75561464263ae624a18f59cedb
 SHA512:
-  metadata.gz: 32ed21dfa78360ba8dec458c2f6646a4af09a448957b84e51c0ee686aa1fb6e031334f676e7bb5a51e759bceb9c8e88a942f022b39c80189e64877949f121aa2
-  data.tar.gz: 9e903a0e2716f72c524753d35de1a5ecfdb0f71228b6aa4aef1f0f55e92c3bdf9a6cb38c9fdfad99acc49a19f2501992d4175180daa1b7805cde33b84f5bb305
+  metadata.gz: 01a92b3af2d701c2a900c74282d666642ed00cead1aac4d3781dbe5ece2ca2439d84cda0923c0e1ec3420f108443690061cfc18233281d484f07c7750a94a867
+  data.tar.gz: 164b856f25c3ebed7cb00134b118dc5815de8d522f3bc5cf395dc9f626b4ac118049528f7cc09a4b7b65532ae7f4c9f473fdd212d1a83f71e0a4364c52695f46

data/README.md

@@ -17,10 +17,12 @@ This is a port of the java functional library [Totally Lazy](https://code.google
 
 ### Install
 
+This gem requires ruby 2.x.x
+
 In your bundler Gemfile
 
 ```ruby
- gem totally_lazy, '~>0.0.4' 
+ gem totally_lazy, '~>0.0.6' 
 ```
 
 Or with rubygems

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/lib/pair.rb

@@ -25,6 +25,16 @@ module Pair
       @second.call
     end
 
+    def first=(v)
+     @first = -> { v }
+    end
+    alias key= first=
+
+    def second=(v)
+      @second = -> { v }
+    end
+    alias value= second=
+
     def each(&block)
       [first,second].each do |i|
         block.call(i)

data/lib/predicates/compare.rb

@@ -3,30 +3,23 @@ module Predicates
   module Compare
 
     def equals(value)
-      -> (v, meth=:self, invert=false) do
-        invert ? inverted_value(v, value, meth, :==) : regular_value(v, value, meth, :==)
-      end
+      value_predicate(:equals,:==,value)
     end
 
     alias equal_to equals
 
     def greater_than(value)
-      -> (v, meth=:self, invert=false) do
-        invert ? inverted_value(v, value, meth, :>) : regular_value(v, value, meth, :>)
-      end
+      value_predicate(:greater_than,:>,value)
     end
 
     def less_than(value)
-      -> (v, meth=:self, invert=false) do
-        invert ? inverted_value(v, value, meth, :<) : regular_value(v, value, meth, :<)
-      end
+      value_predicate(:less_than,:<,value)
     end
 
-    def matches(regex)
-      -> (v, meth=:self, invert=false) do
-        invert ? inverted_regex(v, regex, meth) : regular_regex(v, regex, meth)
-      end
+    def matches(value)
+      regex_predicate(:matches,value)
     end
+
   end
 
 end

data/lib/predicates/conversions.rb

@@ -3,19 +3,19 @@ module Predicates
   module Conversions
 
     def as_string
-      -> (v) { v.to_s }
+      simple_predicate(:as_string, -> (v) { v.to_s } )
     end
 
     def as_int
-      -> (v) { Type.responds(v, :to_i); v.to_i }
+      simple_predicate(:as_int,  -> (v) { Type.responds(v, :to_i); v.to_i } )
     end
 
     def as_float
-      -> (v) { Type.responds(v, :to_i); v.to_f }
+      simple_predicate(:as_float, -> (v) { Type.responds(v, :to_f); v.to_f } )
     end
 
     def as_array
-      -> (v) { [v] }
+      simple_predicate(:as_array,  -> (v) { [v] } )
     end
 
   end

data/lib/predicates/numbers.rb

@@ -3,15 +3,11 @@ module Predicates
   module Numbers
 
     def even
-      -> (v, meth=:self, invert=false) do
-        invert ? inverted(v, meth, :even?) : regular(v, meth, :even?)
-      end
+      self_predicate(:even,:even?)
     end
 
     def odd
-      -> (v, meth=:self, invert=false) do
-        invert ? inverted(v, meth, :odd?) : regular(v, meth, :odd?)
-      end
+      self_predicate(:odd,:odd?)
     end
     #
     # def between(lower, higher)

data/lib/predicates/predicates.rb

@@ -1,57 +1,141 @@
 module Predicates
 
-  def inverted(v, meth, pred)
-    if meth == :self
-      Type.responds(v, pred)
-      v unless v.send(pred)
+  class Predicate
+
+    def inverted(v, meth, pred)
+      if meth == :self
+        Type.responds(v, pred)
+        v unless v.send(pred)
+      end
+    end
+
+    def regular(v, meth, pred)
+      if meth == :self
+        Type.responds(v, pred)
+        v if v.send(pred)
+      else
+        r = v.send(meth)
+        Type.responds(r, pred)
+        v if r.send(pred)
+      end
+    end
+
+    def inverted_value(v, value, meth, pred)
+      if meth == :self
+        Type.responds(v, pred)
+        v unless v.send(pred, value)
+      end
+    end
+
+    def regular_value(v, value, meth, pred)
+      if meth == :self
+        Type.responds(v, pred)
+        v if v.send(pred, value)
+      else
+        r = v.send(meth)
+        Type.responds(r, pred)
+        v if r.send(pred, value)
+      end
+    end
+
+    def regular_regex(v, regex, meth)
+      if meth == :self
+        v if v.to_s.match(regex)
+      else
+        r = v.send(meth)
+        v if r.to_s.match(regex)
+      end
     end
-  end
 
-  def regular(v, meth, pred)
-    if meth == :self
-      Type.responds(v, pred)
-      v if v.send(pred)
-    else
-      r = v.send(meth)
-      Type.responds(r, pred)
-      v if r.send(pred)
+    def inverted_regex(v, regex, meth)
+      if meth == :self
+        v unless v.to_s.match(regex)
+      else
+        r = v.send(meth)
+        v unless r.to_s.match(regex)
+      end
     end
+
+  end
+
+  def value_predicate(name, pred, value)
+    ValuePredicate.new(name, pred, value)
+  end
+
+  def regex_predicate(name, value)
+    RegexPredicate.new(name, value)
+  end
+
+  def self_predicate(name,pred)
+    SelfPredicate.new(name,pred)
+  end
+
+  def simple_predicate(name,exec)
+    SimplePredicate.new(name,exec)
   end
 
-  def inverted_value(v, value, meth, pred)
-    if meth == :self
-      Type.responds(v, pred)
-      v unless v.send(pred, value)
+
+  class ValuePredicate < Predicates::Predicate
+
+    attr_reader :name, :pred, :value
+
+    def initialize(name, pred, value)
+      @name = name
+      @pred = pred
+      @value = value
+    end
+
+    def exec
+      -> (v, meth=:self, invert=false) do
+        invert ? inverted_value(v, @value, meth, @pred) : regular_value(v, @value, meth, @pred)
+      end
     end
+
   end
 
-  def regular_value(v, value, meth, pred)
-    if meth == :self
-      Type.responds(v, pred)
-      v if v.send(pred, value)
-    else
-      r = v.send(meth)
-      Type.responds(r, pred)
-      v if r.send(pred, value)
+  class SelfPredicate < Predicates::Predicate
+
+    attr_reader :name, :pred
+
+    def initialize(name, pred)
+      @name = name
+      @pred = pred
+    end
+
+    def exec
+      -> (v, meth=:self, invert=false) do
+        invert ? inverted(v, meth, @pred) : regular(v, meth, @pred)
+      end
     end
+
   end
 
-  def regular_regex(v, regex, meth)
-    if meth == :self
-      v if v.to_s.match(regex)
-    else
-      r = v.send(meth)
-      v if r.to_s.match(regex)
+  class SimplePredicate < Predicates::Predicate
+    attr_reader :name, :exec
+
+    def initialize(name, exec)
+      @name = name
+      @exec = exec
     end
+
   end
 
-  def inverted_regex(v, regex, meth)
-    if meth == :self
-      v unless v.to_s.match(regex)
-    else
-      r = v.send(meth)
-      v unless r.to_s.match(regex)
+  class RegexPredicate < Predicates::Predicate
+
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
     end
+
+    def exec
+      -> (v, meth=:self, invert=false) do
+        invert ? inverted_regex(v, @value, meth) : regular_regex(v, @value, meth)
+      end
+    end
+
   end
 
+
 end

data/lib/predicates/where_processor.rb

@@ -5,9 +5,9 @@ class WhereProcessor
 
   def apply(predicates, invert=false)
     if invert
-      @value if predicates.map { |x| x.value.call(@value, x.key) }.contains?(nil)
+      @value if predicates.map { |x| x.value.exec.call(@value, x.key) }.contains?(nil)
     else
-      @value unless predicates.map { |x| x.value.call(@value, x.key) }.contains?(nil)
+      @value unless predicates.map { |x| x.value.exec.call(@value, x.key) }.contains?(nil)
     end
   end
 end

data/lib/sequence.rb

@@ -4,6 +4,9 @@ end
 class UnsupportedTypeException < RuntimeError
 end
 
+class UnsupportedMethodException < RuntimeError
+end
+
 module Sequences
 
   # Creates a sequence
@@ -84,7 +87,7 @@ module Sequences
     def map(predicate=nil, &block)
       if predicate
         Sequence.new(self) { |yielder, val|
-          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.call(val)
+          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.exec.call(val)
           yielder << v unless v.nil?
         }
       else
@@ -121,7 +124,7 @@ module Sequences
     def select(predicate=nil, &block)
       if predicate
         Sequence.new(self) { |yielder, val|
-          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.call(val)
+          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.exec.call(val)
           yielder << v unless v.nil?
         }
       else
@@ -139,7 +142,7 @@ module Sequences
     def reject(predicate=nil, &block)
       if predicate
         Sequence.new(self) { |yielder, val|
-          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates, true) : predicate.call(val, :self, true)
+          v = predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates, true) : predicate.exec.call(val, :self, true)
           yielder << v unless v.nil?
         }
       else
@@ -187,15 +190,15 @@ module Sequences
     end
 
     def take(n)
-      taken = 0
-      Sequence.new(self) { |yielder, val|
-        if taken < n
-          yielder << val
-          taken += 1
-        else
-          raise StopIteration
+      Sequence.new(Sequence::Generator.new do |g|
+        self.each_with_index do |v, i|
+          if i < n
+            g.yield v
+          else
+            raise StopIteration
+          end
         end
-      }
+      end)
     end
 
     def take_while(&block)
@@ -334,6 +337,18 @@ module Sequences
       end)
     end
 
+    def to_maps(symbolize=true)
+      Sequence.new(Sequence::Generator.new do |g|
+        self.each_slice(2) do |k, v|
+          if symbolize
+            g.yield k.to_s.to_sym => v
+          else
+            g.yield k => v
+          end
+        end
+      end)
+    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 }
@@ -372,6 +387,25 @@ module Sequences
       end
     end
 
+    def update(item)
+      Sequence.new(Sequence::Generator.new do |g|
+        if item.is_a?(Hash)
+          self.map do |e|
+            item.map { |k, v|
+              raise(UnsupportedMethodException.new, "Tried to call method: #{k} on #{e.class} but method not supported") unless e.respond_to?(k) or e.respond_to?(":#{k}=")
+              begin
+                e.send(k, v) if e.respond_to?(k); e
+              rescue
+                e.send("#{k}=", v) if e.respond_to?("#{k}="); e
+              end
+            }.first
+          end
+        else
+          self.map { item }
+        end.each { |i| g.yield i }
+      end)
+    end
+
     def marshal_dump
       serialize
     end
@@ -396,6 +430,24 @@ module Sequences
       to_a.flatten
     end
 
+    def sorting_by(*attr, &block)
+      if attr.empty?
+        Sequence.new(Sequence::Generator.new do |g|
+          self.sort_by { |e| block.call(e) }.each { |i| g.yield i }
+        end)
+      else
+        Sequence.new(Sequence::Generator.new do |g|
+          self.sort_by { |e| attr.map{|v| e.send(v)} }.each { |i| g.yield i }
+        end)
+      end
+    end
+
+    def sorting
+      Sequence.new(Sequence::Generator.new do |g|
+        self.sort.each { |i| g.yield i }
+      end)
+    end
+
     def get_or_else(index, or_else)
       blank?(sequence[index]) ? or_else : sequence[index]
     end
@@ -418,7 +470,7 @@ module Sequences
       if predicate
         Sequence.new(Sequence::Generator.new do |g|
           Parallel.map(self.entries, options) { |val|
-            predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.call(val)
+            predicate.is_a?(WherePredicate) ? WhereProcessor.new(val).apply(predicate.predicates) : predicate.exec.call(val)
           }.each { |i| g.yield i unless i.nil? }
         end)
       else

data/lib/totally_lazy.rb

@@ -14,6 +14,7 @@ require_relative 'predicates/where_processor'
 require_relative 'parallel/parallel'
 require_relative 'generators'
 require_relative 'any'
+require_relative 'utils'
 
 include Sequences
 include Option
@@ -25,6 +26,7 @@ include Predicates::Compare
 include Predicates::Where
 include Generators
 include Any
+include Maps
 
 
 # p sequence(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12).filter(
@@ -127,6 +129,35 @@ include Any
 # p f - s
 
 
+# p Seq.range(1,20).filter(odd).update(10).to_a
+
+# require 'ostruct'
+# #
+# #
+# # p Seq.repeat(->{OpenStruct.new(name:Any.string(5),age:Any.int(2))}).take(100000).update(age:11,name:'woops').take(1000).head
+# #
+# # p sequence({apple:1,pear:2}).each_slice(2).map{|s| [s[0],s[1]]}.to_a
+#
+# a = Seq.range(1,10).map{|n| OpenStruct.new(name:Any.string(5),age:Any.int(2)) }.to_a
+#
+# orig = sequence(a)
+#
+# updates = orig.filter(where(age:greater_than(70))).update(age:2)
+#
+# p orig.count
+# p updates.count
+
+# p where(id:equals(1)).as_map.entries
+
+#
+
+# p sequence(1,2,3,4).filter(where(is equal_to(2))).entries
+
+# p where(is equal_to 2).predicates.head.value
+
+
+# p sequence(1,2,3,4,5,6).map(as_string).to_a
+
 
 
 

data/lib/utils.rb

@@ -0,0 +1,9 @@
+module Maps
+
+  module_function
+
+ def merge(sequence_of_maps)
+   sequence_of_maps.reduce({}){|a,b| a.merge(b) }
+ end
+
+end

data/spec/sequence_spec.rb

@@ -192,4 +192,26 @@ describe 'Sequence' do
     expect(sequence(:name,'kings',:age,39).in_pairs.to_a).to eq(sequence(pair(:name,'kings'),pair(:age,39)).to_a)
   end
 
+  it 'should update items in a sequence' do
+    expect(Seq.repeat(->{OpenStruct.new(name:Any.string(5),age:Any.int(2))}).take(100000).update(age:11,name:'woops').take(10).map{|s| [s.name,s.age]}.head).to eq(['woops',11])
+    expect(Seq.range(1,10).filter(odd).update(2)).to eq(sequence(2,2,2,2,2))
+  end
+
+  it 'should sort by attributes' do
+    expect(sequence(pair(:a,1),pair(:d,4),pair(:c,3),pair(:b,2)).sorting_by{|e| e.value }.to_a).to eq([{:a=>1}, {:b=>2}, {:c=>3}, {:d=>4}])
+    expect(sequence(pair(:a,1),pair(:d,4),pair(:c,3),pair(:b,2)).sorting_by(:value).to_a).to eq([{:a=>1}, {:b=>2}, {:c=>3}, {:d=>4}])
+    expect(sequence(
+        OpenStruct.new(first_name:'David',age:19,job:'computers'),
+        OpenStruct.new(first_name:'Chris',age:19,job:'art'),
+        OpenStruct.new(first_name:'Andrew',age:32,job:'dancing'),
+        OpenStruct.new(first_name:'Andrew',age:18,job:'dancing'),
+           ).sorting_by{|e| [e.first_name,e.age] }.map{|e| [e.first_name,e.age,e.job]}.to_a).to eq([['Andrew', 18, 'dancing'], ['Andrew', 32, 'dancing'], ['Chris', 19, 'art'], ['David', 19, 'computers']])
+  end
+
+  it 'should sort' do
+    expect(sequence(5,2,3,1,4).sorting).to eq(sequence(1,2,3,4,5))
+  end
+
+
+
 end

data/spec/util_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Maps' do
+
+  it 'should return a sequence of maps as a merged map' do
+    expect(Maps.merge(sequence(:a,2,:b,4).to_maps)).to eq({a:2,b:4})
+    expect(Maps.merge(sequence(1,2,3,4).to_maps(false))).to eq({1=>2,3=>4})
+  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.5 ruby lib
+# stub: totally_lazy 0.0.6 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "totally_lazy"
-  s.version = "0.0.5"
+  s.version = "0.0.6"
 
   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 = "2014-09-22"
+  s.date = "2014-10-03"
   s.description = "Port of java functional library totally lazy to ruby"
   s.email = "kingsleyhendrickse@me.com"
   s.extra_rdoc_files = [
@@ -44,6 +44,7 @@ Gem::Specification.new do |s|
     "lib/sequence.rb",
     "lib/totally_lazy.rb",
     "lib/type_check.rb",
+    "lib/utils.rb",
     "spec/functor_spec.rb",
     "spec/generators_spec.rb",
     "spec/option_spec.rb",
@@ -53,6 +54,7 @@ Gem::Specification.new do |s|
     "spec/serialization_spec.rb",
     "spec/spec_helper.rb",
     "spec/type_check_spec.rb",
+    "spec/util_spec.rb",
     "totally_lazy.gemspec"
   ]
   s.homepage = "http://github.com/kingsleyh/totally_lazy"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: totally_lazy
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Kingsley Hendrickse
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-22 00:00:00.000000000 Z
+date: 2014-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -169,6 +169,7 @@ files:
 - lib/sequence.rb
 - lib/totally_lazy.rb
 - lib/type_check.rb
+- lib/utils.rb
 - spec/functor_spec.rb
 - spec/generators_spec.rb
 - spec/option_spec.rb
@@ -178,6 +179,7 @@ files:
 - spec/serialization_spec.rb
 - spec/spec_helper.rb
 - spec/type_check_spec.rb
+- spec/util_spec.rb
 - totally_lazy.gemspec
 homepage: http://github.com/kingsleyh/totally_lazy
 licenses: