producer-core 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69bc1d881cfd85eea00037b60c396d9b09bf7bdd
-  data.tar.gz: 6d440b7bd0beb137b073d00c2096222bb7f2b58a
+  metadata.gz: 459e9b701305da92f97559b14552a99a244d3df2
+  data.tar.gz: 9803a517b543aba2e7f7eb23de3eb59eee7696df
 SHA512:
-  metadata.gz: 837737ed2a5bc77959a9c0e7c8295acdc7a997884a63fd286035cb9d811191ac7097d93ed5fb3e24c0c8c0afe22db4d05ca6b45afefcc4f5a69af34da3595e74
-  data.tar.gz: 098654fa4620affd4eac4b89fb8906a57537c13b134b9ab8c1a47e48cff83cce96d48b8cdbeed4cd50df2de4e95fbdfa7cd9589c4f5be04dedee3810630cc26d
+  metadata.gz: 027259efb32585c69b5f05c8aac66a8b5917037b33f4d82ea727eb8946a897229e4e546c1e395b27a7dd501321fdc247bccb475a03146c4227ed850045cdc5ca
+  data.tar.gz: 2aa5aa800650d057e0a6b13aca136c56c615c8d572879dc56d010bacf97fe4b5d0607b8b96af3f576d6b002eac3b045a07d4f2ba90dce6d6771f9823001b1a8b

data/features/recipes/macro.feature

