stuka 0.0.10 → 0.0.11

data/lib/stuka/internal/validator.rb

@@ -1,35 +1,50 @@
-require_relative 'process'
+require 'stuka/internal/domain/process'
 
 module Stuka
 
   class Validator
 
-    def self.process_valid?(process)
+    attr_reader :message
+
+    def process_valid?(process)
       
       Stuka::Process::ATTRS.each do |arg|
         result = process.public_send(arg.to_sym)
-        return false if result.nil?
+        if result.nil?
+          @message = "#{process} does not all required attributes"
+          return false
+        end
       end
 
       Stuka::Process::REQUIRED_ATTRS.each do |arg|
         result = process.public_send(arg.to_sym)
-        return false if result.nil? || result.empty?
+        if result.nil? || result.empty?
+          @mesasge = "#{process} has empty values of required attributes"
+          return false 
+        end
       end
 
       true
     end
 
-    def self.process_set_valid?(processes)
+    def process_set_valid?(processes)
 
-      return false if processes.include? nil
+      if processes.include? nil
+        @message = "processes include nil"
+        return false 
+      end
 
       names = processes.map(&:name)
       
-      return false if names.include?(nil) || names.include?("")
+      if names.include?(nil) || names.include?("")
+        @message = "some processes have no name or empty name"
+        return false 
+      end
 
       if names.uniq.length == names.length
         return true
       else
+        @message = "multiple processes with same name defined"
         return false
       end
     end

data/lib/stuka/paths/stuka_paths.rb

@@ -0,0 +1,18 @@
+module Stuka
+
+  module StukaPaths
+
+    PROCESSES_DEFINITION_PATH = "#{Dir.pwd}/process_definition"
+
+    PROCESSES_SOURCE_PATH = "#{Dir.pwd}/processes"
+
+    TEST_PROCESSES_DEFINITION_PATH = "#{File.expand_path(File.dirname(__FILE__))}/../../../spec/unit/internal/processes_dsl_test"
+    TEST_PROCESSES_INCORRECT_DEFINITION_PATH = "#{File.expand_path(File.dirname(__FILE__))}/../../../spec/unit/internal/processes_dsl_test_incorrect"
+
+    TEST_PROCESSES_SOURCE_PATH = "#{File.expand_path(File.dirname(__FILE__))}/../../../spec/unit/internal/processes_source_test"
+
+    TEMPLATES_PATH = "#{File.expand_path(File.dirname(__FILE__))}/../templates"
+
+  end
+
+end

data/lib/stuka/templates/source/process.tt

@@ -1,8 +1,23 @@
-class <%= @name.capitalize %>Process
+require 'stuka/external/business_process'
 
-  def initialize <%= @arguments.join(', ') %>
-    <% for arg in @arguments %>@<%= arg %> = <%= arg %>
+class <%= @name.capitalize %> < Stuka::BusinessProcess
+
+  TRANSITION_MAP = {
+    <% @transitions.keys.each do |action| %>
+    "<%= action %>" => {
+      <% @transitions[action].keys.each do |action_transition| %>
+      <%= action_transition %>: "<%= @transitions[action][action_transition] %>",
+      <% end %>
+    },
     <% end %>
+  }
+
+  def transition_map
+    TRANSITION_MAP
+  end
+
+  def start_action
+    "<%= @start_action %>"
   end
 
 end

data/lib/stuka/version.rb

@@ -1,3 +1,3 @@
 module Stuka
-  VERSION = "0.0.10"
-end
+  VERSION = "0.0.11"
+end

data/lib/stuka.rb

@@ -1,2 +1 @@
 require_relative "stuka/version"
-require_relative "stuka/stuka_cli"

data/spec/{commands → aceptance/commands}/new_command_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require_relative "../../lib/stuka/stuka_cli"
+require "stuka/commands/stuka_cli"
 require 'fileutils'
 
 describe "new command" do

data/spec/aceptance/commands/process_command_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "stuka/commands/stuka_cli"
+require 'fileutils'
+
+describe "process file command" do
+
+  around(:each) do |example|
+    Stuka::StukaCli.start ["new", "test_pro"]
+    example.run
+    FileUtils.rm_rf 'test_pro'
+  end
+
+  it "sets up the project" do
+    Dir.chdir "test_pro" do
+      expect { Stuka::StukaCli.start ["process", "test_process"] }.to output(%r|Process file 'test_process.rb' created|).to_stdout
+      
+      definition_files = Dir["#{Stuka::StukaPaths::PROCESSES_DEFINITION_PATH}/**/*.rb"]
+      expect { definition_files.to include("#{Stuka::StukaPaths::PROCESSES_DEFINITION_PATH}/test_process.rb}") }
+    end
+  end
+
+end

