gem-release 1.0.0 → 2.0.0.dev.1

data/lib/gem/release/context/gem.rb

@@ -0,0 +1,28 @@
+require 'gem/release/context/gemspec'
+
+module Gem
+  module Release
+    class Context
+      class Gem
+        attr_reader :name, :spec
+
+        def initialize(name)
+          @spec = Gemspec.new(name)
+          @name = name
+        end
+
+        def version
+          spec.version.to_s if spec
+        end
+
+        def filename
+          spec.gem_filename if spec
+        end
+
+        def spec_filename
+          spec.filename if name
+        end
+      end
+    end
+  end
+end

data/lib/gem/release/context/gemspec.rb

@@ -0,0 +1,41 @@
+module Gem
+  module Release
+    class Context
+      class Gemspec < Struct.new(:name)
+        attr_reader :filename
+
+        def initialize(*)
+          super
+          @filename = name && "#{name}.gemspec" || filenames.first
+        end
+
+        def gem_name
+          gemspec.name if gemspec
+        end
+
+        def version
+          gemspec.version.to_s if gemspec
+        end
+
+        def gem_filename
+          gemspec.file_name if gemspec
+        end
+
+        def exists?
+          filename && File.exists?(filename)
+        end
+
+        private
+
+          def gemspec
+            return @gemspec if instance_variable_defined?(:@gemspec)
+            @gemspec = exists? ? ::Gem::Specification.load(filename) : nil
+          end
+
+          def filenames
+            Dir['*.gemspec'].map { |path| File.basename(path) }
+          end
+      end
+    end
+  end
+end

data/lib/gem/release/context/paths.rb

@@ -0,0 +1,87 @@
+require 'pathname'
+
+module Gem
+  module Release
+    class Context
+      class Paths < Struct.new(:names, :opts)
+        class Base < Struct.new(:names, :opts)
+          def in_dir(dir, &block)
+            dir == cwd ? yield : Dir.chdir(dir, &block)
+          end
+
+          def current
+            [[cwd, cwd.basename.to_s]]
+          end
+
+          def cwd
+            @cwd ||= Pathname.pwd
+          end
+        end
+
+        class ByNames < Base
+          def in_dirs(&block)
+            dirs.each do |dir, name|
+              dir.mkdir unless dir == cwd || dir.exist?
+              in_dir(dir) { yield name }
+            end
+          end
+
+          private
+
+            def dirs
+              names.any? ? dirs_by_names : current
+            end
+
+            def dirs_by_names
+              names.map { |name| [Pathname.new(dir || name).expand_path, name] }
+            end
+
+            def dir
+              opts[:dir]
+            end
+        end
+
+        class ByGemspecs < Base
+          def in_dirs(&block)
+            dirs.each do |dir, name|
+              in_dir(dir) { yield name }
+            end
+          end
+
+          private
+
+            def dirs
+              dirs = by_gemspecs if opts[:recurse]
+              dirs ||= by_names  if names.any?
+              dirs ||= gemspec
+              dirs || by_gemspecs || current
+            end
+
+            def by_gemspecs
+              paths = gemspecs(true).map { |path| [path.dirname, name_for(path)] }
+              paths unless paths.empty?
+            end
+
+            def by_names
+              paths = names.map { |arg| by_gemspecs.detect { |_, name| name == arg } }.compact
+              paths unless paths.empty?
+            end
+
+            def gemspec
+              path = gemspecs.first
+              [[path.expand_path.dirname, name_for(path)]] if path
+            end
+
+            def name_for(path)
+              path.basename('.gemspec').to_s
+            end
+
+            def gemspecs(recurse = false)
+              pattern = recurse ? '**/*.gemspec' : '*.gemspec'
+              Pathname.glob(pattern).map(&:expand_path).sort
+            end
+        end
+      end
+    end
+  end
+end

data/lib/gem/release/context/system.rb

@@ -0,0 +1,36 @@
+module Gem
+  module Release
+    class Context
+      class System
+        def run(cmd)
+          system(cmd)
+        end
+
+        def gem_cmd(cmd, *args)
+          ::Gem::Commands.const_get("#{cmd.to_s.capitalize}Command").new.invoke(*args.flatten)
+          # TODO what's with the return value? maybe add our own abstraction that can check the result?
+          true
+        end
+
+        def git_remotes
+          `git remote`.split("\n")
+        end
+
+        def git_user_name
+          str = `git config --get user.name`.strip
+          str unless str.empty?
+        end
+
+        def git_user_email
+          str = `git config --get user.email`.strip
+          str unless str.empty?
+        end
+
+        def github_user_name
+          str = `git config --get github.user`.strip
+          str.empty? ? git_user_name : str
+        end
+      end
+    end
+  end
+end

data/lib/gem/release/data.rb

