producer-core 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b765ca3e62a5f6d52c70023568a7ff479eb90fb4
-  data.tar.gz: c742add987d14bc54d14933bf560d236e89f3be0
+  metadata.gz: 6a595e50ec520bdedf5e94b927b4dd8080a1acef
+  data.tar.gz: 1c7c1f218276ed668d62c2d31f482e12a2f3ca40
 SHA512:
-  metadata.gz: a59aea6fc1ea7fc7ce56b0ce33adbd53095d895945f2a036a2057b2b9f9b5460047d92b94a5f20866b20756d39511ab38e032dca792f85e5b786d73995028792
-  data.tar.gz: dd3ef0d2f879a4d9e1dd4b1bd3cb2747c390070f9d7544db077d044aa76dda67e11883ff08b45e79042fba471a6ca2bf351e625f7ee67457b4d9272f74f0b959
+  metadata.gz: 727921d665f949d90cb092b3c653c698a7f1c82d2d48e1dd8f73adbb9905fd60c3b0348a6bfdc3c1e01b77c35f7843507768c3f18102d3e5e9ae8d16b748b9a6
+  data.tar.gz: b2ece9b39a0be51041fd89f1b526c2d8042a252c3e4961be6cb9c621420c1f5bbccfab531df0885b3fa8f29473c07c32de8f30d46b2a6f7332bdccff2b2f9d73

data/features/cli_usage.feature

@@ -6,5 +6,10 @@ Feature: CLI usage
     Then the exit status must be 64
     And the output must contain exactly:
       """
-      Usage: producer [-v] [-n] [-t host.example] recipe_file
+      Usage: producer [options] [recipes]
+
+      options:
+          -v, --verbose                    enable verbose mode
+          -n, --dry-run                    enable dry run mode
+          -t, --target HOST                target host
       """

data/features/registry.feature

