stove 1.0.0

data/features/step_definitions/cli_steps.rb

@@ -0,0 +1,23 @@
+Given /^the environment variable (.+) is "(.+)"$/ do |variable, value|
+  set_env(variable, value)
+end
+
+Then /^the exit status will be "(.+)"$/ do |error|
+  code = Stove.const_get(error).exit_code
+  assert_exit_status(code)
+end
+
+When /^the CLI options are all off$/ do
+  class Stove::Cli
+    private
+      def options
+        @options ||= {
+          :git       => false,
+          :jira      => false,
+          :upload    => false,
+          :changelog => false,
+          :log_level => :debug,
+        }
+      end
+  end
+end

data/features/step_definitions/community_site_steps.rb

@@ -0,0 +1,25 @@
+Given /^the Community Site has the cookbooks?:$/ do |table|
+  table.raw.each do |name, version, category|
+    version  ||= '0.0.0'
+    category ||= 'Other'
+
+    CommunityZero::Cookbook.create({
+      name: name,
+      version: version,
+      category: category,
+    })
+  end
+end
+
+Then /^the Community Site will( not)? have the cookbooks?:$/ do |negate, table|
+  table.raw.each do |name, version, category|
+    cookbook = CommunityZero::Store.find(name, version)
+
+    if negate
+      expect(cookbook).to be_nil
+    else
+      expect(cookbook).to_not be_nil
+      expect(cookbook.category).to eql(category) if category
+    end
+  end
+end

data/features/step_definitions/cookbook_steps.rb

@@ -0,0 +1,25 @@
+Given /^I have a cookbook named "(.+)"(?: (?:at|with) version "(.+)")?$/ do |name, version|
+  create_cookbook(name, version)
+end
+
+Given /^I have a cookbook named "(.+)"(?: (?:at|with) version "(.+)")? with git support$/ do |name, version|
+  create_cookbook(name, version, git: true)
+end
+
+
+# Create a new cookbook with the given name and version.
+#
+# @param [String] name
+# @param [String] version (default: 0.0.0.0)
+# @param [Hash] options
+def create_cookbook(name, version, options = {})
+  create_dir(name)
+  cd(name)
+  write_file('CHANGELOG.md', "#{name} Cookbook CHANGELOG\n=====\n\nv0.0.0\n-----")
+  write_file('README.md', 'This is a README')
+  write_file('metadata.rb', "name '#{name}'\nversion '#{version || '0.0.0'}'")
+
+  if options[:git]
+    git_init(current_dir)
+  end
+end

data/features/step_definitions/git_steps.rb

@@ -0,0 +1,19 @@
+Then /^the git remote will( not)? have the commit "(.+)"$/ do |negate, message|
+  commits = git_commits(fake_git_remote)
+
+  if negate
+    expect(commits).to_not include(message)
+  else
+    expect(commits).to include(message)
+  end
+end
+
+Then /^the git remote will( not)? have the tag "(.+)"$/ do |negate, tag|
+  tags = git_tags(fake_git_remote)
+
+  if negate
+    expect(tags).to_not include(tag)
+  else
+    expect(tags).to include(tag)
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,29 @@
+require 'aruba/api'
+require 'aruba/cucumber'
+require 'aruba/in_process'
+require 'rspec/expectations'
+require 'stove'
+
+require_relative '../../spec/support/community_site'
+require_relative '../../spec/support/git'
+
+World(Aruba::Api)
+World(Stove::RSpec::Git)
+
+Aruba::InProcess.main_class = Stove::Cli
+Aruba.process = Aruba::InProcess
+
+Stove.set_formatter(:silent)
+Stove::RSpec::CommunitySite.start(port: 3390)
+Stove::CommunitySite.base_uri(Stove::RSpec::CommunitySite.server_url)
+Stove::CommunitySite.http_uri(Stove::RSpec::CommunitySite.server_url)
+
+Before do
+  @dirs = [Dir.mktmpdir]
+  Stove::RSpec::CommunitySite.reset!
+end
+
+# The path to Aruba's "stuff"
+def tmp_path
+  File.expand_path(@dirs.first.to_s)
+end

data/features/upload.feature