@@ -0,0 +1,60 @@
+require 'erb'
+require 'ostruct'
+require 'gem/release/helper/string'
+
+module Gem
+  module Release
+    class Data < Struct.new(:system, :gem, :opts)
+      include Helper::String
+
+      def data
+        {
+          gem_name:     gem_name,
+          gem_path:     gem_name.gsub('-', '/'),
+          module_names: module_names,
+          author:       user_name,
+          email:        user_email,
+          homepage:     homepage,
+          licenses:     licenses,
+          summary:      '[summary]',
+          description:  '[description]',
+          files:        files
+        }
+      end
+
+      private
+
+        def module_names
+          gem_name.split('-').map { |part| camelize(part) }
+        end
+
+        def gem_name
+          gem.name || raise('No gem_name given.')
+        end
+
+        def user_name
+          system.git_user_name || '[your name]'
+        end
+
+        def user_email
+          system.git_user_email || '[your email]'
+        end
+
+        def homepage
+          "https://github.com/#{user_name}/#{gem_name}"
+        end
+
+        def licenses
+          Array(license).join(',').split(',').map(&:upcase)
+        end
+
+        def license
+          opts[:license] if opts[:license]
+        end
+
+        def files
+          STRATEGIES[(opts[:strategy] || :glob).to_sym] || STRATEGIES[:glob]
+        end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'gem/release/files/template/context'
+
+module Gem
+  module Release
+    module Files
+      class Template
+        FILES = {
+          '.gitignore' => '.gitignore',
+          'Gemfile'    => 'Gemfile',
+          'gemspec'    => '%{gem_name}.gemspec',
+          'license'    => 'MIT-LICENSE.md',
+          'main.rb'    => 'lib/%{gem_path}.rb',
+          'version.rb' => 'lib/%{gem_path}/version.rb'
+        }
+
+        attr_accessor :source, :target, :data
+
+        def initialize(source, target, data)
+          @source = source
+          @target = (FILES[target] || target) % data
+          @data   = data
+        end
+
+        PATH = File.expand_path('../..', __FILE__)
+
+        def filename
+          File.basename(target)
+        end
+
+        def write
+          return false if exists?
+          FileUtils.mkdir_p(File.dirname(target))
+          File.write(target, render)
+          true
+        end
+
+        def exists?
+          File.exist?(target.to_s)
+        end
+
+        private
+
+          def render
+            template.result(binding)
+          end
+
+          def template
+            ERB.new(File.read(source))
+          end
+
+          def binding
+            context.instance_eval { binding }
+          end
+
+          def context
+            Context.new(data)
+          end
+      end
+    end
+  end
+end

data/lib/gem/release/files/template/context.rb

@@ -0,0 +1,30 @@
+module Gem
+  module Release
+    module Files
+      class Template
+        class Context < OpenStruct
+          class Const < Struct.new(:type, :names)
+            def define(&block)
+              lines = build(names) { |name| "#{type} #{name}" }
+              lines << indent(block.call, names.size) if block
+              lines += build(names) { |name| 'end' }.reverse
+              lines.join("\n")
+            end
+
+            def build(names, &block)
+              names.map.with_index { |name, ix| indent(block.call(name), ix) }
+            end
+
+            def indent(str, level)
+              "#{'  ' * level}#{str}"
+            end
+          end
+
+          def define(type, &block)
+            Const.new(type, module_names).define(&block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Gem
+  module Release
+    module Files
+      class Templates < Struct.new(:files, :groups, :data)
+        BUILTIN = [
+          ['./.gem-release/%s'],
+          ['~/.gem-release/%s'],
+          ['../../templates/', __FILE__],
+        ]
+
+        CUSTOM = [
+          ['./.gem-release/%s'],
+          ['~/.gem-release/%s'],
+          ['../../templates/%s', __FILE__],
+        ]
+
+        LICENSE = [
+          ['./.gem-release/licenses'],
+          ['~/.gem-release/licenses'],
+          ['../../templates/licenses', __FILE__],
+        ]
+
+        def self.license(name, data)
+          file = Templates.new(["#{name}{,.*}"], [], data).license
+          file.target = "LICENSE#{File.extname(file.target)}" if file
+          file
+        end
+
+        def [](filename)
+          all.detect { |file| file.filename == filename }
+        end
+
+        def all
+          all = builtin + custom
+          all.flatten.uniq(&:target)
+        end
+
+        def builtin
+          templates_for(BUILTIN, files)
+        end
+
+        def custom
+          templates_for(CUSTOM, '**/*')
+        end
+
+        def license
+          templates_for(LICENSE, files).first
+        end
+
+        def templates_for(sources, files)
+          all = Group.new(groups, data, sources, files).all
+          all.map { |source, target| Template.new(source, target, data) }
+        end
+      end
+    end
+  end
+end
+
+require 'gem/release/files/templates/group'

data/lib/gem/release/files/templates/group.rb

@@ -0,0 +1,47 @@
+module Gem
+  module Release
+    module Files
+      class Templates
+        class Group
+          attr_reader :groups, :data, :sources, :files
+
+          def initialize(groups, data, sources, files)
+            @groups  = [:default] + Array(groups)
+            @data    = data
+            @sources = sources
+            @files   = Array(files)
+          end
+
+          def all
+            return [] unless paths.any?
+            all = Dir.glob(pattern, File::FNM_DOTMATCH)
+            all = all.select { |file| File.file?(file) }
+            all.map { |file| [file, relative(file)] }
+          end
+
+          private
+
+            def pattern
+              "{#{paths.join(',')}}/{#{files.join(',')}}"
+            end
+
+            def relative(file)
+              paths.inject(file) { |file, path| file.sub("#{path}/", '') }
+            end
+
+            def paths
+              @paths ||= groups.map do |group|
+                paths = paths_for(group).map { |path| File.expand_path(*path) }
+                paths.detect { |path| File.exists?(path) }
+              end.compact
+            end
+
+            def paths_for(group)
+              sources.map { |paths| paths.map { |path| path % group } }
+            end
+        end
+      end
+    end
+  end
+end
+