producer-core 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: faa828c272b7b1283b43c4484b3058c3150c1406
-  data.tar.gz: a2cd0da5eab61ceaadfb8970f2db93ed9fa00c10
+  metadata.gz: 1a3adf6101a1558efb3ddeaf66acf177c1d60cc1
+  data.tar.gz: 0013660606738921e69b6cda3198ca828bcf4b8b
 SHA512:
-  metadata.gz: 9f1f5de22346bd0ba148b9c27a60f3d4bb14320fc14fdbdd4422300b526f6bcf904ebc99909a1d31994a27ec06176eca91a17b78be82b8e8a644c171b5032fef
-  data.tar.gz: e3eb1cdb96edbc33280530a0036704860fdb160dbd71c879e97deecff92a53596d6dc2cc2c25b049d157933545c21517bdfce26e8b544e4b54002edc7001090d
+  metadata.gz: ca676ef9b26f0fd6ff8b4a0b88e1cc7caec24da357b8f40280692d19991b8e64b7e7b4c6697a6d5e5debe9bbb3ef4b84ce2cc03ac30c9145a1aceb06a9df04fb
+  data.tar.gz: b8606bd4d3cd7c3507e8ea7e87ad4199a8a5538b95ca2438deff520d40244382b350bfc51b3d1a5fda11ea2ca90f55d3b206cac37f45de059ee2a8632d18b2f1

data/features/{test_negated_test.feature → condition_negated_test.feature}

@@ -1,40 +1,47 @@
-@sshd
 Feature: negated test prefix (no_)
 
   Scenario: prefixed test fails when non-prefixed test is successful
     Given a recipe with:
       """
+      test_macro :even? do |n|
+        n % 2 == 0
+      end
+
       task :successful_test do
-        condition { env? :shell }
+        condition { even? 4 }
 
         echo 'successful_test'
       end
 
       task :negated_test do
-        condition { no_env? :shell }
+        condition { no_even? 4 }
 
         echo 'negated_test'
       end
       """
-    When I successfully execute the recipe on remote target
+    When I successfully execute the recipe
     Then the output must contain "successful_test"
     And the output must not contain "negated_test"
 
-  Scenario: prefixed test fails when non-prefixed test is failing
+  Scenario: prefixed test succeed when non-prefixed test is failing
     Given a recipe with:
       """
+      test_macro :even? do |n|
+        n % 2 == 0
+      end
+
       task :failing_test do
-        condition { env? :inexistent_var }
+        condition { even? 5 }
 
         echo 'failing_test'
       end
 
       task :negated_test do
-        condition { no_env? :inexistent_var }
+        condition { no_even? 5 }
 
         echo 'negated_test'
       end
       """
-    When I successfully execute the recipe on remote target
+    When I successfully execute the recipe
     Then the output must not contain "failing_test"
     And the output must contain "negated_test"

data/features/{recipe_ask.feature → task_ask.feature}

@@ -1,4 +1,4 @@
-Feature: `ask' recipe keyword
+Feature: `ask' task keyword
 
   @exec
   Scenario: prompts user with a list of choices on standard output

data/lib/producer/core/cli.rb

@@ -58,7 +58,7 @@ module Producer
       end
 
       def recipe
-        @recipe ||= Recipe.evaluate_from_file(@arguments.first, env)
+        @recipe ||= Recipe::FileEvaluator.evaluate(@arguments.first, env)
       end
     end
   end

data/lib/producer/core/condition.rb

@@ -2,16 +2,45 @@ module Producer
   module Core
     class Condition
       class << self
+        def define_test(keyword, test)
+          {
+            keyword         => false,
+            "no_#{keyword}" => true
+          }.each do |kw, negated|
+            define_method(kw) do |*args|
+              if test.respond_to? :call
+                args  = [test, *args]
+                klass = Tests::ConditionTest
+              else
+                klass = test
+              end
+              t = klass.new(@env, *args, negated: negated)
+              @tests << t
+            end
+          end
+        end
+
         def evaluate(env, *args, &block)
