producer-core 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c778784a6586dca4a73ef7c76bbb345ed990d3d4
-  data.tar.gz: 05ae1a88da59938098403eb45a4e98457ef6c68b
+  metadata.gz: e6a27039a047e17f8490bd070f3906b435939441
+  data.tar.gz: 7f1c4c346f1258e97f59454a6bcf3a20c6e02288
 SHA512:
-  metadata.gz: 22156c33ab610cebd1ee5f82c3f6cf60f50f3a3b2c5c7d0a6194d30fcb958635201e34b86af415b3d6885a1d0b3cbeb3c38e52a752f7457626164d37c463d379
-  data.tar.gz: 8669e86c30cb7a8be71420f85f4280c0a8b67ef61520e5c8c7f37c849a0eedaed3c1184d385ff039c3920aabef6c08f17981f199dfe22c19b133bb21545b0bda
+  metadata.gz: 1b84f00106289af7baa8f57ab9aa336eaf2f4a9114a5a7553d5431e83ec8a04b8512ed37657c1599367bd75f41f8f99fabb241eada0c3bf4c9c88c2c5a88bc80
+  data.tar.gz: c3ed29fc5633c033e6f35f83d990325d0cdbce10a8a753cbc9f1e7f063795633ad9c465bc322327963ddeb096ec3e0e6c16f6919d2ffef6b753108a52016c7e9

data/features/recipes/ask.feature

