itamae-mitsurin 0.50 → 1.0.0

data/test/test_itamae-mitsurin/test_handler_proxy.rb

@@ -1,38 +0,0 @@
-module ItamaeMitsurin
-  class HandlerProxy
-    def initialize
-      @instances = []
-    end
-
-    def register_instance(instance)
-      @instances << instance
-    end
-
-    def event(*args, &block)
-      if block_given?
-        _event_with_block(*args, &block)
-      else
-        _event(*args)
-      end
-    end
-
-    private
-
-    def _event(*args)
-      @instances.each do |i|
-        i.event(*args)
-      end
-    end
-
-    def _event_with_block(event_name, *args, &block)
-      event("#{event_name}_started".to_sym, *args)
-      block.call
-    rescue
-      event("#{event_name}_failed".to_sym, *args)
-      raise
-    else
-      event("#{event_name}_completed".to_sym, *args)
-    end
-  end
-end
-

data/test/test_itamae-mitsurin/test_logger.rb

@@ -1,124 +0,0 @@
-require 'itamae-mitsurin'
-require 'logger'
-require 'ansi/code'
-
-module ItamaeMitsurin
-  module Logger
-    module Helper
-      def with_indent
-        indent
-        yield
-      ensure
-        outdent
-      end
-
-      def with_indent_if(condition, &block)
-        if condition
-          with_indent(&block)
-        else
-          block.call
-        end
-      end
-
-      def indent
-        self.indent_depth += 1
-      end
-
-      def outdent
-        self.indent_depth -= 1
-        self.indent_depth = 0 if self.indent_depth < 0
-      end
-
-      def indent_depth
-        @indent_depth ||= 0
-      end
-
-      def indent_depth=(val)
-        @indent_depth = val
-      end
-
-      def color(code, &block)
-        if self.formatter.respond_to?(:color)
-          self.formatter.color(code, &block)
-        else
-          block.call
-        end
-      end
-
-      %w!debug info warn error fatal unknown!.each do |level|
-        module_eval(<<-EOC, __FILE__, __LINE__ + 1)
-          def #{level}(msg)
-            super("  " * indent_depth + msg)
-          end
-        EOC
-      end
-    end
-
-    class Formatter
-      attr_accessor :colored
-
-      def call(severity, datetime, progname, msg)
-        log = "%s : %s\n" % ["%5s" % severity, msg2str(msg)]
-        if colored
-          colorize(log, severity)
-        else
-          log
-        end
-      end
-
-      def color(code)
-        prev_color = @color
-        @color = code
-        yield
-      ensure
-        @color = prev_color
-      end
-
-      private
-
-      def msg2str(msg)
-        case msg
-        when ::String
-          msg
-        when ::Exception
-          "#{ msg.message } (#{ msg.class })\n" <<
-          (msg.backtrace || []).join("\n")
-        else
-          msg.inspect
-        end
-      end
-
-      def colorize(str, severity)
-        if @color
-          color_code = @color
-        else
-          color_code = case severity
-                       when "INFO"
-                         :clear
-                       when "WARN"
-                         :magenta
-                       when "ERROR"
-                         :red
-                       else
-                         :clear
-                       end
-        end
-        ANSI.public_send(color_code) { str }
-      end
-    end
-  end
-
-  @logger = ::Logger.new($stdout).tap do |l|
-    l.formatter = ItamaeMitsurin::Logger::Formatter.new
-  end.extend(ItamaeMitsurin::Logger::Helper)
-
-  class << self
-    def logger
-      @logger
-    end
-
-    def logger=(l)
-      @logger = l.extend(ItamaeMitsurin::Logger::Helper)
-    end
-  end
-end

data/test/test_itamae-mitsurin/test_mitsurin.rb