@@ -34,3 +34,15 @@ Feature: key/value registry
       """
     When I successfully execute the recipe
     Then the output must contain "some_value"
+
+  Scenario: `get' keyword should trigger an error when given invalid key
+    Given a recipe with:
+      """
+      task :some_task do
+        echo get :no_key
+        echo 'after_fail'
+      end
+      """
+    When I execute the recipe
+    Then the output must not contain "after_fail"
+    And the output must match /\A\w+Error:\s+:no_key/

data/features/task_nested_tasks.feature

@@ -13,3 +13,8 @@ Feature: nested tasks
     Scenario: applies nested tasks
       When I successfully execute the recipe
       Then the output must match /\AOK/
+
+    Scenario: indents logging from nested tasks
+      When I successfully execute the recipe with option -v
+      Then the output must match /^  Task:.+/
+      And the output must match /^   action:.+/

data/lib/producer/core/cli.rb

@@ -3,8 +3,7 @@ module Producer
     class CLI
       ArgumentError = Class.new(::ArgumentError)
 
-      OPTIONS_USAGE = '[-v] [-n] [-t host.example]'.freeze
-      USAGE = "Usage: #{File.basename $0} #{OPTIONS_USAGE} recipe_file".freeze
+      USAGE = "Usage: #{File.basename $0} [options] [recipes]".freeze
 
       EX_USAGE    = 64
       EX_SOFTWARE = 70
@@ -15,8 +14,8 @@ module Producer
           begin
             cli.parse_arguments!
             cli.run
-          rescue ArgumentError
-            stderr.puts USAGE
+          rescue ArgumentError => e
+            stderr.puts e.message
             exit EX_USAGE
           rescue RuntimeError => e
             stderr.puts "#{e.class.name.split('::').last}: #{e.message}"
@@ -25,40 +24,55 @@ module Producer
         end
       end
 
-      attr_reader :arguments, :env
+      attr_reader :arguments, :stdin, :stdout, :stderr, :env
 
       def initialize(args, stdin: $stdin, stdout: $stdout, stderr: $stderr)
         @arguments  = args
         @stdin      = stdin
         @stdout     = stdout
-        @env        = Env.new(input: stdin, output: stdout, error_output: stderr)
+        @stderr     = stderr
+        @env        = build_env
       end
 
       def parse_arguments!
-        @arguments = arguments.each_with_index.inject([]) do |m, (e, i)|
-          case e
-          when '-v'
-            env.verbose = true
-          when '-n'
-            env.dry_run = true
-          when '-t'
-            env.target = arguments.delete_at i + 1
-          else
-            m << e
-          end
-          m
-        end
-
-        fail ArgumentError unless @arguments.any?
+        option_parser.parse!(@arguments)
+        fail ArgumentError, option_parser if @arguments.empty?
       end
 
       def run(worker: Worker.new(@env))
-        worker.process recipe.tasks
+        evaluate_recipes.each { |recipe| worker.process recipe.tasks }
         @env.cleanup
       end
 
-      def recipe
-        @recipe ||= Recipe::FileEvaluator.evaluate(@arguments.first, env)
+      def evaluate_recipes
+        @arguments.map { |e| Recipe::FileEvaluator.evaluate(e, @env) }
+      end
+
+
+      private
+
+      def build_env
+        Env.new(input: @stdin, output: @stdout, error_output: @stderr)
+      end
+
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.separator ''
+          opts.separator 'options:'
+
+          opts.on '-v', '--verbose', 'enable verbose mode' do |e|
+            env.verbose = true
+          end
+
+          opts.on '-n', '--dry-run', 'enable dry run mode' do |e|
+            env.dry_run = true
+          end
+
+          opts.on '-t', '--target HOST', 'target host' do |e|
+            env.target = e
+          end
+        end
       end
     end
   end

data/lib/producer/core/env.rb

@@ -18,7 +18,9 @@ module Producer
       end
 
       def [](key)
-        @registry[key]
+        @registry.fetch key
+      rescue KeyError
+        fail RegistryKeyError, key.inspect
       end
       alias get []
 

data/lib/producer/core/errors.rb

@@ -4,5 +4,6 @@ module Producer
     RuntimeError                = Class.new(RuntimeError)
     ConditionNotMetError        = Class.new(Error)
     RemoteCommandExecutionError = Class.new(RuntimeError)
+    RegistryKeyError            = Class.new(RuntimeError)
   end
 end

data/lib/producer/core/version.rb

@@ -1,5 +1,5 @@
 module Producer
   module Core
-    VERSION = '0.3.7'.freeze
+    VERSION = '0.3.8'.freeze
   end
 end

data/lib/producer/core/worker.rb

@@ -14,21 +14,29 @@ module Producer
         tasks.each { |t| process_task t }
       end
 
-      def process_task(task)
+      def process_task(task, indent_level = 0)
         if task.condition_met?
-          @env.log "Task: `#{task}' applying..."
+          log "Task: `#{task}' applying...", indent_level
           task.actions.each do |e|
             case e
-            when Task then process_task e
+            when Task then process_task e, indent_level + 2
             else
-              @env.log " action: #{e}"
+              log " action: #{e}", indent_level
               e.apply unless @env.dry_run?
             end
           end
         else
-          @env.log "Task: `#{task}' skipped"
+          log "Task: `#{task}' skipped", indent_level
         end
       end
+
+
+      private
+
+      def log(message, indent_level)
+        message = [' ' * indent_level, message].join
+        @env.log message
+      end
     end
   end
 end

data/lib/producer/core.rb

@@ -1,5 +1,6 @@
 require 'etc'
 require 'forwardable'
+require 'optparse'
 require 'pathname'
 
 require 'net/ssh'

data/spec/producer/core/cli_spec.rb

@@ -5,28 +5,42 @@ module Producer::Core
     include ExitHelpers
     include FixturesHelpers
 
-    let(:recipe_file) { fixture_path_for 'recipes/some_recipe.rb' }
     let(:options)     { [] }
+    let(:recipe_file) { fixture_path_for 'recipes/some_recipe.rb' }
     let(:arguments)   { [*options, recipe_file] }
 
     subject(:cli)     { described_class.new(arguments) }
 
     describe '.run!' do
-      let(:stderr)    { StringIO.new }
-      subject(:run!)  { described_class.run! arguments, stderr: stderr }
+      subject(:run!) { described_class.run! arguments }
+
+      it 'builds a new CLI instance with given arguments' do
+        expect(described_class)
+          .to receive(:new).with(arguments, anything).and_call_original
+        run!
+      end
+
+      it 'parses new CLI instance arguments' do
+        expect_any_instance_of(described_class).to receive :parse_arguments!
+        run!
+      end
+
+      it 'runs the new CLI instance' do
+        expect_any_instance_of(described_class).to receive :run
+        run!
+      end
 
-      context 'when given arguments are invalid' do
+      context 'when no recipe is given' do
         let(:arguments) { [] }
 
         it 'exits with a return status of 64' do
-          expect { run! }.to raise_error(SystemExit) do |e|
-            expect(e.status).to eq 64
-          end
+          expect { described_class.run! arguments, stderr: StringIO.new }
+            .to raise_error(SystemExit) { |e| expect(e.status).to eq 64 }
         end
 
         it 'prints the usage on the error stream' do
-          trap_exit { run! }
-          expect(stderr.string).to match /\AUsage: .+/
+          expect { trap_exit { run! } }
+            .to output(/\AUsage: .+/).to_stderr
         end
       end
 
@@ -34,92 +48,95 @@ module Producer::Core
         let(:recipe_file) { fixture_path_for 'recipes/raise.rb' }
 
         it 'exits with a return status of 70' do
-          expect { run! }.to raise_error(SystemExit) do |e|
-            expect(e.status).to eq 70
-          end
+          expect { described_class.run! arguments, stderr: StringIO.new }
+            .to raise_error(SystemExit) { |e| expect(e.status).to eq 70 }
         end
 
         it 'prints exception name and message and the error stream' do
-          trap_exit { run! }
-          expect(stderr.string).to eq "RemoteCommandExecutionError: false\n"
+          expect { trap_exit { run! } }
+            .to output("RemoteCommandExecutionError: false\n").to_stderr
         end
       end
     end
 
-    describe '#env' do
-      let(:stdin)   { StringIO.new }
-      let(:stdout)  { StringIO.new }
-      let(:stderr)  { StringIO.new }
-
-      subject(:cli) { described_class.new(arguments,
-                        stdin: stdin, stdout: stdout, stderr: stderr) }
-
-      it 'returns an env' do
+    describe '#initialize' do
+      it 'assigns an env' do
         expect(cli.env).to be_an Env
       end
 
       it 'assigns CLI stdin as the env input' do
-        expect(cli.env.input).to be stdin
+        expect(cli.env.input).to be cli.stdin
       end
 
       it 'assigns CLI stdout as the env output' do
-        expect(cli.env.output).to be stdout
+        expect(cli.env.output).to be cli.stdout
       end
 
       it 'assigns CLI stderr as the env error output' do
-        expect(cli.env.error_output).to be stderr
+        expect(cli.env.error_output).to be cli.stderr
       end
     end
 
     describe '#parse_arguments!' do
-      context 'with options' do
-        let(:options) { %w[-v -t some_host.example] }
+      let(:options) { %w[-v -t some_host.example] }
+
+      it 'removes options from arguments' do
+        cli.parse_arguments!
+        expect(cli.arguments).to eq [recipe_file]
+      end
 
-        before { cli.parse_arguments! }
+      context 'with verbose option' do
+        let(:options) { %w[-v] }
 
-        it 'removes options from arguments' do
-          expect(cli.arguments).to eq [recipe_file]
+        it 'enables env verbose mode' do
+          cli.parse_arguments!
+          expect(cli.env).to be_verbose
         end
+      end
 
-        context 'verbose' do
-          let(:options) { %w[-v] }
+      context 'with dry run option' do
+        let(:options) { %w[-n] }
 
-          it 'enables env verbose mode' do
-            expect(cli.env).to be_verbose
-          end
+        it 'enables env dry run mode' do
+          cli.parse_arguments!
+          expect(cli.env).to be_dry_run
         end
+      end
 
-        context 'dry run' do
-          let(:options) { %w[-n] }
+      context 'with target option' do
+        let(:options) { %w[-t some_host.example] }
 
-          it 'enables env dry run mode' do
-            expect(cli.env).to be_dry_run
-          end
+        it 'assigns the given target to the env' do
+          cli.parse_arguments!
+          expect(cli.env.target).to eq 'some_host.example'
         end
+      end
 
-        context 'target' do
-          let(:options) { %w[-t some_host.example] }
+      context 'with combined options' do
+        let(:options) { %w[-vn]}
 
-          it 'assigns the given target to the env' do
-            expect(cli.env.target).to eq 'some_host.example'
-          end
+        it 'handles combined options' do
+          cli.parse_arguments!
+          expect(cli.env).to be_verbose.and be_dry_run
         end
       end
 
-      context 'without arguments' do
+      context 'when no arguments remains after parsing' do
         let(:arguments) { [] }
 
-        it 'raises the argument error exception' do
-          expect { cli.parse_arguments! }.to raise_error described_class::ArgumentError
+        it 'raises an error' do
+          expect { cli.parse_arguments! }
+            .to raise_error described_class::ArgumentError
         end
       end
     end
 
     describe '#run' do
-      it 'processes recipe tasks with a worker' do
+      it 'processes recipes tasks with a worker' do
         worker = instance_spy Worker
         cli.run worker: worker
-        expect(worker).to have_received(:process).with cli.recipe.tasks
+        expect(worker).to have_received(:process)
+          .with all be_an_instance_of Task
       end
 
       it 'cleans up the env' do
@@ -128,12 +145,9 @@ module Producer::Core
       end
     end
 
-    describe '#recipe' do
-      it 'returns the evaluated recipe' do
-        expect(cli.recipe.tasks).to match [
-          an_object_having_attributes(name: :some_task),
-          an_object_having_attributes(name: :another_task)
-        ]
+    describe '#evaluate_recipes' do
+      it 'returns the evaluated recipes' do
+        expect(cli.evaluate_recipes).to all be_an_instance_of Recipe
       end
     end
   end

data/spec/producer/core/env_spec.rb

@@ -107,6 +107,10 @@ module Producer::Core
       it 'returns the value indexed by given key from the registry' do
         expect(env[:some_key]).to eq :some_value
       end
+
+      it 'raises an error when given invalid key' do
+        expect { env[:no_key] }.to raise_error RegistryKeyError
+      end
     end
 
     describe '#[]=' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: producer-core
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.3.8
 platform: ruby
 authors:
 - Thibault Jouan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-25 00:00:00.000000000 Z
+date: 2014-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh