cascadence 0.1.2 → 0.2.0

data/fixtures/README.md

@@ -0,0 +1 @@
+fasdfa\n=

data/fixtures/amazon/madeira_flow.rb

@@ -0,0 +1,26 @@
+module Amazon
+  class MadeiraFlow < ::Cascadence::Flow
+    cascading_order :step1, :step2, :step3
+
+    def initialize(state)
+      self.state = state || "initialized"
+      puts state
+    end
+
+    def step1
+      self.state += "1"
+      puts state
+    end
+
+    def step2
+      self.state += "2"
+      puts state
+    end
+
+    def step3
+      self.state += "3"
+      puts state
+    end
+
+  end
+end

data/fixtures/amazon/rio_negro_flow.rb

@@ -0,0 +1 @@
+asdf

data/fixtures/amazon_flow.rb

@@ -0,0 +1,2 @@
+module Amazon
+end

data/fixtures/dogwood.clj

@@ -0,0 +1 @@
+(defn dogwood [ca] (ca) )

data/fixtures/faggot_spec.rb

@@ -0,0 +1 @@
+describe Faggot do; end

data/fixtures/flow_helper.rb

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), "amazon", "madeira_flow")
+
+Cascadence.config.zero_state_generator = lambda { "zerostate" }

data/fixtures/lib/nothing.rb

@@ -0,0 +1 @@
+asdfasdfasdfasdf

data/fixtures/nile/blue_nile_flow.rb

@@ -0,0 +1 @@
+dfasdf

data/fixtures/nile/white_nile/gray_nile_flow.rb

@@ -0,0 +1 @@
+fajsdf

data/fixtures/nile/white_nile_flow.rb

@@ -0,0 +1 @@
+dfasdf

data/fixtures/nile_flow.rb

@@ -0,0 +1 @@
+describe Faggot do; end

data/lib/cascadence.rb

@@ -1,7 +1,21 @@
-
+require "thor"
+require "active_support/core_ext/string"
+require "active_support/core_ext/module"
+require "singleton"
 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")
+  autoload :Commander, File.join( File.dirname(__FILE__), "cascadence", "commander")
+  autoload :Runner, File.join( File.dirname(__FILE__), "cascadence", "runner")
+  autoload :Config, File.join( File.dirname(__FILE__), "cascadence", "config")
+  autoload :Task, File.join( File.dirname(__FILE__), "cascadence", "task")
+  def self.config
+    Config.instance
+  end 
+
+  def self.runner
+    Runner.instance
+  end
 end

data/lib/cascadence/commander.rb

@@ -0,0 +1,75 @@
+module Cascadence
+  class Commander < Thor
+
+    desc "version", "Not implemented yet. That's right, the command that tells you what version of cascadence you're running has not been implemented yet."
+    def version
+      puts "El Psy Congroo"
+    end
+
+    desc "flow", "Runs the flow specified in the given file. If given a directory, runs all the flows in the directory."
+    def flow(filepath=Dir.pwd)
+      files = _get_files_from_filepath _absolutize_filepath filepath 
+      _setup_environment_from_filepath!(filepath)
+      tasks = files.map { |file| _get_task_from_file file }
+      _run_tasks tasks
+    end
+
+    private
+
+    def _run_tasks(tasks)
+      Cascadence.runner.run_tasks tasks
+    end
+
+    def _absolutize_filepath(filepath)
+      return filepath if filepath =~ /^\//
+      return File.expand_path(filepath) if filepath =~ /^~/
+      return File.join(Dir.pwd, filepath)
+    end
+
+    def _get_files_from_filepath(filepath)
+      return [filepath] if _flow_file? filepath
+      return [] unless File.exists? filepath
+      Dir[File.join(filepath, "*")].map { |file_or_dir| _get_files_from_filepath file_or_dir }.flatten
+    end
+
+    def _flow_file?(filepath)
+      (filepath =~ /_flow\.rb$/) && File.file?(filepath)
+    end
+
+    def _setup_environment_from_filepath!(filepath)
+      require _find_flow_helper_from_filepath filepath
+    end
+
+    def _find_flow_helper_from_filepath( filepath )
+      _find_flow_helper_from_filepath File.expand_path("..", filepath) unless File.directory? filepath
+      throw :NoFlowHelperFound if filepath == "/"
+      Dir[File.join(filepath, "*")].select { |file| _flow_helper? file }.first || _find_flow_helper_from_filepath( File.expand_path("..", filepath) )
+    end
+
+    def _flow_helper?(filepath)
+      (filepath =~ /\/flow_helper\.rb$/) && File.file?(filepath)
+    end
+
+    def _get_task_from_file(file)
+      flow = _get_flow_from_file file
+      Cascadence::Task.new(_get_zero_state_generator_from_flow flow) do |state=nil|
+        flow.new(state).run_states
+      end
+    end
+
+    def _get_zero_state_generator_from_flow(flow)
+      return flow.zero_state_generator if flow.respond_to? :zero_state_generator
+      return Cascadence.config.zero_state_generator if flow == Object
+      _get_zero_state_generator_from_flow(flow.parent)
+    end
+
+    def _get_flow_from_file(file)
+      Cascadence::Flow.subclasses.select { |subclass| _reasonably_matched?(subclass.to_s, file.chomp(".rb")) }.first
+    end
+
+    def _reasonably_matched?(str1, str2)
+      !(str2.to_s.gsub(/^\/?/, "/") =~ Regexp.new("\/" + str1.to_s.split("::").map(&:underscore).join("/") + "$")).nil?
+    end
+
+  end
+end