@@ -1,14 +0,0 @@
-require 'itamae-mitsurin/version'
-require 'itamae-mitsurin/mitsurin/cli'
-require 'itamae-mitsurin/mitsurin/creators'
-require 'aws-sdk'
-#require 'itamae-mitsurin/mitsurin/itamae_task'
-#require 'itamae-mitsurin/mitsurin/serverspec_task'
-#require 'itamae-mitsurin/mitsurin/itamae_with_git_task'
-
-
-module ItamaeMitsurin
-  module Mitsurin
-  # TODO
-  end
-end

data/test/test_itamae-mitsurin/test_node.rb

@@ -1,74 +0,0 @@
-require 'itamae-mitsurin'
-require 'hashie'
-require 'json'
-require 'schash'
-
-module ItamaeMitsurin
-  class Node
-    ValidationError = Class.new(StandardError)
-
-    attr_reader :mash
-
-    def initialize(hash, backend)
-      @mash = Hashie::Mash.new(hash)
-      @backend = backend
-    end
-
-    def reverse_merge(other_hash)
-      self.class.new(_reverse_merge(other_hash), @backend)
-    end
-
-    def reverse_merge!(other_hash)
-      @mash.replace(_reverse_merge(other_hash))
-    end
-
-    def [](key)
-      if @mash.has_key?(key)
-        @mash[key]
-      else
-        fetch_inventory_value(key)
-      end
-    end
-
-    def validate!(&block)
-      errors = Schash::Validator.new(&block).validate(@mash)
-      unless errors.empty?
-        errors.each do |error|
-          ItamaeMitsurin.logger.error "'#{error.position.join('->')}' #{error.message}"
-        end
-        raise ValidationError
-      end
-    end
-
-    private
-
-    def _reverse_merge(other_hash)
-      Hashie::Mash.new(other_hash).merge(@mash)
-    end
-
-    def method_missing(method, *args)
-      if @mash.respond_to?(method)
-        return @mash.public_send(method, *args)
-      elsif args.empty? && value = fetch_inventory_value(method)
-        return value
-      end
-
-      super
-    end
-
-    def respond_to?(method, priv = false)
-      @mash.respond_to?(method, priv) || super
-    end
-
-    def fetch_inventory_value(key)
-      value = @backend.host_inventory[key]
-      if value.is_a?(Hash)
-        value = Hashie::Mash.new(value)
-      end
-
-      value
-    rescue NotImplementedError, NameError
-      nil
-    end
-  end
-end

data/test/test_itamae-mitsurin/test_notification.rb

@@ -1,46 +0,0 @@
-require 'itamae-mitsurin'
-
-module ItamaeMitsurin
-  class Notification < Struct.new(:defined_in_resource, :action, :target_resource_desc, :timing)
-    def self.create(*args)
-      self.new(*args).tap(&:validate!)
-    end
-
-    def resource
-      runner.children.find_resource_by_description(target_resource_desc)
-    end
-
-    def run
-      action_resource.run(action)
-    end
-
-    def action_resource
-      resource
-    end
-
-    def runner
-      defined_in_resource.recipe.runner
-    end
-
-    def delayed?
-      [:delay, :delayed].include?(timing)
-    end
-
-    def immediately?
-      timing == :immediately
-    end
-
-    def validate!
-      unless [:delay, :delayed, :immediately].include?(timing)
-        ItamaeMitsurin.logger.error "'#{timing}' is not valid notification timing. (Valid option is delayed or immediately)"
-        abort
-      end
-    end
-  end
-
-  class Subscription < Notification
-    def action_resource
-      defined_in_resource
-    end
-  end
-end

data/test/test_itamae-mitsurin/test_recipe.rb