@@ -0,0 +1,44 @@
+Feature: Upload
+  As a stove user
+  In order to upload cookbooks
+  I want to tar and push to a Community Site
+
+  Background:
+    * I have a cookbook named "bacon"
+    * the CLI options are all off
+
+  Scenario: --no-upload
+    * I successfully run `bake 1.0.0 --no-upload`
+    * the Community Site will not have the cookbook:
+      | bacon | 1.0.0 |
+
+  Scenario: --upload (no category, no existing)
+    * I run `bake 1.0.0 --upload`
+    * the Community Site will not have the cookbook:
+      | bacon | 1.0.0 |
+    * the exit status will be "CookbookCategoryNotFound"
+
+  Scenario: --upload (no category, existing)
+    * the Community Site has the cookbook:
+      | bacon | 0.0.0 | Application |
+    * I successfully run `bake 1.0.0 --upload`
+    * the Community Site will have the cookbook:
+      | bacon | 1.0.0 | Application |
+
+  Scenario: --upload (category, no existing)
+    * I successfully run `bake 1.0.0 --upload --category Application`
+    * the Community Site will have the cookbook:
+      | bacon | 1.0.0 | Application |
+
+  Scenario: --upload (category, existing)
+    * the Community Site has the cookbook:
+      | bacon | 0.0.0 | Application |
+    * I successfully run `bake 1.0.0 --upload --category Application`
+    * the Community Site will have the cookbook:
+      | bacon | 1.0.0 | Application |
+
+  Scenario: --upload (existing version)
+    * the Community Site has the cookbook:
+      | bacon | 1.0.0 | Application |
+    * I run `bake 1.0.0 --upload`
+    * the exit status will be "UploadError"

data/lib/stove.rb

@@ -0,0 +1,26 @@
+module Stove
+  require_relative 'stove/config'
+  require_relative 'stove/git'
+  require_relative 'stove/logger'
+
+  require_relative 'stove/cli'
+  require_relative 'stove/community_site'
+  require_relative 'stove/cookbook'
+  require_relative 'stove/error'
+  require_relative 'stove/formatter'
+  require_relative 'stove/jira'
+  require_relative 'stove/mash'
+  require_relative 'stove/packager'
+  require_relative 'stove/uploader'
+  require_relative 'stove/version'
+
+  class << self
+    def formatter
+      @formatter ||= Stove::Formatter::Human.new
+    end
+
+    def set_formatter(name)
+      @formatter = Stove::Formatter::Base.formatters[name.to_sym].new
+    end
+  end
+end

data/lib/stove/cli.rb

