stove 1.1.2 → 2.0.0.beta.1

data/lib/stove/cli.rb

@@ -3,122 +3,150 @@ require 'stove'
 
 module Stove
   class Cli
+    include Mixin::Loggable
+
     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!
+      $stdout, $stderr = @stdout, @stderr
+
+      # Parse the options hash
       option_parser.parse!(@argv)
-      options[:new_version] = @argv.first
 
-      raise Stove::InvalidVersionError unless valid_version?(options[:new_version])
+      # Set the log level
+      Stove.log_level = options[:log_level]
 
-      Stove::Logger.set_level(options.delete(:log_level))
+      # Parse out the version from ARGV
+      options[:version] = @argv.shift
 
-      Stove::Cookbook.new(options).release!
-      @kernel.exit(0)
-    rescue => e
-      @stderr.puts "#{e.class}: #{e.message}"
+      # Useful debugging output for when people type the wrong fucking command
+      # and then open an issue like it's somehow my fault
+      log.info("Options: #{options.inspect}")
+      log.info("ARGV: #{@argv.inspect}")
 
-      if Stove::Logger.sev_threshold == ::Logger::DEBUG
-        @stderr.puts "  #{e.backtrace.join("\n  ")}"
+      # Unless the user specified --no-bump, version is a required argument, so
+      # blow up if we don't get it or if it's not a nice version string
+      if options[:bump]
+        raise OptionParser::MissingArgument.new(:version) unless options[:version]
       end
 
+      # Make a new cookbook object - this will raise an exception if there is
+      # no cookbook at the given path
+      cookbook = Cookbook.new(options[:path])
+
+      # Now execute the actual runners (validations and errors might occur)
+      Runner.run(cookbook, options)
+
+      # If we got this far, everything was successful :)
+      @kernel.exit(0)
+    rescue => e
+      log.error('Stove experienced an error!')
+      log.error(e.class.name)
+      log.error(e.message)
+      log.error(e.backtrace.join("\n"))
+
       @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
+    #
+    # 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.separator ''
+        opts.separator 'Actions:'
+
+        actions = Action.constants.map(&Action.method(:const_get))
+        actions.select(&:id).each do |action|
+          opts.on("--[no-]#{action.id}", action.description) do |v|
+            options[action.id.to_sym] = v
           end
+        end
 
-          opts.on('-p', '--path [PATH]', String, 'The path to the cookbook to release (default: PWD)') do |v|
-            options[:path] = v
-          end
+        opts.separator ''
+        opts.separator 'Plugins:'
 
-          opts.on('--[no-]git', 'Automatically tag and push to git (default: true)') do |v|
-            options[:git] = v
+        plugins = Plugin.constants.map(&Plugin.method(:const_get))
+        plugins.select(&:id).each do |plugin|
+          opts.on("--[no-]#{plugin.id}", plugin.description) do |v|
+            options[plugin.id.to_sym] = v
           end
+        end
 
-          opts.on('--[no-]github', 'Automatically release to GitHub (default: true)') do |v|
-            options[:git] = v if v
-            options[:github] = v
-          end
+        opts.separator ''
+        opts.separator 'Global Options:'
 
-          opts.on('-r', '--remote [REMOTE]', String, 'The name of the git remote to push to') do |v|
-            options[:remote] = v
-          end
+        opts.on('--locale [LANGUAGE]', 'Change the language to output messages') do |locale|
+          I18n.locale = locale
+        end
 
-          opts.on('-b', '--branch [BRANCH]', String, 'The name of the git branch to push to') do |v|
-            options[:branch] = v
-          end
+        opts.on('--log-level [LEVEL]', 'Set the log verbosity') do |v|
+          options[:log_level] = v
+        end
 
-          opts.on('--[no-]devodd', 'Automatically bump the metadata for devodd releases') do |v|
-            options[:devodd] = v
-          end
+        opts.on('--category [CATEGORY]', 'Set category for the cookbook') do |v|
+          options[:category] = 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('--path [PATH]', 'Change the path to a cookbook') do |v|
+          options[:path] = v
+        end
 
-          opts.on('--[no-]upload', 'Upload the cookbook to the Opscode Community Site (default: true)') do |v|
-            options[:upload] = v
-          end
+        opts.on('--remote [REMOTE]', 'The name of the git remote to push to') do |v|
+          options[:remote] = v
+        end
 
-          opts.on('--[no-]changelog', 'Automatically generate a CHANGELOG (default: true)') do |v|
-            options[:changelog] = v
-          end
+        opts.on('--branch [BRANCH]', 'The name of the git branch to push to') do |v|
+          options[:branch] = v
+        end
 
