totally_lazy 0.0.20 → 0.1.0

data/lib/predicates/predicates.rb

@@ -1,141 +0,0 @@
-module Predicates
-
-  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
-
-    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_transform(name,exec)
-    SimpleTransform.new(name,exec)
-  end
-
-
-  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
-
-  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
-
-  class SimpleTransform < Predicates::Predicate
-    attr_reader :name, :exec
-
-    def initialize(name, exec)
-      @name = name
-      @exec = exec
-    end
-
-  end
-
-  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.rb

@@ -1,34 +0,0 @@
-module Predicates
-
-  module Where
-    class WherePredicate
-
-      attr_reader :predicates
-
-      def initialize
-        @predicates = empty
-      end
-
-      def where(predicates)
-        @predicates = predicates.is_a?(Pair::Pair) ? @predicates.append(predicates) : @predicates.join(Pair.from_map(predicates))
-        self
-      end
-
-      def and(predicates)
-        @predicates = predicates.is_a?(Pair::Pair) ? @predicates.append(predicates) : @predicates.join(Pair.from_map(predicates))
-        self
-      end
-
-    end
-
-    def where(predicate_map)
-      WherePredicate.new.where(predicate_map)
-    end
-
-    def is(single_predicate)
-      pair(:self, single_predicate)
-    end
-
-  end
-
-end

data/lib/predicates/where_processor.rb

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

data/lib/type_check.rb

@@ -1,19 +0,0 @@
-class Type
-
-  def self.check(actual, expected)
-    raise(UnsupportedTypeException.new, "Target must be of type: #{expected} but was: #{actual.class}") unless actual.kind_of?(expected)
-    actual
-  end
-
-  def self.responds(value, meth)
-    raise(UnsupportedTypeException.new, "Target must respond to: #{meth} - but did not with: #{value.class} of: #{value.inspect}") unless value.respond_to?(meth)
-    value
-  end
-
-  def self.responds_all(values, meth)
-    values.each do |value|
-      raise(UnsupportedTypeException.new, "Target must respond to: #{meth} - but did not with: #{value.class} of: #{value.inspect}") unless value.respond_to?(meth)
-    end
-  end
-
-end

data/lib/utils.rb

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

data/spec/functor_spec.rb

@@ -1,35 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'Functor' do
-
-    it 'should create a new functor' do
-      fc = Functor.new do |op, *a, &b|
-        [op, a, b]
-      end
-      expect(fc+1).to eq([:+, [1], nil])
-    end
-
-    it 'should support class method' do
-      fc = Functor.new do |op, *a, &b|
-        [op, a, b]
-      end
-      expect( fc.__class__).to eq(Functor)
-    end
-
-    it 'should support to proc' do
-      f = Functor.new do |op, *a|
-        [op, *a]
-      end
-      p = f.to_proc
-      expect(p.class).to eq(Proc)
-      expect(p.call(:+,1,2,3)).to eq([:+,1,2,3])
-    end
-
-    it 'should cache a new functor' do
-      Functor.cache(:cached) do |op, *a, &b|
-          [op, a, b]
-        end
-      expect(Functor.cache(:cached) + 1).to eq([:+, [1], nil])
-     end
-
-end

data/spec/generators_spec.rb

@@ -1,37 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'Generators' do
-
-  it 'should support repeat' do
-    expect(Seq.repeat('car').take(2)).to eq(sequence('car', 'car'))
-    expect(Iter.repeat('car').take(2).entries).to eq(%w(car car))
-  end
-
-  it 'should support range' do
-    expect(Seq.range(1, 4)).to eq(sequence(1, 2, 3, 4))
-    expect(Iter.range(1, 4).entries).to eq([1, 2, 3, 4])
-  end
-
-  it 'should support iterate' do
-    expect(Seq.iterate(:+, 1).take(4)).to eq(sequence(1, 2, 3, 4))
-    expect(Iter.iterate(:+, 1).take(4).entries).to eq([1, 2, 3, 4])
-    expect(Seq.iterate(:+, 1, 5).take(4)).to eq(sequence(5, 6, 7, 8))
-    expect(Iter.iterate(:+, 1, 5).take(4).entries).to eq([5, 6, 7, 8])
-  end
-
-  it 'should support primes' do
-    expect(Seq.primes.take(3)).to eq(sequence(2, 3, 5))
-    expect(Iter.primes.take(3).entries).to eq([2, 3, 5])
-  end
-
-  it 'should support fibonacci' do
-    expect(Seq.fibonacci.take(3)).to eq(sequence(1, 1, 2))
-    expect(Iter.fibonacci.take(3).entries).to eq([1, 1, 2])
-  end
-
-  it 'should support powers_of' do
-    expect(Seq.range(1, 4)).to eq(sequence(1, 2, 3, 4))
-    expect(Iter.range(1, 4).entries).to eq([1, 2, 3, 4])
-  end
-
-end

