optional 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+/.bundle
+/log/*.log
+/tmp
+/tags
+/coverage
+*.gem

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    optional (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.1)
+    multi_json (1.7.2)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  optional!
+  rspec
+  simplecov

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2012 On The Beach Ltd
+
+MIT License
+
+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,60 @@
+# id
+### simple models based on hashes
+
+JSON is a great way to transfer data between systems, and it's easy to parse into a Ruby hash. But sometimes it's nice to have actual methods to call when you want to get attributes from your data, rather than coupling your entire codebase to the hash representation by littering it with calls to `fetch` or `[]`. The same goes for BSON documents stored in Mongo.
+
+That's where `id` (as in Freud) comes in. You define your model classes using syntax that should look pretty familiar if you've used any popular Ruby ORMs - but `id` is not an ORM. Model objects defined with `id` have a constructor that accepts a hash, and you define the values of this hash that are made readable as fields - but that hash can come from any source.
+
+#### Defining a model
+
+Defining a model looks like this:
+
+    class MyModel
+      include Id::Model
+
+      field :foo
+      field :bar, default: 42
+      field :baz, key: 'barry'
+
+    end
+
+    my_model = MyModel.new(foo: 7, barry: 'hello')
+    my_model.foo # => 7
+    my_model.bar # => 42
+    my_model.baz # => 'hello'
+
+As you can see, you can specify default values as well as key aliases.
+
+#### Associations
+
+You can also specify has_one or has_many "associations" - what would be nested subdocuments in MongoDB for example - like this:
+
+    class Zoo
+      include Id::Model
+
+      has_many :lions
+      has_many :zebras
+      has_one :zookeeper, type: Person
+    end
+
+    zoo = Zoo.new(lions: [{name: 'Hetty'}],
+                  zebras: [{name: 'Lisa'}],
+                  zookeeper: {name: 'Russell' d})
+
+    zoo.lions.first.class # => Lion
+    zoo.lions.first.name  # => "Hetty"
+    zoo.zookeeper.class   # => Person
+    zoo.zookeeper.name    # => "Russell"
+
+Types are inferred from the association name unless one is specified.
+
+#### Designed for immutability
+
+`id` models provide accessor methods, but no mutator methods, because they are designed for immutability. How do immutable models work? When you need to change some field of a model object, a new copy of the object is created with the field changed as required. This is handled for you by `id`'s `set` method:
+
+    person = Person.new(name: 'Russell', job: 'programmer')
+    person.set(name: 'Radek') # => returns a new Person whose name is Radek and whose job is 'programmer'
+
+You can even set fields on nested models in this way:
+
+    person.hat.set(color: 'red') # => returns a new person object with a new hat object with its color set to red

data/lib/optional/all.rb

@@ -0,0 +1,4 @@
+require_relative 'option/all'
+require_relative 'option'
+require_relative 'some'
+require_relative 'none'

data/lib/optional/none.rb

@@ -0,0 +1,35 @@
+module None
+  include Option
+  extend self
+
+  def each
+  end
+
+  def none?
+    true
+  end
+
+  def some?(type=nil)
+    false
+  end
+
+  def value
+    raise Option::ValueOfNoneError
+  end
+
+  def value_or
+    yield
+  end
+
+  def & other
+    self
+  end
+
+  def | other
+    other
+  end
+
+  def to_s
+    "None"
+  end
+end

data/lib/optional/option/all.rb

@@ -0,0 +1,3 @@
+require_relative 'enumerable'
+require_relative 'errors'
+require_relative 'match'

data/lib/optional/option/enumerable.rb

@@ -0,0 +1,38 @@
+module Option
+  module Enumerable
+    include ::Enumerable
+
+    def map
+      from_array super
+    end
+    alias_method :collect, :map
+    alias_method :flat_map, :map
+    alias_method :collect_concat, :map
+
+    def detect
+      from_value super
+    end
+    alias_method :find, :detect
+
+    def select
+      from_array super
+    end
+    alias_method :find_all, :select
+
+    def grep(value)
+      from_array super
+    end
+
+    def reject
+      from_array super
+    end
+
+    def reduce(*args, &block)
+      if none? && (args.size < 1 || args.size < 2 && block.nil?)
+        raise ValueOfNoneError
+      end
+      super
+    end
+    alias_method :inject, :reduce
+  end
+end

data/lib/optional/option/errors.rb

@@ -0,0 +1,6 @@
+module Option
+  class ValueOfNoneError < StandardError
+  end
+  class BadMatchError < StandardError
+  end
+end

data/lib/optional/option/match.rb

@@ -0,0 +1,84 @@
+module Option
+  class Match
+
+    def some(guard=always, &block)
+      some_clauses << SomeClause.new(guard, block)
+    end
+
+    def none(&block)
+      self.none_clause = NoneClause.new(block)
+    end
+
+    def evaluate(option)
+      case option
+      when Some
+        matched(option).evaluate(option.value)
+      when None
+        none_clause.evaluate
+      end
+    end
+
+    private
+
+    def some_clauses
+      @some_clauses ||= []
+    end
+
+    def none_clause
+      @none_clause ||= NoneClause.new(lambda {})
+    end
+
+    def matched(option)
+      some_clauses.find { |clause| clause.matches? option.value }.tap do |match|
+        raise Option::BadMatchError if match.nil?
+      end
+    end
+
+    def always
+      lambda { |x| true }
+    end
+
+    attr_writer :none_clause
+
+    class SomeClause
+
+      def initialize(guard=always, block)
+        @guard = guard
+        @block = block
+      end
+
+      def matches?(value)
+        guard.call(value)
+      end
+
+      def evaluate(value)
+        block.call(value)
+      end
+
+      private
+
+      attr_reader :block
+
+      def guard
+        @guard.is_a?(Proc) ? @guard : ->(x) { x == @guard }
+      end
+
+    end
+
+    class NoneClause
+
+      def initialize(block)
+        @block = block
+      end
+
+      def evaluate
+        block.call
+      end
+
+      private
+
+      attr_reader :block
+    end
+
+  end
+end

data/lib/optional/option.rb

@@ -0,0 +1,24 @@
+module Option
+  include Option::Enumerable
+
+  def match(&block)
+    Match.new.tap { |m| block.call(m) }.evaluate(self)
+  end
+
+  protected
+
+  def and_option(option)
+    none? ? self : Some[*[option.value, value].flatten]
+  end
+
+  private
+
+  def from_array(values)
+    values.empty? ? None : Some[values.first]
+  end
+
+  def from_value(value)
+    value.nil? ? None : Some[value]
+  end
+
+end

data/lib/optional/some.rb

@@ -0,0 +1,46 @@
+class Some
+  include Option
+
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def each
+    yield value
+  end
+
+  def none?(&block)
+    block.nil? ? false : super
+  end
+
+  def value_or
+    value
+  end
+
+  def some?(type=value.class)
+    value.class == type
+  end
+
+  def & other
+    other.and_option(self)
+  end
+
+  def == other
+    other.some? && value == other.value
+  end
+
+  def | other
+    self
+  end
+
+  def to_s
+    "Some[#{value}]"
+  end
+
+  def self.[](*values)
+    new(values.size == 1 ? values.first : values)
+  end
+
+end

data/lib/optional.rb

@@ -0,0 +1 @@
+require_relative 'optional/all'

data/optional.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name          = 'optional'
+  s.version       = '0.0.1'
+  s.date          = '2013-04-19'
+  s.summary       = "Optional values with pattern matching"
+  s.description   = "Make nils go bye bye with Options!"
+  s.authors       = ["Russell Dunphy", "Radek Molenda"]
+  s.email         = ['russell@russelldunphy.com', 'radek.molenda@gmail.com']
+  s.files         = `git ls-files`.split($\)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.homepage      = 'http://github.com/onthebeach/optional'
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
+
+end

data/spec/lib/optional/none_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe None do
+
+  let (:cat) { Cat.new("MOGGIE!") }
+
+  subject { None }
+
+  it { should be_none }
+  it { should_not be_some }
+  it { should_not be_some Cat }
+
+  it { should eq None }
+  it { should_not eq Some[cat] }
+
+  it "does not have a value" do
+    expect { subject.value }.to raise_error Option::ValueOfNoneError
+  end
+
+  it "does, however, allow you to supply a default in place of a value" do
+    subject.value_or { cat }.should eq cat
+  end
+
+  it "can be anded with another none, yielding none" do
+    (None & None).should be_none
+  end
+
+  it "can be anded with a some, yielding none" do
+    (None & Some[cat]).should be_none
+  end
+
+  it "can be ored with another none, yielding none" do
+    (None | None).should be_none
+  end
+
+  it "can be ored with a some, yielding the some" do
+    (None | Some[cat]).should eq Some[cat]
+  end
+
+  it "prints as None" do
+    None.to_s.should eq "None"
+  end
+end

data/spec/lib/optional/option/enumerable_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe Option::Enumerable do
+
+  let (:cat) { Cat.new("MOGGIE!") }
+
+  describe "#map" do
+
+    it "maps a some to a some" do
+      Some[cat].map(&:name).should eq Some["MOGGIE!"]
+    end
+
+    it "also works for collect" do
+      Some[cat].collect(&:name).should eq Some["MOGGIE!"]
+    end
+
+    it "also works for flat_map" do
+      Some[cat].flat_map(&:name).should eq Some["MOGGIE!"]
+    end
+
+    it "maps none to none" do
+      None.map(&:name).should be_none
+    end
+
+    it "also works for collect" do
+      None.collect(&:name).should be_none
+    end
+
+    it "also works for flat_map" do
+      None.flat_map(&:name).should be_none
+    end
+
+    it "also works for collect_concat" do
+      None.collect_concat(&:name).should be_none
+    end
+  end
+
+  describe "#detect" do
+    it "returns none if called on a none" do
+      None.detect{ |pet| pet.name == "MOGGIE!" }.should be_none
+    end
+
+    it "returns a some if called on a some that matches" do
+      Some[cat].detect{ |pet| pet.name == "MOGGIE!" }.should eq Some[cat]
+    end
+
+    it "returns a none if called on a some that doesn't match" do
+      Some[cat].detect{ |pet| pet.name == "DOGGIE!" }.should be_none
+    end
+
+    it "also works for find" do
+      None.find{ |pet| pet.name == "MOGGIE!" }.should be_none
+      Some[cat].find{ |pet| pet.name == "MOGGIE!" }.should eq Some[cat]
+      Some[cat].find{ |pet| pet.name == "DOGGIE!" }.should be_none
+    end
+
+  end
+
+  describe "#select" do
+
+    it "returns a none if called on a none" do
+      None.select(&:even?).should be_none
+    end
+
+    it "returns a none if called on a some that doesn't match" do
+      Some[3].select(&:even?).should be_none
+    end
+
+    it "returns a some if called on a some that matches" do
+      Some[3].select(&:odd?).should eq Some[3]
+    end
+
+    it "also works for find_all" do
+      None.find_all(&:even?).should be_none
+      Some[3].find_all(&:even?).should be_none
+      Some[3].find_all(&:odd?).should eq Some[3]
+    end
+
+  end
+
+  describe "#grep" do
+    it "returns a none if no matching elements" do
+      None.grep(/ing/).should be_none
+    end
+
+    it "returns a some otherwise" do
+      Some["finger"].grep(/ing/).should eq Some["finger"]
+    end
+  end
+
+  describe "#reduce" do
+    it "raises an error if it is called on None" do
+      expect { None.reduce(:+) }.to raise_error Option::ValueOfNoneError
+      expect { None.reduce{ |acc, x| acc + x } }.to raise_error Option::ValueOfNoneError
+    end
+
+    it "works with a none as expected otherwise" do
+      None.reduce(5, :+).should eq 5
+      None.reduce(5) { |acc, x| acc + x }.should eq 5
+    end
+
+    it "works with a some as expected" do
+      Some[4].reduce(:+).should eq 4
+      Some[4].reduce(5, :+).should eq 9
+      Some[4].reduce(5) { |acc, x| acc + x }.should eq 9
+    end
+
+    it "also works as inject" do
+      Some[4].inject(:+).should eq 4
+    end
+  end
+
+  describe "#none?" do
+    it "returns true if given a block the block evaluates to false for the value" do
+      Some[6].none?(&:odd?).should be_true
+    end
+  end
+
+  describe "#reject" do
+    it "returns either some or none" do
+      None.reject(&:odd?).should be_none
+      Some[3].reject(&:odd?).should be_none
+      Some[4].reject(&:odd?).should eq Some[4]
+    end
+  end
+end

data/spec/lib/optional/option_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Option do
+
+  let (:cat) { Cat.new("MOGGIE!") }
+  let (:dog) { Dog.new("DOGGIE!") }
+
+  context "== pattern matching ==" do
+
+    subject do
+      option.match do |m|
+        m.some { |cat| cat.name }
+        m.none { "no cat :-(" }
+      end
+    end
+
+    context "a match can have one None branch, which matches only None" do
+      let (:option) { None }
+      it { should eq "no cat :-(" }
+    end
+
+    context "a match can have a catchall Some branch which matches any Some" do
+      let (:option) { Some[cat] }
+      it { should eq "MOGGIE!" }
+    end
+
+    it "can have multiple Some branches, each one matching a value" do
+      Some[cat].match do |m|
+        m.some(dog) { :canteloupe }
+        m.some(cat) { :fishsticks }
+      end.should eq :fishsticks
+    end
+
+    it "can take a lambda as a guard to match against" do
+      Some[cat].match do |m|
+        m.some ->(pet) { pet.name == "DOGGIE!" } { :fishsticks }
+        m.some ->(pet) { pet.name == "MOGGIE!" } { :canteloupe }
+      end.should eq :canteloupe
+    end
+  end
+
+end

data/spec/lib/optional/some_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Some do
+
+  let (:cat) { Cat.new("MOGGIE!") }
+  let (:dog) { Dog.new("DOGGIE!") }
+
+  subject { Some[cat] }
+
+  it { should be_some }
+  it { should be_some Cat }
+  it { should_not be_some Dog }
+
+  it { should_not be_none }
+
+  it { should eq Some[cat] }
+  it { should_not eq Some[dog] }
+  it { should_not eq None }
+
+  it "has a value" do
+    Some[cat].value.should eq cat
+  end
+
+  it "can be passed a default value but won't use it" do
+    Some[cat].value_or { dog }.should eq cat
+  end
+
+  it "can be anded with another some" do
+    (Some[cat] & Some[dog]).should eq Some[cat, dog]
+  end
+
+  it "can be anded with a none, resulting in none" do
+    (Some[cat] & None).should eq None
+  end
+
+  it "can be ored with another some" do
+    (Some[cat] | Some[dog]).should eq Some[cat]
+  end
+
+  it "can be ored with a none resulting in itself" do
+    (Some[cat] | None).should eq Some[cat]
+  end
+
+  it "prints as Some[value]" do
+    Some[4].to_s.should eq "Some[4]"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec'
+end
+
+require 'rspec'
+require_relative 'support/cat'
+require_relative '../lib/optional'
+
+
+RSpec.configure do |config|
+  config.order = :rand
+  config.color_enabled = true
+end

data/spec/support/cat.rb

@@ -0,0 +1,21 @@
+class Cat
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+
+  def == other
+    other.is_a?(Cat) && other.name == name
+  end
+end
+
+class Dog
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+
+  def == other
+    other.is_a?(Dog) && other.name == name
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: optional
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Russell Dunphy
+- Radek Molenda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Make nils go bye bye with Options!
+email:
+- russell@russelldunphy.com
+- radek.molenda@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- lib/optional.rb
+- lib/optional/all.rb
+- lib/optional/none.rb
+- lib/optional/option.rb
+- lib/optional/option/all.rb
+- lib/optional/option/enumerable.rb
+- lib/optional/option/errors.rb
+- lib/optional/option/match.rb
+- lib/optional/some.rb
+- optional.gemspec
+- spec/lib/optional/none_spec.rb
+- spec/lib/optional/option/enumerable_spec.rb
+- spec/lib/optional/option_spec.rb
+- spec/lib/optional/some_spec.rb
+- spec/spec_helper.rb
+- spec/support/cat.rb
+homepage: http://github.com/onthebeach/optional
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Optional values with pattern matching
+test_files:
+- spec/lib/optional/none_spec.rb
+- spec/lib/optional/option/enumerable_spec.rb
+- spec/lib/optional/option_spec.rb
+- spec/lib/optional/some_spec.rb
+- spec/spec_helper.rb
+- spec/support/cat.rb
+has_rdoc: