functional-ruby 1.1.0 → 1.2.0

data/lib/functional/synchronization.rb

@@ -0,0 +1,88 @@
+module Functional
+
+  # @!visibility private
+  #
+  # Based on work originally done by Petr Chalupa (@pitr-ch) in Concurrent Ruby.
+  # https://github.com/ruby-concurrency/concurrent-ruby/blob/master/lib/concurrent/synchronization/object.rb
+  module Synchronization
+
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+      require 'jruby'
+
+      # @!visibility private
+      class Object
+
+        # @!visibility private
+        def initialize(*args)
+        end
+
+        protected
+
+        # @!visibility private
+        def synchronize
+          JRuby.reference0(self).synchronized { yield }
+        end
+
+        # @!visibility private
+        def ensure_ivar_visibility!
+          # relying on undocumented behavior of JRuby, ivar access is volatile
+        end
+      end
+
+    elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+
+      # @!visibility private
+      class Object
+
+        # @!visibility private
+        def initialize(*args)
+        end
+
+        protected
+
+        # @!visibility private
+        def synchronize(&block)
+          Rubinius.synchronize(self, &block)
+        end
+
+        # @!visibility private
+        def ensure_ivar_visibility!
+          # Rubinius instance variables are not volatile so we need to insert barrier
+          Rubinius.memory_barrier
+        end
+      end
+
+    else
+
+      require 'thread'
+
+      # @!visibility private
+      class Object
+
+        # @!visibility private
+        def initialize(*args)
+          @__lock__      = ::Mutex.new
+          @__condition__ = ::ConditionVariable.new
+        end
+
+        protected
+
+        # @!visibility private
+        def synchronize
+          if @__lock__.owned?
+            yield
+          else
+            @__lock__.synchronize { yield }
+          end
+        end
+
+        # @!visibility private
+        def ensure_ivar_visibility!
+          # relying on undocumented behavior of CRuby, GVL acquire has lock which ensures visibility of ivars
+          # https://github.com/ruby/ruby/blob/ruby_2_2/thread_pthread.c#L204-L211
+        end
+      end
+    end
+  end
+end

data/lib/functional/tuple.rb

@@ -1,3 +1,5 @@
+require 'functional/synchronization'
+
 module Functional
 
   # A tuple is a pure functional data strcture that is similar to an array but is
@@ -9,8 +11,6 @@ module Functional
   #   contains, the less efficient it will become. A future version will use a fast,
   #   immutable, persistent data structure such as a finger tree or a trie.
   #
-  # @since 1.1.0
-  # 
   # @see http://en.wikipedia.org/wiki/Tuple
   # @see http://msdn.microsoft.com/en-us/library/system.tuple.aspx
   # @see http://www.tutorialspoint.com/python/python_tuples.htm
@@ -20,8 +20,16 @@ module Functional
   # @see http://www.erlang.org/doc/man/erlang.html#make_tuple-2
   # @see http://en.wikibooks.org/wiki/Haskell/Lists_and_tuples#Tuples
   #
-  # @!macro thread_safe_immutable_object
-  class Tuple
+  # @!macro [new] thread_safe_immutable_object
+  #
+  #    @note This is a write-once, read-many, thread safe object that can be
+  #      used in concurrent systems. Thread safety guarantees *cannot* be made
+  #      about objects contained *within* this object, however. Ruby variables
+  #      are mutable references to mutable objects. This cannot be changed. The
+  #      best practice it to only encapsulate immutable, frozen, or thread safe
+  #      objects. Ultimately, thread safety is the responsibility of the
+  #      programmer.
+  class Tuple < Synchronization::Object
 
     # Create a new tuple with the given data items in the given order.
     #
@@ -29,8 +37,10 @@ module Functional
     # @raise [ArgumentError] if data is not an array or does not implement `to_a`
     def initialize(data = [])
       raise ArgumentError.new('data is not an array') unless data.respond_to?(:to_a)
+      super
       @data = data.to_a.dup.freeze
       self.freeze
+      ensure_ivar_visibility!
     end
 
     # Retrieve the item at the given index. Indices begin at zero and increment