data/spec/pair_spec.rb

@@ -1,44 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'Pair' do
-
-  it 'should return the first item: first/key' do
-    expect(pair(1, 2).first).to eq(1)
-    expect(pair(1, 2).key).to eq(1)
-  end
-
-  it 'should return the second item: second/value' do
-    expect(pair(1, 2).second).to eq(2)
-    expect(pair(1, 2).value).to eq(2)
-  end
-
-  it 'should return sequence of values' do
-    expect(pair(1, 2).values).to eq(sequence(1, 2))
-  end
-
-  it 'should convert to string' do
-    expect(pair('apples', 2).to_s).to eq({'apples' => '2'})
-  end
-
-  it 'should convert to a sequence of pairs from a map' do
-    expect(Pair.from_map({apples: '10'}).to_a).to eq(sequence(pair(:apples, '10')).to_a)
-    expect(Pair.from_map({:one => 1, :two => 2}).to_a).to eq(sequence(pair(:one,1),pair(:two,2)).to_a)
-  end
-
-  it 'should convert a pair to a map' do
-    expect(pair(1, 2).to_map).to eq({1 => 2})
-  end
-
-  it 'should convert to int' do
-    expect(pair('1', '2').to_i).to eq({1 => 2})
-  end
-
-  it 'should convert to float' do
-    expect(pair('1', '2').to_f).to eq({1.0 => 2.0})
-  end
-
-  it 'should support each' do
-    expect(pair(1,2).each{|x| x }).to eq([1,2])
-  end
-
-end

data/spec/predicate_spec.rb

@@ -1,77 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'Predicates' do
-
-  it 'should return only even numbers' do
-    expect(sequence(1,2,3,4,5,6).filter(even)).to eq(sequence(2,4,6))
-    expect(sequence(1,2,3,4,5,6).unfilter(odd)).to eq(sequence(2,4,6))
-    expect { sequence(pair(1,2),pair(3,4)).filter(even).entries }.to raise_error(UnsupportedTypeException)
-  end
-
-  it 'should return only odd numbers' do
-    expect(sequence(1,2,3,4,5,6).filter(odd)).to eq(sequence(1,3,5))
-    expect(sequence(1,2,3,4,5,6).unfilter(even)).to eq(sequence(1,3,5))
-    expect { sequence(pair(1,2),pair(3,4)).filter(odd).entries }.to raise_error(UnsupportedTypeException)
-  end
-
-  it 'should support map' do
-    expect(sequence(1,2).map(as_string)).to eq(sequence("1","2"))
-  end
-
-  it 'should support flat_map' do
-    expect(sequence(sequence(1, 2), sequence(3, 4)).flat_map(as_string).to_a).to eq(sequence("1", "2", "3", "4").to_a)
-  end
-
-  it 'should return content as string' do
-    expect(sequence(1,2).map(as_string)).to eq(sequence("1","2"))
-    expect(sequence(pair(1,2),pair(3,4)).map(as_string).entries).to eq([{'1'=>'2'},{'3'=>'4'}])
-  end
-
-  it 'should return content as int' do
-    expect(sequence('1','2').map(as_int)).to eq(sequence(1,2))
-    expect(sequence(pair('1','2'),pair('3','4')).map(as_int).entries).to eq([{1=>2}, {3=>4}])
-  end
-
-  it 'should return content as float' do
-    expect(sequence(1,2).map(as_float)).to eq(sequence(1.0,2.0))
-    expect(sequence(pair(1,2),pair(3,4)).map(as_float).entries).to eq([{1.0=>2.0}, {3.0=>4.0}])
-  end
-
-  it 'should return content as array' do
-    expect(sequence(1,2).map(as_array)).to eq(sequence([1],[2]))
-    expect(sequence(pair(1,2),pair(3,4)).map(as_array).head.class).to eq(Array)
-  end
-
-  it 'should work with basic where predicates' do
-    expect(sequence(1,2,3).filter(where(is greater_than 1))).to eq(sequence(2,3))
-    expect(sequence(1,2,3).filter(where(is greater_than 1).and(is less_than 3))).to eq(sequence(2))
-  end
-
-  it 'should work with method where predicates' do
-    expect(sequence(pair(1,2),pair(3,4),pair(5,7)).filter(where(key:greater_than(1)).and(value:odd)).to_a).to eq(sequence(pair(5,7)).to_a)
-  end
-
-  it 'should work with inverted value predicates' do
-    expect(sequence(1,2,3,4,5).reject(where(is Compare.equal_to 3))).to eq(sequence(1,2,4,5))
-    expect(sequence(pair(1,2),pair(3,4),pair(5,7)).reject(where value:odd).to_a).to eq(sequence(pair(1,2),pair(3,4)).to_a)
-    expect(sequence(pair(1,2),pair(3,4),pair(5,7)).reject(where value:equals(2)).to_a).to eq(sequence(pair(3,4),pair(5,7)).to_a)
-  end
-
-  it 'should work with symbols as values when applying predicates' do
-    expect(sequence(pair(:people,sequence(1,2)), pair(:swans,10)).filter(where(key:equals(:swans))).to_a).to eq(sequence(pair(:swans,10)).to_a)
-  end
-
-  it 'should work with inverted predicates' do
-    expect(sequence(1,2,3,4,5).reject(where(is odd))).to eq(sequence(2,4))
-    expect(sequence(1,2,3,4,5).reject(odd)).to eq(sequence(2,4))
-    expect(sequence(1,2,3,4,5).reject(greater_than 2)).to eq(sequence(1,2))
-    expect(sequence(1,2,3,4,5).filter(greater_than 2)).to eq(sequence(3,4,5))
-  end
-
-  it 'should work with regex predicates' do
-    expect(sequence(pair('apples','pears'),pair('banana','orange'),pair('apples','melon')).filter(where key:matches(/app/)).to_a).to eq(sequence(pair('apples','pears'),pair('apples','melon')).to_a)
-    expect(sequence(pair('apples','pears'),pair('banana','orange'),pair('apples','melon')).reject(where key:matches(/app/)).to_a).to eq(sequence(pair('banana','orange')).to_a)
-  end
-
-
-end