data/lib/cascadence/config.rb

@@ -0,0 +1,12 @@
+module Cascadence
+  class Config
+    include Singleton
+    attr_accessor :parallel, :zero_state_generator, :max_thread_count
+
+    def initialize
+      @parallel = false
+      @zero_state_generator = lambda {}
+      @max_thread_count = 5
+    end
+  end
+end

data/lib/cascadence/flow.rb

@@ -6,7 +6,11 @@ module Cascadence
     include Stateful
     attr_accessor :state
 
+    def self.subclasses
+      @@subclasses ||= []
+    end
     def self.inherited(child)
+      Flow.subclasses.push child
       if child.superclass.respond_to? :cascadence_order
         order = child.superclass.cascadence_order
         child.cascading_order *order

data/lib/cascadence/runner.rb

@@ -0,0 +1,62 @@
+module Cascadence
+  class Runner
+    include Singleton
+
+    def run_tasks(tasks)
+      if Cascadence.config.parallel
+        _run_parallel tasks
+      else
+        _run_sequential tasks
+      end
+    end
+
+    private
+
+    # def _run_parallel(tasks)
+    #   threads = []
+    #   puts "Attempting to run with #{tasks.count} tasks"
+    #   tasks.each do |task|
+    #     thread = Thread.new do
+    #       puts "Spinning up thread number #{threads.count}"
+    #       task.call
+    #     end
+    #     puts "Pushing thread number #{threads.count} to thread pool"
+    #     threads << thread
+    #     sleep 0.5
+    #   end
+    #   while threads.inject(false) { |finished, thread| finished || thread.alive? }
+    #     sleep 0.5
+    #   end
+    # end
+
+    def _run_parallel(tasks, threads=[])
+      return if tasks.empty? && threads.empty?
+      package = _maybe_spin_up_thread(tasks, threads)
+      new_tasks = package.first
+      new_threads = package.last
+      _run_parallel new_tasks, new_threads 
+    end
+
+    def _maybe_spin_up_thread(tasks, threads=[])
+      if threads.count > Cascadence.config.max_thread_count
+        new_threads = threads
+        new_tasks = tasks
+      else
+        new_threads = _spin_up_task(tasks.pop, threads)
+        new_tasks = tasks
+      end
+      sleep 0.5
+      return [new_tasks, new_threads.select(&:alive?)]
+    end
+
+    def _spin_up_task(task, threads=[])
+      puts "Spinning up thread no.#{threads.count} out of #{Cascadence.config.max_thread_count}"
+      thread = Thread.new { task.call } unless task.nil?
+      threads.push thread unless thread.nil?
+    end
+
+    def _run_sequential(tasks)
+      tasks.map(&:call).map(&:state)
+    end
+  end
+end

data/lib/cascadence/task.rb

@@ -0,0 +1,14 @@
+module Cascadence
+  class Task
+    def initialize(zero_state_generator=nil, &block)
+      @block = block
+      @zstate_gen = zero_state_generator
+      @zstate_gen ||= Cascadence.config.zero_state_generator 
+    end
+
+    def call
+      @block.call @zstate_gen.call
+    end
+  end
+end
+

