reduxco 1.0.0

data/lib/reduxco/context/callable_table.rb

@@ -0,0 +1,81 @@
+require_relative '../callable_ref'
+
+module Reduxco
+  class Context
+    # CallableTable is a 'private' helper class to Context which handles resolving
+    # CallableRef instances to their appropriate callables.  This should not be
+    # used directly.
+    class CallableTable
+
+      # The constant returned by +resolve+ when resolution failure occurs.
+      # This constant can be multiply assigned to the same pattern as a
+      # normal resolution, but will assign nil into each value.
+      RESOLUTION_FAILURE = [nil,nil]
+
+      # Instantiate with list of callable maps.
+      def initialize(callable_map_list)
+        @table = Hash[flatten(callable_map_list).sort.reverse]
+      end
+
+      # Resolves the given callref.  The return value usually takes advantage of
+      # multiple assignment to dissect the return into the matching callref and
+      # found callable. however one can check for failed resolution simply by
+      # comparing the result to RESOLUTION_FAILURE.
+      #
+      # Note that if resolution fails, each value in the multiple assignment is
+      # given the value nil.
+      def resolve(callref)
+        if( callref.static? )
+          @table.include?(callref) ? [callref, @table[callref]] : RESOLUTION_FAILURE
+        else
+          @table.find(->{RESOLUTION_FAILURE}) {|refkey, callable| callref.include?(refkey)}
+        end
+      end
+      alias_method :[], :resolve
+
+      # Returns true if the call with teh given callref exists.
+      def include?(callref)
+        !resolve(callref).last.nil?
+      end
+
+      # Given a static callref, resolves the next available shadowed callable
+      # above it.  If the callref is dynamic, then an exception is thrown.
+      def resolve_super(callref)
+        if( callref.dynamic? )
+          raise ArgumentError, "Cannot resolve the 'super' of a dyanmic CallableReference.", caller
+        else
+          # This is really nice, but runs in O(n):
+          #   @table.find(->{RESOLUTION_FAILURE}) {|refkey, callable| refkey.name == callref.name && refkey.depth < callref.depth}
+          # This is more performant on large tables O(1) but has the potential for a lot of recursion depth:
+          #   if( callref.depth <= CallableRef::MIN_DEPTH )
+          #     RESOLUTION_FAILURE
+          #   else
+          #     resolution = resolve(callref.pred)
+          #     resolution == RESOLUTION_FAILURE ? resolve_super(callref.pred) : resolution
+          #   end
+          # So we go for this imperative C-style flat iteration for O(1) and no recursion.
+          ref = callref
+          while( ref.depth > CallableRef::MIN_DEPTH )
+            ref = ref.pred
+            resolution = resolve(ref)
+            return resolution if(resolution != RESOLUTION_FAILURE)
+          end
+          RESOLUTION_FAILURE
+        end
+      end
+
+      private
+
+      # Flattens the given list of independent maps into a flat symbol table.
+      def flatten(callable_map_list)
+        callable_map_list.each_with_object({table:{}, depth:CallableRef::MIN_DEPTH}) do |map, memo|
+          map.each do |name, callable|
+            memo[:table][CallableRef.new(name, memo[:depth])] = callable
+          end
+          memo[:depth] += 1
+        end[:table]
+      end
+
+    end
+  end
+end

data/lib/reduxco/context/callstack.rb

