gem-release 1.0.0 → 2.0.0.dev.1

data/lib/gem/release/cmds/release.rb

@@ -0,0 +1,100 @@
+require 'gem/release/cmds/base'
+require 'rubygems/commands/build_command'
+require 'rubygems/commands/push_command'
+
+module Gem
+  module Release
+    module Cmds
+      class Release < Base
+        summary 'Releases one or all gems in this directory.'
+
+        description <<~str
+          Builds one or many gems from the given gemspec(s), pushes them to rubygems.org
+          (or another, compatible host), and removes the left over gem file.
+
+          Optionally invoke `gem tag`.
+
+          If no argument is given the first gemspec's name is assumed as the gem name.
+          If one or many arguments are given then these will be used. If `--recurse` is
+          given then all gem names from all gemspecs in this directory or any of its
+          subdirectories will be used.
+        str
+
+        arg :gem_name, 'name of the gem (optional, will use the first gemspec, or all gemspecs if --recurse is given)'
+
+        DESCR = {
+          host:    'Push to a compatible host other than rubygems.org',
+          key:     'Use the API key from ~/.gem/credentials',
+          tag:     'Shortcut for running the `gem tag` command',
+          recurse: 'Recurse into directories that contain gemspec files'
+        }
+
+        opt '-h', '--host HOST', DESCR[:host] do |value|
+          opts[:host] = value
+        end
+
+        opt '-k', '--key KEY', DESCR[:key] do |value|
+          opts[:key] = value
+        end
+
+        opt '-t', '--tag', DESCR[:tag] do |value|
+          opts[:tag] = value
+        end
+
+        opt '--recurse', DESCR[:recurse] do |value|
+          opts[:recurse] = value
+        end
+
+        MSGS = {
+          release: 'Releasing %s with version %s',
+          build:   'Building %s',
+          push:    'Pushing %s',
+          cleanup: 'Deleting left over gem file %s'
+        }
+
+        CMDS = {
+          cleanup: 'rm -f %s'
+        }
+
+        def run
+          in_gem_dirs do
+            release
+          end
+          tag if opts[:tag]
+        end
+
+        private
+
+          def release
+            announce :release, gem.name, gem.version
+            build
+            push
+          ensure
+            cleanup
+          end
+
+          def tag
+            Tag.new(context, args, opts).run
+          end
+
+          def build
+            gem_cmd :build, gem.spec_filename
+          end
+
+          def push
+            gem_cmd :push, gem.filename, *push_args
+          end
+
+          def push_args
+            args = [:key, :host].map { |opt| ["--#{opt}", opts[opt]] if opts[opt] }
+            args << "--quiet" if quiet?
+            args.compact.flatten
+          end
+
+          def cleanup
+            cmd :cleanup, gem.filename
+          end
+      end
+    end
+  end
+end

data/lib/gem/release/cmds/runner.rb

@@ -0,0 +1,52 @@
+require 'gem/release/context'
+
+module Gem
+  module Release
+    module Cmds
+      class Runner < Struct.new(:context, :name, :args, :opts)
+        def run
+          run_cmd
+          success
+        end
+
+        private
+
+          def run_cmd
+            const.new(context.class.new, args, opts).run
+          end
+
+          def const
+            Base[name]
+          end
+
+          def opts
+            except(super, :args, :build_args)
+          end
+
+          def args
+            super.select { |arg| arg.is_a?(String) && arg[0] != '-' }
+          end
+
+          def success
+            context.announce "All is good, thanks my friend." unless quiet?
+          end
+
+          def quiet?
+            opts[:quiet] || opts[:silent]
+          end
+
+          def opts
+            @opts ||= config.merge(super)
+          end
+
+          def config
+            context.config.for(name.to_sym)
+          end
+
+          def except(hash, *keys)
+            hash.reject { |key, _| keys.include?(key) }
+          end
+      end
+    end
+  end
+end

data/lib/gem/release/cmds/tag.rb

@@ -0,0 +1,93 @@
+require 'gem/release/cmds/base'
+
+module Gem
+  module Release
+    module Cmds
+      class Tag < Base
+        summary "Tags the HEAD commit with the gem's current version."
+
+        description <<~str
+          Creates an annotated tag for the current HEAD commit, using the gem's
+          current version.
+
+          Optionally pushes the tag to the origin repository.
+
+          If one or many arguments are given then gemspecs with the same names
+          will be searched, and the working directory changed to their respective
+          directories. If `--recurse` is given then the directories all gem names from
+          all gemspecs in this directory or any of its subdirectories will be used.
+          This assumes that these directories are separate git repositories.
+
+          The tag name will be `v[version]`.  For example, if the current version is
+          `1.0.0`, then The tag is created using the command `git tag -am "tag v1.0.0"
+          v1.0.0`.
+        str
+
+        DEFAULTS = {
+          push: true,
+          remote: 'origin'
+        }
+
+        DESCR = {
+          push:    'Push tag to the remote git repository',
+          remote:  'Git remote to push to (defaults to origin)',
+        }
+
+        opt '-p', '--[no]-push', DESCR[:push] do
+          opts[:push] = true
+        end
+
+        opt '--remote REMOTE', DESCR[:remote] do |value|
+          opts[:remote] = value
+        end
+
+        MSGS = {
+          tag:       'Tagging %s as version %s',
+          git_tag:   'Creating git tag %s',
+          git_push:  'Pushing tags to the %s git repository',
+          no_remote: 'Cannot push to missing git remote %s',
+        }
+
+        CMDS = {
+          git_tag:   'git tag -am "tag %s" %s',
+          git_push:  'git push --tags %s'
+        }
+
+        def run
+          in_gem_dirs do
+            announce :tag, gem.name, gem.version
+            validate
+            tag
+            push if opts[:push]
+          end
+        end
+
+        private
+
+          def validate
+            abort :no_remote, remote if push? && !git_remotes.include?(remote)
+          end
+
+          def tag
+            cmd :git_tag, tag_name, tag_name
+          end
+
+          def push
+            cmd :git_push, remote
+          end
+
+          def tag_name
+            "v#{gem.version}"
+          end
+
+          def push?
+            opts[:push] || opts[:push_commit]
+          end
+
+          def remote
+            opts[:remote]
+          end
+      end
+    end
+  end
+end

