cascadence 0.1.1

data/lib/cascadence/class_methods.rb

@@ -0,0 +1,39 @@
+
+module Cascadence
+
+  module ClassMethods
+    # Yes, I realize this is confusing
+    # I'm sorry for code-gulfing
+    # TODO: Write this class so we don't depend so heavily
+    # on recusion and "lazy evaluation" to get the ordering.
+    # This is probably 100% necessary if this project were
+    # ever to get big and require junk
+    def cascadence_order
+      @cascadence_order ||= []
+      @forked_position ||= []
+      @merge_position ||= []
+      unless @cascadence_order.nil?
+        Helper.generate_tributary(@cascadence_order.reverse, @forked_position.clone, @merge_position.clone)
+      end
+    end
+
+    def cascading_order( *order )
+      @cascadence_order ||= []
+      @cascadence_order << order
+    end    
+
+    def fork_after( location )
+      @forked_position ||= []
+      index = cascadence_order.index location
+      @forked_position << (index + 1)
+    end
+
+    def merge_before( location )
+      @merge_position ||= []
+      index = cascadence_order.index location
+      @merge_position << (index - 1)
+    end
+
+  end
+
+end

data/lib/cascadence/flow.rb

@@ -0,0 +1,17 @@
+
+module Cascadence
+
+  # A simple implementation of stateful
+  class Flow
+    include Stateful
+    attr_accessor :state
+
+    def self.inherited(child)
+      if child.superclass.respond_to? :cascadence_order
+        order = child.superclass.cascadence_order
+        child.cascading_order *order
+      end
+    end
+  end
+
+end

data/lib/cascadence/helper.rb

@@ -0,0 +1,21 @@
+module Cascadence
+  module Helper
+    # see the specs for what these guys do
+    def self.generate_tributary( arrays, starts=[], finish=[] )
+
+      if starts.empty? || arrays.count == 1
+        return arrays.reverse.flatten
+      end
+      generate_tributary arrays.push(replace_in_part(arrays.pop, arrays.pop, starts.pop, finish.pop) ), starts, finish
+    end
+
+    def self.replace_in_part(original, chunk, start, finish=nil)
+      return chunk if original.nil? || original.empty?
+      throw :OutOfRange if start >= original.count
+      result = original.clone
+      result[start..(finish||-1)] = chunk
+      return result
+    end
+
+  end
+end

data/lib/cascadence/stateful.rb

@@ -0,0 +1,81 @@
+
+module Cascadence
+
+  module Stateful
+
+    def self.included( base )
+      base.extend ClassMethods
+      base.class_exec do
+        attr_reader :cascadence_position
+      end # class_exec
+    end
+
+    def run_states
+      run_until :end
+    end
+
+    def run_until( target=nil )
+      
+      return run_next if target.nil? and !block_given?
+      
+      if block_given?
+        while !_cascadence_end? and !yield(self)
+          run_next
+        end
+        return self
+      end
+      
+      case target.class.to_s
+      when "String", "Symbol"
+        return run_until { |state| state.current_step_name.to_s == target.to_s }
+      when "Fixnum", "Integer"
+        return run_until { |state| state.cascadence_position == target }
+      else
+        throw "Bad input error." unless target.respond_to? :call
+        return run_until { |state| target.call state }
+      end
+    end
+
+    def run_next
+      _debug_helper
+
+      unless next_step_name.nil?
+        send next_step_name
+        _increment_cascadence
+      end
+      self
+    end
+
+    def current_step_name
+      return nil if cascadence_position.nil?
+      self.class.cascadence_order[cascadence_position]
+    end
+
+    def next_step_name
+      return self.class.cascadence_order.first if cascadence_position.nil?
+      self.class.cascadence_order[cascadence_position+1]
+    end
+
+    private
+
+    def _cascadence_end?
+      return false if cascadence_position.nil?
+      cascadence_position >= self.class.cascadence_order.count - 1
+    end
+
+    def _increment_cascadence
+      if @cascadence_position.nil?
+        @cascadence_position = 0
+      else
+        @cascadence_position += 1
+      end
+    end
+
+    def _debug_helper
+      @debug_counter ||= 0
+      @debug_counter += 1
+      throw "Recursion Limit Reached! cascadence_position: #{cascadence_position} --> #{next_step_name}" if 100 < @debug_counter
+    end
+  end
+
+end

data/lib/cascadence.rb