-          opts.on_tail('-h', '--help', 'Show this message') do
-            puts opts
-            exit
-          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
+        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,
-          github:    true,
-          devodd:    false,
-          remote:    'origin',
-          branch:    'master',
-          jira:      false,
-          upload:    true,
-          changelog: true,
-          log_level: :warn,
-        }
+    # The options to pass to the cookbook. Includes default values
+    # that are manipulated by the option parser.
+    #
+    # @return [Hash]
+    def options
+      @options ||= Hash.new(default_value).tap do |h|
+        h[:path]      = Dir.pwd
+        h[:log_level] = :warn
+
+        # Default actions/plugins
+        h[:jira]      = false
+        h[:start]     = true
+        h[:finish]    = true
+
+        h[:remote]    = 'origin'
+        h[:branch]    = 'master'
       end
+    end
 
-      # Determine if the given string is a valid version string.
-      #
-      # @return [Boolean]
-      def valid_version?(version)
-        version.to_s =~ /^\d+\.\d+\.\d+$/
+    def default_value
+      @default_value ||= if ENV['CLI_DEFAULT']
+        !!(ENV['CLI_DEFAULT'] =~ /^(true|t|yes|y|1)$/i)
+      else
+        true
       end
+    end
   end
 end

data/lib/stove/community.rb

@@ -0,0 +1,124 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module Stove
+  class Community
+    include Mixin::Instanceable
+    include Mixin::Loggable
+    include Mixin::Optionable
+
+    option :base_url,
+      ENV['COMMUNITY_URL'] || 'https://cookbooks.opscode.com/api/v1'
+
+    #
+    # Get and cache a community cookbook's JSON response from the given name
+    # and version.
+    #
+    # @example Find a cookbook by name
+    #   Community.cookbook('apache2') #=> {...}
+    #
+    # @example Find a cookbook by name and version
+    #   Community.cookbook('apache2', '1.0.0') #=> {...}
+    #
+    # @example Find a non-existent cookbook
+    #   Community.cookbook('not-real') #=> Community::BadResponse
+    #
+    # @raise [Community::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
+    #
+    # @return [Hash]
+    #   the hash of the cookbook
+    #
+    def cookbook(name, version = nil)
+      if version.nil?
+        connection.get("cookbooks/#{name}").body
+      else
+        connection.get("cookbooks/#{name}/versions/#{Util.version_for_url(version)}").body
+      end
+    end
+
+    #
+    # Upload a cookbook to the community site.
+    #
+    # @param [Cookbook] cookbook
+    #   the cookbook to upload
+    #
+    def upload(cookbook)
+      connection.post('cookbooks', {
+        tarball:  Faraday::UploadIO.new(cookbook.tarball, 'application/x-tar'),
+        cookbook: { category: cookbook.category }.to_json,
+      })
+    end
+
+    private
+
+    #
+    # The Faraday connection object with lots of pretty middleware.
+    #
+    def connection
+      @connection ||= Faraday.new(base_url) do |builder|
+        # Enable multi-part requests (for uploading)
+        builder.request :multipart
+        builder.request :url_encoded
+
+        # Encode request bodies as JSON
+        builder.request :json
+
+        # Add Mixlib authentication headers
+        builder.use Stove::Middleware::ChefAuthentication, client, key
+
+        # Handle any common errors
+        builder.use Stove::Middleware::Exceptions
+
+        # Decode responses as JSON if the Content-Type is json
+        builder.response :json
+        builder.response :json_fix
+
+        # Allow up to 3 redirects
+        builder.response :follow_redirects, limit: 3
+
+        # 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
+
+        # Set the User-Agent header for logging purposes
+        builder.headers[:user_agent] = Stove::USER_AGENT
+
+        # Set some options, such as timeouts
+        builder.options[:timeout]      = 30
+        builder.options[:open_timeout] = 30
+      end
+    end
+
+    #
+    # The name of the client to use (by default, this is the username).
+    #
+    # @return [String]
+    #
+    def client
+      Config[:community][:username]
+    end
+
+    #
+    # The path to the key on disk for authentication with the community site.
+    # If a relative path is given, it is expanded relative to the configuration
+    # file on disk.
+    #
+    # @return [String]
+    #   the path to the key on disk
+    #
+    def key
+      File.expand_path(Config[:community][:key], Config.__path__)
+    end
+  end
+end

data/lib/stove/config.rb

@@ -1,18 +1,67 @@
+require 'json'
+
 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'))) rescue {}