-          dsl = DSL.new(env, &block)
-          return_value = dsl.evaluate *args
-          Condition.new(dsl.tests, return_value)
+          new.tap do |o|
+            o.instance_eval { @env = env }
+            return_value = o.instance_exec *args, &block
+            o.instance_eval { @return_value = return_value }
+          end
         end
       end
 
+      define_test :`,               Tests::ShellCommandStatus
+      define_test :sh,              Tests::ShellCommandStatus
+      define_test :file_contains,   Tests::FileContains
+      define_test :file_eq,         Tests::FileEq
+      define_test :env?,            Tests::HasEnv
+      define_test :executable?,     Tests::HasExecutable
+      define_test :dir?,            Tests::HasDir
+      define_test :file?,           Tests::HasFile
+
       attr_reader :tests, :return_value
 
-      def initialize(tests, return_value = nil)
+      def initialize(tests = [], return_value = nil)
         @tests        = tests
         @return_value = return_value
       end

data/lib/producer/core/recipe/file_evaluator.rb

@@ -0,0 +1,14 @@
+module Producer
+  module Core
+    class Recipe
+      class FileEvaluator
+        class << self
+          def evaluate(file_path, env)
+            content = File.read(file_path)
+            Recipe.new(env).tap { |o| o.instance_eval content, file_path }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/producer/core/recipe.rb

@@ -2,16 +2,46 @@ module Producer
   module Core
     class Recipe
       class << self
-        def evaluate_from_file(filepath, env)
-          dsl = DSL.new(env, File.read(filepath)).evaluate
-          Recipe.new(dsl.tasks)
+        def define_macro(name, block)
+          define_method(name) { |*args| task name, *args, &block }
         end
       end
 
-      attr_accessor :tasks
+      attr_reader :env, :tasks
 
-      def initialize(tasks = [])
-        @tasks = tasks
+      def initialize(env)
+        @env    = env
+        @tasks  = []
+      end
+
+      def source(filepath)
+        instance_eval File.read("./#{filepath}.rb"), "#{filepath}.rb"
+      end
+
+      def target(hostname)
+        env.target ||= hostname
+      end
+
+      def task(name, *args, &block)
+        @tasks << Task.evaluate(env, name, *args, &block)
+      end
+
+      def macro(name, &block)
+        define_singleton_method(name) do |*args|
+          task("#{name}", *args, &block)
+        end
+      end
+
+      def test_macro(name, &block)
+        Condition.define_test(name, block)
+      end
+
+      def set(key, value)
+        env[key] = value
+      end
+
+      def get(key)
+        env[key]
       end
     end
   end

data/lib/producer/core/task.rb

@@ -2,28 +2,54 @@ module Producer
   module Core
     class Task
       class << self
-        def evaluate(name, env, *args, &block)
-          dsl = DSL.new(env, &block)
-          dsl.evaluate(*args)
-          Task.new(name, dsl.actions, dsl.condition)
+        def define_action(keyword, klass)
+          define_method(keyword) do |*args|
+            @actions << klass.new(@env, *args)
+          end
+        end
+
+        def evaluate(env, name, *args, &block)
+          new(env, name).tap { |o| o.instance_exec *args, &block }
         end
       end
 
+      define_action :echo,                  Actions::Echo
+      define_action :sh,                    Actions::ShellCommand
+
+      define_action :mkdir,                 Actions::Mkdir
+      define_action :file_append,           Actions::FileAppend
+      define_action :file_replace_content,  Actions::FileReplaceContent
+      define_action :file_write,            Actions::FileWriter
+
       attr_reader :name, :actions, :condition
 
-      def initialize(name, actions = [], condition = true)
+      def initialize(env, name, actions = [], condition = true)
+        @env        = env
         @name       = name
         @actions    = actions
         @condition  = condition
       end
 
       def to_s
-        name.to_s
+        @name.to_s
       end
 
       def condition_met?
         !!@condition
       end
+
+      def condition(&block)
+        @condition = Condition.evaluate(@env, &block) if block
+        @condition
+      end
+
+      def ask(question, choices, prompter: Prompter.new(@env.input, @env.output))
+        prompter.prompt(question, choices)
+      end
+
+      def get(key)
+        @env[key]
+      end
     end
   end
 end

data/lib/producer/core/version.rb

@@ -1,5 +1,5 @@
 module Producer
   module Core
-    VERSION = '0.3.0'.freeze
+    VERSION = '0.3.1'.freeze
   end
 end

data/lib/producer/core/worker.rb

@@ -4,27 +4,25 @@ module Producer
       DRY_RUN_WARNING =
         'running in dry run mode, actions will NOT be applied'.freeze
 
-      attr_accessor :env
-
       def initialize(env)
         @env = env
       end
 
       def process(tasks)
-        env.log DRY_RUN_WARNING, :warn if env.dry_run?
+        @env.log DRY_RUN_WARNING, :warn if @env.dry_run?
 
         tasks.each { |t| process_task t }
       end
 
       def process_task(task)
         if task.condition_met?
-          env.log "Task: `#{task}' applying..."
+          @env.log "Task: `#{task}' applying..."
           task.actions.each do |e|