data/lib/gem/release/config.rb

@@ -0,0 +1,42 @@
+require 'gem/release/config/env'
+require 'gem/release/config/files'
+require 'gem/release/helper/hash'
+
+module Gem
+  module Release
+    class Config
+      include Helper::Hash
+
+      attr_reader :opts
+
+      SOURCES = [Env, Files]
+
+      def initialize
+        @opts = load
+      end
+
+      def [](key)
+        opts[key]
+      end
+
+      def for(key)
+        common.merge(self[key] || {})
+      end
+
+      def common
+        opts.reject { |_, value| value.is_a?(Hash) }
+      end
+
+      private
+
+        def load
+          opts = sources.map(&:load)
+          opts.inject { |one, other| deep_merge(one, other) }
+        end
+
+        def sources
+          SOURCES.map(&:new)
+        end
+    end
+  end
+end

data/lib/gem/release/config/env.rb

@@ -0,0 +1,49 @@
+require 'gem/release/helper/hash'
+
+module Gem
+  module Release
+    class Config
+      class Env
+        include Helper::Hash
+
+        PREFIX = 'GEM_RELEASE_'
+        TRUE   = /^(true|yes|on)$/
+        FALSE  = /^(false|no|off)$/
+
+        def load
+          opts = vars.map { |key, value| to_hash(keys_for(key), cast(value)) }
+          opts = opts.inject { |one, other| deep_merge(one, other) }
+          opts || {}
+        end
+
+        private
+
+          def vars
+            ENV.select { |key, _| key.start_with?(PREFIX) }
+          end
+
+          def keys_for(key)
+            key.sub(PREFIX, '').split('_').map(&:downcase).map(&:to_sym)
+          end
+
+          def to_hash(keys, value)
+            keys = keys.reverse
+            keys.inject(keys.shift => value) { |value, key| { key => value } }
+          end
+
+          def cast(value)
+            case value
+            when TRUE
+              true
+            when FALSE
+              false
+            when ''
+              false
+            else
+              value
+            end
+          end
+      end
+    end
+  end
+end

data/lib/gem/release/config/files.rb

@@ -0,0 +1,35 @@
+require 'yaml'
+require 'gem/release/helper/hash'
+
+module Gem
+  module Release
+    class Config
+      class Files
+        include Helper::Hash
+
+        PATHS = %w(
+          ./.gem_release/config.yml
+          ./.gem_release.yml
+          ~/.gem_release/config.yml
+          ~/.gem_release.yml
+        )
+
+        def load
+          return {} unless path
+          symbolize_keys(YAML.load_file(path) || {})
+        end
+
+        private
+
+          def path
+            @path ||= paths.first
+          end
+
+          def paths
+            paths = PATHS.map { |path| File.expand_path(path) }
+            paths.select { |path| File.exists?(path) }
+          end
+      end
+    end
+  end
+end

data/lib/gem/release/context.rb

@@ -0,0 +1,76 @@
+require 'gem/release/context/gem'
+require 'gem/release/context/paths'
+require 'gem/release/context/system'
+
+module Gem
+  module Release
+    class Context
+      class << self
+        attr_accessor :last
+      end
+
+      attr_accessor :config, :gem, :system
+
+      COLORS = {
+        red:    "\e[31m",
+        green:  "\e[32m",
+        yellow: "\e[33m",
+        blue:   "\e[34m",
+        gray:   "\e[37m",
+        reset:  "\e[0m"
+      }
+
+      def initialize(name = nil)
+        @config = Config.new
+        @gem    = Gem.new(name || File.basename(Dir.pwd))
+        @system = System.new
+      end
+
+      def announce(str)
+        puts colored(:green, with_spacing(str, true))
+      end
+
+      def info(str)
+        puts colored(:blue, with_spacing(str, true))
+      end
+
+      def notice(str)
+        puts colored(:gray, with_spacing(str, false))
+      end
+
+      def warn(str)
+        puts colored(:yellow, with_spacing(str, false))
+      end
+
+      def error(str)
+        puts colored(:red, with_spacing(str, true))
+      end
+
+      def abort(str)
+        error(str)
+        exit 1
+      end
+
+      def in_dirs(args, opts, &block)
+        Paths::ByNames.new(args, opts).in_dirs(&block)
+      end
+
+      def in_gem_dirs(args, opts, &block)
+        Paths::ByGemspecs.new(args, opts).in_dirs(&block)
+      end
+
+      private
+
+        def colored(color, str)
+          [COLORS[color], str, COLORS[:reset]].join
+        end
+
+        def with_spacing(str, space)
+          space = false if self.class.last.nil?
+          str = "\n#{str}" if space && !self.class.last
+          self.class.last = space
+          str
+        end
+    end
+  end
+end