@@ -0,0 +1,7 @@
+
+module Cascadence
+  autoload :Stateful, File.join( File.dirname(__FILE__), "cascadence", "stateful" )
+  autoload :ClassMethods, File.join( File.dirname(__FILE__), "cascadence", "class_methods" )
+  autoload :Flow, File.join( File.dirname(__FILE__), "cascadence", "flow" )
+  autoload :Helper, File.join( File.dirname(__FILE__), "cascadence", "helper")
+end

data/spec/cascadence/class_methods_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Cascadence::ClassMethods do
+
+  let(:life) do 
+    Class.new( Cascadence::Flow ) do
+      cascading_order :childhood, :teenage, :adulthood, :marriage, :mid_age, :old_age, :death
+
+      def initialize
+        self.state = "created"
+      end
+
+      def childhood
+        self.state += "-happy"
+      end
+
+      def teenage
+        self.state += "-misunderstood"
+      end
+
+      def adulthood
+        self.state += "-responsible"
+      end
+
+      def marriage
+        self.state += "-busy"
+      end
+
+      def mid_age
+        self.state += "-content"
+      end
+
+      def old_age
+        self.state += "-tired"
+      end
+
+      def death
+        self.state += "-rip"
+      end
+    end
+  end
+
+  describe "position" do
+
+    it "should give me the correct numerical value for the index command" do
+      life.cascadence_order.index(:teenage).should eq 1
+    end
+  end
+
+  describe "inheritance" do
+    let(:japanese) { Class.new(life) }
+
+    describe "defaults" do
+
+      describe "#cascadence_order" do
+        subject { japanese.cascadence_order }
+
+        it "should be inherited from the parent cascadence order" do
+          should eq life.cascadence_order
+        end
+      end
+
+      describe "#run_states" do
+        subject { japanese.new.run_states.state }
+
+        it "should match exactly the states as run by the parent" do
+          should eq life.new.run_states.state
+        end
+      end
+
+    end
+
+    describe "difference" do
+
+      before :each do 
+        japanese.class_exec do
+          def loli
+            self.state += "-kawaii"
+          end
+
+          def schoolgirl
+            self.state += "-chikan"
+          end
+
+          def ol
+            self.state += "-alcoholic"
+          end
+
+          def settle
+            self.state += "-ntr"
+          end
+
+          def mid_age
+            self.state += "-depressed"
+          end
+        end
+      end
+
+      describe "position" do
+        it "should have the correct position" do
+          japanese.fork_after :childhood
+          japanese.merge_before :mid_age
+          japanese.cascadence_order.should eq [:childhood, :teenage, :adulthood, :marriage, :mid_age, :old_age, :death]
+          japanese.cascading_order :loli, :schoolgirl, :ol, :settle
+          japanese.cascadence_order.should eq [:childhood, :loli, :schoolgirl, :ol, :settle, :mid_age, :old_age, :death]
+        end
+      end
+
+      describe "results" do
+        before :each do
+          japanese.fork_after :childhood
+          japanese.merge_before :mid_age
+          japanese.cascading_order :loli, :schoolgirl, :ol, :settle
+        end
+        it "should have a different cascadence order than the parent class" do
+          life.cascadence_order.should_not eq japanese.cascadence_order
+        end
+
+        it "should result in a different terminal state when the states are run" do
+          life.new.run_states.state.should_not eq japanese.new.run_states.state
+        end
+      end
+
+    end
+
+  end
+
+end  

data/spec/cascadence/flow_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+class FlowTest < Cascadence::Flow
+
+  cascading_order :step1, :step2, :step3, :step4
+
+  def initialize
+    self.state = "initialized"
+  end
+
+  def step1
+    self.state += "-step1"
+  end
+
+  def step2
+    self.state += "-step2"
+  end
+
+  def step3
+    self.state += "-step3"
+  end
+
+  def step4
+    self.state += "-step4"
+  end
+
+end
+
+describe Cascadence::Flow do
+
+  before :each do
+    @flow = FlowTest.new
+  end
+
+  describe "sanity" do
+
+    it "should be an instance of flowtest" do
+      @flow.class.should eq FlowTest
+    end
+
+    it "should respond to state" do
+      @flow.should respond_to :state
+      @flow.should respond_to :state=
+      @flow.state.should eq "initialized"
+    end 
+
+    it "should be an instance of cascadence::flow" do
+      FlowTest.superclass.should eq Cascadence::Flow
+    end
+
+  end
+
+  describe "run states" do
+
+    before(:each) { @expected = "initialized-step1-step2-step3-step4" }
+    let(:actual) { @flow.run_states }
+
+    it "should run all four states in the specified cascading order" do
+      actual.state.should eq @expected
+    end
+
+  end
+
+end