data/spec/serialization_spec.rb

@@ -1,56 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'Sequence Serialization/Deserialization' do
-
-  it 'should serialize a sequence' do
-    serialized = sequence(pair(7, 8), sequence(1, 2), sequence(3, sequence(5, 6)), sequence(pair(:apple, 99), option(1), none), [10, 11], {:apple => 8, :pear => 9}).serialize
-    expect(serialized).to eq([{:type => :pair, :values => {7 => 8}}, {:type => :sequence, :values => [1, 2]}, {:type => :sequence, :values => [3, {:type => :sequence, :values => [5, 6]}]}, {:type => :sequence, :values => [{:type => :pair, :values => {:apple => 99}}, {:type => :some, :values => 1}, {:type => :none, :values => nil}]}, {:type => Array, :values => [10, 11]}, {:type => Hash, :values => [{:type => Array, :values => [:apple, 8]}, {:type => Array, :values => [:pear, 9]}]}])
-  end
-
-  it 'should serialize a pair containing sequences' do
-    serialized = sequence(pair(:people,sequence(1,2))).serialize
-    expect(serialized).to eq([{:type => :pair, :values => [:people, {:type => :sequence, :values => [1,2]}]}])
-  end
-
-  it 'should deserialize a pair containing sequences' do
-     serialized = sequence(pair(:people,sequence(1,2))).serialize
-     expect(deserialize(serialized)[0].key).to eq(:people)
-     expect(deserialize(serialized)[0].value).to eq(sequence(1,2))
-  end
-
-  it 'should deserialize a serialized sequence containing pair' do
-    expect(seq[0].to_map).to eq(pair(7, 8).to_map)
-  end
-
-  it 'should deserialize a serialized sequence containing sequence' do
-    expect(seq[1]).to eq(sequence(1, 2))
-  end
-
-  it 'should deserialize a serialized sequence containing nested sequence' do
-    expect(seq[2]).to eq(sequence(3, sequence(5, 6)))
-  end
-
-  it 'should deserialize a serialized sequence containing some' do
-    expect(seq[3][1]).to eq(option(1))
-  end
-
-  it 'should deserialize a serialized sequence containing none' do
-    expect(seq[3][2]).to eq(none)
-  end
-
-  it 'should deserialize a serialized sequence containing an array' do
-    expect(seq[4]).to eq([10,11])
-  end
-
-  it 'should deserialize a serialized sequence containing a hash' do
-    expect(seq[5]).to eq({:apple => 8, :pear => 9})
-  end
-
-  private
-
-  def seq
-    serialized = sequence(pair(7, 8), sequence(1, 2), sequence(3, sequence(5, 6)), sequence(pair(:apple, 99), option(1), none), [10, 11], {:apple => 8, :pear => 9}).serialize
-    deserialize(serialized)
-  end
-
-end

