seam 1.1.3 → 2.0.0a2

data/lib/seam/effort.rb

@@ -1,86 +0,0 @@
-module Seam
-  class Effort
-    attr_accessor :completed_steps
-    attr_accessor :created_at
-    attr_accessor :complete
-    attr_accessor :completed_at
-    attr_accessor :id
-    attr_accessor :next_execute_at
-    attr_accessor :next_step
-    attr_accessor :flow
-    attr_accessor :data
-    attr_accessor :history
-
-    class << self
-
-      def find effort_id
-        Seam::Persistence.find_by_effort_id effort_id
-      end
-
-      def find_all_by_step step
-        Seam::Persistence.find_all_pending_executions_by_step step
-      end
-
-      def parse document
-        Effort.new( {
-                      id:              document['id'],
-                      created_at:      Time.parse(document['created_at'].to_s),
-                      next_execute_at: document['next_execute_at'],
-                      next_step:       document['next_step'],
-                      flow:            HashWithIndifferentAccess.new(document['flow']),
-                      data:            HashWithIndifferentAccess.new(document['data']),
-                      history:         document['history'].map { |x| HashWithIndifferentAccess.new x },
-                      completed_steps: document['completed_steps'],
-                      complete:        document['complete'],
-                      completed_at:    document['completed_at']
-                    } )
-      end
-
-    end
-    
-    def initialize(args = {})
-      @completed_steps = []
-      @history         = []
-      @complete        = false
-      args.each { |k, v| self.send "#{k}=".to_sym, v }
-    end
-
-    def self.create args
-      effort = Seam::Effort.new args
-      effort.save
-      effort
-    end
-
-    def save
-      existing_record = Seam::Effort.find self.id
-      if existing_record
-        Seam::Persistence.save self
-      else
-        Seam::Persistence.create self
-      end
-    end
-
-    def complete?
-      complete
-    end
-
-    def to_hash
-      {
-        id:              self.id,
-        created_at:      self.created_at,
-        completed_steps: self.completed_steps,
-        completed_at:    self.completed_at,
-        next_execute_at: self.next_execute_at,
-        next_step:       self.next_step,
-        flow:            self.flow,
-        data:            self.data,
-        history:         self.history,
-        complete:        self.complete,
-      }
-    end
-
-    def clone
-      Seam::Effort.parse HashWithIndifferentAccess.new(self.to_hash)
-    end
-  end
-end

data/lib/seam/flow.rb

@@ -1,53 +0,0 @@
-module Seam
-  class Flow
-
-    attr_accessor :stamp_data_history
-
-    def initialize
-      @steps = []
-      @stamp_data_history = false
-    end
-
-    def method_missing(meth, *args, &blk)
-      meth = meth.to_s
-      @steps << { name: meth, arguments: args }
-      true
-    end
-
-    def start(data = {})
-      Seam::Effort.create( {
-                             id:              SecureRandom.uuid.to_s,
-                             created_at:      Time.parse(Time.now.to_s),
-                             next_execute_at: Time.parse(Time.now.to_s),
-                             next_step:       self.steps.first.name.to_s,
-                             flow:            the_flow_from,
-                             data:            ActiveSupport::HashWithIndifferentAccess.new(data)
-                           } )
-    end
-
-    def the_flow_from
-      hash = self.to_hash
-      flow = ActiveSupport::HashWithIndifferentAccess.new hash
-      flow['steps'].each do |step|
-        step['id'] = SecureRandom.uuid.to_s
-      end
-      flow
-    end
-
-    def to_hash
-      { 
-        steps: self.steps.map { |x| x.to_hash },
-        stamp_data_history: @stamp_data_history
-      }
-    end
-
-    def steps
-      @steps.each.map do |step|
-        Seam::Step.new( { name:      step[:name],
-                          type:      'do',
-                          arguments: step[:arguments] } )
-
-      end
-    end
-  end
-end

data/lib/seam/in_memory.rb

@@ -1,13 +0,0 @@
-module Seam
-  module InMemory
-    class << self
-      def records
-        @records ||= []
-      end
-
-      def records=(records)
-        @records = records
-      end
-    end
-  end
-end

data/lib/seam/persistence.rb