data/spec/cascadence/fork_merge_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Cascadence::Flow do
+  let(:euphrates) do
+    Class.new( Cascadence::Flow ) do
+      cascading_order :eden, :babylon, :gulf
+
+      def initialize
+        self.state = "created"
+      end
+
+      def eden
+        self.state += "-innocence"
+      end
+
+      def babylon
+        self.state += "-prosperity"
+      end
+
+      def gulf
+        self.state += "-downfall"
+      end
+
+    end
+  end
+
+  let(:tigris) do
+    Class.new( euphrates ) do
+      fork_after :eden
+      merge_before :gulf
+      cascading_order :sumer, :israel
+      def sumer
+        self.state += "-discovery"
+      end
+
+      def israel
+        self.state += "-arrogance"
+      end
+    end
+  end
+
+  describe "#cascadence_order" do
+
+    context "parent" do
+      subject { euphrates.cascadence_order }
+
+      it "should remain unchanged from what it was" do
+        should eq [:eden, :babylon, :gulf]
+      end
+    end
+
+    context "child" do
+      subject { tigris.cascadence_order }
+
+      it "should have been forked from the parent cascadence order" do
+        should eq [:eden, :sumer, :israel, :gulf]
+      end
+
+    end
+  end
+
+  describe "#run_state" do
+
+    describe "parent" do
+      subject { euphrates.new.run_states.state }
+
+      it "should generate the expected state without regard to forks" do
+        should eq "created-innocence-prosperity-downfall"
+      end
+    end
+
+    describe "child" do
+      subject { tigris.new.run_states.state }
+
+      it "should have the right states to run" do
+        tigris.cascadence_order.should eq [:eden, :sumer, :israel, :gulf]
+        tigris.new.run_states.state.should eq "created-innocence-discovery-arrogance-downfall"
+      end
+      it "should generate the expected state after succesful forking from the parent" do
+        should eq "created-innocence-discovery-arrogance-downfall"
+      end
+    end
+
+  end
+
+end   

data/spec/cascadence/helper_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Cascadence::Helper do
+  let(:api) { Cascadence::Helper }
+
+  describe "#generate_tributary" do
+    context "standard usage" do
+      before :each do
+        @arrays = [
+          ["o","t"] ,
+          ["a","g"] ,
+          ["f","b","c","g"]
+        ]
+        @starts = [1]
+        @finishes = [2]
+        @expected = ["f","a","g","g","o","t"]
+      end
+
+      it "should reduce the given array to the expected array" do
+        api.generate_tributary(@arrays, @starts, @finishes).should eq @expected
+      end
+
+      it "should work with simpler arrays also" do
+        arrays = [
+          ['a','g','g','o'] ,
+          ['f','b','b','b','t']
+        ]
+        start = [1]
+        merge = [3]
+        api.generate_tributary(arrays, start, merge).should eq @expected
+      end
+    end
+
+    context "weird input" do
+      before :each do
+        @arrays = [
+          ["o","t"] ,
+          ["a","g"] ,
+          ["f","b","c","g"]
+        ]
+        @starts = [1]
+        @finishes = [2]
+        @expected = ["f","a","g","g","o","t"]
+      end
+
+      it "should return the array as is" do
+        api.generate_tributary([[1,2,3,4]]).should eq [1,2,3,4]
+      end
+
+      it "should entirely ignore merge points if no fork points were specified" do
+        api.generate_tributary(@arrays, [1], [23,234,23,23,3,2]).should eq @expected
+      end
+
+      it "should entirely replace to the end if no merge points were specified" do
+        arrays = [
+          "I love eating food".split(" ") ,
+          "big throbbing ipad".split(" ") ,
+          "explicitive deleted".split(" ")
+        ].reverse
+        api.generate_tributary(arrays, [4,2]).join(" ").should eq "I love big throbbing explicitive deleted"
+      end
+    end
+
+    context "bad input" do
+
+      it "should do as much as possible and ignore the rest of the starts if the initial array isn't long enough" do
+        api.generate_tributary([[1,2,3,4,5], [10,2,3,4]], [5,4,3,1]).should eq [10,1,2,3,4,5]
+      end
+
+      it "should throw an error if you attempt to start well after the array" do
+        expect do
+          api.generate_tributary([[1,2,3,4],[1,2,3]], [99])
+        end.to throw_symbol :OutOfRange
+      end
+    end
+
+  end
+
+  describe "#replace_in_part" do
+
+    it "should replace the specified chunk in a given array" do
+      original = "f a b t".split " "
+      chunk = "g g o".split " "
+      api.replace_in_part( original, chunk, 2, 2).join.should eq "faggot"
+      original.join.should eq "fabt"
+      chunk.join.should eq "ggo"
+    end
+  end
+
+  it "should replace as much as possible and then just append the rest in the case the replacement is longer than the original" do
+    original = "asd".split ""
+    chunk = "sshole".split ""
+    api.replace_in_part(original, chunk, 1).join.should eq "asshole"
+  end
+
+  it "should return the chunk if the original array is empty; it should ignore the other options" do
+    api.replace_in_part([], [1,2,3,4], 42).should eq [1,2,3,4]
+  end
+
+  it "should return a cropped version of the array if the replacement chunk is empty" do
+    api.replace_in_part([1,2,3,4], [], 2).should eq [1,2]
+    api.replace_in_part([0,1,2,3,4,5,6,7],[], 2, 4).should eq [0,1,5,6,7]
+  end
+  
+
+end

