kamaze-project 1.0.0

data/lib/kamaze/project/tools/gemspec/builder.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require 'fileutils'
+require 'rubygems'
+require 'rubygems/gem_runner'
+
+require_relative 'packager'
+
+# Package a ``gem`` from its own ``gemspec`` file
+#
+# The build command allows you to create a ``gem`` from a ruby ``gemspec``.
+#
+# The best way to build a gem is to use a Rakefile and the Gem::PackageTask
+# which ships with RubyGems. But, you can also use this class ;).
+#
+# Sample of use:
+#
+# ```ruby
+# builder = Kamaze.project.tools.fetch(:gemspec_builder)
+# builder.build if builder.ready?
+# ```
+class Kamaze::Project::Tools::Gemspec::Builder
+  # Build ``.gem`` file
+  #
+  # @return [self]
+  def build
+    prepare
+
+    buildable_dir = self.buildable.dirname.realpath
+
+    # dive into ``src`` file
+    Dir.chdir(gemspec_srcfile.dirname) do
+      Gem::GemRunner.new.run(build_args).yield_self do |file|
+        FileUtils.mv(file, buildable_dir)
+
+        buildable_dir.join(file)
+      end
+    end
+
+    self
+  end
+
+  # Get buildable (relative path)
+  #
+  # @return [Pathname]
+  def buildable
+    full_name = gemspec_reader.read(Hash).fetch(:full_name)
+    file_path = fs.package_dirs
+                  .fetch(:gem)
+                  .join("#{full_name}.gem")
+                  .to_s
+                  .gsub(%r{^\./}, '')
+
+    ::Pathname.new(file_path)
+  end
+
+  def ready?
+    gemspec_reader.read(Hash)[:full_name].nil? ? false : super
+  end
+
+  alias buildable? ready?
+
+  # Get path do gemspec present in ``src`` dir
+  #
+  # @return [Pathname]
+  def gemspec_srcfile
+    (package_dirs.fetch(:src)
+                 .realpath
+                 .join(buildable.basename('.*')).to_s
+                 .gsub(/-([0-9 \.])+$/, '') + '.gemspec').yield_self do |s|
+      Pathname.new(s)
+    end
+  end
+
+  protected
+
+  def setup
+    super
+
+    self.package_labels = [:src, :gem]
+    self.purgeables     = [:gem]
+    self.package_name   = "ruby/gem-#{Gem::VERSION}"
+  end
+
+  # Get args used by ``gem`` command
+  #
+  # @return [Array<String>]
+  def build_args
+    Dir.chdir(pwd) do
+      [:build, gemspec_srcfile, '--norc'].map(&:to_s)
+    end
+  end
+end

data/lib/kamaze/project/tools/gemspec/concern.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../gemspec'
+
+# Concern for ``Gemspec``
+module Kamaze::Project::Tools::Gemspec::Concern
+end

data/lib/kamaze/project/tools/gemspec/concern/reading.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../reader'
+require_relative '../concern'
+
+# Provides gemspec reader
+#
+# Base objects using a ``gemspec`` to obtain specification
+#
+# @see Kamaze::Project::Tools::Gemspec::Reader
+module Kamaze::Project::Tools::Gemspec::Concern::Reading
+  class << self
+    def included(base)
+      return if base.respond_to?(:'gemspec_reader=')
+
+      base.class_eval <<-"ACCESSORS", __FILE__, __LINE__ + 1
+        attr_writer :gemspec_reader
+      ACCESSORS
+    end
+  end
+
+  protected
+
+  # @return [Kamaze::Project::Tools::Gemspec::Reader]
+  def gemspec_reader
+    @gemspec_reader ||= Kamaze.project.fetch(:gemspec_reader)
+
+    @gemspec_reader
+  end
+
+  # Get specification
+  #
+  # @return [Gem::Specification]
+  def specification
+    specification = gemspec_reader.read
+
+    specification.define_singleton_method(:'ready?') do
+      gemspec_reader.read(Hash).include?(:full_name)
+    end
+
+    specification
+  end
+end