@@ -0,0 +1,22 @@
+Feature: `ask' recipe keyword
+
+  Scenario: prompts user with a list of choices on standard output
+    Given a recipe with:
+      """
+      task :ask_letter do
+        letter = ask 'Which letter?', [[:a, ?A], [:b, ?B]]
+
+        echo letter.inspect
+      end
+      """
+    When I execute the recipe interactively
+    And I type "1"
+    Then the output must contain:
+      """
+      Which letter?
+      0: A
+      1: B
+      Choice:
+      :b
+      """
+    And the exit status must be 0

data/features/steps/recipe_steps.rb

@@ -10,3 +10,7 @@ When(/^I successfully execute the recipe$/) do
   step 'I execute the recipe'
   assert_exit_status(0)
 end
+
+When(/^I execute the recipe interactively$/) do
+  run_interactive('producer recipe.rb')
+end

data/lib/producer/core.rb

@@ -14,6 +14,7 @@ require 'producer/core/condition'
 require 'producer/core/condition/dsl'
 require 'producer/core/env'
 require 'producer/core/errors'
+require 'producer/core/prompter'
 require 'producer/core/recipe'
 require 'producer/core/recipe/dsl'
 require 'producer/core/remote'

data/lib/producer/core/action.rb

@@ -4,10 +4,10 @@ module Producer
       require 'forwardable'
 
       extend Forwardable
-      def_delegators :@env, :output, :remote
+      def_delegators :@env, :input, :output, :remote
       def_delegators :remote, :fs
 
-      attr_accessor :env, :arguments
+      attr_reader :env, :arguments
 
       def initialize(env, *args)
         @env        = env

data/lib/producer/core/cli.rb

@@ -19,8 +19,7 @@ module Producer
         end
       end
 
-      attr_reader :arguments, :stdout
-      attr_accessor :recipe
+      attr_reader :arguments, :stdout, :recipe
 
       def initialize(arguments, stdout: $stdout)
         raise ArgumentError unless arguments.any?

data/lib/producer/core/condition.rb

@@ -9,6 +9,8 @@ module Producer
         end
       end
 
+      attr_reader :tests, :return_value
+
       def initialize(tests, return_value = nil)
         @tests        = tests
         @return_value = return_value

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

@@ -16,7 +16,7 @@ module Producer
         define_test :has_env,   Tests::HasEnv
         define_test :has_file,  Tests::HasFile
 
-        attr_accessor :tests
+        attr_reader :block, :env, :tests
 
         def initialize(env, &block)
           @env    = env

data/lib/producer/core/env.rb

@@ -1,9 +1,11 @@
 module Producer
   module Core
     class Env
-      attr_accessor :output, :target
+      attr_reader   :input, :output
+      attr_accessor :target
 
-      def initialize(output: $stdout)
+      def initialize(input: $stdin, output: $stdout)
+        @input  = input
         @output = output
         @target = nil
       end

data/lib/producer/core/prompter.rb

@@ -0,0 +1,21 @@
+module Producer
+  module Core
+    class Prompter
+      attr_reader :input, :output
+
+      def initialize(input, output)
+        @input  = input
+        @output = output
+      end
+
+      def prompt(question, choices)
+        cs = choices.each_with_index.inject('') do |m, (c, i)|
+          m += "#{i}: #{c.last}\n"
+        end
+        output.puts "#{question}\n#{cs}Choice:"
+        choice = input.gets
+        choices[choice.to_i].first
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@ module Producer
   module Core
     class Recipe
       class DSL
-        attr_reader :env, :tasks
+        attr_reader :env, :code, :block, :tasks
 
         def initialize(env, code = nil, &block)
           @env    = env
@@ -20,8 +20,6 @@ module Producer
           self
         end
 
-        private
-
         def source(filepath)
           instance_eval File.read("./#{filepath}.rb"), "#{filepath}.rb"
         end

data/lib/producer/core/remote.rb

@@ -4,7 +4,7 @@ module Producer
       require 'etc'
       require 'net/ssh'
 
-      attr_accessor :hostname
+      attr_reader :hostname
 
       def initialize(hostname)
         @hostname = hostname

data/lib/producer/core/remote/environment.rb

@@ -15,7 +15,9 @@ module Producer
         require 'forwardable'
 
         extend Forwardable
-        def_delegator :@variables, :key?
+        def_delegators :@variables, :[], :key?
+
+        attr_reader :variables
 
         def initialize(variables)
           @variables = variables

data/lib/producer/core/remote/fs.rb

@@ -4,6 +4,8 @@ module Producer
       class FS
         require 'net/sftp'
 
+        attr_reader :remote
+
         def initialize(remote)
           @remote = remote
         end

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

@@ -15,7 +15,7 @@ module Producer
 
         define_action :file_write,  Actions::FileWriter
 
-        attr_accessor :env, :actions
+        attr_reader :env, :block, :actions
 
         def initialize(env, &block)
           @env        = env
@@ -32,6 +32,10 @@ module Producer
           @condition = Condition.evaluate(@env, &block) if block
           @condition
         end
+
+        def ask(question, choices, prompter: Prompter)
+          prompter.new(env.input, env.output).prompt(question, choices)
+        end
       end
     end
   end

data/lib/producer/core/test.rb

@@ -1,6 +1,12 @@
 module Producer
   module Core
     class Test
+      require 'forwardable'
+
+      extend Forwardable
+      def_delegators :@env, :remote
+      def_delegators :remote, :fs
+
       attr_reader :env, :arguments
 
       def initialize(env, *arguments, negated: false)

data/lib/producer/core/tests/has_env.rb

@@ -3,7 +3,7 @@ module Producer
     module Tests
       class HasEnv < Test
         def verify
-          env.remote.environment.key? arguments.first.to_s.upcase
+          remote.environment.key? arguments.first.to_s.upcase
         end
       end
     end

data/lib/producer/core/tests/has_file.rb

@@ -3,7 +3,7 @@ module Producer
     module Tests
       class HasFile < Test
         def verify
-          env.remote.fs.file? arguments.first
+          fs.file? arguments.first
         end
       end
     end

data/lib/producer/core/version.rb

@@ -1,5 +1,5 @@
 module Producer
   module Core
-    VERSION = '0.1.10'
+    VERSION = '0.1.11'
   end
 end

data/spec/producer/core/action_spec.rb

@@ -2,8 +2,9 @@ require 'spec_helper'
 
 module Producer::Core
   describe Action do
+    let(:input)       { StringIO.new }
     let(:output)      { StringIO.new }
-    let(:env)         { Env.new(output: output) }
+    let(:env)         { Env.new(input: input, output: output) }
     let(:arguments)   { [:some, :arguments] }
     subject(:action)  { Action.new(env, *arguments) }
 
@@ -19,6 +20,12 @@ module Producer::Core
       end
     end
 
+    describe '#input' do
+      it 'returns env input' do
+        expect(action.input).to be input
+      end
+    end
+
     describe '#output' do
       it 'delegates to env output' do
         action.output.puts 'some content'

data/spec/producer/core/cli_spec.rb

@@ -53,7 +53,9 @@ module Producer::Core
       context 'without arguments' do
         let(:arguments) { [] }
 
-        specify { expect { cli }.to raise_error described_class::ArgumentError }
+        it 'raises our ArgumentError exception' do
+          expect { cli }.to raise_error described_class::ArgumentError
+        end
       end
     end
 
@@ -69,14 +71,6 @@ module Producer::Core
       end
     end
 
-    describe '#recipe' do
-      it 'returns the assigned recipe' do
-        recipe = double 'recipe'
-        cli.recipe = recipe
-        expect(cli.recipe).to be recipe
-      end
-    end
-
     describe '#run' do
       it 'loads the recipe' do
         cli.run

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

@@ -13,7 +13,7 @@ module Producer::Core
     end
 
     describe '.define_test' do
-      let(:some_test_class) { double 'SomeTest class' }
+      let(:some_test_class) { Test }
 
       before { Condition::DSL.define_test(:some_test, some_test_class) }
 
@@ -24,15 +24,38 @@ module Producer::Core
       it 'defines the negated test' do
         expect(dsl).to respond_to :no_some_test
       end
+
+      context 'when a test keyword is called' do
+        it 'registers the test' do
+          expect { dsl.some_test }.to change { dsl.tests.count }.by 1
+        end
+
+        it 'registers the test with current env' do
+          dsl.some_test
+          expect(dsl.tests.first.env).to be env
+        end
+
+        it 'registers the test with given arguments' do
+          dsl.some_test :some, :args
+          expect(dsl.tests.first.arguments).to eq [:some, :args]
+        end
+      end
+
+      context 'when a negated test keyword is called' do
+        it 'registers a negated test' do
+          dsl.no_some_test
+          expect(dsl.tests.first).to be_negated
+        end
+      end
     end
 
     describe '#initialize' do
-      it 'assigns the code' do
-        expect(dsl.instance_eval { @block }).to be block
+      it 'assigns the env' do
+        expect(dsl.env).to be env
       end
 
-      it 'assigns the env' do
-        expect(dsl.instance_eval { @env }).to be env
+      it 'assigns the code' do
+        expect(dsl.block).to be block
       end
 
       it 'assigns no test' do
@@ -40,46 +63,15 @@ module Producer::Core
       end
     end
 
-    describe '#tests' do
-      it 'returns the assigned tests' do
-        dsl.instance_eval { @tests = [:some_test] }
-        expect(dsl.tests).to eq [:some_test]
+    describe '#evaluate' do
+      it 'evaluates its code' do
+        dsl = described_class.new(env) { throw :condition_code }
+        expect { dsl.evaluate }.to throw_symbol :condition_code
       end
-    end
 
-    describe '#evaluate' do
       it 'returns the value returned by the assigned block' do
         expect(dsl.evaluate).to eq block.call
       end
-
-      context 'when a defined test keyword is called' do
-        let(:some_test_class) { double 'SomeTest class' }
-        let(:block)           { proc { some_test :some, :args } }
-
-        before { Condition::DSL.define_test(:some_test, some_test_class) }
-
-        it 'builds a new test with the env and given arguments' do
-          expect(some_test_class).to receive(:new).with(env, :some, :args)
-          dsl.evaluate
-        end
-
-        it 'registers the new test' do
-          some_test = double 'SomeTest instance'
-          allow(some_test_class).to receive(:new) { some_test }
-          dsl.evaluate
-          expect(dsl.tests).to include(some_test)
-        end
-
-        context 'when keyword is prefixed with "no_"' do
-          let(:block) { proc { no_some_test :some, :args } }
-
-          it 'builds a negated test' do
-            expect(some_test_class)
-              .to receive(:new).with(env, :some, :args, negated: true)
-            dsl.evaluate
-          end
-        end
-      end
     end
   end
 end

data/spec/producer/core/condition_spec.rb

@@ -2,56 +2,40 @@ require 'spec_helper'
 
 module Producer::Core
   describe Condition do
-    include TestsHelpers
-
+    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) }
 
     describe '.evaluate' do
-      let(:env)   { double 'env' }
-      let(:block) { proc { :some_condition_code } }
-
-      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.evaluate(env, &block)
-      end
+      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) }
 
-      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
+      before { Condition::DSL.define_test(:some_test, some_test_class) }
 
-      it 'returns the condition' do
-        condition = double 'task'
-        allow(Condition).to receive(:new) { condition }
-        expect(Condition.evaluate(env, &block)).to be condition
+      it 'returns an evaluated condition' do
+        expect(condition.tests.first).to be_a Test
+        expect(condition.return_value).to eq :some_return_value
       end
     end
 
     describe '#initialize' do
       it 'assigns the tests' do
-        expect(condition.instance_eval { @tests }).to eq tests
+        expect(condition.tests).to eq tests
       end
 
       it 'assigns nil as a default return value' do
-        expect(condition.instance_eval { @return_value }).to be nil
+        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) { Condition.new(tests, return_value) }
+        subject(:condition) { described_class.new(tests, return_value) }
 
         it 'assigns the return value' do
-          expect(condition.instance_eval { @return_value }).to eq return_value
+          expect(condition.return_value).to eq return_value
         end
       end
     end
@@ -74,7 +58,7 @@ module Producer::Core
       end
 
       context 'when there are no test' do
-        subject(:condition) { Condition.new([], return_value) }
+        subject(:condition) { described_class.new([], return_value) }
 
         context 'and return value is truthy' do
           let(:return_value) { :some_truthy_value }

data/spec/producer/core/env_spec.rb

@@ -2,32 +2,37 @@ require 'spec_helper'
 
 module Producer::Core
   describe Env do
-    let(:output)  { double 'output' }
     subject(:env) { Env.new }
 
     describe '#initialize' do
+      it 'assigns $stdin as the default output' do
+        expect(env.input).to be $stdin
+      end
+
       it 'assigns $stdout as the default output' do
-        expect(env.instance_eval { @output }).to eq $stdout
+        expect(env.output).to be $stdout
       end
 
       it 'assigns no default target' do
         expect(env.target).not_to be
       end
 
-      context 'when output is given as argument' do
-        subject(:env) { Env.new(output: output) }
+      context 'when input is given as argument' do
+        let(:input)   { double 'input' }
+        subject(:env) { described_class.new(input: input) }
 
-        it 'assigns the given output' do
-          expect(env.instance_eval { @output }).to eq output
+        it 'assigns the given input' do
+          expect(env.input).to eq input
         end
       end
-    end
 
-    describe '#output' do
-      subject(:env) { Env.new(output: output) }
+      context 'when output is given as argument' do
+        let(:output)  { double 'output' }
+        subject(:env) { described_class.new(output: output) }
 
-      it 'returns the assigned output' do
-        expect(env.output).to eq output
+        it 'assigns the given output' do
+          expect(env.output).to eq output
+        end
       end
     end
 

data/spec/producer/core/prompter_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Producer::Core
+  describe Prompter do
+    let(:input)         { StringIO.new }
+    let(:output)        { StringIO.new }
+    let(:env)           { Env.new(input: input, output: output) }
+    subject(:prompter)  { Prompter.new(input, output) }
+
+    describe '#initialize' do
+      it 'assigns the given input' do
+        expect(prompter.input).to be input
+      end
+
+      it 'assigns the given output' do
+        expect(prompter.output).to be output
+      end
+    end
+
+    describe '#prompt' do
+      let(:question)  { 'Which letter?' }
+      let(:choices)   { [[:a, ?A], [:b, ?B]] }
+
+      it 'prompts choices' do
+        prompter.prompt question, choices
+        expect(output.string).to eq <<-eoh.gsub /^\s+\|/, ''
+          |#{question}
+          |0: A
+          |1: B
+          |Choice:
+        eoh
+      end
+
+      it 'returns value for entry chosen by user' do
+        input.puts '1'
+        input.rewind
+        expect(prompter.prompt question, choices).to eq :b
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Producer::Core
     include FixturesHelpers
 
     let(:code)    { proc { :some_recipe_code } }
-    let(:env)     { double('env').as_null_object }
+    let(:env)     { Env.new }
     subject(:dsl) { Recipe::DSL.new(env, &code) }
 
     describe '#initialize' do
@@ -19,16 +19,16 @@ module Producer::Core
 
       context 'when a string of code is given as argument' do
         let(:code)    { 'some_code' }
-        subject(:dsl) { Recipe::DSL.new(env, code) }
+        subject(:dsl) { described_class.new(env, code) }
 
         it 'assigns the string of code' do
-          expect(dsl.instance_eval { @code }).to eq code
+          expect(dsl.code).to eq code
         end
       end
 
       context 'when a code block is given as argument' do
         it 'assigns the code block' do
-          expect(dsl.instance_eval { @block }).to be code
+          expect(dsl.block).to be code
         end
       end
     end
@@ -44,7 +44,7 @@ module Producer::Core
 
     describe '#evaluate' do
       it 'evaluates its code' do
-        dsl = Recipe::DSL.new(env) { throw :recipe_code }
+        dsl = described_class.new(env) { throw :recipe_code }
         expect { dsl.evaluate }.to throw_symbol :recipe_code
       end
 
@@ -53,76 +53,50 @@ module Producer::Core
       end
     end
 
-    context 'DSL specific methods' do
-      subject(:dsl) { Recipe::DSL.new(env, &code).evaluate }
+    describe '#source' do
+      let(:filepath)  { fixture_path_for 'recipes/throw' }
 
-      describe '#env' do
-        let(:code) { proc { env.some_message } }
-
-        it 'returns the current environment' do
-          expect(env).to receive :some_message
-          dsl.evaluate
-        end
+      it 'sources the recipe given as argument' do
+        expect { dsl.source filepath }.to throw_symbol :recipe_code
       end
+    end
 
-      describe '#source' do
-        let(:filepath)  { fixture_path_for 'recipes/throw' }
-        let(:code)      { "source '#{filepath}'" }
-        subject(:dsl)   { Recipe::DSL.new(env, code) }
+    describe '#target' do
+      let(:host) { 'some_host.example' }
 
-        it 'sources the recipe given as argument' do
-          expect { dsl.evaluate }.to throw_symbol :recipe_code
-        end
+      it 'registers the target host in the env' do
+        dsl.target host
+        expect(env.target).to eq host
       end
+    end
 
-      describe '#target' do
-        let(:code) { proc { target 'some_host.example' } }
-
-        it 'registers the target host in the env' do
-          expect(env).to receive(:target=).with('some_host.example')
-          dsl
-        end
+    describe '#task' do
+      it 'registers a new evaluated task' do
+        expect { dsl.task(:some_task) { :some_task_code } }
+          .to change { dsl.tasks.count }.by 1
       end
+    end
 
-      describe '#task' do
-        let(:code) { proc { task(:some_task, :some, :arg) { :some_value } } }
+    describe '#macro' do
+      it 'defines the new recipe keyword' do
+        dsl.macro :hello
+        expect(dsl).to respond_to(:hello)
+      end
 
-        it 'builds a new evaluated task' do
-          expect(Task)
-            .to receive(:evaluate).with(:some_task, env, :some, :arg) do |&b|
-              expect(b.call).to eq :some_value
-            end
-          dsl
-        end
+      context 'when a defined macro is called' do
+        before { dsl.macro(:hello) { :some_macro_code } }
 
         it 'registers the new task' do
-          task = double('task').as_null_object
-          allow(Task).to receive(:new) { task }
-          expect(dsl.tasks).to include(task)
+          expect { dsl.hello }.to change { dsl.tasks.count }.by 1
         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 } }
+      context 'when a defined macro is called with arguments' do
+        before { dsl.macro(:hello) { |a, b| echo a, b } }
 
-          it 'evaluates task code with arguments' do
-            expect(dsl.tasks.first.actions.first.arguments.first).to be :arg
-          end
+        it 'evaluates task code with arguments' do
+          dsl.hello :some, :args
+          expect(dsl.tasks.first.actions.first.arguments).to eq [:some, :args]
         end
       end
     end

data/spec/producer/core/remote/environment_spec.rb

@@ -9,37 +9,40 @@ module Producer::Core
 
     describe '.string_to_hash' do
       it 'converts key=value pairs separated by new lines to a hash' do
-        expect(Remote::Environment.string_to_hash(string))
-          .to eq variables
+        expect(described_class.string_to_hash(string)).to eq variables
       end
     end
 
     describe '.new_from_string' do
-      it 'builds a new instance after converting from string' do
-        expect(Remote::Environment).to receive(:new).with(variables)
-        Remote::Environment.new_from_string(string)
-      end
-
-      it 'returns the instance' do
-        environment = double 'environment'
-        allow(Remote::Environment).to receive(:new) { environment }
-        expect(Remote::Environment.new_from_string(string)).to be environment
+      it 'returns a new instance with converted keys and values' do
+        environment = described_class.new_from_string string
+        expect(environment.variables).to eq variables
       end
     end
 
     describe '#initialize' do
       it 'assigns the key/value pairs' do
-        expect(environment.instance_eval { @variables }).to eq variables
+        expect(environment.variables).to eq variables
       end
     end
 
     describe '#key?' do
-      let(:key) { 'SOME_KEY' }
+      context 'when key is defined' do
+        it 'returns true' do
+          expect(environment.key? 'FOO').to be true
+        end
+      end
+
+      context 'when key is not defined' do
+        it 'returns false' do
+          expect(environment.key? 'INEXISTENT_KEY').to be false
+        end
+      end
+    end
 
-      it 'forwards the message to @variables' do
-        expect(environment.instance_eval { @variables })
-          .to receive(:key?).with(key)
-        environment.key? key
+    describe '#[]' do
+      it 'returns the value indexed by given key' do
+        expect(environment['FOO']).to eq 'bar'
       end
     end
   end

data/spec/producer/core/remote/fs_spec.rb

@@ -7,7 +7,7 @@ module Producer::Core
 
     describe '#new' do
       it 'assigns the remote given as argument' do
-        expect(fs.instance_eval { @remote }).to be remote
+        expect(fs.remote).to be remote
       end
     end
 

data/spec/producer/core/remote_spec.rb

@@ -5,8 +5,8 @@ module Producer::Core
     let(:hostname)    { 'some_host.example' }
     subject(:remote)  { Remote.new(hostname) }
 
-    describe '#hostname' do
-      it 'returns the assignated hostname' do
+    describe '#initialize' do
+      it 'assigns the given hostname' do
         expect(remote.hostname).to eq hostname
       end
     end
@@ -116,26 +116,14 @@ module Producer::Core
       end
     end
 
-    describe '#environment', :ssh do
+    describe '#environment' do
       let(:command) { 'env' }
-      let(:output)  { "FOO=bar\nBAZ=qux" }
+      let(:output)  { 'FOO=bar' }
 
-      before do
-        story_with_new_channel do |ch|
-          ch.sends_exec command
-          ch.gets_data output
-        end
-      end
-
-      it 'builds a remote environment with the result of `env` command' do
-        expect(Remote::Environment).to receive(:new_from_string).with(output)
-        remote.environment
-      end
+      before { allow(remote).to receive(:execute) { output } }
 
-      it 'returns the environment' do
-        environment = double 'environment'
-        allow(Remote::Environment).to receive(:new_from_string) { environment }
-        expect(remote.environment).to be environment
+      it 'returns a remote environment' do
+        expect(remote.environment['FOO']).to eq 'bar'
       end
     end
   end

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Producer::Core
   describe Task::DSL do
     let(:block)   { proc {} }
-    let(:env)     { double 'env' }
+    let(:env)     { Env.new }
     subject(:dsl) { Task::DSL.new(env, &block) }
 
     %w[echo sh file_write].each do |action|
@@ -13,10 +13,29 @@ module Producer::Core
     end
 
     describe '.define_action' do
+      let(:some_action_class) { Class.new(Action) }
+
+      before { described_class.define_action(:some_action, some_action_class) }
+
       it 'defines a new action keyword' do
-        Task::DSL.define_action(:some_action, Object)
         expect(dsl).to respond_to :some_action
       end
+
+      context 'when an action keyword is called' do
+        it 'registers the action' do
+          expect { dsl.some_action }.to change { dsl.actions.count }.by 1
+        end
+
+        it 'registers the action with current env' do
+          dsl.some_action
+          expect(dsl.actions.first.env).to be env
+        end
+
+        it 'registers the action with given arguments' do
+          dsl.some_action :some, :args
+          expect(dsl.actions.first.arguments).to eq [:some, :args]
+        end
+      end
     end
 
     describe '#initialize' do
@@ -24,28 +43,16 @@ module Producer::Core
         expect(dsl.env).to be env
       end
 
+      it 'assigns the given block' do
+        expect(dsl.block).to be block
+      end
+
       it 'assigns no action' do
         expect(dsl.actions).to be_empty
       end
 
       it 'assigns true as the condition' do
-        expect(dsl.instance_eval { @condition }).to be true
-      end
-    end
-
-    describe '#actions' do
-      it 'returns the assigned actions' do
-        dsl.instance_eval { @actions = [:some_action] }
-        expect(dsl.actions).to eq [:some_action]
-      end
-    end
-
-    describe '#condition' do
-      context 'without block' do
-        it 'returns the assigned condition' do
-          dsl.instance_eval { @condition = :some_condition }
-          expect(dsl.condition).to be :some_condition
-        end
+        expect(dsl.condition).to be true
       end
     end
 
@@ -65,47 +72,34 @@ module Producer::Core
             .to throw_symbol :some_argument
         end
       end
+    end
 
-      context 'when a defined keyword action is called' do
-        let(:some_action_class) { Class.new(Action) }
-        let(:block)             { proc { some_action } }
-
-        before do
-          Task::DSL.define_action(:some_action, some_action_class)
-          dsl.evaluate
+    describe '#condition' do
+      context 'when a block is given' do
+        it 'assigns a new evaluated condition' do
+          dsl.condition { :some_return_value }
+          expect(dsl.condition.return_value).to eq :some_return_value
         end
+      end
+    end
 
-        it 'registers the action' do
-          expect(dsl.actions.first).to be_an Action
-        end
+    describe '#ask' do
+      let(:question)        { 'Which letter?' }
+      let(:choices)         { [[:a, ?A], [:b, ?B]] }
+      let(:prompter_class)  { double('prompter class').as_null_object }
+      subject(:ask)         { dsl.ask question, choices,
+                              prompter: prompter_class }
 
-        it 'provides the env to the registered action' do
-          expect(dsl.actions.first.env).to eq env
-        end
+      it 'builds a prompter' do
+        expect(prompter_class).to receive(:new).with(env.input, env.output)
+        ask
       end
-    end
 
-    context 'DSL specific methods' do
-      subject(:dsl) { Task::DSL.new(env, &block).evaluate }
-
-      describe '#condition' do
-        context 'when a block is given' do
-          let(:block) { proc { condition { :some_value } } }
-
-          it 'builds a new evaluated condition' do
-            expect(Condition)
-              .to receive :evaluate do |&b|
-                expect(b.call).to eq :some_value
-              end
-            dsl
-          end
-
-          it 'assigns the new condition' do
-            condition = double('condition').as_null_object
-            allow(Condition).to receive(:evaluate) { condition }
-            expect(dsl.condition).to be condition
-          end
-        end
+      it 'prompts and returns the choice' do
+        prompter = double 'prompter'
+        allow(prompter_class).to receive(:new) { prompter }
+        allow(prompter).to receive(:prompt) { :choice }
+        expect(ask).to eq :choice
       end
     end
   end

data/spec/producer/core/task_spec.rb

@@ -8,54 +8,44 @@ module Producer::Core
     subject(:task)  { Task.new(name, [action], condition) }
 
     describe '.evaluate' do
-      let(:env)   { double 'env' }
-      let(:args)  { [:some, :arguments] }
-      let(:block) { proc { :some_task_code } }
-
-      it 'builds a new DSL sandbox with given env and code' do
-        dsl = double('dsl').as_null_object
-        expect(Task::DSL).to receive(:new).with(env) do |&b|
-          expect(b).to be block
-          dsl
-        end
-        Task.evaluate(name, env, *args, &block)
-      end
+      let(:name)              { :some_task }
+      let(:env)               { double 'env' }
+      let(:block)             { proc { condition { :condition }; some_action } }
+      let(:some_action_class) { Class.new(Action) }
+      subject(:task)          { Task.evaluate(name, env, :some, :args, &block) }
 
-      it 'evaluates the DSL sandbox code with given arguments' do
-        dsl = double('dsl').as_null_object
-        allow(Task::DSL).to receive(:new) { dsl }
-        expect(dsl).to receive(:evaluate).with(*args)
-        Task.evaluate(name, env, *args, &block)
-      end
+      before { Task::DSL.define_action(:some_action, some_action_class) }
 
-      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)
+      it 'returns an evaluated task' do
+        expect(task).to be_kind_of Task
       end
 
-      it 'returns the task' do
-        task = double 'task'
-        allow(Task).to receive(:new) { task }
-        expect(Task.evaluate(name, env, *args, &block)).to be task
+      context 'evaluated task' do
+        it 'has the requested name' do
+          expect(task.name).to eq name
+        end
+
+        it 'has the requested actions' do
+          expect(task.actions.first).to be_kind_of some_action_class
+        end
+
+        it 'has the requested condition' do
+          expect(task.condition.return_value).to be :condition
+        end
       end
     end
 
     describe '#initialize' do
       it 'assigns the name' do
-        expect(task.instance_eval { @name }).to eq name
+        expect(task.name).to eq name
       end
 
       it 'assigns the actions' do
-        expect(task.instance_eval { @actions }).to eq [action]
+        expect(task.actions).to eq [action]
       end
 
       it 'assigns the condition' do
-        expect(task.instance_eval { @condition }).to eq condition
+        expect(task.condition).to eq condition
       end
 
       context 'when only the name is given as argument' do
@@ -71,24 +61,6 @@ module Producer::Core
       end
     end
 
-    describe '#name' do
-      it 'returns its name' do
-        expect(task.name).to eq name
-      end
-    end
-
-    describe '#actions' do
-      it 'returns the assigned actions' do
-        expect(task.actions).to eq [action]
-      end
-    end
-
-    describe '#condition' do
-      it 'returns the assigned condition' do
-        expect(task.condition).to be condition
-      end
-    end
-
     describe '#condition_met?' do
       context 'when condition is truthy' do
         let(:condition) { Condition.new([], true) }

data/spec/producer/core/test_spec.rb

@@ -2,41 +2,41 @@ require 'spec_helper'
 
 module Producer::Core
   describe Test do
-    let(:env)         { double 'env' }
+    let(:env)         { Env.new }
     let(:arguments)   { [:some, :arguments] }
     subject(:test)    { Test.new(env, *arguments) }
 
     describe '#initialize' do
       it 'assigns the env' do
-        expect(test.instance_eval { @env }).to be env
+        expect(test.env).to be env
       end
 
       it 'assigns the arguments' do
-        expect(test.instance_eval { @arguments }).to eq arguments
+        expect(test.arguments).to eq arguments
       end
 
       it 'assigns negated as false by default' do
-        expect(test.instance_eval { @negated }).to be false
+        expect(test).to_not be_negated
       end
 
       context 'when negated option is true' do
-        subject(:test) { Test.new(env, *arguments, negated: true) }
+        subject(:test) { described_class.new(env, *arguments, negated: true) }
 
         it 'assigns negated as true' do
-          expect(test.instance_eval { @negated }).to be true
+          expect(test).to be_negated
         end
       end
     end
 
-    describe '#env' do
-      it 'returns the assigned env' do
-        expect(test.env).to be env
+    describe '#remote' do
+      it 'returns env remote' do
+        expect(test.remote).to be test.env.remote
       end
     end
 
-    describe '#arguments' do
-      it 'returns the assigned arguments' do
-        expect(test.arguments).to eq arguments
+    describe '#fs' do
+      it 'returns env remote fs' do
+        expect(test.fs).to be test.env.remote.fs
       end
     end
 
@@ -46,7 +46,7 @@ module Producer::Core
       end
 
       context 'when test is negated' do
-        subject(:test) { Test.new(env, *arguments, negated: true) }
+        subject(:test) { described_class.new(env, *arguments, negated: true) }
 
         it 'returns true' do
           expect(test.negated?).to be true
@@ -66,7 +66,7 @@ module Producer::Core
       end
 
       context 'when test is negated' do
-        subject(:test) { Test.new(env, *arguments, negated: true) }
+        subject(:test) { described_class.new(env, *arguments, negated: true) }
 
         it 'returns false when #verify is true' do
           allow(test).to receive(:verify) { true }

data/spec/spec_helper.rb

@@ -3,7 +3,6 @@ require 'producer/core'
 require 'support/exit_helpers'
 require 'support/fixtures_helpers'
 require 'support/net_ssh_story_helpers'
-require 'support/tests_helpers'
 
 
 RSpec.configure do |c|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: producer-core
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Thibault Jouan
@@ -112,6 +112,7 @@ files:
 - features/actions/file_write.feature
 - features/actions/sh.feature
 - features/cli/usage.feature
+- features/recipes/ask.feature
 - features/recipes/env.feature
 - features/recipes/evaluation.feature
 - features/recipes/macro.feature
@@ -140,6 +141,7 @@ files:
 - lib/producer/core/condition/dsl.rb
 - lib/producer/core/env.rb
 - lib/producer/core/errors.rb
+- lib/producer/core/prompter.rb
 - lib/producer/core/recipe.rb
 - lib/producer/core/recipe/dsl.rb
 - lib/producer/core/remote.rb
@@ -164,6 +166,7 @@ files:
 - spec/producer/core/condition/dsl_spec.rb
 - spec/producer/core/condition_spec.rb
 - spec/producer/core/env_spec.rb
+- spec/producer/core/prompter_spec.rb
 - spec/producer/core/recipe/dsl_spec.rb
 - spec/producer/core/recipe_spec.rb
 - spec/producer/core/remote/environment_spec.rb
@@ -179,7 +182,6 @@ files:
 - spec/support/exit_helpers.rb
 - spec/support/fixtures_helpers.rb
 - spec/support/net_ssh_story_helpers.rb
-- spec/support/tests_helpers.rb
 homepage: https://rubygems.org/gems/producer-core
 licenses: []
 metadata: {}
@@ -208,6 +210,7 @@ test_files:
 - features/actions/file_write.feature
 - features/actions/sh.feature
 - features/cli/usage.feature
+- features/recipes/ask.feature
 - features/recipes/env.feature
 - features/recipes/evaluation.feature
 - features/recipes/macro.feature
@@ -237,6 +240,7 @@ test_files:
 - spec/producer/core/condition/dsl_spec.rb
 - spec/producer/core/condition_spec.rb
 - spec/producer/core/env_spec.rb
+- spec/producer/core/prompter_spec.rb
 - spec/producer/core/recipe/dsl_spec.rb
 - spec/producer/core/recipe_spec.rb
 - spec/producer/core/remote/environment_spec.rb
@@ -252,5 +256,4 @@ test_files:
 - spec/support/exit_helpers.rb
 - spec/support/fixtures_helpers.rb
 - spec/support/net_ssh_story_helpers.rb
-- spec/support/tests_helpers.rb
 has_rdoc: 

data/spec/support/tests_helpers.rb

@@ -1,9 +0,0 @@
-module TestsHelpers
-  def test_ok
-    double 'test', pass?: true
-  end
-
-  def test_ko
-    double 'test', pass?: false
-  end
-end