data/spec/{commands → aceptance/commands}/setup_command_spec.rb

@@ -1,5 +1,5 @@
 require "spec_helper"
-require_relative "../../lib/stuka/stuka_cli"
+require "stuka/commands/stuka_cli"
 require 'fileutils'
 
 describe "setup command" do

data/spec/aceptance/external/action_aceptance_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require "stuka/external/business_action"
+require_relative 'processes/cat/check_food'
+
+describe "CheckFood" do
+
+  let(:process) { double(transition: nil, can_transition_to?: true) }
+  let(:outstream)  { StringIO.new }
+  let(:action) { Cat::CheckFood.new(process) }
+
+  after :each do
+    outstream.close
+  end
+
+  it "calls the process if it succeeds" do
+
+    expect(process).to receive :transition
+    action.run({name: "George", outstream: outstream})
+    expect(outstream.string).to include "There is enaugh food"
+
+  end
+
+
+end

data/spec/aceptance/external/feed_cat_process_aceptance_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'stuka/external/business_process'
+require_relative 'processes/feed_cat_process'
+
+describe "Feed cat process" do
+
+  before :each do
+    Stuka::StukaPaths::PROCESSES_SOURCE_PATH.replace "#{File.dirname(__FILE__)}/processes"
+  end
+
+  let(:process) do
+
+    FeedCatProcess.new({}) do |on|
+      
+      on.success { |params|
+        params[:outstream].puts "yay success"
+      }
+      
+      on.failure { |params|
+        params[:outstream].puts "nay failure"
+      }
+
+    end
+
+  end
+
+  let(:outstream)  { StringIO.new }
+  
+  after :each do
+    outstream.close
+  end
+
+  it "process starts executing actions when it ran" do
+
+    expect(process.current_state).to eq(Stuka::BusinessProcess::PROCESS_STATES[:inactive])
+  
+    process.run({name: "George", outstream: outstream})
+
+    expect(process.current_state).to eq(Stuka::BusinessProcess::PROCESS_STATES[:finished])
+
+    expect(outstream.string).to include "There is enaugh food\nGeorge's food plate filled up\nyay success\n"
+
+  end
+
+
+end

data/spec/aceptance/external/processes/cat/check_food.rb

@@ -0,0 +1,14 @@
+require "stuka/external/business_action"
+
+module Cat
+
+  class CheckFood < Stuka::BusinessAction
+
+    def run(params)
+      params[:outstream].puts "There is enaugh food"
+      has_food(params)
+    end
+
+  end
+
+end

data/spec/aceptance/external/processes/cat/fill_up_plate.rb

@@ -0,0 +1,14 @@
+require "stuka/external/business_action"
+
+module Cat
+
+  class FillUpPlate < Stuka::BusinessAction
+
+    def run(params)
+      params[:outstream].puts "#{params[:name]}'s food plate filled up"
+      success(params)
+    end
+
+  end
+
+end

data/spec/aceptance/external/processes/cat/go_to_store.rb

@@ -0,0 +1,14 @@
+require "stuka/external/business_action"
+
+module Cat
+
+  class GoToStore < Stuka::BusinessAction
+
+    def run(params)
+      params[:outstream].puts "went to store"
+      success(params)
+    end
+
+  end
+
+end

data/spec/aceptance/external/processes/feed_cat_process.rb

@@ -0,0 +1,28 @@
+require "stuka/external/business_process"
+
+class FeedCatProcess < Stuka::BusinessProcess
+
+  TRANSITION_MAP = {
+    "cat::check_food" => {
+      has_food: "cat::fill_up_plate",
+      no_food: "cat::go_to_store"
+    },
+    "cat::fill_up_plate" => {
+      success: "process::success",
+      failure: "process::failure"
+    },
+    "cat::go_to_store" => {
+      success: "cat::fill_up_plate",
+      failure: "process::failure"
+    }
+  }
+
+  def transition_map
+    TRANSITION_MAP
+  end
+
+  def start_action
+    "cat::check_food"
+  end
+
+end

