chef-stove 7.1.1

data/lib/stove/filter.rb

@@ -0,0 +1,60 @@
+module Stove
+  class Filter
+    include Logify
+
+    include Mixin::Insideable
+
+    #
+    # The class that created this filter.
+    #
+    # @return [~Plugin::Base]
+    #
+    attr_reader :klass
+
+    #
+    # The message given by the filter.
+    #
+    # @return [String]
+    #
+    attr_reader :message
+
+    #
+    # The block captured by the filter.
+    #
+    # @return [Proc]
+    #
+    attr_reader :block
+
+    #
+    # Create a new filter object.
+    #
+    # @param [~Plugin::Base] klass
+    #   the class that created this filter
+    # @param [String] message
+    #   the message given by the filter
+    # @param [Proc] block
+    #   the block captured by this filter
+    #
+    def initialize(klass, message, &block)
+      @klass   = klass
+      @message = message
+      @block   = block
+    end
+
+    #
+    # Execute this filter in the context of the creating class, inside the
+    # given cookbook's path.
+    #
+    # @param [Cookbook]
+    #   the cookbook to run this filter against
+    #
+    def run(cookbook, options = {})
+      log.info(message)
+      instance = klass.new(cookbook, options)
+
+      inside(cookbook) do
+        instance.instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/stove/mash.rb

@@ -0,0 +1,25 @@
+module Stove
+  class Mash < ::Hash
+    def method_missing(m, *args, &block)
+      if has_key?(m.to_sym)
+        self[m.to_sym]
+      elsif has_key?(m.to_s)
+        self[m.to_s]
+      else
+        super
+      end
+    end
+
+    def methods(include_private = false)
+      super + self.keys.map(&:to_sym)
+    end
+
+    def respond_to?(m, include_private = false)
+      if has_key?(m.to_sym) || has_key?(m.to_s)
+        true
+      else
+        super
+      end
+    end
+  end
+end

data/lib/stove/mixins/insideable.rb

@@ -0,0 +1,13 @@
+module Stove
+  module Mixin::Insideable
+    #
+    # Execute the command inside the cookbook.
+    #
+    # @param [Cookbook]
+    #   the cookbook to execute inside of
+    #
+    def inside(cookbook, &block)
+      Dir.chdir(cookbook.path, &block)
+    end
+  end
+end

data/lib/stove/mixins/instanceable.rb

@@ -0,0 +1,24 @@
+require 'singleton'
+
+module Stove
+  module Mixin::Instanceable
+    def self.included(base)
+      base.send(:include, Singleton)
+      base.send(:extend, ClassMethods)
+    end
+
+    def self.extended(base)
+      base.send(:include, Singleton)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def to_s; instance.to_s; end
+      def inspect; instance.inspect; end
+
+      def method_missing(m, *args, &block)
+        instance.send(m, *args, &block)
+      end
+    end
+  end
+end

data/lib/stove/mixins/optionable.rb