-            env.log " action: #{e}"
-            e.apply unless env.dry_run?
+            @env.log " action: #{e}"
+            e.apply unless @env.dry_run?
           end
         else
-          env.log "Task: `#{task}' skipped"
+          @env.log "Task: `#{task}' skipped"
         end
       end
     end

data/lib/producer/core.rb

@@ -14,7 +14,7 @@ require 'producer/core/actions/file_append'
 require 'producer/core/actions/file_replace_content'
 require 'producer/core/actions/file_writer'
 
-# condition tests (need to be defined before the condition DSL)
+# condition tests
 require 'producer/core/test'
 require 'producer/core/tests/condition_test'
 require 'producer/core/tests/file_contains'
@@ -27,17 +27,15 @@ require 'producer/core/tests/shell_command_status'
 
 require 'producer/core/cli'
 require 'producer/core/condition'
-require 'producer/core/condition/dsl'
 require 'producer/core/env'
 require 'producer/core/errors'
 require 'producer/core/logger_formatter'
 require 'producer/core/prompter'
 require 'producer/core/recipe'
-require 'producer/core/recipe/dsl'
+require 'producer/core/recipe/file_evaluator'
 require 'producer/core/remote'
 require 'producer/core/remote/environment'
 require 'producer/core/remote/fs'
 require 'producer/core/task'
-require 'producer/core/task/dsl'
 require 'producer/core/version'
 require 'producer/core/worker'

data/spec/producer/core/condition_spec.rb

@@ -2,45 +2,128 @@ require 'spec_helper'
 
 module Producer::Core
   describe Condition do