@@ -0,0 +1,131 @@
+require 'optparse'
+require 'stove'
+
+module Stove
+  class Cli
+    def initialize(argv, stdin=STDIN, stdout=STDOUT, stderr=STDERR, kernel=Kernel)
+      @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+      $stdout, @stderr = @stdout, @stderr
+    end
+
+    def execute!
+      option_parser.parse!(@argv)
+      options[:new_version] = @argv.first
+
+      raise Stove::InvalidVersionError unless valid_version?(options[:new_version])
+
+      Stove::Cookbook.new(options).release!
+      @kernel.exit(0)
+    rescue => e
+      @stderr.puts "#{e.class}: #{e.message}"
+
+      if Stove::Logger.sev_threshold == ::Logger::DEBUG
+        @stderr.puts "  #{e.backtrace.join("\n  ")}"
+      end
+
+      @kernel.exit(e.respond_to?(:exit_code) ? e.exit_code : 500)
+    ensure
+      $stdout, $stderr = STDOUT, STDERR
+    end
+
+    private
+      # The option parser for handling command line flags.
+      #
+      # @return [OptionParser]
+      def option_parser
+        @option_parser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: bake x.y.z"
+
+          opts.on('-l', '--log-level [LEVEL]', [:fatal, :error, :warn, :info, :debug], 'Ruby log level') do |v|
+            options[:log_level] = v
+          end
+
+          opts.on('-c', '--category [CATEGORY]', String, 'The category for the cookbook (optional for existing cookbooks)') do |v|
+            options[:category] = v
+          end
+
+          opts.on('-p', '--path [PATH]', String, 'The path to the cookbook to release (default: PWD)') do |v|
+            options[:path] = v
+          end
+
+          opts.on('--[no-]git', 'Automatically tag and push to git (default: true)') do |v|
+            options[:git] = v
+          end
+
+          opts.on('-r', '--remote', String, 'The name of the git remote to push to') do |v|
+            options[:remote] = v
+          end
+
+          opts.on('-b', '--branch', String, 'The name of the git branch to push to') do |v|
+            options[:branch] = v
+          end
+
+          opts.on('--[no-]jira', 'Automatically populate the CHANGELOG from JIRA tickets and close them (default: false)') do |v|
+            options[:jira] = v
+          end
+
+          opts.on('--[no-]upload', 'Upload the cookbook to the Opscode Community Site (default: true)') do |v|
+            options[:upload] = v
+          end
+
+          opts.on('--[no-]changelog', 'Automatically generate a CHANGELOG (default: true)') do |v|
+            options[:changelog] = v
+          end
+
+          opts.on_tail('-h', '--help', 'Show this message') do
+            puts opts
+            exit
+          end
+
+          opts.on_tail('-v', '--version', 'Show version') do
+            puts Stove::VERSION
+            exit(0)
+          end
+        end
+      end
+
+      # The options to pass to the cookbook. Includes default values
+      # that are manipulated by the option parser.
+      #
+      # @return [Hash]
+      def options
+        @options ||= {
+          :path      => Dir.pwd,
+          :git       => true,
+          :remote    => 'origin',
+          :branch    => 'master',
+          :jira      => false,
+          :upload    => true,
+          :changelog => true,
+          :log_level => :warn,
+        }
+      end
+
+      # Determine if the given string is a valid version string.
+      #
+      # @return [Boolean]
+      def valid_version?(version)
+        version.to_s =~ /^\d+\.\d+\.\d+$/
+      end
+
+      # Convert a string to it's logger constant.
+      #
+      # @return [Object]
+      def level_to_constant(level)
+        case level.to_s.strip.downcase.to_sym
+          when :fatal
+            ::Logger::FATAL
+          when :error
+            ::Logger::ERROR
+          when :warn
+            ::Logger::WARN
+          when :info
+            ::Logger::INFO
+          when :debug
+            ::Logger::DEBUG
+          else
+            ::Logger::INFO
+          end
+      end
+  end
+end

data/lib/stove/community_site.rb

@@ -0,0 +1,85 @@
+require 'httparty'
+
+module Stove
+  class CommunitySite
+    include HTTParty
+    base_uri 'https://cookbooks.opscode.com/api/v1'
+    headers 'Content-Type' => 'application/json', 'Accept' => 'application/json'
+
+    class << self
+      # The URI for the web-based version of the site. (default:
+      # https://community.opscode.com).
+      #
+      # If a parameter is given, the {http_uri} is set to that value.
+      #
+      # @return [String]
+      def http_uri(arg = nil)
+        if arg.nil?
+          @http_uri ||= 'https://community.opscode.com'
+        else
+          @http_uri = arg
+          @http_uri
+        end
+      end
+
+      # Get and cache a community cookbook's JSON response from the given name
+      # and version.
+      #
+      # @example Find a cookbook by name
+      #   CommunitySite.cookbook('apache2') #=> {...}
+      #
+      # @example Find a cookbook by name and version
+      #   CommunitySite.cookbook('apache2', '1.0.0') #=> {...}
+      #
+      # @example Find a non-existent cookbook
+      #   CommunitySite.cookbook('not-real') #=> CommunitySite::BadResponse
+      #
+      # @raise [CommunitySite::BadResponse]
+      #   if the given cookbook (or cookbook version) does not exist on the community site
+      #
+      # @param [String] name
+      #   the name of the cookbook on the community site
+      # @param [String] version (optional)
+      #   the version of the cookbook to find
+      def cookbook(name, version = nil)
+        if version.nil?
+          get("/cookbooks/#{name}")
+        else
+          get("/cookbooks/#{name}/versions/#{format_version(version)}")
+        end
+      end
+
+      private
+        # Convert a version string (x.y.z) to a community-site friendly format
+        # (x_y_z).
+        #
+        # @example Convert a version to a version string
+        #   format_version('1.2.3') #=> 1_2_3
+        #
+        # @param [#to_s] version
+        #  the version string to convert
+        #
+        # @return [String]
+        def format_version(version)
+          version.gsub('.', '_')
+        end
+
+        # @override [HTTParty.get]
+        def get(path, options = {}, &block)
+          cache[path] ||= begin
+            Stove::Logger.debug "Getting #{path}"
+            response = super(path)
+            raise Stove::BadResponse.new(response) unless response.ok?
+            response.parsed_response
+          end
+        end
+
+        # A small, unpersisted cache for storing responses
+        #
+        # @return [Hash]
+        def cache
+          @cache ||= {}
+        end
+    end
+  end
+end