data/spec/type_check_spec.rb

@@ -1,20 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe 'Type Check' do
-
-  it 'should raise UnsupportedTypeException exception if value is not of specified type' do
-    expect(Type.check(1, Fixnum)).to eq(1)
-    expect { Type.check('1', Fixnum) }.to raise_error(UnsupportedTypeException)
-  end
-
-  it 'should raise UnsupportedTypeException exception if value does not respond to specified method' do
-     expect(Type.responds(1, :even?)).to eq(1)
-     expect { Type.responds('1', :even?) }.to raise_error(UnsupportedTypeException)
-  end
-
-  it 'should raise UnsupportedTypeException exception if values do not respond to specified method' do
-     expect(Type.responds_all(sequence(1,2,3), :to_s)).to eq([1,2,3])
-     expect { Type.responds_all(sequence(1,2,3), :is_cool) }.to raise_error(UnsupportedTypeException)
-   end
-
-end

data/spec/util_spec.rb

@@ -1,10 +0,0 @@
-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

@@ -1,101 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-# stub: totally_lazy 0.0.20 ruby lib
-
-Gem::Specification.new do |s|
-  s.name = "totally_lazy"
-  s.version = "0.0.20"
-
-  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-09"
-  s.description = "Port of java functional library totally lazy to ruby"
-  s.email = "kingsleyhendrickse@me.com"
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.md"
-  ]
-  s.files = [
-    ".document",
-    ".rspec",
-    ".travis.yml",
-    "Gemfile",
-    "Guardfile",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "lib/any.rb",
-    "lib/functor.rb",
-    "lib/generators.rb",
-    "lib/option.rb",
-    "lib/pair.rb",
-    "lib/parallel/parallel.rb",
-    "lib/parallel/processor_count.rb",
-    "lib/predicates/compare.rb",
-    "lib/predicates/conversions.rb",
-    "lib/predicates/numbers.rb",
-    "lib/predicates/predicates.rb",
-    "lib/predicates/where.rb",
-    "lib/predicates/where_processor.rb",
-    "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",
-    "spec/pair_spec.rb",
-    "spec/predicate_spec.rb",
-    "spec/sequence_spec.rb",
-    "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"
-  s.licenses = ["MIT"]
-  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
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["~> 3.0.0"])
-      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
-      s.add_development_dependency(%q<rspec_html_formatter>, ["~> 0.3.0"])
-      s.add_development_dependency(%q<rake>, ["~> 10.3.2"])
-      s.add_development_dependency(%q<simplecov>, [">= 0"])
-      s.add_development_dependency(%q<coveralls>, [">= 0"])
-      s.add_development_dependency(%q<guard-rspec>, [">= 0"])
-    else
-      s.add_dependency(%q<rspec>, ["~> 3.0.0"])
-      s.add_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_dependency(%q<bundler>, ["~> 1.0"])
-      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
-      s.add_dependency(%q<rspec_html_formatter>, ["~> 0.3.0"])
-      s.add_dependency(%q<rake>, ["~> 10.3.2"])
-      s.add_dependency(%q<simplecov>, [">= 0"])
-      s.add_dependency(%q<coveralls>, [">= 0"])
-      s.add_dependency(%q<guard-rspec>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rspec>, ["~> 3.0.0"])
-    s.add_dependency(%q<rdoc>, ["~> 3.12"])
-    s.add_dependency(%q<bundler>, ["~> 1.0"])
-    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
-    s.add_dependency(%q<rspec_html_formatter>, ["~> 0.3.0"])
-    s.add_dependency(%q<rake>, ["~> 10.3.2"])
-    s.add_dependency(%q<simplecov>, [">= 0"])
-    s.add_dependency(%q<coveralls>, [">= 0"])
-    s.add_dependency(%q<guard-rspec>, [">= 0"])
-  end
-end
-