data/lib/functional/type_check.rb

@@ -3,8 +3,6 @@ module Functional
   # Supplies type-checking helpers whenever included.
   #
   # @see http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor/TypeCheck.html TypeCheck in Concurrent Ruby
-  #
-  # @since 1.0.0
   module TypeCheck
 
     # Performs an `is_a?` check of the given value object against the

data/lib/functional/union.rb

@@ -1,4 +1,5 @@
-require_relative 'abstract_struct'
+require 'functional/abstract_struct'
+require 'functional/synchronization'
 
 module Functional
 
@@ -47,13 +48,10 @@ module Functional
   #   Functional::Union::Suit.hearts('Queen')
   #    #=> #<union Functional::Union::Suit :clubs=>nil, :diamonds=>nil, :hearts=>"Queen", :spades=>nil>
   #
-  # @see Functional::AbstractStruct
   # @see Functional::Union
   # @see http://www.ruby-doc.org/core-2.1.2/Struct.html Ruby `Struct` class
   # @see http://en.wikipedia.org/wiki/Union_type "Union type" on Wikipedia
   #
-  # @since 1.0.0
-  #
   # @!macro thread_safe_immutable_object
   module Union
     extend self
@@ -127,6 +125,7 @@ module Functional
     # @return [Functional::AbstractStruct] the union class
     def define_initializer(union)
       union.send(:define_method, :initialize) do |field, value|
+        super()
         @field = field
         @value = value
         data = fields.reduce({}) do |memo, field|
@@ -135,6 +134,8 @@ module Functional
         end
         set_data_hash(data)
         set_values_array(data.values)
+        ensure_ivar_visibility!
+        self.freeze
       end
       union
     end

data/lib/functional/value_struct.rb

@@ -1,3 +1,5 @@
+require 'functional/synchronization'
+
 module Functional
 
   # A variation on Ruby's `OpenStruct` in which all fields are immutable and
@@ -18,22 +20,22 @@ module Functional
   #   name.last?   #=> true
   #   name.middle? #=> false
   #
-  # @since 1.1.0
-  #
   # @see Functional::Record
   # @see Functional::FinalStruct
   # @see http://www.ruby-doc.org/stdlib-2.1.2/libdoc/ostruct/rdoc/OpenStruct.html
   #
   # @!macro thread_safe_immutable_object
-  class ValueStruct
+  class ValueStruct < Synchronization::Object
 
     def initialize(attributes)
       raise ArgumentError.new('attributes must be given as a hash') unless attributes.respond_to?(:each_pair)
+      super
       @attribute_hash = {}
       attributes.each_pair do |field, value|
         set_attribute(field, value)
       end
       @attribute_hash.freeze
+      ensure_ivar_visibility!
       self.freeze
     end
 

data/lib/functional/version.rb

@@ -1,5 +1,5 @@
 module Functional
 
   # The current gem version.
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/spec/functional/complex_pattern_matching_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'ostruct'
 
 class Bar
@@ -194,7 +193,7 @@ describe 'complex pattern matching' do
 
     specify { expect(Fizzbuzz.new.who(5)).to eq 15 }
     specify { expect(Fizzbuzz.new.who()).to eq 0 }