@@ -0,0 +1,74 @@
+module Reduxco
+  class Context
+    # Defines and implements a callstack interface.
+    #
+    # Callstacks are made of frames, and the top element of the stack is the
+    # current frame.
+    class Callstack
+
+      # Initialize an empty callstack.  Optionally takes an array of frames,
+      # reading from top of the stack to the bottom.
+      def initialize(array=[])
+        @stack = array.reverse
+      end
+
+      # Pushes the given frame onto the callstack
+      def push(frame)
+        @stack.push(frame)
+        self
+      end
+
+      # Pops the top frame from the callstack and returns it.
+      def pop
+        @stack.pop
+      end
+
+      # Returns the element at the top of the stack.
+      def top
+        @stack.last
+      end
+
+      # Returns true if the callstack contains the given frame
+      def include?(frame)
+        @stack.include?(frame)
+      end
+
+      # Returns teh callstack depth
+      def depth
+        @stack.length
+      end
+
+      # Returns a Callstack instance for everything below the top of the stack.
+      def rest
+        self.class.new(@stack[0..-2].reverse)
+      end
+
+      # Returns a copy of this callstack.
+      def dup
+        self.class.new(@stack.dup.reverse)
+      end
+
+      # Returns the callstack in a form that looks like Ruby's caller method,
+      # so that it can be placed in exception backtraces.  Typically one wants
+      # the top of the caller-style stack to be the trace to where Context#call was
+      # invoked in a caller, so this may be provided.
+      def to_caller(top=nil)
+        @stack.reverse.map {|frame| "#{self.class.name} frame: #{frame}"}.tap do |cc|
+          cc.unshift top.to_s unless top.nil?
+        end
+      end
+
+      # Output the Callstack from top to bottom.
+      def to_s
+        @stack.reverse.to_s
+      end
+
+      # Inspect the Callstack, with the top frame first.
+      def inspect
+        @stack.reverse.inspect
+      end
+
+    end
+  end
+end
+

data/lib/reduxco/reduxer.rb

@@ -0,0 +1,41 @@
+require_relative 'context'
+
+module Reduxco
+  # The primary public facing Reduxco class.
+  class Reduxer
+
+    # When given one or more maps of callables, instantiates with the given
+    # callable maps.
+    #
+    # When the first argument is a Context, it instantiates with a new Context
+    # that has the same callable maps.
+    def initialize(*args)
+      case args.first
+      when Context
+        @context = args.first.dup
+      else
+        @context = Context.new(*args)
+      end
+    end
+
+    # Returns a reference to the enclosing Context.  This is typically not
+    # needed, and its use is more often than not related to a client design
+    # mistake.
+    attr_reader :context
+
+    # Retrieves the value of the given refname.  Both final and intermediate
+    # values are cached, so multiple calls have low overhead.
+    def call(refname=:app)
+      @context.call(refname)
+    end
+    alias_method :[], :call
+    alias_method :reduce, :call
+
+    # Acts as a copy constructor, giving a new Reduxer instantiated with the
+    # same arguments as this one.
+    def dup
+      self.class.new(@context)
+    end
+
+  end
+end

data/lib/reduxco/version.rb

@@ -0,0 +1,4 @@
+module Reduxco
+  # The current version of the Reduxco gem.
+  VERSION = '1.0.0'
+end

data/spec/callable_ref_spec.rb