+  class Config
+    include Mixin::Instanceable
+    include Mixin::Loggable
+
+    #
+    # Create a new configuration object. If a configuration file does not
+    # exist, this method will output a warning to the UI and use an empty
+    # hash as the data structure.
+    #
+    def initialize
+      log.debug("Reading from config at `#{__path__}'")
+
+      contents = File.read(__path__)
+      data = JSON.parse(contents, symbolize_names: true)
+
+      log.debug("Config:\n#{JSON.pretty_generate(sanitize(data))}")
+
+      @data = data
+    rescue Errno::ENOENT
+      log.warn(<<-EOH.gsub(/^ {8}/, ''))
+        No Stove configuration file found at `#{__path__}'. Stove will assume an
+        empty configuration, which may cause problems with some plugins. It is
+        recommended that you create a Stove configuration file as documented:
+
+            https://github.com/sethvargo/stove#installation
+      EOH
+
+      @data = {}
+    end
+
+    #
+    # This is a special key that tells me where stove lives. If you actually
+    # have a key in your config called +__path__+, then it sucks to be you.
+    #
+    # @return [String]
+    #
+    def __path__
+      @path ||= File.expand_path(ENV['STOVE_CONFIG'] || '~/.stove')
+    end
+
+    #
+    # Deletegate all method calls to the underlyng hash.
+    #
+    def method_missing(m, *args, &block)
+      @data.send(m, *args, &block)
+    end
+
+    private
+
+    def sanitize(data)
+      Hash[*data.map do |key, value|
+        if value.is_a?(Hash)
+          [key, sanitize(value)]
+        else
+          if key =~ /acecss|token|password/
+            [key, '[FILTERED]']
+          else
+            [key, value]
+          end
         end
+      end.flatten(1)]
     end
   end
 end

data/lib/stove/cookbook.rb

@@ -1,165 +1,128 @@
 require 'fileutils'
-require 'retryable'
 require 'tempfile'
 require 'time'
 
 module Stove
   class Cookbook
-    require_relative 'cookbook/metadata'
+    include Mixin::Loggable
 
-    include Stove::Git
+    require_relative 'cookbook/metadata'
 
-    # The path to this cookbook.
     #
-    # @return [String]
+    # The path to this cookbook on disk.
+    #
+    # @return [Pathname]
+    #
     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
+    # The changeset for this cookbook. This is written by the changelog
+    # generator and read by various plugins.
+    #
+    # @return [String, nil]
+    #   the changeset for this cookbook
+    #
+    attr_accessor :changeset
 
+    #
     # 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
-
+    # @param [String] path
+    #   the relative or absolute path to the cookbook on disk
+    #
+    def initialize(path)
+      @path = Pathname.new(path).expand_path
       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
+      @category ||= Community.cookbook(name)['category']
+    rescue Faraday::Error::ResourceNotFound
+      log.warn("Cookbook `#{name}' not found on the Chef community site")
+      nil
     end
 
+    #
     # The URL for the cookbook on the Community Site.
     #
     # @return [String]
+    #
     def url
-      "#{Stove::CommunitySite.http_uri}/cookbooks/#{name}"
+      URI.join(Community.base_url, '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
+    #
+    # The tag version. This is just the current version prefixed with the
+    # letter "v".
+    #
+    # @example Tag version for 1.0.0
+    #   cookbook.tag_version #=> "v1.0.0"
+    #
+    # @return [String]
+    #
+    def tag_version
+      "v#{version}"
     end
 
-    # The unreleased JIRA tickets for this cookbook.
     #
-    # @return [Hashie::Dash, Array]
-    def unreleased_tickets
-      @unreleased_tickets ||= Stove::JIRA.unreleased_tickets_for(name)
+    # Deterine if this cookbook version is released on the community site
+    #
+    # @warn
+    #   This is a fairly expensive operation and the result cannot be
+    #   reliably cached!
+    #
+    # @return [Boolean]
+    #   true if this cookbook at the current version exists on the community
+    #   site, false otherwise
+    #
+    def released?
+      Community.cookbook(name, version)
+      true
+    rescue Faraday::Error::ResourceNotFound
+      false
     end
 
     #
     def release!
-      if options[:git]
-        Stove::Logger.info "Running validations"
-        validate_git_repo!
-        validate_git_clean!
-        validate_remote_updated!
-      end
-
-      Stove::Logger.info "Bumping version"
-      version_bump
-
       if options[:changelog]
-        Stove::Logger.info "Updating changelog"
+        log.info('Updating changelog')
         update_changelog
       end
-
-      if options[:git]
-        Dir.chdir(path) do
-          Stove::Logger.info "Committing git changes in '#{path}'"
-
-          git "add metadata.rb"
-          git "add CHANGELOG.md"
-          git "commit -m 'Version bump to #{tag_version}'"
-          git "push #{options[:remote]} #{options[:branch]}"
-
-          if options[:github]
-            Stove::Logger.info "Pushing release to GitHub"
-            Stove::GitHub.new(self).publish_release!
-          else
-            Stove::Logger.info "Tagging a release"
-            git "tag #{tag_version}"
-            git "push #{options[:remote]} #{tag_version}"
-          end
-        end
-      end
-
-      if options[:upload]
-        Stove::Logger.info "Uploading cookbook"
-        retryable(tries: 3) do
-          upload
-        end
-      end
-
-      if options[:jira]
-        Stove::Logger.info "Resolving JIRA issues"
-        resolve_jira_issues
-      end
-
-      if options[:devodd]
-        Stove::Logger.info "Bumping devodd release"
-        split = version.split('.').map(&:to_i)
-        split[2] += 1
-        devodd = split.join('.')
-
-        version_bump(devodd)
-
-        if options[:git]
-          Dir.chdir(path) do
-            git "add metadata.rb"
-            git "commit -m 'Version bump to #{tag_version}'"
-            git "push #{options[:remote]} #{options[:branch]}"
-          end
-        end
-      end
-    end
-
-    def tag_version
-      "v#{version}"
     end
 
+    #
     # So there's this really really crazy bug that the tmp directory could
     # be deleted mid-request...
     #
     # @return [File]
+    #
     def tarball
       return @tarball if @tarball && File.exists?(@tarball)
 
@@ -170,59 +133,25 @@ module Stove
     end
 
     #
-    def upload
-      Stove::Uploader.new(self).upload!
-    end
-
-    # The URL for this repository on GitHub. This method automatically
-    # translates SSH and git:// URLs to https:// URLs.
+    # Bump the version in the metdata.rb to the specified
+    # parameter.
     #
-    # @return [String]
-    def repository_url
-      @repository_url ||= git("config --get remote.#{options[:remote]}.url")
-                            .strip
-                            .gsub(/\.git$/, '')
-                            .gsub(':', '/')
-                            .gsub('@', '://')
-                            .gsub('git://', 'https://')
-    end
-
-    # The set of changes for this diff/patch in markdown format.
+    # @param [String] new_version
+    #   the version to bump to
     #
     # @return [String]
-    def changeset
-      return @changeset if @changeset
-
-      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'],
-          }
+    #   the new version string
+    #
+    def bump(new_version)
+      return true if new_version.to_s == version.to_s
 