data/spec/cascadence/advanced_fork_merge_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Cascadence::Flow do
+  let(:amazon) do
+    Class.new(Cascadence::Flow) do
+      cascading_order :step1, :step2, :step3, :stepcrap
+      def initialize
+        self.state = "initialize"
+      end
+
+      def step1
+        self.state += "1"
+      end
+
+      def step2
+        self.state += "2"
+      end
+
+      def step3
+        self.state += "3"
+      end
+
+      def stepcrap
+        self.state += "crap"
+      end
+    end
+  end
+  context "preemptivization" do
+    let(:amazon_zero) do
+      Class.new(amazon) do
+        merge_before :step1
+        cascading_order :step0
+
+        def step0
+          self.state += "0"
+        end
+      end
+    end
+    describe "#cascadence_order" do
+      context "child" do
+        subject { amazon_zero.cascadence_order }
+
+        it "should be a continuation of the parent" do
+          pending "Not going to worry about this unless this is actually needed"
+          should eq [:step0, :step1, :step2, :step3, :stepcrap]
+        end
+      end
+      context "parent" do
+        subject { amazon.cascadence_order }
+
+        it "should be as expected from the declaration" do
+          should eq [:step1, :step2, :step3, :stepcrap]
+        end
+      end
+    end
+    describe "#run_states" do
+      context "child" do
+        subject { amazon_zero.new.run_states.state }
+
+        it "should give the expected state value" do
+          pending "Not going to worry about this unless this is actually needed"
+          should eq "initialize0123crap"
+        end
+      end
+      context "parent" do
+        subject {amazon.new.run_states.state }
+        it "should give the expected parent state value" do
+          should eq "initialize123crap"
+        end
+      end
+    end
+  end
+  context "continuation" do
+    let(:amazon_prime) do
+      Class.new(amazon) do
+        fork_after :step3
+        cascading_order :step4, :step5
+
+        def step4
+          self.state += "4"
+        end
+
+        def step5
+          self.state += "5"
+        end
+      end
+    end
+
+    describe "#cascadence_order" do
+      context "child" do
+        subject { amazon_prime.cascadence_order }
+
+        it "should be a continuation of the parent" do
+          should eq [:step1, :step2, :step3, :step4, :step5]
+        end
+      end
+      context "parent" do
+        subject { amazon.cascadence_order }
+
+        it "should be as expected from the declaration" do
+          should eq [:step1, :step2, :step3, :stepcrap]
+        end
+      end
+    end
+
+    describe "#run_states" do
+      context "child" do
+        subject { amazon_prime.new.run_states.state }
+
+        it "should give the expected state value" do
+          should eq "initialize12345"
+        end
+      end
+      context "parent" do
+        subject {amazon.new.run_states.state }
+        it "should give the expected parent state value" do
+          should eq "initialize123crap"
+        end
+      end
+    end
+  end
+end

data/spec/cascadence/commander_spec.rb