@@ -1,43 +0,0 @@
-module Seam
-  module Persistence
-    def self.find_by_effort_id effort_id
-      effort = Seam::InMemory.records.select { |x| x.id == effort_id }.first
-      return nil unless effort
-      effort.clone
-    end
-
-    def self.find_all_pending_executions_by_step step
-      Seam::InMemory.records
-        .select { |x| x.next_step == step && x.next_execute_at <= Time.now }
-        .map { |x| x.clone }
-    end
-
-    def self.find_something_to_do
-      Seam::InMemory.records
-        .select { |x| x.complete.nil? || x.complete == false }
-        .select { |x| x.next_execute_at <= Time.now }
-        .select { |x| x.next_step != nil }
-        .map    { |x| x.clone }
-    end
-
-    def self.save effort
-      old_record = find_by_effort_id effort.id
-      if old_record
-        Seam::InMemory.records = Seam::InMemory.records.select { |x| x.id != effort.id }.to_a
-      end
-      create effort
-    end
-
-    def self.create effort
-      Seam::InMemory.records = [Seam::InMemory.records, effort].flatten
-    end
-
-    def self.all
-      Seam::InMemory.records.to_a
-    end
-
-    def self.destroy
-      Seam::InMemory.records = []
-    end
-  end
-end

data/lib/seam/step.rb

@@ -1,33 +0,0 @@
-module Seam
-  class Step
-    attr_accessor :id
-    attr_accessor :name
-    attr_accessor :type
-    attr_accessor :arguments
-
-    def initialize(args = {})
-      args.each { |k, v| self.send "#{k}=".to_sym, v }
-    end
-
-    def to_hash
-      {
-        id:        id,
-        name:      name,
-        type:      type,
-        arguments: get_arguments
-      }
-    end
-
-    private
-
-    def get_arguments
-      arguments.map do |x|
-        if x.is_a? Hash
-          HashWithIndifferentAccess.new(x)
-        else
-          x
-        end
-      end
-    end
-  end
-end

data/lib/seam/wait_worker.rb

@@ -1,30 +0,0 @@
-module Seam
-
-  class WaitWorker < ::Seam::Worker
-
-    def initialize
-      handles :wait
-    end
-
-    def process
-      move_to_next_step( { on: the_time_to_move_on } )
-    end
-
-    private
-
-    def the_time_to_move_on
-      time_of_last_execution + the_amount_of_time_to_wait
-    end
-
-    def the_amount_of_time_to_wait
-      current_step[:arguments][0]
-    end
-
-    def time_of_last_execution
-      return effort.created_at if effort.history.count == 0
-      effort.history.last[:stopped_at]
-    end
-
-  end
-
-end

data/lib/seam/worker.rb

@@ -1,166 +0,0 @@
-module Seam
-
-  class Worker
-
-    def handles step
-      @step = step
-    end
-
-    def execute effort
-      set_current_effort effort
-      before_process
-      process
-      after_process
-    end
-
-    def self.inherited handler
-      @handlers ||= []
-      @handlers << handler
-    end
-
-    def self.handler_for step
-      @handlers.each do |handler|
-        instance = handler.new
-        return instance if instance.step == step
-      end
-      nil
-    end
-
-    def self.all
-      (@handlers || []).map { |x| x.new }
-    end
-
-    def execute_all
-      efforts_to_execute.each { |e| execute e }
-    end
-
-    def eject
-      @operation_to_execute = :eject
-    end
-
-    def move_to_next_step(options = {})
-      @operation_to_execute = :move_to_next_step
-      operation_args[:next_execute_at] = (options[:on] || Time.now)
-    end
-
-    def try_again_in seconds
-      @operation_to_execute    = :try_again_in
-      operation_args[:seconds] = seconds
-    end
-
-    def try_again_on time
-      @operation_to_execute = :try_again_on
-      operation_args[:time] = time
-    end
-
-    attr_accessor :operation_args
-    def operation_args
-      @operation_args ||= {}
-    end
-
-    def operations
-      {
-        try_again_in:      -> do
-                                seconds = operation_args[:seconds]
-                                try_again_on = Time.now + seconds
-
-                                history[:try_again_on] = try_again_on
-
-                                effort.next_execute_at = try_again_on
-                              end,
-        try_again_on:      -> do
-                                history[:try_again_on] = operation_args[:time]
-                                effort.next_execute_at = operation_args[:time]
-                              end,
-        move_to_next_step: -> do
-                                effort.next_execute_at = operation_args[:next_execute_at] if operation_args[:next_execute_at]
-
-                                effort.completed_steps << effort.next_step
-
-                                steps = effort.flow['steps'].map { |x| x['name'] }
-                                next_step = steps[effort.completed_steps.count]
-
-                                effort.next_step = next_step
-                                mark_effort_as_complete if next_step.nil?
-
-                              end,
-        eject:             -> { mark_effort_as_complete }
-      }
-    end
-
-    def effort
-      @current_effort
-    end
-
-    def history
-      @current_run
-    end
-
-    def step
-      s = @step || self.class.name.underscore.gsub('_worker', '').split('/')[-1]
-      s.to_s
-    end
-
-    def current_step
-      effort.flow["steps"][effort.completed_steps.count]
-    end
-
-    private
-
-    def mark_effort_as_complete
-      effort.next_step    = nil
-      effort.complete     = true
-      effort.completed_at = Time.now
-    end
-
-    def set_current_effort effort
-      @current_effort = effort
-    end
-
-    def before_process
-      run = { 
-              started_at:  Time.now,
-              step:        step, 
-              step_id:     current_step['id'],
-              data_before: stamping_the_history? ? effort.data.clone : nil
-            }
-      @current_run = HashWithIndifferentAccess.new run
-    end
-
-    def after_process
-      execute_the_appropriate_operation
-      stamp_the_new_history_record
-      save_the_effort
-    end
-
-    def efforts_to_execute
-      Seam::Effort.find_all_by_step step
-    end
-
-    def execute_the_appropriate_operation
-      @operation_to_execute ||= :move_to_next_step
-      operations[@operation_to_execute].call
-    end
-
-    def stamp_the_new_history_record
-      history[:result]     = @operation_to_execute
-      history[:stopped_at] = Time.now
-
-      if stamping_the_history?
-        history[:data_after] = effort.data.clone
-      end
-
-      effort.history << history
-    end
-
-    def stamping_the_history?
-      effort.flow['stamp_data_history']
-    end
-
-    def save_the_effort
-      effort.save
-    end
-
-  end
-
-end