data/lib/kamaze/project/tools/gemspec/packager.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require_relative '../gemspec'
+require_relative 'concern/reading'
+
+# Provide a specialized packager, for ``gemspec`` based projects
+#
+# A ``gemspec`` reader class is used,
+# it can be retrieved through ``project`` tools.
+# This dynamic behaviour is the default one, but a specific reader or
+# a ``project`` can be defined during initialization.
+#
+# Gem ``specification`` (``Gem::Specification``) is retrieved through
+# the gemspec reader. The gemspec reader
+# can be dynamically retrieved through the project.
+#
+# @abstract
+class Kamaze::Project::Tools::Gemspec::Packager
+  include Kamaze::Project::Tools::Gemspec::Concern::Reading
+
+  def mutable_attributes
+    [:gemspec_reader]
+  end
+
+  # Denote ready
+  #
+  # Test to detect if specification seems to be complete,
+  # incomplete specification denotes a missing gemspec file
+  #
+  # @return [Boolean]
+  def ready?
+    gemspec_reader.read(Hash).include?(:full_name)
+  end
+
+  protected
+
+  # Get package(d) files
+  #
+  # @return [Array<String>]
+  def package_files
+    (Dir.glob([
+                '*.gemspec',
+                'Gemfile', 'Gemfile.lock',
+                'gems.rb', 'gems.locked',
+              ]) + (gemspec_reader.read&.files).to_a).sort
+  end
+
+  def setup
+    @gemspec_reader ||= Kamaze.project.tools.fetch(:gemspec_reader)
+
+    self.verbose      = false
+    self.source_files = package_files if self.source_files.to_a.empty?
+  end
+
+  # Get specification
+  #
+  # @return [Gem::Specification]
+  def specification
+    gemspec_reader.read
+  end
+end

data/lib/kamaze/project/tools/gemspec/packer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require 'pathname'
+require 'rubygems'
+require_relative 'reader'
+require_relative 'packer/command'
+
+# Provides a ready to use interface based on rubyc (aka ruby-packer)
+#
+# @see https://github.com/pmq20/ruby-packer
+class Kamaze::Project::Tools::Gemspec::Packer
+  # Binary (executable) used to pack the project
+  #
+  # @see https://github.com/pmq20/ruby-packer
+  attr_accessor :compiler
+
+  # Get buildable (relative path)
+  #
+  # @return [Array<Pathname>]
+  def packables
+    specification.executables.map do |executable|
+      package_dirs.fetch(:bin)
+                  .join(executable)
+                  .to_s.gsub(%r{^./}, '')
+                  .yield_self { |path| ::Pathname.new(path) }
+    end
+  end
+
+  # Get host config, retrieved from ``RbConfig::CONFIG``
+  #
+  # @return [Hash]
+  def config
+    (RbConfig::CONFIG.map { |k, v| [k.to_sym, v] }).to_h
+  end
+
+  # Pack given packable
+  #
+  # @param [String] packable
+  # @return [Pathname]
+  def pack(packable)
+    bin_dir = ::Pathname.new(specification.bin_dir)
+
+    prepare
+    command_for(packable).execute
+
+    bin_dir.join(packable)
+  end
+
+  def mutable_attributes
+    super + [:compiler]
+  end
+
+  protected
+
+  def setup
+    super
+
+    self.package_labels = [:src, :tmp, :bin]
+    self.purgeables     = [:bin]
+    self.package_name   = '%<os>s/%<arch>s' % {
+      os: config.fetch(:host_os),
+      arch: config.fetch(:host_cpu)
+    }
+  end
+
+  # Get command for (packing) a given packable
+  #
+  # @param [String] packable
+  # @return [Command]
+  def command_for(packable)
+    bin_dir = ::Pathname.new(specification.bin_dir)
+
+    Dir.chdir(pwd) do
+      Command.new do |command|
+        command.executable = compiler
+        command.src_dir    = package_dirs.fetch(:src)
+        command.tmp_dir    = package_dirs.fetch(:tmp)
+        command.bin_dir    = bin_dir
+        command.packable   = packable
+      end
+    end
+  end
+end