data/spec/cascadence/stateful_spec.rb

@@ -0,0 +1,136 @@
+require "spec_helper"
+
+class CascadeTest
+  include Cascadence::Stateful
+
+  cascading_order :step1, :step2, :step3
+
+  attr_reader :foo
+
+  def step1
+    @foo = 2
+  end
+
+  def step2
+    @foo *= 3
+  end
+
+  def step3
+    @foo -= 5
+  end
+end
+
+describe Cascadence do
+
+  before :each do
+    @test = CascadeTest.new
+  end
+
+  describe "CascadeTest.new" do
+
+    it "should have the cascadence_position property" do
+      @test.should respond_to :cascadence_position
+    end
+
+    it "should have a null current step" do
+      @test.current_step_name.should be_nil
+    end
+
+    it "should have step1 as it's next step" do
+      @test.next_step_name.should eq :step1
+    end
+
+  end
+
+  describe "CascadeTest" do
+
+    it "should have the cascadence_order property" do
+      CascadeTest.should respond_to :cascadence_order
+    end 
+
+  end
+
+  describe "run next" do 
+
+    it "should run the first thing specified by the cascadence order" do
+      @test.run_next.foo.should eq 2
+    end
+
+    it "should run the first two steps specified by the cascadence order" do
+      @test.run_next.tap do |cascade|
+        cascade.foo.should eq 2
+      end.run_next.foo.should eq 6
+    end
+
+    it "should run all 3 steps specified by the cascadence order" do
+      @test.run_next.run_next.run_next.foo.should eq 1
+    end 
+
+    it "should not do anything to the result on extra calls" do
+      exp = [2,6,1]
+      (0..6).to_a.inject(@test) do |mem, nex|
+        n = nex < 3 ? nex : 2
+        res = mem.run_next
+        res.class.should eq CascadeTest
+        res.foo.should_not be_nil
+        exp[n].should_not be_nil
+        res.foo.should eq exp[n]
+        res
+      end.foo.should eq exp.last
+    end 
+  end 
+
+  describe "run states" do
+
+    let(:final) { @test.run_states }
+
+    it "should have a valid final state" do
+      final.should_not be_nil
+    end
+
+    it "should have maintained the correct cascadence order" do
+      final.class.cascadence_order.should eq [:step1, :step2, :step3]
+    end 
+
+    it "should have advanced to the final cascadence position" do
+      final.cascadence_position.should eq 2
+    end 
+
+    it "should have the correct cascadence result" do
+      final.foo.should eq 1
+    end
+
+  end
+
+  describe "run until" do
+    
+    it "should run to a specified block" do
+      result = @test.run_until do |state|
+        :step3 == state.current_step_name
+      end
+      result.current_step_name.should eq :step3
+      result.foo.should eq 1
+    end
+
+    it "should run to a specified order" do
+      @test.run_until(:step2).foo.should eq 6
+    end
+
+    it "should run to a specified number" do
+      @test.run_until(1).foo.should eq 6
+    end
+
+    it "should run to a specified foreign class" do
+      checker = lambda do |state|
+        state.current_step_name == :step3
+      end
+      @test.run_until(checker).foo.should eq 1
+    end
+
+    it "should have the same result when calling successively" do
+      @test.run_until.run_until.run_until.foo.should eq 1
+    end
+
+  end 
+
+end

data/spec/cascadence_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Cascadence do
+  it "should pass the presence sanity test" do
+    Cascadence.class.should eq Module
+  end
+
+  [:Flow, :ClassMethods, :Stateful, :Helper].each do |constant|
+    it "should contain the correct #{constant} constant" do
+      Cascadence.const_get(constant).should_not be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'simplecov'
+require File.join File.expand_path("..", File.dirname(__FILE__)), "lib", "cascadence"
+
+SimpleCov.start