data/seam.gemspec

@@ -1,30 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'seam/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "seam"
-  spec.version       = Seam::VERSION
-  spec.authors       = ["Darren Cauthon"]
-  spec.email         = ["darren@cauthon.com"]
-  spec.description   = %q{Simple workflows}
-  spec.summary       = %q{Simple workflows}
-  spec.homepage      = ""
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_runtime_dependency "activesupport"
-  spec.add_runtime_dependency "i18n"
-  spec.add_runtime_dependency "json"
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "subtle"
-  spec.add_development_dependency "mocha"
-  spec.add_development_dependency "contrast"
-  spec.add_development_dependency "timecop"
-end

data/spec/seam/effort_spec.rb

@@ -1,43 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Seam::Effort do
-  before do
-    Seam::Persistence.destroy
-  end
-
-  let(:flow) do
-    f = Seam::Flow.new
-    f.step1
-    f.step2
-    f
-  end
-
-  describe "updating an effort" do
-    it "should not create another document in the collection" do
-      first_effort = flow.start
-      Seam::Persistence.all.count.must_equal 1
-      first_effort.save
-      Seam::Persistence.all.count.must_equal 1
-
-      second_effort = flow.start
-      Seam::Persistence.all.count.must_equal 2
-      second_effort.save
-      Seam::Persistence.all.count.must_equal 2
-    end
-
-    it "should update the information" do
-      first_effort = flow.start
-      second_effort = flow.start
-
-      first_effort.next_step = 'i_changed_the_first_one'
-      first_effort.save
-      first_effort.to_hash.contrast_with! Seam::Effort.find(first_effort.id).to_hash, [:id, :created_at]
-      second_effort.to_hash.contrast_with! Seam::Effort.find(second_effort.id).to_hash, [:id, :created_at]
-
-      second_effort.next_step = 'i_changed_the_second_one'
-      second_effort.save
-      first_effort.to_hash.contrast_with! Seam::Effort.find(first_effort.id).to_hash, [:id, :created_at]
-      second_effort.to_hash.contrast_with! Seam::Effort.find(second_effort.id).to_hash, [:id, :created_at]
-    end
-  end
-end

data/spec/seam/flow_spec.rb