-    let(:test_ok)       { double 'test', pass?: true }
-    let(:test_ko)       { double 'test', pass?: false }
-    let(:tests)         { [test_ok, test_ko] }
-    subject(:condition) { Condition.new(tests) }
+    subject(:condition) { described_class.new }
+
+    %w[
+      `
+      sh
+      file_contains
+      file_eq
+      dir?
+      env?
+      executable?
+      file?
+    ].each do |test|
+      it "has `#{test}' test defined" do
+        expect(condition).to respond_to test.to_sym
+      end
+    end
+
+    describe '.define_test' do
+      let(:some_test) { Test }
+
+      before { described_class.define_test(:some_test, some_test) }
+
+      it 'defines a new test keyword' do
+        expect(condition).to respond_to :some_test
+      end
+
+      it 'defines the negated test' do
+        expect(condition).to respond_to :no_some_test
+      end
+
+      context 'when a test keyword is called' do
+        it 'registers the test' do
+          expect { condition.some_test }.to change { condition.tests.count }.by 1
+        end
+
+        it 'registers the test with assigned env' do
+          env = double 'env'
+          condition.instance_eval { @env = env }
+          condition.some_test
+          expect(condition.tests.last.env).to be env
+        end
+
+        it 'registers the test with given arguments' do
+          condition.some_test :foo, :bar
+          expect(condition.tests.last.arguments).to eq %i[foo bar]
+        end
+
+        context 'when given test is callable' do
+          let(:some_test) { proc { } }
+
+          before { condition.some_test }
+
+          it 'registers a condition test' do
+            expect(condition.tests.last).to be_a Tests::ConditionTest
+          end
+
+          it 'registers the test with given block' do
+            expect(condition.tests.last.condition_block).to be some_test
+          end
+
+          it 'registers the test with given arguments' do
+            condition.some_test :foo, :bar
+            expect(condition.tests.last.condition_args).to eq %i[foo bar]
+          end
+        end
+      end
+
+      context 'when a negated test keyword is called' do
+        it 'registers a negated test' do
+          condition.no_some_test
+          expect(condition.tests.last).to be_negated
+        end
+      end
+    end
 
     describe '.evaluate' do
-      let(:env)             { double 'env' }
-      let(:block)           { proc { some_test; :some_return_value } }
-      let(:some_test_class) { Class.new(Test) }
-      subject(:condition)   { described_class.evaluate(env, &block) }
+      let(:env)           { double 'env' }
+      let(:code)          { proc { some_test; :some_return_value } }
+      let(:some_test)     { Class.new(Test) }
+      let(:arguments)     { [] }
+      subject(:condition) { described_class.evaluate(env, *arguments, &code) }
 
-      before { Condition::DSL.define_test(:some_test, some_test_class) }
+      before { described_class.define_test(:some_test, some_test) }
 
       it 'returns an evaluated condition' do
+        expect(condition).to be_a Condition
+      end
+
+      it 'evaluates the condition tests' do
         expect(condition.tests.first).to be_a Test
+      end
+
+      it 'evaluates the condition return value' do
         expect(condition.return_value).to eq :some_return_value
       end
+
+      context 'when arguments are given' do
+        let(:code)      { proc { |a, b| throw a } }
+        let(:arguments) { %i[foo bar] }
+
+        it 'passes arguments as block parameters' do
+          expect { condition }
+            .to throw_symbol :foo
+        end
+      end
     end
 
     describe '#initialize' do
-      it 'assigns the tests' do
-        expect(condition.tests).to eq tests
+      it 'assigns no tests' do
+        expect(condition.tests).to be_empty
       end
 
-      it 'assigns nil as a default return value' do
+      it 'assigns the return value as nil' do
         expect(condition.return_value).to be nil
       end
-
-      context 'when a return value is given as argument' do
-        let(:return_value)  { :some_return_value }
-        subject(:condition) { described_class.new(tests, return_value) }
-
-        it 'assigns the return value' do
-          expect(condition.return_value).to eq return_value
-        end
-      end
     end
 
     describe '#met?' do
+      let(:test_ok)       { instance_spy Test, pass?: true }
+      let(:test_ko)       { instance_spy Test, pass?: false }
+      subject(:condition) { described_class.new(tests) }
+
       context 'when all tests are successful' do
         let(:tests) { [test_ok, test_ok] }
 
@@ -58,6 +141,7 @@ module Producer::Core
       end
 
       context 'when there are no test' do
+        let(:tests)         { [] }
         subject(:condition) { described_class.new([], return_value) }
 
         context 'and return value is truthy' do

data/spec/producer/core/recipe/file_evaluator_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Producer::Core
+  class Recipe
+    describe FileEvaluator do
+      include FixturesHelpers
+
+      describe '.evaluate' do
+        let(:env)         { Env.new }
+        let(:file_path)   { fixture_path_for 'recipes/some_recipe.rb' }
+        subject(:recipe)  { described_class.evaluate(file_path, env) }
+
+        it 'returns an evaluated recipe' do
+          expect(recipe.tasks).to match [
+            an_object_having_attributes(name: :some_task),
+            an_object_having_attributes(name: :another_task)
+          ]
+        end
+      end
+    end
+  end
+end

data/spec/producer/core/recipe_spec.rb

@@ -4,33 +4,92 @@ module Producer::Core
   describe Recipe do
     include FixturesHelpers
 
-    subject(:recipe) { Recipe.new }
+    let(:env)         { Env.new }
+    subject(:recipe)  { described_class.new(env) }
 
-    describe '.evaluate_from_file' do
-      let(:env)         { double 'env' }
-      let(:filepath)    { fixture_path_for 'recipes/some_recipe.rb' }
-      subject(:recipe)  { Recipe.evaluate_from_file(filepath, env) }
+    describe '#initialize' do
+      it 'assigns no task' do
+        expect(recipe.tasks).to be_empty
+      end
+    end
+
+    describe '#source' do
+      let(:filepath) { fixture_path_for 'recipes/throw' }
 
-      it 'returns an evaluated recipe' do
-        expect(recipe.tasks.map(&:name)).to eq [:some_task, :another_task]
+      it 'sources the recipe given as argument' do
+        expect { recipe.source filepath }.to throw_symbol :recipe_code
       end
     end
 
-    describe '#initialize' do
-      context 'without arguments' do
-        it 'assigns no task' do
-          expect(recipe.tasks).to be_empty
+    describe '#target' do
+      let(:host) { 'some_host.example' }
+
+      context 'when env has no assigned target' do
+        it 'registers the target host in the env' do
+          recipe.target host
+          expect(env.target).to eq host
         end
       end
 
-      context 'when tasks are given as argument' do
-        let(:tasks)       { [double('task')] }
-        subject(:recipe)  { Recipe.new(tasks) }
+      context 'when env has an assigned target' do
+        before { env.target = 'already_assigned_host.example' }
 
-        it 'assigns the tasks' do
-          expect(recipe.tasks).to eq tasks
+        it 'does not change env target' do
+          expect { recipe.target host }.not_to change { env.target }
         end
       end
     end
+
+    describe '#task' do
+      it 'registers a new evaluated task' do
+        expect { recipe.task(:some_task) { :some_task_code } }
+          .to change { recipe.tasks.count }.by 1
+      end
+    end
+
+    describe '#macro' do
+      it 'defines the new recipe keyword' do
+        recipe.macro :hello
+        expect(recipe).to respond_to(:hello)
+      end
+
+      context 'when a defined macro is called' do
+        before { recipe.macro(:hello) { :some_macro_code } }
+
+        it 'registers the new task' do
+          expect { recipe.hello }.to change { recipe.tasks.count }.by 1
+        end
+      end
+
+      context 'when a defined macro is called with arguments' do
+        before { recipe.macro(:hello) { |a, b| echo a, b } }
+
+        it 'evaluates task code with given arguments' do
+          recipe.hello :foo, :bar
+          expect(recipe.tasks.first.actions.first.arguments).to eq %i[foo bar]
+        end
+      end
+    end
+
+    describe '#test_macro' do
+      it 'defines the new test' do
+        recipe.test_macro(:some_test) { }
+        expect(Condition.new).to respond_to :some_test
+      end
+    end
+
+    describe '#set' do
+      it 'registers a key/value pair in env registry' do
+        recipe.set :some_key, :some_value
+        expect(env[:some_key]).to eq :some_value
+      end
+    end
+
+    describe '#get' do
+      it 'fetches a value from the registry at given index' do
+        recipe.set :some_key, :some_value
+        expect(recipe.get :some_key).to eq :some_value
+      end
+    end
   end
 end