cascadence 0.2.3 → 0.2.4

data/lib/cascadence/commander.rb

@@ -3,74 +3,20 @@ module Cascadence
 
     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"
+      Cascadence::Commander::Version.instance.run
     end
 
     desc "flow [FILEPATH]", "Runs the flow specified in the given file. If given a directory, runs all the flows in the directory."
     def flow(filepath=Dir.pwd)
-      abs_file_path = _absolutize_filepath filepath
-      files = _get_files_from_filepath abs_file_path
-      _setup_environment_from_filepath!(_absolutize_filepath filepath)
-      tasks = files.map { |file| _get_task_from_file file }
-      _run_tasks tasks
+      Cascadence::Commander::Flow.instance.run(filepath)
     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 || !flow.respond_to?(:parent)
-      _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?
+    desc "generate [FLOWNAME]", "generates the flow project as specified by the name with respect to your current directory."
+    def generate(flowname)
+      Cascadence::Commander::Generate.start ["dosomeshit", flowname, Dir.pwd]
     end
 
   end
-end
+end
+
+Dir[File.join(File.dirname(__FILE__), "commander", "*.rb")].each { |f| require f }

data/lib/cascadence/commander/flow.rb

@@ -0,0 +1,74 @@
+module Cascadence
+  class Commander
+    class Flow
+      include Singleton
+
+      def run(filepath)
+        abs_file_path = _absolutize_filepath filepath
+        files = _get_files_from_filepath abs_file_path
+        _setup_environment_from_filepath!(_absolutize_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
+        throw "Bad flow from #{file}. Available flows: #{Cascadence::Flow.subclasses.to_s}" if flow.nil?
+        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 || !flow.respond_to?(:parent)
+        _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
+end

data/lib/cascadence/commander/generate.rb

@@ -0,0 +1,35 @@
+module Cascadence
+  class Commander
+    class Generate < Thor
+      include Singleton
+      include Thor::Actions
+      attr_accessor :project_name, :project_dir
+
+      desc "dosomeshit [FLOWNAME] [PROJECTDIR]", "Generates a project name."
+      def dosomeshit(flowname, project_dir=Dir.pwd)
+        _setup_instance_variables!(flowname, project_dir)
+        directory _get_source_path, _get_destination
+      end
+
+      def self.source_root
+        File.expand_path("../../templates", __FILE__)
+      end
+
+      private
+
+      def _setup_instance_variables!(flowname, project_dir)
+        @project_name = flowname
+        @project_dir = project_dir
+      end
+
+      def _get_source_path
+        self.class.source_root
+      end
+
+      def _get_destination
+        File.join(project_dir, project_name, "flows")
+      end
+
+    end
+  end
+end

data/lib/cascadence/commander/version.rb

@@ -0,0 +1,11 @@
+module Cascadence
+  class Commander
+    class Version
+      include Singleton
+
+      def run
+        File.read File.expand_path("../../../../VERSION", __FILE__)
+      end
+    end
+  end
+end

data/lib/cascadence/templates/%project_name%.rb.tt

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), "<%= project_name.underscore %>", "base_flow")
+module <%= project_name.camelcase %>
+  def self.zero_state_generator
+    throw :ImplementOrDeleteMe
+  end
+end

data/lib/cascadence/templates/%project_name%/base_flow.rb.tt

@@ -0,0 +1,8 @@
+module <%= project_name.camelcase %>
+  class BaseFlow < ::Cascadence::Flow
+
+    def initialize(state)
+      throw :NotImplementedError
+    end
+  end
+end

data/lib/cascadence/templates/flow_helper.rb.tt

@@ -0,0 +1,19 @@
+require "capybara"
+Dir[File.expand_path("../*.rb", __FILE__)].each { |f| require f }
+
+Cascadence.config do |config|
+  # Cascadence supports parallelism when running your flows.
+  # Each file that ends with _flow.rb will be treated as an
+  # individual flow that you want cascadence to run. It is
+  # highly recommended that you set max_thread_count to a 
+  # reasonably small number since running firefox instances
+  # tend to be fairly expensive
+  config.parallel = false
+  config.max_thread_count = 4
+
+  # The zero_state_generator creates the initial state used
+  # by your flows. Global configs here is just the default
+  # generator used in the event specific generators are not
+  # provided in the individual flows.
+  config.zero_state_generator = lambda { Capybara::Session.new :selenium }
+end

data/spec/cascadence/commander/flow_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe Cascadence::Commander::Flow do
+  let(:lolcat) { Cascadence::Commander::Flow.instance }
+  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

data/spec/cascadence/commander/generate_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Cascadence::Commander::Generate do
+  let(:api) { Cascadence::Commander::Generate }
+  context "public" do
+    describe "#dosomeshit" do
+      let(:pubic) { api.start ["dosomeshit", @project_name, RSpec::RootPath] }
+      before :each do
+        @project_name = "tmp_shit"
+        @directory = File.join RSpec::RootPath, @project_name
+        FileUtils.rm_r @directory if Dir.exists? @directory
+      end
+      it "should create the new folder with all the sorts of crap in there" do
+        Dir.exists?(@directory).should_not be_true
+        pubic
+        Dir.exists?(@directory).should be_true
+      end
+      after :each do
+        FileUtils.rm_r @directory if Dir.exists? @directory
+      end
+    end
+  end
+  context "private" do
+    describe "#_setup_instance_variables!" do
+
+    end
+    describe "#_get_source_path" do
+
+    end
+    describe "#_get_destination" do
+
+    end
+  end
+
+end