@@ -0,0 +1,273 @@
+require 'spec_helper'
+
+describe Reduxco::CallableRef do
+
+  describe 'basic properites' do
+
+    it 'should error if the depth is 0 or less.' do
+      ->{Reduxco::CallableRef.new(:foo, 0)}.should raise_error(IndexError)
+      ->{Reduxco::CallableRef.new(:foo, -100)}.should raise_error(IndexError)
+    end
+
+    it 'should be dynamic with a symbol name' do
+      ref = Reduxco::CallableRef.new(:foo)
+      ref.should be_dynamic
+      ref.should_not be_static
+    end
+
+    it 'should be static with a symbol name and depth' do
+      ref = Reduxco::CallableRef.new(:foo, 3)
+      ref.should be_static
+      ref.should_not be_dynamic
+    end
+
+    it 'should give the name' do
+      ref = Reduxco::CallableRef.new(:foo)
+      ref.name.should == :foo
+    end
+
+    it 'should give the depth' do
+      ref = Reduxco::CallableRef.new(:foo, 3)
+      ref.depth.should == 3
+    end
+
+    it 'should give nil for the depth of a dynamic ref' do
+      ref = Reduxco::CallableRef.new(:foo)
+      ref.depth.should be_nil
+    end
+
+    it 'should be immutable' do
+      ref = Reduxco::CallableRef.new(:foo)
+      ref.should_not respond_to(:name=)
+      ref.should_not respond_to(:depth=)
+    end
+
+    it 'should accept non-symbol names' do
+      name = Object.new
+      ref = Reduxco::CallableRef.new(name)
+      ref.name.should == name
+    end
+
+    it 'should not change strings to symbols' do
+      ref = Reduxco::CallableRef.new('foo')
+      ref.name.should_not == :foo
+      ref.name.should == 'foo'
+    end
+
+    it 'should be a symantecially identical callref when a callref is given as the name' do
+      name = Object.new # Purposefully choose an object that, if duplicated, will give a differing equality.
+      callref = Reduxco::CallableRef.new(name, 3)
+
+      copyref = Reduxco::CallableRef.new(callref)
+      copyref.name.should == callref.name
+      copyref.depth.should == callref.depth
+      copyref.should == callref
+    end
+
+    it 'should override a passed callref\'s depth when a depth arg is given' do
+      name = Object.new # Purposefully choose an object that, if duplicated, will give a differing equality.
+      callref = Reduxco::CallableRef.new(name, 3)
+
+      copyref = Reduxco::CallableRef.new(callref, 8)
+      copyref.name.should == callref.name
+      copyref.depth.should == 8
+      copyref.should_not == callref
+    end
+
+  end
+
+  describe 'movement' do
+
+    describe 'succ' do
+
+      it 'should return a ref with the same name, but one level deeper' do
+        name = Object.new
+        ref = Reduxco::CallableRef.new(name, 10)
+
+        ref.succ.tap do |r|
+          r.name.should == name
+          r.depth.should == 11
+        end
+      end
+
+      it 'should raise an exception when dynamic' do
+        ->{ Reduxco::CallableRef.new(:foo).succ }.should raise_error
+      end
+
+      it 'should alias next to succ' do
+        ref = Reduxco::CallableRef.new('foo')
+        ref.method(:next).should == ref.method(:succ)
+      end
+
+    end
+
+    describe 'pred' do
+
+      it 'should return a ref with the same name, but one level higher' do
+        name = Object.new
+        ref = Reduxco::CallableRef.new(name, 10)
+
+        ref.pred.tap do |r|
+          r.name.should == name
+          r.depth.should == 9
+        end
+      end
+
+      it 'should raise an exception when stepping too low' do
+        name = Object.new
+        ref = Reduxco::CallableRef.new(name, 1)
+
+        ->{ ref.pred }.should raise_error(IndexError)
+      end
+
+      it 'should raise an exception when dynamic' do
+        ->{ Reduxco::CallableRef.new(:foo).pred }.should raise_error
+      end
+
+    end
+
+  end
+
+  describe 'equality' do
+
+    it 'should compute a predictable hash based on name' do
+      name = Object.new
+      ref1 = Reduxco::CallableRef.new(name)
+      ref2 = Reduxco::CallableRef.new(name)
+      refz = Reduxco::CallableRef.new(Object.new)
+
+      ref2.hash.should == ref1.hash
+      refz.hash.should_not == ref1.hash
+    end
+
+    it 'should compute a predictable hash based on depth' do
+      ref1 = Reduxco::CallableRef.new(:foo, 3)
+      ref2 = Reduxco::CallableRef.new(:foo, 3)
+      refy = Reduxco::CallableRef.new(:foo)
+      refz = Reduxco::CallableRef.new(:foo, 4)
+
+      ref2.hash.should == ref1.hash
+      refy.hash.should_not == ref1.hash
+      refz.hash.should_not == ref1.hash
+    end
+
+    it 'should compute different hashes for a string and symbol name' do
+      Reduxco::CallableRef.new(:foo).hash.should_not == Reduxco::CallableRef.new('foo').hash
+    end
+
+    it 'should compute static refs as included in a same-named dynamic ref' do
+      ref = Reduxco::CallableRef.new(:foo)
+
+      ref1 = Reduxco::CallableRef.new(:foo, 3)
+      ref2 = Reduxco::CallableRef.new(:foo, 4)
+      ref3 = Reduxco::CallableRef.new(:bar, 4)
+      ref4 = Reduxco::CallableRef.new(:foo)
+
+      ref.should include(ref1)
+      ref.should include(ref2)
+      ref.should_not include(ref3)
+      ref.should include(ref4)
+    end
+
+    it 'should compute dynamic refs as only equal to dynamic refs with the same name' do
+      ref = Reduxco::CallableRef.new(:foo)
+
+      ref1 = Reduxco::CallableRef.new(:foo)
+      ref2 = Reduxco::CallableRef.new(:foo, 4)
+
+      ref1.should == ref
+      ref2.should_not == ref
+    end
+
+    it 'should compute static refs as only equal to refs with the same name and depth' do
+      ref = Reduxco::CallableRef.new(:foo, 4)
+
+      ref1 = Reduxco::CallableRef.new(:foo)
+      ref2 = Reduxco::CallableRef.new(:foo, 3)
+      ref3 = Reduxco::CallableRef.new(:foo, 4)
+
+      ref1.should_not == ref
+      ref2.should_not == ref
+      ref3.should == ref
+    end
+
+    it 'should not consider a string value of a ref equal to the ref' do
+      ref = Reduxco::CallableRef.new(:foo, 4)
+      ref.should_not == ref.to_s
+    end
+
+  end
+
+  describe 'sortability' do
+
+    it 'should not allow sorting of dynamic refs with static ones' do
+      refs = [[:foo,3], [:bar]].map {|args| Reduxco::CallableRef.new(*args)}
+      ->{refs.sort}.should raise_error(ArgumentError)
+    end
+
+    it 'should sort equivalently named refs of lower depth above those of higher depths' do
+      depths = [6,1,2,2,9]
+      refs = depths.map {|depth| Reduxco::CallableRef.new(:foo, depth)}
+
+      refs.sort.map {|ref| ref.depth}.should == depths.sort
+    end
+
+    it 'should sort names of same depth when sortable' do
+      names = ['cdr', 'cons', 'car']
+      dyn_refs = names.map {|name| Reduxco::CallableRef.new(name)}
+      stc_refs = names.map {|name| Reduxco::CallableRef.new(name, 3)}
+
+      dyn_refs.sort.map {|ref| ref.name}.should == names.sort
+      stc_refs.sort.map {|ref| ref.name}.should == names.sort
+    end
+
+    it 'should not reject unsortable names (just be ambiguous)' do
+      names = [3, nil, :foo, Object.new]
+      dyn_refs = names.map {|name| Reduxco::CallableRef.new(name)}
+      stc_refs = names.map {|name| Reduxco::CallableRef.new(name, 3)}
+
+      ->{ dyn_refs.sort.map {|ref| ref.name} }.should_not raise_error
+      ->{ stc_refs.sort.map {|ref| ref.name} }.should_not raise_error
+    end
+
+  end
+
+  describe 'coercion' do
+
+    before(:each) do
+      @dyn_ref = Reduxco::CallableRef.new(:foo)
+      @stc_ref = Reduxco::CallableRef.new(:foo, 3)
+    end
+
+    it 'should convert to array' do
+      @dyn_ref.to_a.should == [@dyn_ref.name, @dyn_ref.depth]
+      @stc_ref.to_a.should == [@stc_ref.name, @stc_ref.depth]
+    end
+
+    it 'should convert to hash' do
+      @dyn_ref.to_h.should == {name: @dyn_ref.name, depth: @dyn_ref.depth}
+      @stc_ref.to_h.should == {name: @stc_ref.name, depth: @stc_ref.depth}
+    end
+
+
+    describe 'string form' do
+
+      it 'should convert dynamic ref to string without depth' do
+        @dyn_ref.to_s.should include(@stc_ref.name.to_s)
+        @dyn_ref.to_s.should_not include(@stc_ref.depth.to_s)
+      end
+
+      it 'should convert static ref to string' do
+        @stc_ref.to_s.should include(@stc_ref.name.to_s)
+        @stc_ref.to_s.should include(@stc_ref.depth.to_s)
+      end
+
+      it 'should not convert to string a missing args splat like it had one' do
+        Reduxco::CallableRef.new([:foo,3]).to_s.should_not == Reduxco::CallableRef.new(:foo,3).to_s
+      end
+
+    end
+
+  end
+
+end