totally_lazy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2a0d97dd8aedb8afc89adef7c596aa2a547a24d
+  data.tar.gz: 7a6b85c74b930787327b38eea1557ca615f397f5
+SHA512:
+  metadata.gz: 97d6df56b8e0a9f295117f7e3f52e6f5bdf11c280c8df69b7fffb49c02fca403ce36e76a0875b5bb9d71ff20dc63bdc510b1ede0782ac02780f2defc2afb8251
+  data.tar.gz: f2e0cb93b2217ae84954a03d876a77a29b17f11e36b7e1624a1262abdd19e57a9e9f1bf09b112983ea3d67dc61b69632b08b8ac371ee25e05e780f1fa905a2cd

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+group :development do
+  gem 'rspec', '~> 3.0.0'
+  gem 'rdoc', '~> 3.12'
+  gem 'bundler', '~> 1.0'
+  gem 'jeweler', '~> 2.0.1'
+  gem 'rspec_html_formatter', '~> 0.3.0'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Kingsley Hendrickse
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Totally Lazy for Ruby
+
+This is a port of the java functional library [Totally Lazy](https://code.google.com/p/totallylazy/) to the ruby language. I've tried to get it as close as I can to the original concepts behind the java version of Totally Lazy but I'm still pretty far away from being happy with it.
+
+### Summary
+
+* Tries to be as lazy as possible
+* Supports method chaining
+* Is primarily based on ruby Enumerators
+
+### Install
+
+In your bundler Gemfile
+
+```ruby
+ gem totally_lazy, '~>0.0.1' 
+```
+
+Or with rubygems
+
+```
+ gem install totall_lazy
+```
+
+### Examples
+
+The following are some simple examples of the currently implemented functionality.
+
+```ruby
+sequence(1,2,3,4).filter{|i| i.even? } # lazily returns 2,4
+sequence(1,2).map{|i| i.to_s} # lazily returns "1","2"
+sequence(1,2,3).take(2) # lazily returns 1,2
+sequence(1,2,3).drop(2) # lazily returns 3
+sequence(1,2,3).tail # lazily returns 2,3
+sequence(1,2,3).head # eagerly returns 1
+```
+
+Naturally you can combine these operations together:
+
+```ruby
+option(1).join(sequence(2,3,4)).join(sequence(5,6)).filter{|i| i.odd?}.take(2) 
+# lazily returns 1,3
+```

data/Rakefile

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "totally_lazy"
+  gem.homepage = "http://github.com/kingsleyh/totally_lazy"
+  gem.license = "MIT"
+  gem.summary = %Q{Port of java functional library totally lazy to ruby}
+  gem.description = %Q{Port of java functional library totally lazy to ruby}
+  gem.email = "kingsleyhendrickse@me.com"
+  gem.authors = ["Kingsley Hendrickse"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['spec'].execute
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "totally_lazy #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/option.rb

@@ -0,0 +1,108 @@
+module Option
+
+  def option(thing)
+    thing.nil? ? none : some(thing)
+  end
+
+  def some(thing)
+    Some.new(thing)
+  end
+
+  def none(thing=nil)
+    None.new(thing)
+  end
+
+  class Some
+
+    include Comparable
+
+    def initialize(content)
+      @content = content
+      raise(Exception,'some cannot be nil') if @content.nil?
+    end
+
+    def <=>(object)
+      self.state <=> object.state
+    end
+
+    def get
+      @content
+    end
+
+    def value
+      get
+    end
+
+    def empty?
+      @content.empty?
+    end
+
+    def defined?
+      !empty?
+    end
+
+    def get_or_else(item)
+      blank? ? item : @content
+    end
+
+    def get_or_nil
+      @content
+    end
+
+    def get_or_throw(exception)
+      blank? ? @content : exception.call
+    end
+
+    def to_seq
+      sequence(self)
+    end
+
+    def contains(item)
+     value == item
+    end
+
+    def exists?(predicate)
+
+    end
+
+    def join(target_sequence)
+     sequence(value) << target_sequence
+    end
+    alias + join
+    alias << join
+
+    protected
+    def state
+      @content
+    end
+
+    private
+
+    def blank?
+      @content.nil? || @content.empty?
+    end
+
+  end
+
+  class None
+
+    include Comparable
+
+    def initialize(content)
+      @content = content
+    end
+
+    def <=>(object)
+      self.state <=> object.state
+    end
+
+    protected
+
+    def state
+      @content
+    end
+
+  end
+
+
+end

data/lib/pair.rb

@@ -0,0 +1,47 @@
+module Pair
+
+  def pair(first, second)
+    Pair.new(first, second)
+  end
+
+  def from_map(a_map)
+    Pair.from_map(a_map)
+  end
+
+  class Pair
+
+    def initialize(first, second)
+      @first = -> { first }
+      @second = -> { second }
+    end
+
+    def first
+      @first.call
+    end
+    alias key first
+
+    def second
+      @second.call
+    end
+    alias value second
+
+    def to_map
+      {first => second}
+    end
+
+    def self.from_map(a_map)
+     sequence(a_map).map{|k,v| Pair.new(k,v)}
+    end
+
+    def to_s
+      to_map.inspect
+    end
+
+    def values
+      sequence(first, second)
+    end
+
+  end
+
+
+end

data/lib/sequence.rb

@@ -0,0 +1,248 @@
+class NoSuchElementException < RuntimeError
+end
+
+class Empty
+
+  def each
+    yield self
+  end
+
+end
+
+module Sequences
+
+  def sequence(*items)
+    if items.size == 1
+      if items.first.kind_of?(Range)
+        Sequence.new(items.first)
+      elsif items.first.kind_of?(Hash)
+        Sequence.new(items.first)
+      else
+        Sequence.new(items)
+      end
+    else
+      Sequence.new(items)
+    end
+  end
+
+  def empty
+    sequence(Empty.new)
+  end
+
+  class Sequence < Enumerator
+
+    include Comparable
+
+    def initialize(obj, &block)
+      super() { |yielder|
+        begin
+          obj.each { |x|
+            if block
+              block.call(yielder, x)
+            else
+              yielder << x
+            end
+          }
+        rescue StopIteration
+        end
+      }
+    end
+
+    def <=>(object)
+      self.class <=> object.class
+    end
+
+    def map(&block)
+      Sequence.new(self) { |yielder, val|
+        yielder << block.call(val)
+      }
+    end
+
+    alias collect map
+
+    def select(&block)
+      Sequence.new(self) { |yielder, val|
+        if block.call(val)
+          yielder << val
+        end
+      }
+    end
+
+    alias find_all select
+    alias filter select
+
+    def reject(&block)
+      Sequence.new(self) { |yielder, val|
+        if not block.call(val)
+          yielder << val
+        end
+      }
+    end
+
+    def grep(pattern)
+      Sequence.new(self) { |yielder, val|
+        if pattern === val
+          yielder << val
+        end
+      }
+    end
+
+    def drop(n)
+      dropped = 0
+      Sequence.new(self) { |yielder, val|
+        if dropped < n
+          dropped += 1
+        else
+          yielder << val
+        end
+      }
+    end
+
+    def drop_while(&block)
+      dropping = true
+      Sequence.new(self) { |yielder, val|
+        if dropping
+          if not block.call(val)
+            yielder << val
+            dropping = false
+          end
+        else
+          yielder << val
+        end
+      }
+    end
+
+    def take(n)
+      taken = 0
+      Sequence.new(self) { |yielder, val|
+        if taken < n
+          yielder << val
+          taken += 1
+        else
+          raise StopIteration
+        end
+      }
+    end
+
+    def take_while(&block)
+      Sequence.new(self) { |yielder, val|
+        if block.call(val)
+          yielder << val
+        else
+          raise StopIteration
+        end
+      }
+    end
+
+    def flat_map(&block)
+      Sequence.new(self) { |yielder, val|
+        ary = block.call(val)
+        # TODO: check ary is an Array
+        ary.each { |x|
+          yielder << x
+        }
+      }
+    end
+
+    alias collect_concat flat_map
+
+    def zip(*args, &block)
+      enums = [self] + args
+      Sequence.new(self) { |yielder, val|
+        ary = enums.map { |e| e.next }
+        if block
+          yielder << block.call(ary)
+        else
+          yielder << ary
+        end
+      }
+    end
+
+    def [](n)
+      Sequence.new(self).entries[n]
+    end
+
+    alias get []
+
+    def empty?
+      sequence.next.kind_of?(Empty)
+    end
+
+    def head
+      sequence.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : sequence.first
+    end
+
+    def head_option
+      sequence.empty? ? none : some(sequence.first)
+    end
+
+    def last
+      sequence.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : sequence.entries.last
+    end
+
+    def last_option
+      sequence.empty? ? none : some(sequence.entries.last)
+    end
+
+    def tail
+      Sequence.new(Sequence::Generator.new do |g|
+        self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : self.drop(1).each { |i| g.yield i }
+      end)
+    end
+
+    def init
+      Sequence.new(Sequence::Generator.new do |g|
+        size = self.count
+        self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : self.first(size-1).each { |i| g.yield i }
+      end)
+    end
+
+    def shuffle
+      Sequence.new(Sequence::Generator.new do |g|
+        self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : self.entries.shuffle.each { |i| g.yield i }
+      end)
+    end
+
+    def transpose
+      Sequence.new(Sequence::Generator.new do |g|
+        result = []
+        max_size = self.entries.max { |a, b| a.size <=> b.size }.size
+        max_size.times do |i|
+          result[i] = [self.entries.first.size]
+          self.entries.each_with_index { |r, j| result[i][j] = r[i] }
+        end
+        result
+        self.empty? ? raise(NoSuchElementException.new, 'The sequence was empty') : result.each { |i| g.yield i }
+      end)
+    end
+
+    def join(target_sequence)
+      Sequence.new(Sequence::Generator.new do |g|
+        raise(Exception.new, 'The target (right side) must be a sequence') unless target_sequence.kind_of?(Sequences::Sequence)
+        (self.entries << target_sequence.entries).flatten.each{|i| g.yield i}
+      end)
+    end
+    alias + join
+    alias << join
+
+    private
+    def sequence
+      Sequence.new(self)
+    end
+
+  end
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/totally_lazy.rb

@@ -0,0 +1,8 @@
+require_relative 'sequence'
+require_relative 'pair'
+require_relative 'option'
+
+include Sequences
+include Option
+include Pair
+

data/lib/tuple.rb

@@ -0,0 +1,5 @@
+class Tuple
+
+
+
+end

data/spec/option_spec.rb

@@ -0,0 +1,45 @@
+require 'rspec'
+require_relative '../lib/totally_lazy'
+
+describe 'Option' do
+
+  it 'should support contains' do
+    expect(option(1).contains(1)).to be(true)
+  end
+
+  it 'should support is alias' do
+    pending('support is alias')
+    pass
+  end
+
+  it 'should support exists' do
+    pending('exists')
+    pass
+  end
+
+  it 'should support join' do
+    expect(option(1).join(sequence(2,3))).to eq(sequence(1,2,3))
+  end
+
+  it 'should get value of some' do
+
+  end
+
+  it 'should not get value of none' do
+
+  end
+
+  it 'should get or else' do
+
+  end
+
+  it 'should get or nil' do
+
+  end
+
+  it 'should get or raise exception' do
+
+  end
+
+
+end

data/spec/pair_spec.rb

@@ -0,0 +1,32 @@
+require 'rspec'
+require_relative '../lib/totally_lazy'
+
+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 eq(sequence(pair(:apples,'10')))
+  end
+
+  it 'should convert a pair to a map' do
+    expect(pair(1,2).to_map).to eq({1=>2})
+  end
+
+end

data/spec/sequence_spec.rb

@@ -0,0 +1,50 @@
+require 'rspec'
+require_relative '../lib/totally_lazy'
+
+describe 'Sequence' do
+
+  it 'should create empty sequence when iterable is nil' do
+    expect(sequence(nil)).to eq(empty)
+  end
+
+  it 'should support transpose' do
+    expect(sequence(sequence(1, 2), sequence(3, 4), sequence(5, 6))).to include(sequence(1, 3, 5), sequence(2, 4, 6))
+  end
+
+  it 'should eagerly return the first element of a sequence, returns NoSuchElementException if empty' do
+    expect(sequence(1, 2).head).to eq(1)
+    expect { empty.head }.to raise_error(NoSuchElementException)
+  end
+
+  it 'should eagerly return the first element of a sequence wrapped in a some, returns none if empty' do
+    expect(sequence(1, 2).head_option).to eq(some(1))
+    expect(empty.head_option).to eq(none)
+  end
+
+  it 'should eagerly return the last element of a finite sequence, throws NoSuchElementException if empty' do
+    expect(sequence(1, 2).last).to eq(2)
+    expect { empty.last }.to raise_error(NoSuchElementException)
+  end
+
+  it 'should eagerly return the last element of a finite sequence wrapped in a some, returns none if empty' do
+    expect(sequence(1, 2).last_option).to eq(some(2))
+    expect(empty.last_option).to eq(none)
+  end
+
+  it 'should lazily return the elements except the last one - throws NoSuchElementException if empty. Works with infinite sequences' do
+    expect(sequence(1, 2, 3).tail).to eq(sequence(2, 3))
+    expect { empty.tail.first }.to raise_error(NoSuchElementException)
+  end
+
+  it 'should lazily return the elements except the first one - throws NoSuchElementException if empty' do
+    expect(sequence(1, 2, 3).init).to eq(sequence(1, 2))
+    expect { empty.init.first }.to raise_error(NoSuchElementException)
+  end
+
+  it 'should lazily shuffle the elements - throws NoSuchElementException if empty' do
+    expect(sequence(1..50).shuffle.entries).not_to eq(sequence(1..50).entries)
+    expect { empty.shuffle.first }.to raise_error(NoSuchElementException)
+  end
+
+
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: totally_lazy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kingsley Hendrickse
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: rspec_html_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: Port of java functional library totally lazy to ruby
+email: kingsleyhendrickse@me.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/option.rb
+- lib/pair.rb
+- lib/sequence.rb
+- lib/totally_lazy.rb
+- lib/tuple.rb
+- spec/option_spec.rb
+- spec/pair_spec.rb
+- spec/sequence_spec.rb
+- spec/tuple_spec.rb
+homepage: http://github.com/kingsleyh/totally_lazy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Port of java functional library totally lazy to ruby
+test_files: []