-    specify { 
+    specify {
       expect {
         Fizzbuzz.new.who('Jerry', 'secret middle name', "D'Antonio")
       }.to raise_error(NoMethodError)

data/spec/functional/configuration_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 module Functional
 
   context Configuration do

data/spec/functional/delay_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 module Functional
 
   describe Delay do

data/spec/functional/either_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require_relative 'abstract_struct_shared'
 
 module Functional

data/spec/functional/final_struct_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'ostruct'
 
 module Functional

data/spec/functional/final_var_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 module Functional
 
   describe FinalVar do

data/spec/functional/memo_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 module Functional
 
   describe Memo do
@@ -163,30 +161,29 @@ module Functional
 
     context 'thread safety' do
 
-      let(:mutex){ Mutex.new }
+      let(:memoizer_factory){ Functional::Memo::ClassMethods.const_get(:Memoizer) }
+      let(:memoizer){ memoizer_factory.new(:func, 0) }
 
       before(:each) do
-        allow(Mutex).to receive(:new).with(no_args).and_return(mutex)
-        allow(mutex).to receive(:lock).with(no_args).and_return(mutex)
-        allow(mutex).to receive(:unlock).with(no_args).and_return(mutex)
+        allow(memoizer_factory).to receive(:new).with(any_args).and_return(memoizer)
       end
 
       it 'locks a mutex whenever a memoized function is called' do
-        expect(mutex).to receive(:lock).exactly(:once).with(no_args)
+        expect(memoizer).to receive(:synchronize).exactly(:once).with(no_args)
 
         subject.memoize(:increment)
         subject.increment(0)
       end
 
       it 'unlocks the mutex whenever a memoized function is called' do
-        expect(mutex).to receive(:unlock).exactly(:once).with(no_args)
+        expect(memoizer).to receive(:synchronize).exactly(:once).with(no_args)
 
         subject.memoize(:increment)
         subject.increment(0)
       end
 
       it 'unlocks the mutex when the method call raises an exception' do
-        expect(mutex).to receive(:unlock).exactly(:once).with(no_args)
+        expect(memoizer).to receive(:synchronize).exactly(:once).with(no_args)
 
         subject.memoize(:exception)
         begin
@@ -197,7 +194,7 @@ module Functional
       end
 
       it 'uses different mutexes for different functions' do
-        expect(Mutex).to receive(:new).with(no_args).exactly(3).times.and_return(mutex)
+        expect(memoizer_factory).to receive(:new).with(any_args).exactly(3).times.and_return(memoizer)
         # once for memoize(:add) in the definition
         subject.memoize(:increment)
         subject.memoize(:exception)

data/spec/functional/option_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require_relative 'abstract_struct_shared'
 require 'securerandom'
 

data/spec/functional/pattern_matching_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'ostruct'
 
 module Functional

data/spec/functional/protocol_info_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 module Functional
 
   describe ProtocolInfo do

data/spec/functional/protocol_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe 'protocol specification' do
 
   before(:each) do
@@ -96,7 +94,7 @@ describe 'protocol specification' do
         end
 
         expect(
-          Functional::Protocol.Satisfy?('object', :foo)
+          Functional::Protocol.Satisfy?(clazz.new, :foo)
         ).to be false
       end
 

data/spec/functional/record_spec.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
 require_relative 'abstract_struct_shared'
+require 'securerandom'
 
 module Functional
 
@@ -16,12 +16,49 @@ module Functional
 
     context 'definition' do
 
-      it 'registers the new class with Record when given a string name' do
-        Record.new('Foo', :foo, :bar, :baz)
-        expect(defined?(Record::Foo)).to eq 'constant'
+      it 'does not register a new class when no name is given' do
+        Record.new(:foo, :bar, :baz)
+        expect(defined?(Record::Foo)).to be_falsey
       end
 
-      it 'default all fields values to nil' do
+      it 'creates a new class when given an array of field names' do
+        clazz = Record.new(:foo, :bar, :baz)
+        expect(clazz).to be_a Class
+        expect(clazz.ancestors).to include(Functional::AbstractStruct)
+      end
+
+      it 'registers the new class with Record when given a string name and an array' do
+        Record.new('Bar', :foo, :bar, :baz)
+        expect(defined?(Record::Bar)).to eq 'constant'
+      end
+
+      it 'creates a new class when given a hash of field names and types/protocols' do
+        clazz = Record.new(foo: String, bar: String, baz: String)
+        expect(clazz).to be_a Class
+        expect(clazz.ancestors).to include(Functional::AbstractStruct)
+      end
+
+      it 'registers the new class with Record when given a string name and a hash' do
+        Record.new('Boom', foo: String, bar: String, baz: String)
+        expect(defined?(Record::Boom)).to eq 'constant'
+      end
+
+      it 'raises an exception when given a hash with an invalid type/protocol' do
+        expect {
+          Record.new(foo: 'String', bar: String, baz: String)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'raises an exception when given an invalid definition' do
+        expect {
+          Record.new(:foo, bar: String, baz: String)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'initialization' do
+
+      it 'sets all fields values to nil' do
         fields = [:foo, :bar, :baz]
         clazz = Record.new(*fields)
 
@@ -41,74 +78,156 @@ module Functional
         expect(record.baz).to eq 3
       end
 
-      it 'defaults fields to values given during class creation' do
-        clazz = Record.new(:foo, :bar, :baz) do
-          default :foo, 42
-          default :bar, 'w00t!'
+      context 'with default values' do
+
+        it 'defaults fields to values given during class creation' do
+          clazz = Record.new(:foo, :bar, :baz) do
+            default :foo, 42
+            default :bar, 'w00t!'
+          end
+
+          record = clazz.new
+          expect(record.foo).to eq 42
+          expect(record.bar).to eq 'w00t!'
+          expect(record.baz).to be_nil
         end
 
-        record = clazz.new
-        expect(record.foo).to eq 42
-        expect(record.bar).to eq 'w00t!'
-        expect(record.baz).to be_nil
-      end
+        it 'overrides default values with values provided at object construction' do
+          clazz = Record.new(:foo, :bar, :baz) do
+            default :foo, 42
+            default :bar, 'w00t!'
+            default :baz, :bogus
+          end
 
-      it 'overrides default values with values provided at object construction' do
-        clazz = Record.new(:foo, :bar, :baz) do
-          default :foo, 42
-          default :bar, 'w00t!'
-          default :baz, :bogus
+          record = clazz.new(foo: 1, bar: 2)
+
+          expect(record.foo).to eq 1
+          expect(record.bar).to eq 2
+          expect(record.baz).to eq :bogus
         end
 
-        record = clazz.new(foo: 1, bar: 2)
+        it 'duplicates default values when assigning to a new object' do
+          original = 'Foo'
+          clazz = Record.new(:foo, :bar, :baz) do
+            default :foo, original
+          end
 
-        expect(record.foo).to eq 1
-        expect(record.bar).to eq 2
-        expect(record.baz).to eq :bogus
+          record = clazz.new
+          expect(record.foo).to eq original
+          expect(record.foo.object_id).to_not eql original.object_id
+        end
+
+        it 'does not conflate defaults across record classes' do
+          clazz_foo = Record.new(:foo, :bar, :baz) do
+            default :foo, 42
+          end
+
+          clazz_matz = Record.new(:foo, :bar, :baz) do
+            default :foo, 'Matsumoto'
+          end
+
+          expect(clazz_foo.new.foo).to eq 42
+          expect(clazz_matz.new.foo).to eq 'Matsumoto'
+        end
       end
 
-      it 'duplicates default values when assigning to a new object' do
-        original = 'Foo'
-        clazz = Record.new(:foo, :bar, :baz) do
-          default :foo, original
+      context 'with mandatory fields' do
+
+        it 'raises an exception when values for requred field are not provided' do
+          clazz = Record.new(:foo, :bar, :baz) do
+            mandatory :foo
+          end
+
+          expect {
+            clazz.new(bar: 1)
+          }.to raise_exception(ArgumentError)
         end
 
-        record = clazz.new
-        expect(record.foo).to eq original
-        expect(record.foo.object_id).to_not eql original.object_id
-      end
+        it 'raises an exception when required values are nil' do
+          clazz = Record.new(:foo, :bar, :baz) do
+            mandatory :foo
+          end
 
-      it 'does not conflate defaults across record classes' do
-        clazz_foo = Record.new(:foo, :bar, :baz) do
-          default :foo, 42
+          expect {
+            clazz.new(foo: nil, bar: 1)
+          }.to raise_exception(ArgumentError)
         end
 
-        clazz_matz = Record.new(:foo, :bar, :baz) do
-          default :foo, 'Matsumoto'
+        it 'allows multiple required fields to be specified together' do
+          clazz = Record.new(:foo, :bar, :baz) do
+            mandatory :foo, :bar, :baz
+          end
+
+          expect {
+            clazz.new(foo: 1, bar: 2)
+          }.to raise_exception(ArgumentError)
+
+          expect {
+            clazz.new(bar: 2, baz: 3)
+          }.to raise_exception(ArgumentError)
+
+          expect {
+            clazz.new(foo: 1, bar: 2, baz: 3)
+          }.to_not raise_exception
         end
 
-        expect(clazz_foo.new.foo).to eq 42
-        expect(clazz_matz.new.foo).to eq 'Matsumoto'
+        it 'does not conflate default values across record classes' do
+          clazz_foo = Record.new(:foo, :bar, :baz) do
+            mandatory :foo
+          end
+
+          clazz_baz = Record.new(:foo, :bar, :baz) do
+            mandatory :baz
+          end
+
+          expect {
+            clazz_foo.new(foo: 42)
+          }.to_not raise_error
+
+          expect {
+            clazz_baz.new(baz: 42)
+          }.to_not raise_error
+        end
       end
 
-      it 'raises an exception when values for requred field are not provided' do
-        clazz = Record.new(:foo, :bar, :baz) do
-          mandatory :foo
+      context 'with field type specification' do
+
+        let(:type_safe_definition) do
+          {foo: String, bar: Fixnum, baz: protocol}
         end
 
-        expect {
-          clazz.new(bar: 1)
-        }.to raise_exception(ArgumentError)
-      end
+        let(:protocol){ SecureRandom.uuid.to_sym }
 
-      it 'raises an exception when required values are nil' do
-        clazz = Record.new(:foo, :bar, :baz) do
-          mandatory :foo
+        let(:clazz_with_protocol) do
+          Class.new do
+            def foo() nil end
+          end
         end
 
-        expect {
-          clazz.new(foo: nil, bar: 1)
-        }.to raise_exception(ArgumentError)
+        let(:record_clazz) do
+          Record.new(type_safe_definition)
+        end
+
+        before(:each) do
+          Functional::SpecifyProtocol(protocol){ instance_method(:foo) }
+        end
+
+        it 'raises an exception for a value with an invalid type' do
+          expect {
+            record_clazz.new(foo: 'foo', bar: 'bar', baz: clazz_with_protocol.new)
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'raises an exception for a value that does not satisfy a protocol' do
+          expect {
+            record_clazz.new(foo: 'foo', bar: 42, baz: 'baz')
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'creates the object when all values match the appropriate types and protocols' do
+          record = record_clazz.new(foo: 'foo', bar: 42, baz: clazz_with_protocol.new)
+          expect(record).to be_a record_clazz
+        end
       end
 
       it 'allows a field to be required and have a default value' do
@@ -124,24 +243,6 @@ module Functional
         expect(clazz.new.foo).to eq 42
       end
 
-      it 'allows multiple required fields to be specified together' do
-        clazz = Record.new(:foo, :bar, :baz) do
-          mandatory :foo, :bar, :baz
-        end
-
-        expect {
-          clazz.new(foo: 1, bar: 2)
-        }.to raise_exception(ArgumentError)
-
-        expect {
-          clazz.new(bar: 2, baz: 3)
-        }.to raise_exception(ArgumentError)
-
-        expect {
-          clazz.new(foo: 1, bar: 2, baz: 3)
-        }.to_not raise_exception
-      end
-
       it 'raises an exception if the default value for a require field is nil' do
         clazz = Record.new(:foo, :bar, :baz) do
           mandatory :foo
@@ -152,24 +253,6 @@ module Functional
           clazz.new
         }.to raise_exception(ArgumentError)
       end
-
-      it 'does not conflate default values across record classes' do
-        clazz_foo = Record.new(:foo, :bar, :baz) do
-          mandatory :foo
-        end
-
-        clazz_baz = Record.new(:foo, :bar, :baz) do
-          mandatory :baz
-        end
-
-        expect {
-          clazz_foo.new(foo: 42)
-        }.to_not raise_error
-
-        expect {
-          clazz_baz.new(baz: 42)
-        }.to_not raise_error
-      end
     end
 
     context 'subclassing' do