@@ -1,173 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "flow" do
-  before do
-    Seam::Persistence.destroy
-  end
-
-  after do
-    Timecop.return
-  end
-
-  describe "a useful example" do
-    let(:flow) do
-      f = Seam::Flow.new
-      f.wait_for_attempting_contact_stage limit: 2.weeks
-      f.determine_if_postcard_should_be_sent
-      f.send_postcard_if_necessary
-      f
-    end
-
-    describe "steps that must be taken" do
-      before do
-        flow
-      end
-
-      it "should not throw an error" do
-        flow.steps.count.must_equal 3
-      end
-
-      it "should set the name of the three steps" do
-        flow.steps[0].name.must_equal "wait_for_attempting_contact_stage"
-        flow.steps[1].name.must_equal "determine_if_postcard_should_be_sent"
-        flow.steps[2].name.must_equal "send_postcard_if_necessary"
-      end
-
-      it "should set the step types of the three steps" do
-        flow.steps[0].type.must_equal "do"
-        flow.steps[1].type.must_equal "do"
-        flow.steps[2].type.must_equal "do"
-      end
-      
-      it "should set the arguments as well" do
-        flow.steps[0].arguments.must_equal [{ limit: 14.days.to_i }]
-        flow.steps[1].arguments.must_equal []
-        flow.steps[2].arguments.must_equal []
-      end
-    end
-  end
-
-  describe "a more useful example" do
-
-    describe "starting an effort" do
-      let(:flow) do
-        flow = Seam::Flow.new
-        flow.do_something
-        flow.do_something_else
-        flow
-      end
-
-      let(:now) { Time.parse('1/1/2011') }
-
-      before do
-        Timecop.freeze now
-
-        @expected_uuid = SecureRandom.uuid.to_s
-        SecureRandom.stubs(:uuid).returns(@expected_uuid)
-                                 .then.returns(1)
-                                 .then.returns(2)
-
-        @effort = flow.start( { first_name: 'John' } )
-      end
-
-      it "should mark no steps as completed" do
-        @effort.completed_steps.count.must_equal 0
-      end
-
-      it "should stamp the effort with a uuid" do
-        @effort.id.must_equal @expected_uuid
-      end
-
-      it "should stamp the create date" do
-        @effort.created_at.must_equal now
-      end
-
-      it "should stamp the next execute date" do
-        @effort.next_execute_at.must_equal now
-      end
-
-      it "should stamp the next step name" do
-        @effort.next_step.must_equal "do_something"
-      end
-
-      it "should save an effort in the db" do
-        effort = Seam::Effort.find @effort.id
-        effort.to_hash.contrast_with! @effort.to_hash, [:id, :created_at]
-      end
-
-      it "should set unique identifiers on the flow ids" do
-        effort = Seam::Effort.find @effort.id
-        effort.flow['steps'][0]['id'].must_equal '1'
-        effort.flow['steps'][1]['id'].must_equal '2'
-      end
-
-    end
-  end
-
-  describe "adding steps" do
-    describe "new steps" do
-      it "should return true" do
-        flow = Seam::Flow.new
-        flow.do_something.must_equal true
-        flow.do_something_else.must_equal true
-      end
-    end
-
-    describe "repeating steps" do
-      it "should only add the step once" do
-        flow = Seam::Flow.new
-        flow.do_something.must_equal true
-        flow.steps.count.must_equal 1
-        flow.do_something.must_equal true
-        flow.steps.count.must_equal 2
-      end
-    end
-
-    describe "repeating steps with different data" do
-      it "should only add the step once" do
-        flow = Seam::Flow.new
-        flow.do_something(special_id: 'one').must_equal true
-        flow.do_something( { special_id: 'two' }, 4).must_equal true
-        flow.steps.count.must_equal 2
-
-        flow.steps[0].arguments.count.must_equal 1
-        flow.steps[0].arguments[0].contrast_with!( { special_id: 'one' } )
-        flow.steps[1].arguments.count.must_equal 2
-        flow.steps[1].arguments[0].contrast_with!( { special_id: 'two' } )
-        flow.steps[1].arguments[1].must_equal 4
-      end
-    end
-  end
-
-  describe "stamping history" do
-    describe "default" do
-      it "should should be false" do
-        flow = Seam::Flow.new
-        flow.stamp_data_history.must_equal false
-      end
-    end
-
-    describe "setting it to true" do
-      it "allow to be set to true" do
-        flow = Seam::Flow.new
-        flow.stamp_data_history = true
-        flow.stamp_data_history.must_equal true
-      end
-    end
-
-    describe "carrying the value through the serialization" do
-
-      it "should be able to persist false" do
-        flow = Seam::Flow.new
-        flow.stamp_data_history = false
-        flow.to_hash[:stamp_data_history].must_equal false
-      end
-
-      it "should be able to persist true" do
-        flow = Seam::Flow.new
-        flow.stamp_data_history = true
-        flow.to_hash[:stamp_data_history].must_equal true
-      end
-    end
-  end
-end