stove 1.1.2 → 2.0.0.beta.1

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,23 @@
+require 'singleton'
+
+module Stove
+  module Mixin::Instanceable
+    def self.included(base)
+      base.send(:include, Singleton)
+      base.send(:undef_method, :inspect, :to_s)
+      base.send(:extend, ClassMethods)
+    end
+
+    def self.extended(base)
+      base.send(:include, Singleton)
+      base.send(:undef_method, :inspect, :to_s)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def method_missing(m, *args, &block)
+        instance.send(m, *args, &block)
+      end
+    end
+  end
+end

data/lib/stove/mixins/loggable.rb

@@ -0,0 +1,32 @@
+require 'log4r'
+
+module Stove
+  module Mixin::Loggable
+    def self.extended(base)
+      base.send(:include, InstanceMethods)
+      base.send(:extend, ClassMethods)
+    end
+
+    def self.included(base)
+      base.send(:include, InstanceMethods)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def log
+        return @log if @log
+
+        @log = Log4r::Logger.new(self.name)
+        @log.outputters = Log4r::Outputter.stdout
+        @log.level = 1
+        @log
+      end
+    end
+
+    module InstanceMethods
+      def log
+        self.class.log
+      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,7 @@
+module Stove
+  module Mixin::Validatable
+    def validate(id, &block)
+      Runner.validations << Validator.new(self, id, &block)
+    end
+  end
+end

data/lib/stove/packager.rb

@@ -49,34 +49,35 @@ module Stove
     end
 
     private
-      def pack!
-        destination = Tempfile.new(cookbook.name).path
 
-        # Sandbox
-        sandbox = Dir.mktmpdir
-        FileUtils.mkdir_p(sandbox)
+    def pack!
+      destination = Tempfile.new(cookbook.name).path
 
-        # Containing folder
-        container = File.join(sandbox, cookbook.name)
-        FileUtils.mkdir_p(container)
+      # Sandbox
+      sandbox = Dir.mktmpdir
+      FileUtils.mkdir_p(sandbox)
 
-        # Copy filles
-        FileUtils.cp_r(cookbook_files, container)
+      # Containing folder
+      container = File.join(sandbox, cookbook.name)
+      FileUtils.mkdir_p(container)
 
-        # Generate metadata
-        File.open(File.join(container, 'metadata.json'), 'w') do |f|
-          f.write(cookbook.metadata.to_json)
-        end
+      # Copy filles
+      FileUtils.cp_r(cookbook_files, container)
 
-        Dir.chdir(sandbox) do |dir|
-          # This is super fucking annoying. The community site should really
-          # be better at reading tarballs
-          relative_path = container.gsub(sandbox + '/', '') + '/'
-          tgz = Zlib::GzipWriter.new(File.open(destination, 'wb'))
-          Archive::Tar::Minitar.pack(relative_path, tgz)
-        end
+      # Generate metadata
+      File.open(File.join(container, 'metadata.json'), 'w') do |f|
+        f.write(cookbook.metadata.to_json)
+      end
 
-        return destination
+      Dir.chdir(sandbox) do |dir|
+        # This is super fucking annoying. The community site should really
+        # be better at reading tarballs
+        relative_path = container.gsub(sandbox + '/', '') + '/'
+        tgz = Zlib::GzipWriter.new(File.open(destination, 'wb'))
+        Archive::Tar::Minitar.pack(relative_path, tgz)
       end
+
+      return destination
+    end
   end
 end

data/lib/stove/plugins/base.rb

@@ -0,0 +1,35 @@
+module Stove
+  class Plugin::Base
+    extend Mixin::Filterable
+    extend Mixin::Loggable
+    extend Mixin::Optionable
+    extend Mixin::Validatable
+
+    option :id
+    option :description
+
+    class << self
+      def onload(&block)
+        if block
+          @onload = block
+        else
+          @onload
+        end
+      end
+    end
+
+    attr_reader :cookbook
+    attr_reader :options
+
+    def initialize(cookbook, options = {})
+      @cookbook, @options = cookbook, options
+      instance_eval(&onload)
+    end
+
+    private
+
+    def onload
+      self.class.onload || Proc.new {}
+    end
+  end
+end

data/lib/stove/plugins/git.rb

@@ -0,0 +1,71 @@
+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 -s').strip.empty?
+    end
+
+    validate(:up_to_date) do
+      git_null('fetch')
+      local  = git_null("rev-parse #{options[:branch]}").strip
+      remote = git_null("rev-parse #{options[:remote]}/#{options[:branch]}").strip
+
+      log.debug("Local SHA: #{local}")
+      log.debug("Remote SHA: #{remote}")
+
+      local == remote
+    end
+
+    after(:bump, 'Performing version bump') do
+      git %|add metadata.rb|
+      git %|commit -m "Version bump to #{cookbook.version}"|
+    end
+
+    after(:changelog, 'Committing CHANGELOG') do
+      git %|add CHANGELOG.md|
+      git %|commit -m "Publish #{cookbook.version} Changelog"|
+    end
+
+    before(:upload, 'Tagging new release') do
+      git %|tag #{cookbook.tag_version}|
+      git %|push #{options[:remote]} #{cookbook.tag_version}|
+    end
+
+    after(:dev, 'Bumping devodd release') do
+      git %|add metadata.rb|
+      git %|commit -m "Version bump to #{cookbook.version} (for development)"|
+    end
+
+    before(:finish, 'Pushing to git remote(s)') do
+      git %|push #{options[:remote]} #{options[:branch]}|
+    end
+
+    def git(command, errors = true)
+      log.debug("Running `git #{command}', errors: #{errors}")
+      response = %x|cd "#{cookbook.path}" && git #{command}|
+
+      if errors && !$?.success?
+        raise Error::GitFailed.new(command: command)
+      end
+
+      response
+    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
+  end
+end