@@ -0,0 +1,41 @@
+module Stove
+  module Mixin::Optionable
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    def self.extended(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      #
+      # This is a magical method. It does three things:
+      #
+      # 1. Defines a class method getter and setter for the given option
+      # 2. Defines an instance method that delegates to the class method
+      # 3. (Optionally) sets the initial value
+      #
+      # @param [String, Symbol] name
+      #   the name of the option
+      # @param [Object] initial
+      #   the initial value to set (optional)
+      #
+      def option(name, initial = UNSET_VALUE)
+        define_singleton_method(name) do |value = UNSET_VALUE|
+          if value == UNSET_VALUE
+            instance_variable_get("@#{name}")
+          else
+            instance_variable_set("@#{name}", value)
+          end
+        end
+
+        define_method(name) { self.class.send(name) }
+
+        unless initial == UNSET_VALUE
+          send(name, initial)
+        end
+      end
+    end
+  end
+end

data/lib/stove/mixins/validatable.rb

@@ -0,0 +1,11 @@
+module Stove
+  module Mixin::Validatable
+    def validate(id, &block)
+      validations[id] = Validator.new(self, id, &block)
+    end
+
+    def validations
+      @validations ||= {}
+    end
+  end
+end

data/lib/stove/packager.rb

@@ -0,0 +1,156 @@
+require 'rubygems/package'
+require 'fileutils'
+require 'tempfile'
+require 'zlib'
+
+module Stove
+  class Packager
+    include Logify
+
+    ACCEPTABLE_FILES = [
+      '.foodcritic',
+      'README.*',
+      'CHANGELOG.*',
+      'CONTRIBUTING.md',
+      'MAINTAINERS.md',
+      'metadata.{json,rb}',
+      'attributes/*.rb',
+      'definitions/*.rb',
+      'files/**/*',
+      'libraries/**/*.rb',
+      'providers/**/*.rb',
+      'recipes/*.rb',
+      'resources/**/*.rb',
+      'templates/**/*',
+    ].freeze
+
+    ACCEPTABLE_FILES_LIST = ACCEPTABLE_FILES.join(',').freeze
+
+    TMP_FILES = [
+      /^(?:.*[\\\/])?\.[^\\\/]+\.sw[p-z]$/,
+      /~$/,
+    ].freeze
+
+    # The cookbook to package.
+    #
+    # @erturn [Stove::Cookbook]
+    attr_reader :cookbook
+
+    # Whether to include the new extended metadata attributes.
+    #
+    # @return [true, false]
+    attr_reader :extended_metadata
+
+    # Create a new packager instance.
+    #
+    # @param [Stove::Cookbook]
+    #   the cookbook to package
+    # @param [true, false] extended_metadata
+    #   include new extended metadata attributes
+    def initialize(cookbook, extended_metadata = false)
+      @cookbook = cookbook
+      @extended_metadata = extended_metadata
+    end
+
+    # A map from physical file path to tarball file path
+    #
+    # @example
+    #   # Assuming +cookbook.name+ is 'apt'
+    #
+    #   {
+    #     '/home/user/apt-cookbook/metadata.json' => 'apt/metadata.json',
+    #     '/home/user/apt-cookbook/README.md' => 'apt/README.md'
+    #   }
+    #
+    # @return [Hash<String, String>]
+    #   the map of file paths
+    def packaging_slip
+      root = File.expand_path(cookbook.path)
+      path = File.join(root, "{#{ACCEPTABLE_FILES_LIST}}")
+
+      Dir.glob(path, File::FNM_DOTMATCH)
+        .reject { |path| %w(. ..).include?(File.basename(path)) }
+        .reject { |path| TMP_FILES.any? { |regex| path.match(regex) } }
+        .map    { |path| [path, path.sub(/^#{Regexp.escape(root)}/, cookbook.name)] }
+        .reduce({}) do |map, (cookbook_file, tarball_file)|
+          map[cookbook_file] = tarball_file
+        map
+      end
+    end
+
+    def tarball
+      # Generate the metadata.json on the fly
+      metadata_json = File.join(cookbook.path, 'metadata.json')
+      json = JSON.fast_generate(cookbook.metadata.to_hash(extended_metadata))
+      File.open(metadata_json, 'wb') { |f| f.write(json) }
+
+      io  = tar(File.dirname(cookbook.path), packaging_slip)
+      tgz = gzip(io)
+
+      tempfile = Tempfile.new([cookbook.name, '.tar.gz'], Dir.tmpdir)
+      tempfile.binmode
+
+      while buffer = tgz.read(1024)
+        tempfile.write(buffer)
+      end
+
+      tempfile.rewind
+      tempfile
+    ensure
+      if defined?(metadata_json) && File.exist?(File.join(cookbook.path, 'metadata.rb'))
+        File.delete(metadata_json)
+      end
+    end
+
+    #
+    # Create a tar file from the given root and packaging slip
+    #
+    # @param [String] root
+    #   the root where the tar files are being created
+    # @param [Hash<String, String>] slip
+    #   the map from physical file path to tarball file path
+    #
+    # @return [StringIO]
+    #   the io object that contains the tarball contents
+    #
+    def tar(root, slip)
+      io = StringIO.new('', 'r+b')
+      Gem::Package::TarWriter.new(io) do |tar|
+        slip.each do |original_file, tarball_file|
+          mode = File.stat(original_file).mode
+
+          if File.directory?(original_file)
+            tar.mkdir(tarball_file, mode)
+          else
+            tar.add_file(tarball_file, mode) do |tf|
+              File.open(original_file, 'rb') { |f| tf.write(f.read) }
+            end
+          end
+        end
+      end
+
+      io.rewind
+      io
+    end
+
+    #
+    # GZip the given IO object (like a File or StringIO).
+    #
+    # @param [IO] io
+    #   the io object to gzip
+    #
+    # @return [IO]
+    #   the gzipped IO object
+    #
+    def gzip(io)
+      gz = StringIO.new('')
+      z = Zlib::GzipWriter.new(gz)
+      z.write(io.string)
+      z.close
+
+      # z was closed to write the gzip footer, so
+      # now we need a new StringIO
+      StringIO.new(gz.string)
+    end
+  end
+end

data/lib/stove/plugins/artifactory.rb

@@ -0,0 +1,14 @@
+module Stove
+  class Plugin::Artifactory < Plugin::Base
+    id 'artifactory'
+    description 'Publish the release to an Artifactory server'
+
+    validate(:key) do
+      Config.artifactory_key && !Config.artifactory_key.strip.empty?
+    end
+
+    run('Publishing the release to the Artifactory server') do
+      Artifactory.upload(cookbook, options[:extended_metadata])
+    end
+  end
+end

data/lib/stove/plugins/base.rb

@@ -0,0 +1,48 @@
+module Stove
+  class Plugin::Base
+    include Logify
+
+    extend Mixin::Optionable
+    extend Mixin::Validatable
+
+    class << self
+      def run(description, &block)
+        actions << Proc.new do |instance|
+          log.info { description }
+          instance.instance_eval(&block)
+        end
+      end
+
+      def actions
+        @actions ||= []
+      end
+    end
+
+    option :id
+    option :description
+
+    attr_reader :cookbook
+    attr_reader :options
+
+    def initialize(cookbook, options = {})
+      @cookbook, @options = cookbook, options
+    end
+
+    def run
+      run_validations
+      run_actions
+    end
+
+    def run_validations
+      self.class.validations.each do |id, validation|
+        validation.run(cookbook, options)
+      end
+    end
+
+    def run_actions
+      self.class.actions.each do |action|
+        action.call(self)
+      end
+    end
+  end
+end

data/lib/stove/plugins/git.rb

@@ -0,0 +1,70 @@
+module Stove
+  class Plugin::Git < Plugin::Base
+    id 'git'
+    description 'Tag and push to a git remote'
+
+    validate(:repository) do
+      File.directory?(File.join(Dir.pwd, '.git'))
+    end
+
+    validate(:clean) do
+      git_null('status --porcelain').strip.empty?
+    end
+
+    validate(:up_to_date) do
+      git_null('fetch')
+      local_sha  = git_null("rev-parse #{branch}").strip
+      remote_sha = git_null("rev-parse #{remote}/#{branch}").strip
+
+      log.debug("Local SHA: #{local_sha}")
+      log.debug("Remote SHA: #{remote_sha}")
+
+      local_sha == remote_sha
+    end
+
+    run('Tagging new release') do
+      annotation_type = options[:sign] ? '-s' : '-a'
+      tag = cookbook.tag_version
+
+      git %|tag #{annotation_type} #{tag} -m "Release #{tag}"|
+      git %|push #{remote} #{branch}|
+      git %|push #{remote} #{tag}|
+    end
+
+    private
+
+    def git(command, errors = true)
+      log.debug("the command matches")
+      log.debug("Running `git #{command}', errors: #{errors}")
+      Dir.chdir(cookbook.path) do
+        response = %x|git #{command}|
+
+        if errors && !$?.success?
+          raise Error::GitTaggingFailed.new(command: command) if command =~ /^tag/
+          raise Error::GitFailed.new(command: command)
+        end
+
+        response
+      end
+    end
+
+    def git_null(command)
+      null = case RbConfig::CONFIG['host_os']
+             when /mswin|mingw|cygwin/
+               'NUL'
+             else
+               '/dev/null'
+             end
+
+      git("#{command} 2>#{null}", false)
+    end
+
+    def remote
+      options[:remote]
+    end
+
+    def branch
+      options[:branch]
+    end
+  end
+end