@@ -0,0 +1,40 @@
+Feature: `macro' recipe keyword
+
+  Scenario: declares new keyword accepting task code
+    Given a recipe with:
+      """
+      macro :hello do
+        echo 'hello macro'
+      end
+
+      hello
+      """
+    When I successfully execute the recipe
+    Then the output must contain "hello macro"
+
+  Scenario: supports arguments
+    Given a recipe with:
+      """
+      macro :my_echo do |kind, message|
+        echo "#{kind}: #{message}"
+      end
+
+      my_echo 'my', 'hello'
+      """
+    When I successfully execute the recipe
+    Then the output must contain "my: hello"
+
+  Scenario: supports arguments in conditions
+    Given a recipe with:
+      """
+      macro :my_echo do |message|
+        condition { message =~ /bar/ }
+
+        echo message
+      end
+
+      %w[foo bar].each { |e| my_echo e }
+      """
+    When I successfully execute the recipe
+    Then the output must not contain "foo"
+    And the output must contain "bar"

data/lib/producer/core/cli.rb

@@ -1,10 +1,10 @@
 module Producer
   module Core
     class CLI
-      attr_reader :arguments
-
       USAGE = "Usage: #{File.basename $0} recipe_file"
 
+      attr_reader :arguments
+
       def initialize(arguments, stdout = $stdout)
         @stdout     = stdout
         @arguments  = arguments

data/lib/producer/core/condition.rb

@@ -3,7 +3,9 @@ module Producer
     class Condition
       class << self
         def evaluate(env, &block)
-          DSL.evaluate(env, &block)
+          dsl = DSL.new(env, &block)
+          return_value = dsl.evaluate
+          Condition.new(dsl.tests, return_value)
         end
       end
 

data/lib/producer/core/condition/dsl.rb

@@ -3,12 +3,6 @@ module Producer
     class Condition
       class DSL
         class << self
-          def evaluate(env, &block)
-            dsl = new(env, &block)
-            return_value = dsl.evaluate
-            Condition.new(dsl.tests, return_value)
-          end
-
           def define_test(keyword, klass)
             define_method(keyword) do |*args|
               @tests << klass.new(@env, *args)

data/lib/producer/core/recipe.rb

@@ -1,12 +1,15 @@
 module Producer
   module Core
     class Recipe
-      attr_accessor :tasks
-
-      def self.evaluate_from_file(filepath, env)
-        DSL.evaluate(File.read(filepath), env)
+      class << self
+        def evaluate_from_file(filepath, env)
+          dsl = DSL.new(File.read(filepath)).evaluate(env)
+          Recipe.new(dsl.tasks)
+        end
       end
 
+      attr_accessor :tasks
+
       def initialize(tasks = [])
         @tasks = tasks
       end

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

@@ -4,11 +4,6 @@ module Producer
       class DSL
         attr_reader :tasks
 
-        def self.evaluate(code, env)
-          dsl = new(code).evaluate(env)
-          Recipe.new(dsl.tasks)
-        end
-
         def initialize(code = nil, &block)
           @code   = code
           @block  = block
@@ -39,8 +34,14 @@ module Producer
           env.target = hostname
         end
 
-        def task(name, &block)
-          @tasks << Task.evaluate(name, env, &block)
+        def task(name, *args, &block)
+          @tasks << Task.evaluate(name, env, *args, &block)
+        end
+
+        def macro(name, &block)
+          define_singleton_method(name) do |*args|
+            task("#{name}", *args, &block)
+          end
         end
       end
     end

data/lib/producer/core/remote.rb

@@ -34,7 +34,7 @@ module Producer
               output << data
             end
 
-            ch.on_request('exit-status') do |c, data|
+            ch.on_request 'exit-status' do |c, data|
               exit_status = data.read_long
               raise RemoteCommandExecutionError if exit_status != 0
             end

data/lib/producer/core/task.rb

@@ -1,12 +1,16 @@
 module Producer
   module Core
     class Task
-      attr_reader :name, :actions, :condition
-
-      def self.evaluate(name, env, &block)
-        DSL.evaluate(name, env, &block)
+      class << self
+        def evaluate(name, env, *args, &block)
+          dsl = DSL.new(&block)
+          dsl.evaluate(env, *args)
+          Task.new(name, dsl.actions, dsl.condition)
+        end
       end
 
+      attr_reader :name, :actions, :condition
+
       def initialize(name, actions = [], condition = true)
         @name       = name
         @actions    = actions

data/lib/producer/core/task/dsl.rb

@@ -3,12 +3,6 @@ module Producer
     class Task
       class DSL
         class << self
-          def evaluate(name, env, &block)
-            dsl = new(&block)
-            dsl.evaluate(env)
-            Task.new(name, dsl.actions, dsl.condition)
-          end
-
           def define_action(keyword, klass)
             define_method(keyword) do |*args|
               @actions << klass.new(@env, *args)
@@ -29,9 +23,9 @@ module Producer
           @condition  = true
         end
 
-        def evaluate(env)
+        def evaluate(env, *args)
           @env = env
-          instance_eval &@block
+          instance_exec *args, &@block
         end
 
         def condition(&block)

data/lib/producer/core/version.rb

@@ -1,5 +1,5 @@
 module Producer
   module Core
-    VERSION = '0.1.6'
+    VERSION = '0.1.7'
   end
 end

data/spec/producer/core/condition/dsl_spec.rb

@@ -12,33 +12,6 @@ module Producer::Core
       end
     end
 
-    describe '.evaluate' do
-      it 'builds a new DSL sandbox with given env and code' do
-        expect(Condition::DSL)
-          .to receive(:new).with(env, &block).and_call_original
-        Condition::DSL.evaluate(env, &block)
-      end
-
-      it 'evaluates the DSL sandbox code' do
-        dsl = double('dsl').as_null_object
-        allow(Condition::DSL).to receive(:new) { dsl }
-        expect(dsl).to receive :evaluate
-        Condition::DSL.evaluate(env, &block)
-      end
-
-      it 'builds a condition with its test and block return value' do
-        expect(Condition)
-          .to receive(:new).with(dsl.tests, :some_condition_code)
-        Condition::DSL.evaluate(env, &block)
-      end
-
-      it 'returns the condition' do
-        condition = double 'task'
-        allow(Condition).to receive(:new) { condition }
-        expect(Condition::DSL.evaluate(env, &block)).to be condition
-      end
-    end
-
     describe '.define_test' do
       let(:some_test_class) { double 'SomeTest class' }
 

data/spec/producer/core/condition_spec.rb

@@ -11,17 +11,28 @@ module Producer::Core
       let(:env)   { double 'env' }
       let(:block) { proc { :some_condition_code } }
 
-      it 'delegates to DSL.evaluate' do
+      it 'builds a new DSL sandbox with given env and code' do
         expect(Condition::DSL)
-          .to receive(:evaluate).with(env) do |&b|
-            expect(b).to be block
-          end
+          .to receive(:new).with(env, &block).and_call_original
+        Condition.evaluate(env, &block)
+      end
+
+      it 'evaluates the DSL sandbox code' do
+        dsl = double('dsl').as_null_object
+        allow(Condition::DSL).to receive(:new) { dsl }
+        expect(dsl).to receive :evaluate
+        Condition.evaluate(env, &block)
+      end
+
+      it 'builds a condition with its test and block return value' do
+        expect(Condition)
+          .to receive(:new).with([], :some_condition_code)
         Condition.evaluate(env, &block)
       end
 
-      it 'returns the evaluated condition' do
-        condition = double 'condition'
-        allow(Condition::DSL).to receive(:evaluate) { condition }
+      it 'returns the condition' do
+        condition = double 'task'
+        allow(Condition).to receive(:new) { condition }
         expect(Condition.evaluate(env, &block)).to be condition
       end
     end

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

@@ -8,35 +8,6 @@ module Producer::Core
     let(:env)     { double('env').as_null_object }
     subject(:dsl) { Recipe::DSL.new(&code) }
 
-    describe '.evaluate' do
-      let(:code) { 'nil' }
-
-      it 'builds a new DSL sandbox with given code as string' do
-        expect(Recipe::DSL).to receive(:new).with(code).and_call_original
-        Recipe::DSL.evaluate(code, env)
-      end
-
-      it 'evaluates the DSL sandbox code with given environment' do
-        dsl = double('dsl').as_null_object
-        allow(Recipe::DSL).to receive(:new) { dsl }
-        expect(dsl).to receive(:evaluate).with(env)
-        Recipe::DSL.evaluate(code, env)
-      end
-
-      it 'builds a recipe with evaluated tasks' do
-        dsl = Recipe::DSL.new { task(:some_task) { } }
-        allow(Recipe::DSL).to receive(:new) { dsl }
-        expect(Recipe).to receive(:new).with(dsl.tasks)
-        Recipe::DSL.evaluate(code, env)
-      end
-
-      it 'returns the recipe' do
-        recipe = double('recipe').as_null_object
-        allow(Recipe).to receive(:new) { recipe }
-        expect(Recipe::DSL.evaluate(code, env)).to be recipe
-      end
-    end
-
     describe '#initialize' do
       it 'assigns no task' do
         expect(dsl.instance_eval { @tasks }).to be_empty
@@ -110,11 +81,11 @@ module Producer::Core
       end
 
       describe '#task' do
-        let(:code) { proc { task(:some_task) { :some_value } } }
+        let(:code) { proc { task(:some_task, :some, :arg) { :some_value } } }
 
         it 'builds a new evaluated task' do
           expect(Task)
-            .to receive(:evaluate).with(:some_task, env) do |&b|
+            .to receive(:evaluate).with(:some_task, env, :some, :arg) do |&b|
               expect(b.call).to eq :some_value
             end
           dsl
@@ -126,6 +97,30 @@ module Producer::Core
           expect(dsl.tasks).to include(task)
         end
       end
+
+      describe '#macro' do
+        let(:code) { proc { macro(:hello) { echo 'hello' } } }
+
+        it 'defines the new recipe keyword' do
+          expect(dsl).to respond_to(:hello)
+        end
+
+        context 'when the new keyword is called' do
+          let(:code) { proc { macro(:hello) { echo 'hello' }; hello } }
+
+          it 'registers the new task' do
+            expect(dsl.tasks.first.actions.first).to be_an Actions::Echo
+          end
+        end
+
+        context 'when macro takes arguments' do
+          let(:code) { proc { macro(:hello) { |e| echo e }; hello :arg } }
+
+          it 'evaluates task code with arguments' do
+            expect(dsl.tasks.first.actions.first.arguments.first).to be :arg
+          end
+        end
+      end
     end
   end
 end

data/spec/producer/core/recipe_spec.rb

@@ -9,18 +9,33 @@ module Producer::Core
     describe '.evaluate_from_file' do
       let(:env)       { double 'env' }
       let(:filepath)  { fixture_path_for 'recipes/empty.rb' }
+      let(:code)      { File.read(filepath) }
 
-      it 'delegates to DSL.evaluate with the recipe file content' do
-        expect(Recipe::DSL)
-          .to receive(:evaluate).with(File.read(filepath), env)
+      it 'builds a new DSL sandbox with code read from given file path' do
+        expect(Recipe::DSL).to receive(:new).with(code).and_call_original
         Recipe.evaluate_from_file(filepath, env)
       end
 
-      it 'returns the evaluated recipe' do
-        recipe = double 'recipe'
-        allow(Recipe::DSL).to receive(:evaluate) { recipe }
+      it 'evaluates the DSL sandbox code with given environment' do
+        dsl = double('dsl').as_null_object
+        allow(Recipe::DSL).to receive(:new) { dsl }
+        expect(dsl).to receive(:evaluate).with(env)
+        Recipe.evaluate_from_file(filepath, env)
+      end
+
+      it 'builds a recipe with evaluated tasks' do
+        dsl = Recipe::DSL.new { task(:some_task) { } }
+        allow(Recipe::DSL).to receive(:new) { dsl }
+        expect(Recipe).to receive(:new).with(dsl.tasks)
+        Recipe.evaluate_from_file(filepath, env)
+      end
+
+      it 'returns the recipe' do
+        recipe = double('recipe').as_null_object
+        allow(Recipe).to receive(:new) { recipe }
         expect(Recipe.evaluate_from_file(filepath, env)).to be recipe
       end
+
     end
 
     describe '#initialize' do

data/spec/producer/core/task/dsl_spec.rb

@@ -12,42 +12,6 @@ module Producer::Core
       end
     end
 
-    describe '.evaluate' do
-      let(:name) { :some_task }
-
-      it 'builds a new DSL sandbox with given code' do
-        dsl = double('dsl').as_null_object
-        expect(Task::DSL).to receive(:new).with(no_args) do |&b|
-          expect(b).to be block
-          dsl
-        end
-        Task::DSL.evaluate(name, env, &block)
-      end
-
-      it 'evaluates the DSL sandbox code with given environment' do
-        dsl = double('dsl').as_null_object
-        allow(Task::DSL).to receive(:new) { dsl }
-        expect(dsl).to receive(:evaluate).with(env)
-        Task::DSL.evaluate(name, env, &block)
-      end
-
-      it 'builds a task with its name, actions and condition' do
-        dsl = double(
-          'dsl', actions: [:some_action], condition: :some_condition
-        ).as_null_object
-        allow(Task::DSL).to receive(:new) { dsl }
-        expect(Task)
-          .to receive(:new).with(:some_task, [:some_action], :some_condition)
-        Task::DSL.evaluate(name, env, &block)
-      end
-
-      it 'returns the task' do
-        task = double 'task'
-        allow(Task).to receive(:new) { task }
-        expect(Task::DSL.evaluate(name, env, &block)).to be task
-      end
-    end
-
     describe '.define_action' do
       it 'defines a new action keyword' do
         Task::DSL.define_action(:some_action, Object)
@@ -89,6 +53,15 @@ module Producer::Core
           .to throw_symbol :task_code
       end
 
+      context 'when arguments are given' do
+        let(:block) { proc { |e| throw e } }
+
+        it 'passes arguments as block parameters' do
+          expect { dsl.evaluate env, :some_argument }
+            .to throw_symbol :some_argument
+        end
+      end
+
       context 'when a defined keyword action is called' do
         let(:some_action_class) { Class.new(Action) }
         let(:block)             { proc { some_action } }

data/spec/producer/core/task_spec.rb

@@ -9,20 +9,39 @@ module Producer::Core
 
     describe '.evaluate' do
       let(:env)   { double 'env' }
+      let(:args)  { [:some, :arguments] }
       let(:block) { proc { :some_task_code } }
 
-      it 'delegates to DSL.evaluate' do
-        expect(Task::DSL)
-          .to receive(:evaluate).with(name, env) do |&b|
-            expect(b).to be block
-          end
-        Task.evaluate(name, env, &block)
+      it 'builds a new DSL sandbox with given code' do
+        dsl = double('dsl').as_null_object
+        expect(Task::DSL).to receive(:new).with(no_args) do |&b|
+          expect(b).to be block
+          dsl
+        end
+        Task.evaluate(name, env, *args, &block)
+      end
+
+      it 'evaluates the DSL sandbox code with given environment' do
+        dsl = double('dsl').as_null_object
+        allow(Task::DSL).to receive(:new) { dsl }
+        expect(dsl).to receive(:evaluate).with(env, *args)
+        Task.evaluate(name, env, *args, &block)
+      end
+
+      it 'builds the task with its name, actions and condition' do
+        dsl = double(
+          'dsl', actions: [:some_action], condition: :some_condition
+        ).as_null_object
+        allow(Task::DSL).to receive(:new) { dsl }
+        expect(Task)
+          .to receive(:new).with(:some_task, [:some_action], :some_condition)
+        Task.evaluate(name, env, *args, &block)
       end
 
-      it 'returns the evaluated task' do
+      it 'returns the task' do
         task = double 'task'
-        allow(Task::DSL).to receive(:evaluate) { task }
-        expect(Task.evaluate(name, env, &block)).to be task
+        allow(Task).to receive(:new) { task }
+        expect(Task.evaluate(name, env, *args, &block)).to be task
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: producer-core
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Thibault Jouan
@@ -114,6 +114,7 @@ files:
 - features/cli/usage.feature
 - features/recipes/env.feature
 - features/recipes/evaluation.feature
+- features/recipes/macro.feature
 - features/recipes/source.feature
 - features/recipes/target.feature
 - features/ssh/config.feature
@@ -200,7 +201,7 @@ rubyforge_project:
 rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: producer-core-0.1.6
+summary: producer-core-0.1.7
 test_files:
 - features/actions/echo.feature
 - features/actions/file_write.feature
@@ -208,6 +209,7 @@ test_files:
 - features/cli/usage.feature
 - features/recipes/env.feature
 - features/recipes/evaluation.feature
+- features/recipes/macro.feature
 - features/recipes/source.feature
 - features/recipes/target.feature
 - features/ssh/config.feature