data/lib/stove/plugins/github.rb

@@ -0,0 +1,108 @@
+module Stove
+  class Plugin::GitHub < Plugin::Base
+    id 'github'
+    description 'Publish the release to GitHub'
+
+    onload do
+      require 'faraday'
+      require 'faraday_middleware'
+      require 'octokit'
+    end
+
+    validate(:git) do
+      options[:git]
+    end
+
+    validate(:configuration) do
+      Config.has_key?(:github)
+    end
+
+    validate(:access_token) do
+      Config[:github].has_key?(:access_token)
+    end
+
+    after(:upload, 'Publishing the release to GitHub') do
+      release = client.create_release(repository, cookbook.tag_version,
+        name: cookbook.tag_version,
+        body: cookbook.changeset,
+      )
+      asset = client.upload_asset("repos/#{repository}/releases/#{release.id}", cookbook.tarball,
+        content_type: 'application/x-gzip',
+        name: filename,
+      )
+      client.update_release_asset("repos/#{repository}/releases/assets/#{asset.id}",
+        name: filename,
+        label: 'Download Cookbook',
+      )
+    end
+
+    def client
+      return @client if @client
+
+      config = {}.tap do |h|
+        h[:middleware]   = middleware
+        h[:access_token] = Config[:github][:access_token]
+        h[:api_endpoint] = Config[:github][:api_endpoint] if Config[:github][:api_endpoint]
+      end
+
+      @client = Octokit::Client.new(config)
+      @client
+    end
+
+    def changeset
+      @changeset ||= cookbook.changeset.split("\n")[2..-1].join("\n").strip
+    end
+
+    def repository
+      @repository ||= Octokit::Repository.from_url(repo_url)
+    end
+
+    def filename
+      @filename ||= "#{cookbook.name}-#{cookbook.version}.tar.gz"
+    end
+
+    def middleware
+      Faraday::Builder.new do |builder|
+        # Handle any common errors
+        builder.use Stove::Middleware::Exceptions
+        builder.use Octokit::Response::RaiseError
+
+        # Log all requests and responses (useful for development)
+        builder.response :logger, log
+
+        # Raise errors on 40x and 50x responses
+        builder.response :raise_error
+
+        # Use the default adapter (Net::HTTP)
+        builder.adapter :net_http
+      end
+    end
+
+    #
+    # The URL for this repository on GitHub. This method automatically
+    # translates SSH and git:// URLs to https:// URLs.
+    #
+    # @return [String]
+    #
+    def repo_url
+      return @repo_url if @repo_url
+
+      path = File.join('.git', 'config')
+      log.debug("Calculating repo_url from `#{path}'")
+
+      config = File.read(path)
+      log.debug("Config contents:\n#{config}")
+
+      config =~ /\[remote "#{options[:remote]}"\]\n\s+url = (.+)$/
+      log.debug("Match: #{$1.inspect}")
+
+      @repo_url = $1.to_s
+                    .strip
+                    .gsub(/\.git$/, '')
+                    .gsub(':', '/')
+                    .gsub('@', '://')
+                    .gsub('git://', 'https://')
+      @repo_url
+    end
+  end
+end

data/lib/stove/plugins/jira.rb

@@ -0,0 +1,72 @@
+module Stove
+  class Plugin::JIRA < Plugin::Base
+    id 'jira'
+    description 'Resolve JIRA issues'
+
+    validate(:configuration) do
+      Config.has_key?(:jira)
+    end
+
+    validate(:username) do
+      Config[:jira].has_key?(:username)
+    end
+
+    validate(:password) do
+      Config[:jira].has_key?(:password)
+    end
+
+    before(:changelog, 'Generate JIRA changeset') do
+      by_type = unreleased_issues.inject({}) do |hash, issue|
+        type = issue['fields']['issuetype']['name']
+        hash[type] ||= []
+        hash[type] << {
+          key:     issue['key'],
+          summary: issue['fields']['summary'],
+        }
+
+        hash
+      end
+
+      # Calculate the JIRA path based off of the JIRA base_url
+      jira_base = URI.parse(JIRA.base_url)
+      jira_base.path = ''
+      jira_base = jira_base.to_s
+      log.debug("JIRA base is `#{jira_base}'")
+
+      contents = []
+
+      by_type.each do |type, issues|
+        contents << "### #{type}"
+        issues.sort { |a, b| b[:key].to_i <=> a[:key].to_i }.each do |issue|
+          url = "#{jira_base}/browse/#{issue[:key]}"
+          contents << "- **[#{issue[:key]}](#{url})** - #{issue[:summary]}"
+        end
+        contents << ''
+      end
+
+      cookbook.changeset = contents.join("\n")
+    end
+
+    after(:upload, 'Resolving JIRA issues') do
+      unreleased_issues.collect do |issue|
+        Thread.new do
+          JIRA.close_and_comment(issue['key'], "Released in #{cookbook.version}")
+        end
+      end.map(&:join)
+    end
+
+    #
+    # The list of unreleased tickets on JIRA.
+    #
+    # @return [Array<Hash>]
+    #
+    def unreleased_issues
+      @unreleased_issues ||= JIRA.search(
+        project:    'COOK',
+        resolution: 'Fixed',
+        status:     'Fix Committed',
+        component:  cookbook.name,
+      )['issues']
+    end
+  end
+end