@@ -0,0 +1,184 @@
+require "spec_helper"
+
+
+describe Cascadence::Commander do
+  let(:lolcat) { Cascadence::Commander.new }
+  context "public api" do
+    describe "#flow" do
+      let(:result) { lolcat.flow File.join(RSpec::FixturePath, "amazon", "madeira_flow.rb") }
+      it "should run the flow stated" do
+        result.should eq ["initialized123"]
+      end
+    end
+  end
+  context "private" do
+    describe "#_get_zero_state_generator_from_flow" do
+      module GetZero
+        def self.zero_state_generator
+          lambda { "get_zero" }
+        end
+        class Fagbar < Cascadence::Flow
+          class HeyzapFlow < ::Cascadence::Flow
+            class CrossFlow
+              class WeHaveToGoDeeper
+                def self.zero_state_generator
+                  lambda { "we_have_to_go_deeper" }
+                end
+              end
+            end
+          end
+        end
+      end
+      it "should properly give me parents where applicable" do
+        GetZero::Fagbar::HeyzapFlow::CrossFlow::WeHaveToGoDeeper.parent.should eq GetZero::Fagbar::HeyzapFlow::CrossFlow
+      end
+      it "should give me nil for the outer level" do
+        GetZero.parent.should == Object
+      end
+      let(:result) { lolcat.send "_get_zero_state_generator_from_flow", @flow }
+      context "warpspeed" do
+        before :each do
+          @flow = GetZero::Fagbar::HeyzapFlow::CrossFlow
+        end
+        it "should get me the first zero_state_generator" do
+          result.call.should eq "get_zero"
+        end
+      end
+      context "inception" do
+        before :each do
+          @flow = GetZero::Fagbar::HeyzapFlow::CrossFlow::WeHaveToGoDeeper
+        end
+        it "should get the closest zero state generator" do
+          result.call.should eq "we_have_to_go_deeper"
+        end
+      end
+    end
+    describe "#_absolutize_filepath" do
+      let(:path) { lolcat.send "_absolutize_filepath", @input }
+      let(:result) { path.should eq @expected }
+      context "standard usage" do
+        before :each do
+          @input = "dog"
+          @expected = File.join Dir.pwd, @input
+        end
+        it( "should give me an absolute path to the file regardless of existence") { result }
+      end
+      context "~" do
+        before :each do
+          @input = "~/dogfucker"
+          @expected = File.join File.expand_path("~"), "dogfucker"
+        end
+        it( "should expand the tilde to the absolute path") { result }
+      end
+      context "absolute path" do
+        before :each do
+          @input = "/home/shinka/something"
+          @expected = @input
+        end
+        it("should not touch the input if it is already absolute") { result }
+      end
+    end
+    describe "#_reasonably_matched?" do
+      let(:match) { lambda { |s1, s2| lolcat.send "_reasonably_matched?", s1, s2 } }
+      context "true" do
+        before :each do
+          @expectations = {
+            "Dog::Cat::Bat" => "/dog/cat/bat",
+            "AssFuck::Shot" => "/ass_fuck/shot",
+            "Dicker::BatMan::Robin" => "apples/oranges/dicker/bat_man/robin",
+            "Snot" => "/asdf/asdf/asdf/ff/snot"
+          }
+        end
+        it "should be a reasonable match" do
+          @expectations.each { |key, val| match.call(key,val).should be_true }
+        end
+      end
+      context "false" do
+        before :each do
+          @expectations = {
+            "Dog::Cat::Bat" => "/fdasf/dog/cat/rat",
+            "" => "/anything/really" ,
+            "Dicker::AssMan" => "/fd/dicker/ass_man/something"
+          }
+        end
+        it "should not be reasonable matches" do
+          @expectations.each { |key,val| match.call(key,val).should_not be_true }
+        end
+      end
+    end
+    describe "#_get_flow_from_file" do
+      let(:flow) { lolcat.send "_get_flow_from_file", @file }
+      let(:expected) { Amazon::MadeiraFlow }
+      before :each do
+        @file = File.join RSpec::FixturePath, "amazon", "madeira_flow.rb"
+        require @file
+      end
+      context "standard usage" do
+        it "should find the flow class in question" do
+          flow.should eq expected
+        end
+      end
+      describe "#_get_task_from_file" do
+        let(:task) { lolcat.send("_get_task_from_file", @file) }
+
+        it "should be a lambda" do
+          task.should respond_to :call
+        end
+
+        it "should run and give me the correct result" do
+          task.call.state.should eq "initialized123"
+        end
+      end
+    end
+    describe "#_find_flow_helper_from_filepath" do
+      let(:path) { lolcat.send "_find_flow_helper_from_filepath", @starting }
+      context "null case" do
+        before :each do
+          @starting = File.expand_path __FILE__
+        end
+        it "should throw an symbol as it cannot find the flow helper" do
+          expect { path }.to throw_symbol :NoFlowHelperFound
+        end
+      end
+      context "dumb case" do
+        before :each do
+          @starting = File.join RSpec::FixturePath, "flow_helper.rb"
+          @expected = @starting
+        end
+        it "should find it right away" do
+          path.should eq @expected
+        end
+      end
+      context "standard usage" do
+        before :each do
+          @starting = File.join RSpec::FixturePath, "nile", "white_nile"
+          @expected = File.join RSpec::FixturePath, "flow_helper.rb"
+        end
+
+        it "should find the expected flow helper in the fixture folder" do
+          path.should eq @expected
+        end
+      end
+    end
+    describe "#_get_files_from_filepath" do
+      context "standard usage" do
+        let(:files) { lolcat.send( "_get_files_from_filepath", File.join(RSpec::FixturePath) ) }
+        before :each do
+          @expected = Dir[File.join(RSpec::FixturePath, "*_flow.rb")].map { |f| f }
+          @expected += Dir[File.join(RSpec::FixturePath,"**", "*_flow.rb")].map { |f| f }
+          @expected += Dir[File.join(RSpec::FixturePath,"**", "**", "*_flow.rb")].map { |f| f }
+          @expected.uniq!
+        end
+
+        it "should fetch all the files that are flow rubies" do
+          files.sort.should eq @expected.sort
+        end
+      end
+      context "null usage" do
+        it "should out an empty array if the path doesn't exist" do
+          lolcat.send("_get_files_from_filepath", "nigstack").should be_empty
+        end
+      end
+    end
+  end
+end