data/spec/spec_helper.rb

@@ -19,10 +19,18 @@ RSpec.configure do |config|
 # with RSpec, but feel free to customize to your heart's content.
 
   config.before(:each) do
-    require_relative "../lib/stuka/stuka_paths"
+    require "stuka/paths/stuka_paths"
     Stuka::StukaPaths::PROCESSES_DEFINITION_PATH.replace Stuka::StukaPaths::TEST_PROCESSES_DEFINITION_PATH
     Stuka::StukaPaths::PROCESSES_SOURCE_PATH.replace Stuka::StukaPaths::TEST_PROCESSES_SOURCE_PATH
-    Stuka::StukaPaths::ACTIONS_SOURCE_PATH.replace Stuka::StukaPaths::TEST_ACTIONS_SOURCE_PATH
+  end
+
+  original_stdout = $stdout
+  config.before(:all) do 
+    # Redirect stderr and stdout
+    $stdout = File.new(File.join(File.dirname(__FILE__), 'stdout.txt'), 'w')
+  end
+  config.after(:all) do 
+    $stdout = original_stdout
   end
 
 =begin

data/spec/unit/external/example_source/create_world.rb

@@ -0,0 +1,28 @@
+require "stuka/external/business_process"
+
+class CreateWorld < Stuka::BusinessProcess
+
+  TRANSITION_MAP = {
+    "world::gather_materials" => {
+      success: "world::seperate_light_from_darkness",
+      failure: "world::scrap_world"
+    },
+    "world::seperate_light_from_darkness" => {
+      success: "process::success",
+      failure: "world::scrap_world"
+    },
+    "world::scrap_world" => {
+      success: "process::failure",
+      failure: "process::failure"
+    }
+  }
+
+  def transition_map
+    TRANSITION_MAP
+  end
+
+  def start_action
+    "world::gather_materials"
+  end
+
+end

data/spec/unit/external/example_source/kill_monster.rb

@@ -0,0 +1,38 @@
+require "stuka/external/business_process"
+
+class KillMonster < Stuka::BusinessProcess
+
+  TRANSITION_MAP = {
+    "monster::train_hard" => {
+      good_with_sword: "monster::get_a_sharp_sword",
+      sharp_shooter: "monster::get_a_new_gun",
+      failure: "monster::train_fast_running"
+    },
+    "monster::get_a_sharp_sword" => {
+      success: "process::success",
+      failure: "process::failure"
+    },
+    "monster::get_a_new_gun" => {
+      success: "gun::get_bullets",
+      failure: "process::failure"
+    },
+    "gun::get_bullets" => {
+      success: "process::success",
+      failure: "process::failure"
+    },
+    "monster::train_fast_running" => {
+      success: "process::success",
+      failure: "process::failure"
+    }
+
+  }
+
+  def transition_map
+    TRANSITION_MAP
+  end
+
+  def start_action
+    "monster::train_hard"
+  end
+
+end

data/spec/unit/external/example_source/world/gather_materials.rb

@@ -0,0 +1,13 @@
+require "stuka/external/business_action"
+
+module World
+
+  class GatherMaterials < Stuka::BusinessAction
+
+    def run(params = {})
+      success(params)
+    end
+
+  end
+
+end

data/spec/unit/external/example_source/world/scrap_world.rb

@@ -0,0 +1,13 @@
+require "stuka/external/business_action"
+
+module World
+
+  class ScrapWorld < Stuka::BusinessAction
+
+    def run(params = {})
+      success(params)
+    end
+
+  end
+
+end

data/spec/unit/external/example_source/world/seperate_light_from_darkness.rb

@@ -0,0 +1,13 @@
+require "stuka/external/business_action"
+
+module World
+
+  class SeperateLightFromDarkness < Stuka::BusinessAction
+
+    def run(params = {})
+      failure(params)
+    end
+
+  end
+
+end