@@ -1,171 +0,0 @@
-require 'itamae-mitsurin'
-
-module ItamaeMitsurin
-  class Recipe
-    NotFoundError = Class.new(StandardError)
-
-    attr_reader :path
-    attr_reader :runner
-    attr_reader :children
-    attr_reader :delayed_notifications
-
-    class << self
-      def find_recipe_in_gem(recipe)
-        plugin_name, recipe_file = recipe.split('::', 2)
-        recipe_file = recipe_file.gsub("::", "/") if recipe_file
-
-        gem_name = "itamae-plugin-recipe-#{plugin_name}"
-        begin
-          gem gem_name
-        rescue LoadError
-        end
-        spec = Gem.loaded_specs.values.find do |spec|
-          spec.name == gem_name
-        end
-
-        return nil unless spec
-
-        candidate_files = []
-        if recipe_file
-          recipe_file += '.rb' unless recipe_file.end_with?('.rb')
-          candidate_files << "#{plugin_name}/#{recipe_file}"
-        else
-          candidate_files << "#{plugin_name}/default.rb"
-          candidate_files << "#{plugin_name}.rb"
-        end
-
-        candidate_files.map do |file|
-          File.join(spec.lib_dirs_glob, 'itamae', 'plugin', 'recipe', file)
-        end.find do |path|
-          File.exist?(path)
-        end
-      end
-    end
-
-    def initialize(runner, path)
-      @runner = runner
-      @path = path
-      @delayed_notifications = []
-      @children = RecipeChildren.new
-    end
-
-    def dir
-      ::File.dirname(@path)
-    end
-
-    def load(vars = {})
-      context = EvalContext.new(self, vars)
-      context.instance_eval(File.read(path), path, 1)
-    end
-
-    def run
-      show_banner
-
-      @runner.handler.event(:recipe, path: @path) do
-        ItamaeMitsurin.logger.with_indent do
-          @children.run
-          run_delayed_notifications
-        end
-      end
-    end
-
-    private
-
-    def run_delayed_notifications
-      @delayed_notifications.uniq! do |notification|
-        [notification.action, notification.action_resource]
-      end
-
-      while notification = @delayed_notifications.shift
-        notification.run
-      end
-    end
-
-    def show_banner
-      ItamaeMitsurin.logger.info "Recipe: #{@path}"
-    end
-
-    class EvalContext
-      def initialize(recipe, vars)
-        @recipe = recipe
-
-        vars.each do |k, v|
-          define_singleton_method(k) { v }
-        end
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        Resource.get_resource_class(method)
-        true
-      rescue NameError
-        false
-      end
-
-      def method_missing(*args, &block)
-        super unless args.size == 2
-
-        method, name = args
-        begin
-          klass = Resource.get_resource_class(method)
-        rescue NameError
-          super
-        end
-
-        resource = klass.new(@recipe, name, &block)
-        @recipe.children << resource
-      end
-
-      def define(name, params = {}, &block)
-        Resource.define_resource(name, Definition.create_class(name, params, @recipe, &block))
-      end
-
-      def include_recipe(target)
-        expanded_path = ::File.expand_path(target, File.dirname(@recipe.path))
-        expanded_path = ::File.join(expanded_path, 'default.rb') if ::Dir.exists?(expanded_path)
-        expanded_path.concat('.rb') unless expanded_path.end_with?('.rb')
-        candidate_paths = [expanded_path, Recipe.find_recipe_in_gem(target)].compact
-        path = candidate_paths.find {|path| File.exist?(path) }
-
-        unless path
-          raise NotFoundError, "Recipe not found. (#{target})"
-        end
-
-        if runner.children.find_recipe_by_path(path)
-          ItamaeMitsurin.logger.debug "Recipe, #{path}, is skipped because it is already included"
-          return
-        end
-
-        recipe = Recipe.new(runner, path)
-        @recipe.children << recipe
-        recipe.load
-      end
-
-      def node
-        runner.node
-      end
-
-      def runner
-        @recipe.runner
-      end
-
-      def run_command(*args)
-        runner.backend.run_command(*args)
-      end
-    end
-
-    class RecipeFromDefinition < Recipe
-      attr_accessor :definition
-
-      def load(vars = {})
-        context = EvalContext.new(self, vars)
-        context.instance_eval(&@definition.class.definition_block)
-      end
-
-      private
-
-      def show_banner
-        ItamaeMitsurin.logger.debug "#{@definition.resource_type}[#{@definition.resource_name}]"
-      end
-    end
-  end
-end