data/lib/stove/config.rb

@@ -0,0 +1,18 @@
+module Stove
+  class Config < ::Hash
+    class << self
+      def [](thing)
+        instance[thing]
+      end
+
+      def instance
+        @instance ||= load!
+      end
+
+      private
+        def load!
+          JSON.parse(File.read(File.expand_path("~/.stove")))
+        end
+    end
+  end
+end

data/lib/stove/cookbook.rb

@@ -0,0 +1,280 @@
+require 'fileutils'
+require 'time'
+
+module Stove
+  class Cookbook
+    require_relative 'cookbook/metadata'
+
+    include Stove::Git
+
+    # The path to this cookbook.
+    #
+    # @return [String]
+    attr_reader :path
+
+    # The name of the cookbook (must correspond to the name of the
+    # cookbook on the community site).
+    #
+    # @return [String]
+    attr_reader :name
+
+    # The version of this cookbook (originally).
+    #
+    # @return [String]
+    attr_reader :version
+
+    # The new version of the cookbook.
+    #
+    # @return [String]
+    attr_reader :new_version
+
+    # The metadata for this cookbook.
+    #
+    # @return [Stove::Cookbook::Metadata]
+    attr_reader :metadata
+
+    # The list of options passed to the cookbook.
+    #
+    # @return [Hash]
+    attr_reader :options
+
+    # Create a new wrapper around the cookbook object.
+    #
+    # @param [Hash] options
+    #   the list of options
+    def initialize(options = {})
+      @path = options[:path] || Dir.pwd
+      @new_version = options[:new_version]
+      @options = options
+
+      load_metadata!
+    end
+
+    # The category for this cookbook on the community site.
+    #
+    # @return [String]
+    def category
+      @category ||= options[:category] || Stove::CommunitySite.cookbook(name)['category']
+    rescue
+      raise Stove::CookbookCategoryNotFound
+    end
+
+    # The URL for the cookbook on the Community Site.
+    #
+    # @return [String]
+    def url
+      "#{Stove::CommunitySite.http_uri}/cookbooks/#{name}"
+    end
+
+    # Deterine if this cookbook version is released on the community site
+    def released?
+      @_released ||= begin
+        Stove::CommunitySite.cookbook(name, version)
+        true
+      rescue Stove::BadResponse
+        false
+      end
+    end
+
+    # The unreleased JIRA tickets for this cookbook.
+    #
+    # @return [Hashie::Dash, Array]
+    def unreleased_tickets
+      @unreleased_tickets ||= Stove::JIRA.unreleased_tickets_for(name)
+    end
+
+    #
+    def release!
+      if options[:git]
+        validate_git_repo!
+        validate_git_clean!
+      end
+
+      version_bump
+
+      if options[:changelog]
+        update_changelog
+      end
+
+      if options[:git]
+        Dir.chdir(path) do
+          git "add metadata.rb"
+          git "add CHANGELOG.md"
+          git "commit -m 'Version bump to v#{version}'"
+          git "push #{options[:remote] || 'origin'} #{options[:branch] || 'master'}"
+
+          git "tag v#{version}"
+          git "push #{options[:remote] || 'origin'} v#{version}"
+        end
+      end
+
+      if options[:upload]
+        upload
+      end
+
+      if options[:jira]
+        resolve_jira_issues
+      end
+    end
+
+    #
+    def upload
+      return true unless options[:upload]
+      Stove::Uploader.new(self).upload!
+    end
+
+    private
+      # Load the metadata and set the @metadata instance variable.
+      #
+      # @raise [ArgumentError]
+      #   if there is no metadata.rb
+      #
+      # @return [String]
+      #   the path to the metadata file
+      def load_metadata!
+        metadata_path = File.expand_path(File.join(path, 'metadata.rb'))
+
+        @metadata = Stove::Cookbook::Metadata.from_file(metadata_path)
+        @name     = @metadata.name
+        @version  = @metadata.version
+
+        metadata_path
+      end
+      alias_method :reload_metadata!, :load_metadata!
+
+      # Create a new CHANGELOG in markdown format.
+      #
+      # @example given a cookbook named bacon
+      #   cookbook.create_changelog #=> <<EOH
+      # bacon Cookbook CHANGELOG
+      # ------------------------
+      # EOH
+      #
+      # @return [String]
+      #   the path to the new CHANGELOG
+      def create_changelog
+        destination = File.join(path, 'CHANGELOG.md')
+
+        # Be idempotent :)
+        return destination if File.exists?(destination)
+
+        header  = "#{name} Cookbook CHANGELOG\n"
+        header << "#{'='*header.length}\n"
+        header << "This file is used to list changes made in each version of the #{cookbook.name} cookbook.\n\n"
+
+        File.open(destination, 'wb') do |file|
+          file.write(header)
+        end
+
+        destination
+      end
+
+      # Update the CHANGELOG with the new contents, but inserting
+      # the newest version's CHANGELOG at the top of the file (after
+      # the header)
+      def update_changelog
+        changelog = create_changelog
+        contents  = File.readlines(changelog)
+
+        index = contents.find_index { |line| line =~ /(--)+/ } - 2
+        contents.insert(index, "\n" + generate_changelog)
+
+        Dir.mktmpdir do |dir|
+          tmpfile = File.join(dir, 'CHANGELOG.md')
+          File.open(tmpfile, 'w') { |f| f.write(contents.join('')) }
+          response = shellout("$EDITOR #{tmpfile}")
+
+          unless response.success?
+            Stove::Logger.debug response.stderr
+            raise Stove::Error, response.stderr
+          end
+
+          FileUtils.mv(tmpfile, File.join(path, 'CHANGELOG.md'))
+        end
+      rescue SystemExit, Interrupt
+        raise Stove::UserCanceledError
+      end
+
+      # Generate a CHANGELOG in markdown format.
+      #
+      # @param [String] version
+      #   the version string in x.y.z format
+      #
+      # @return [String]
+      def generate_changelog
+        contents = []
+        contents << "v#{version}"
+        contents << '-'*(version.length+1)
+
+        if options[:jira]
+          by_type = unreleased_tickets.inject({}) do |hash, ticket|
+            issue_type = ticket.fields.current['issuetype']['name']
+            hash[issue_type] ||= []
+            hash[issue_type] << {
+              number:  ticket.jira_key,
+              details: ticket.fields.current['summary'],
+            }
+
+            hash
+          end
+
+          by_type.each do |issue_type, tickets|
+            contents << "### #{issue_type}"
+            tickets.sort { |a,b| b[:number].to_i <=> a[:number].to_i }.each do |ticket|
+              contents << "- **[#{ticket[:number]}](#{Stove::JIRA::JIRA_URL}/browse/#{ticket[:number]})** - #{ticket[:details]}"
+            end
+            contents << ""
+          end
+        else
+          contents << "_Enter CHANGELOG for #{name} (#{version}) here_"
+          contents << ""
+        end
+
+        contents.join("\n")
+      end
+
+      # Bump the version in the metdata.rb to the specified
+      # parameter.
+      #
+      # @return [String]
+      #   the new version string
+      def version_bump
+        return true if new_version.to_s == version.to_s
+
+        metadata_path = File.join(path, 'metadata.rb')
+        contents      = File.read(metadata_path)
+
+        contents.sub!(/^version(\s+)('|")#{version.to_s}('|")/, "version\\1\\2#{new_version.to_s}\\3")
+
+        File.open(metadata_path, 'w') { |f| f.write(contents) }
+        reload_metadata!
+      end
+
+      # Resolve all the JIRA issues that have been merged.
+      def resolve_jira_issues
+        unreleased_tickets.collect do |ticket|
+          Thread.new { Stove::JIRA.comment_and_close(ticket, self) }
+        end.map(&:join)
+      end
+
+      # Validate that the current working directory is git repo.
+      #
+      # @raise [Stove::GitError::NotARepo]
+      #   if this is not currently a git repo
+      def validate_git_repo!
+        Dir.chdir(path) do
+          raise Stove::GitError::NotARepo unless git_repo?
+        end
+      end
+
+      # Validate that the current.
+      #
+      # @raise [Stove::GitError::DirtyRepo]
+      #   if the current working directory is not clean
+      def validate_git_clean!
+        Dir.chdir(path) do
+          raise Stove::GitError::DirtyRepo unless git_repo_clean?
+        end
+      end
+  end
+end