data/spec/unit/external/finder_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "unit/external/example_source/create_world"
+require "unit/external/process_interface"
+require "stuka/external/action_finder"
+
+require "unit/external/example_source/world/gather_materials"
+require "unit/external/example_source/world/scrap_world"
+require "unit/external/example_source/world/seperate_light_from_darkness"
+
+describe Stuka::ActionFinder do
+
+  let(:finder) { Stuka::ActionFinder.new }
+  let(:process) { double() }
+
+  before :each do
+    Stuka::StukaPaths::PROCESSES_SOURCE_PATH.replace "#{File.dirname(__FILE__)}/example_source"
+  end
+
+  it "finds actions" do
+    gather_materials = finder.find_action("world::gather_materials", process)
+    expect(gather_materials.class).to be(World::GatherMaterials)
+    expect(gather_materials.process).to be(process)
+
+    scrap_world = finder.find_action("world::scrap_world", process)
+    expect(scrap_world.class).to be(World::ScrapWorld)
+    expect(scrap_world.process).to be(process)
+
+    seperate_light_from_darkness = finder.find_action("world::seperate_light_from_darkness", process)
+    expect(seperate_light_from_darkness.class).to be(World::SeperateLightFromDarkness)
+    expect(seperate_light_from_darkness.process).to be(process)
+  end
+
+  it "throws an UnknownAction error if it can't find the action class" do
+    expect { finder.find_action("some::unknown_action", process) }.to raise_error(Stuka::UnknownAction)
+  end
+
+end

data/spec/unit/external/process_interface.rb

@@ -0,0 +1,9 @@
+shared_examples "a process" do
+
+  let(:runnable) { described_class.new }
+
+  it "responds to run" do
+    expect(runnable).to respond_to(:run)
+  end
+
+end

data/spec/unit/external/process_to_action.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+require "unit/external/example_source/create_world"
+require "unit/external/process_interface"
+require "stuka/external/business_process"
+
+require "unit/external/example_source/world/gather_materials"
+require "unit/external/example_source/world/scrap_world"
+require "unit/external/example_source/world/seperate_light_from_darkness"
+
+describe CreateWorld do
+
+  it_behaves_like "a process"
+
+  let(:stream) { double(puts: nil) }
+  let(:param2) { double(param_method: nil) }
+
+  let(:gather_materials)              { double(process: process) }
+  let(:seperate_light_from_darkness)  { double(process: process) }
+  let(:scrap_world)                   { double(process: process) }
+
+
+  let(:process) do
+  
+    CreateWorld.new() do |on|
+    
+      on.success {
+        puts "yay success"
+      }
+      on.failure {
+        puts "nay failure"
+      }
+
+    end
+
+  end
+
+  before :each do
+
+    allow(gather_materials).to receive(:run) { process.transition({stream: stream, param2: param2}, :success) }
+    allow(seperate_light_from_darkness).to receive(:run) { process.transition({stream: stream}, :failure) }
+    allow(scrap_world).to receive(:run) { process.transition({stream: stream}, :success) }
+
+  end
+
+  it "starts the process with BusinessProcess#run" do
+    
+    expect(World::GatherMaterials).to receive(:new).and_return(gather_materials)
+    expect(World::SeperateLightFromDarkness).to receive(:new).and_return(seperate_light_from_darkness)
+    expect(World::ScrapWorld).to receive(:new).and_return(scrap_world)
+
+    expect(gather_materials).to receive(:run).with({stream: stream, param2: param2})
+    expect(seperate_light_from_darkness).to receive(:run).with({stream: stream, param2: param2})
+    expect(scrap_world).to receive(:run).with({stream: stream})
+
+    process.run({stream: stream, param2: param2})
+
+    expect(process.current_state).to eq Stuka::BusinessProcess::PROCESS_STATES[:finished]
+
+  end
+
+end

data/spec/unit/external/process_to_dispatcher_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+require_relative "example_source/create_world"
+require "stuka/external/business_process"
+
+describe "ExampleProcess" do
+
+  let(:dispatcher) { double(success: "", failure: "", can_end_with?: true) }
+  let(:process) do
+
+    CreateWorld.new(dispatcher: dispatcher) do |on|
+
+      on.success {
+        puts "yay success"
+      }
+      on.failure {
+        puts "nay failure"
+      }
+      
+    end
+
+  end
+
+  before :each do
+    Stuka::StukaPaths::PROCESSES_SOURCE_PATH.replace "#{File.dirname(__FILE__)}/example_source"
+  end
+
+  it "notifies the dispatcher of any other end event" do
+    expect(dispatcher).to receive(:can_end_with?).with(:failure)
+    expect(dispatcher).to receive(:call).with(:failure, {})
+    process.run({})
+
+    expect(process.current_state).to eq(Stuka::BusinessProcess::PROCESS_STATES[:finished])
+  end
+
+end