data/lib/kamaze/project/tools/gemspec/packer/command.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2017-2018 Dimitri Arrigoni <dimitri@arrigoni.me>
+# License GPLv3+: GNU GPL version 3 or later
+# <http://www.gnu.org/licenses/gpl.html>.
+# This is free software: you are free to change and redistribute it.
+# There is NO WARRANTY, to the extent permitted by law.
+
+require 'pathname'
+require 'cliver'
+
+require_relative '../packer'
+require_relative '../../../concern/sh'
+require_relative '../../../concern/cli/with_exit_on_failure'
+
+# Build/pack a buildable
+#
+# Command is able to execute itself.
+# Command depends on ``FileUtils::sh`` provided by ``rake``.
+#
+# During execution, command ``chdir`` to ``src_dir``.
+class Kamaze::Project::Tools::Gemspec::Packer::Command
+  include Kamaze::Project::Concern::Cli::WithExitOnFailure
+  include Kamaze::Project::Concern::Sh
+
+  # Executable used by command
+  #
+  # @type [String|Symbol]
+  attr_writer :executable
+
+  # Filepath to the product issued by command
+  attr_accessor :packable
+
+  # The directory for temporary files
+  attr_accessor :tmp_dir
+
+  # The directory where "compiled" executable stands
+  #
+  # @type [String]
+  attr_writer :bin_dir
+
+  # The path to source files
+  attr_accessor :src_dir
+
+  # @return [Pathname]
+  attr_reader :pwd
+
+  class InitializationError < RuntimeError
+  end
+
+  # @raise InitializationError
+  def initialize
+    yield self
+
+    @executable ||= :rubyc
+    @pwd = ::Pathname.new(Dir.pwd)
+
+    [:executable, :packable, :tmp_dir, :bin_dir].each do |m|
+      self.singleton_class.class_eval { protected "#{m}=" }
+
+      next unless self.__send__(m).nil?
+
+      raise InitializationError, "#{m} must be set, got nil"
+    end
+  end
+
+  # Executable used by command
+  #
+  # @return [Pathname]
+  def executable
+    ::Pathname.new(Cliver.detect!(@executable)).freeze
+  end
+
+  # Get path to "compiled" input file
+  #
+  # SHOULD like to ``bin`` as seen in gemspec ``bindir``
+  #
+  # @return [Pathname]
+  def bin_dir
+    ::Pathname.new(@bin_dir)
+  end
+
+  # @return [Array<String>]
+  def to_a
+    packable = ::Pathname.new(self.packable)
+
+    [executable,
+     bin_dir.join(packable.basename),
+     '-r', '.',
+     '-d', pwd.join(tmp_dir),
+     '-o', pwd.join(packable)].map(&:to_s)
+  end
+
+  def execute
+    env = preserved_env
+
+    Dir.chdir(pwd.join(src_dir)) do
+      with_exit_on_failure do
+        Bundler.with_clean_env do
+          sh(*[env].concat(self.to_a))
+
+          self.retcode = self.shell_runner_last_status.exitstatus
+        end
+      end
+    end
+  end
+
+  protected
+
+  # Process attributes
+  #
+  # @raise InitializationError
+  def process_attrs
+    [:executable, :packable, :tmp_dir, :bin_dir].each do |m|
+      self.singleton_class.class_eval { protected "#{m}=" }
+
+      if self.__send__(m).nil?
+        raise InitializationError, "#{m} must be set, got nil"
+      end
+    end
+
+    self
+  end
+
+  # Get preserved env (from given env)
+  #
+  # @param [ENV|Hash] from
+  # @return [Hash]
+  #
+  # @todo refactor
+  def preserved_env(from = ENV)
+    env = {}
+    from = from.to_h
+
+    ['CPPFLAGS'].each do |key|
+      next unless from.key?(key)
+
+      env[key] = from.fetch(key)
+    end
+
+    env
+  end
+end