-          hash
-        end
+      metadata_path = path.join('metadata.rb')
+      contents      = File.read(metadata_path)
 
-        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.sub!(/^version(\s+)('|")#{version}('|")/, "version\\1\\2#{new_version}\\3")
 
-      @changeset = contents.join("\n")
-      @changeset
+      File.open(metadata_path, 'w') { |f| f.write(contents) }
+      reload_metadata!
     end
 
     private
@@ -234,7 +163,7 @@ module Stove
       # @return [String]
       #   the path to the metadata file
       def load_metadata!
-        metadata_path = File.expand_path(File.join(path, 'metadata.rb'))
+        metadata_path = path.join('metadata.rb')
 
         @metadata = Stove::Cookbook::Metadata.from_file(metadata_path)
         @name     = @metadata.name
@@ -243,96 +172,5 @@ module Stove
         metadata_path
       end
       alias_method :reload_metadata!, :load_metadata!
-
-      # 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 = File.join(path, 'CHANGELOG.md')
-        contents  = File.readlines(changelog)
-        index     = contents.find_index { |line| line =~ /(--)+/ }
-
-        if index.nil?
-          raise Stove::InvalidChangelogError, "Your CHANGELOG does not exist" \
-            " or is not in a valid format!"
-        end
-
-        tmpfile  = Tempfile.new(['changes', '.md'])
-        tmpfile.write(changeset)
-        tmpfile.rewind
-        response = shellout("$EDITOR #{tmpfile.path}")
-
-        unless response.success?
-          Stove::Logger.debug response.stdout
-          Stove::Logger.debug response.stderr
-          raise Stove::Error, response.stderr
-        end
-
-        @changeset = File.read(tmpfile.path).strip
-
-        contents.insert(index - 2, "\n" + @changeset + "\n\n")
-        File.open(changelog, 'w') { |f| f.write(contents.join('')) }
-      rescue SystemExit, Interrupt
-        raise Stove::UserCanceledError
-      ensure
-        if defined?(tmpfile)
-          tmpfile.close
-          tmpfile.unlink
-        end
-      end
-
-      # Bump the version in the metdata.rb to the specified
-      # parameter.
-      #
-      # @return [String]
-      #   the new version string
-      def version_bump(bump_version = new_version)
-        return true if bump_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#{bump_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
-
-      # Validate that the remote git repository is up to date.
-      #
-      # @raise [Stove::GitError::OutOfSync]
-      #   if the current git repo is not up to date with the remote
-      def validate_remote_updated!
-        Dir.chdir(path) do
-          raise Stove::GitError::OutOfSync unless git_remote_uptodate?(options)
-        end
-      end
   end
 end