rubyinstaller-build 0.1.0

data/lib/ruby_installer/build/openstruct.rb

@@ -0,0 +1,29 @@
+module RubyInstaller
+module Build
+class Openstruct
+  def initialize(hash={})
+    @__attrs = {}
+    hash.each do |k,v|
+      send("#{k}=", v)
+    end
+  end
+
+  def method_missing(meth, *args)
+    if meth=~/\A(.*)=\z/ && args.length == 1
+      attr = $1
+      self.class.class_eval do
+        define_method(attr) do
+          @__attrs[attr]
+        end
+        define_method(meth) do |val|
+          @__attrs[attr] = val
+        end
+      end
+      @__attrs[attr] = args.first
+    else
+      super
+    end
+  end
+end
+end
+end

data/lib/ruby_installer/build/release.rb

@@ -0,0 +1,120 @@
+module RubyInstaller
+module Build
+class Release
+  def hfile(ver)
+    "CHANGELOG-#{ver}.md"
+  end
+
+  def version_regex
+    '[\w]+-(?<ver>\d+\.\d+\.\d+(\.[a-z]\w*)?-[\d\w]+)'
+  end
+
+  def headline_regex(rel=nil)
+    "^(?<pre>[^\\w]*)(?<release>#{rel ? Regexp.escape(rel) : version_regex})(?<sp1>[^\\w]+)(?<date>[2Y][0Y][0-9Y][0-9Y]-[0-1M][0-9M]-[0-3D][0-9D])(?<sp2>[ \\w]*)$"
+  end
+
+  def reldate
+    Time.now.strftime("%Y-%m-%d")
+  end
+
+  def release_text(rel)
+    ver = rel_to_ver(rel)
+    m = File.read(hfile(ver)).match(/(?<annotation>#{headline_regex(rel)}.*?)(#{headline_regex}|\z)/m) || raise("Unable to find release #{rel.inspect} in #{hfile(ver)}")
+    m[:annotation]
+  end
+
+  def release_name(rel)
+    ver = rel_to_ver(rel)
+    m = File.read(hfile(ver)).match(/#{headline_regex(rel)}/)
+    m[:release]
+  end
+
+  def rel_to_ver(rel)
+    m = rel.match(/^#{version_regex}$/)
+    raise "invalid version string #{rel.inspect}" unless m
+    m[:ver][0, 3] # Extract major and minor version "2.4" etc.
+  end
+
+  def update_history(rel)
+    hfile = hfile(rel_to_ver(rel))
+    hin = File.read(hfile)
+    hout = hin.sub(/#{headline_regex(rel)}/) do
+      $1 + $2 + $3 + reldate + $5
+    end
+    if hout != hin
+      $stderr.puts "Updating #{hfile} for release."
+      File.write(hfile, hout)
+      Rake::FileUtilsExt.sh "git", "commit", hfile, "-m", "Update release date in #{hfile}"
+    end
+  end
+
+  def tag_version(rel)
+    $stderr.puts "Tag release #{rel} with annotation:"
+    rt = release_text(rel).gsub(/\A[# ]+/, "")
+    $stderr.puts(rt.gsub(/^/, "    "))
+    IO.popen(["git", "tag", "--file=-", rel, "--cleanup=whitespace"], "w") do |fd|
+      fd.write rt
+    end
+  end
+
+  CONTENT_TYPE_FOR_EXT = {
+    ".exe" => "application/vnd.microsoft.portable-executable",
+    ".asc" => "application/pgp-signature",
+    ".7z" => "application/zip",
+    ".yml" => "application/x-yaml",
+  }
+
+  def upload_to_github(tag:, repo:, token: nil, files:)
+    require "octokit"
+
+    client = Octokit::Client.new(access_token: token)
+    release = client.releases(repo).find{|r| r.tag_name==tag }
+    $stderr.puts "#{ release ? "Add to" : "Create" } github release #{tag}"
+
+    if tag =~ /head$/
+      if release
+        headline = release.name
+        body = release.body
+            .gsub(/[2Y][0Y][0-9Y][0-9Y]-[0-1M][0-9M]-[0-3D][0-9D] [0-2H][0-9H]:[0-6M][0-9M]:[0-6S][0-9S] UTC/, Time.now.utc.strftime("%Y-%m-%d %H:%M:%S UTC"))
+            .gsub(/(Ruby version #{RUBY_PLATFORM}.*?```).*?(```)/m) do
+              $1 + "\n" + `ruby --version` + "\n" + $2
+            end
+      else
+        headline = tag
+        body = "Latest build of #{tag}"
+      end
+    else
+      headline = IO.popen(["git", "tag", "-l", tag, "--format=%(subject)"], &:read)
+      body = IO.popen(["git", "tag", "-l", tag, "--format=%(body)"], &:read)
+    end
+    raise "invalid headline of tag #{tag.inspect} #{headline.inspect}" if headline.to_s.strip.empty?
+    raise "invalid body of tag #{tag.inspect} #{body.inspect}" if body.to_s.strip.empty?
+
+    if release
+      release = client.update_release(release.url, name: headline, body: body)
+    else
+      release = client.create_release(repo, tag,
+          target_commitish: "master",
+          name: headline,
+          body: body,
+          draft: true,
+          prerelease: true
+      )
+    end
+
+    old_assets = client.release_assets(release.url)
+
+    files.each do |fname|
+      if old_asset=old_assets.find{|a| a.name == File.basename(fname) }
+        $stderr.puts "Delete old #{old_asset.name}"
+        client.delete_release_asset(old_asset.url)
+      end
+
+      $stderr.print "Uploading #{fname} (#{File.size(fname)} bytes) ... "
+      client.upload_asset(release.url, fname, content_type: CONTENT_TYPE_FOR_EXT[File.extname(fname)])
+      $stderr.puts "OK"
+    end
+  end
+end
+end
+end

data/lib/ruby_installer/build/singleton.rb

@@ -0,0 +1,45 @@
+module RubyInstaller
+module Build # Use for: Build, Runtime
+  class << self
+    # Add +path+ as a search path for DLLs
+    #
+    # This can be used to allow ruby extension files (typically named +<extension>.so+ ) to import dependent DLLs from another directory.
+    #
+    # If this method is called with a block, the path is temporary added until the block is finished.
+    # The method returns a DllDirectory instance, when called without a block.
+    # It can be used to remove the directory later.
+    def add_dll_directory(path, &block)
+      DllDirectory.new(path, &block)
+    end
+
+    # :nodoc:
+    def msys2_installation
+      @msys2_installation ||= Msys2Installation.new
+    end
+
+    # Switch to explicit DLL search paths added by add_dll_directory().
+    # Then enable paths set by RUBY_DLL_PATH environment variable and the MSYS2-MINGW directory, if available.
+    def enable_dll_search_paths
+      ENV['RUBY_DLL_PATH'].to_s.split(File::PATH_SEPARATOR).each do |path|
+        DllDirectory.new(path) rescue DllDirectory::Error
+      end
+
+      msys2_installation.enable_dll_search_paths
+    end
+
+    # Add MSYS2 to the PATH and set other environment variables required to run MSYS2.
+    #
+    # This method tries to find a MSYS2 installation or exits with a description how to install MSYS2.
+    #
+    # +mingwarch+ should be either 'mingw32', 'mingw64' or nil.
+    # In the latter case the mingw architecture is used based on the architecture of the running Ruby process.
+    def enable_msys_apps(**opts)
+      msys2_installation.enable_msys_apps(**opts)
+    end
+
+    def disable_msys_apps(**opts)
+      msys2_installation.disable_msys_apps(**opts)
+    end
+  end
+end
+end

data/lib/ruby_installer/build/task.rb

@@ -0,0 +1,20 @@
+require "rake"
+require "ruby_installer/build"
+
+module RubyInstaller
+module Build
+class Task < Openstruct
+  include Rake::DSL
+  include Utils
+
+  def initialize(thisdir: , **hash)
+    super(hash)
+    self.thisdir = thisdir
+
+    ovl_glob(File.join(thisdir, "[0-9][0-9]-*.rake")).sort.each do |taskfile|
+      eval_file(ovl_expand_file(taskfile))
+    end
+  end
+end
+end
+end

data/lib/ruby_installer/build/utils.rb

@@ -0,0 +1,110 @@
+module RubyInstaller
+module Build
+module Utils
+  WINDOWS_CMD_SHEBANG = <<-EOT.freeze
+:""||{ ""=> %q<-*- ruby -*-
+@"%~dp0ruby" -x "%~f0" %*
+@exit /b %ERRORLEVEL%
+};{ #
+bindir="${0%/*}" #
+exec "$bindir/ruby" -x "$0" "$@" #
+>, #
+} #
+EOT
+
+  def msys_sh(cmd)
+    Build.enable_msys_apps
+    pwd = Dir.pwd
+    sh "sh", "-lc", "cd `cygpath -u #{pwd.inspect}`; #{cmd}"
+  end
+
+  def with_env(hash)
+    olds = hash.map{|k, _| [k, ENV[k.to_s]] }
+    hash.each do |k, v|
+      ENV[k.to_s] = v
+    end
+    begin
+      yield
+    ensure
+      olds.each do |k, v|
+        ENV[k.to_s] = v
+      end
+    end
+  end
+
+  GEM_ROOT = File.expand_path("../../../..", __FILE__)
+
+  # Return the gem files of "rubyinstaller-build"
+  #
+  # The gemspec is either already loaded or taken from our root directory.
+  def rubyinstaller_build_gem_files
+    spec = Gem.loaded_specs["rubyinstaller-build"]
+    if spec
+      # A loaded gemspec has empty #files -> fetch the files from it's path.
+      # This is preferred to gemspec loading to avoid a dependency to git.
+      Dir["**/*", base: spec.full_gem_path].select do |f|
+        FileTest.file?(File.join(spec.full_gem_path, f))
+      end
+    else
+      # Not yet loaded -> load the gemspec and return the files added to the gemspec.
+      Gem::Specification.load(File.join(GEM_ROOT, "rubyinstaller-build.gemspec")).files
+    end
+  end
+
+  # Scan the current and the gem root directory for files matching rel_pattern.
+  #
+  # All paths returned are relative.
+  def ovl_glob(rel_pattern)
+    gem_files = Dir.glob(File.join(GEM_ROOT, rel_pattern)).map do |path|
+      path.sub(GEM_ROOT+"/", "")
+    end
+
+    (gem_files + Dir.glob(rel_pattern)).uniq
+  end
+
+  # Returns the absolute path of rel_file within the current directory or,
+  # if it doesn't exist, from the gem root directory.
+  #
+  # Raises Errno::ENOENT if neither of them exist.
+  def ovl_expand_file(rel_file)
+    if File.exist?(rel_file)
+      File.expand_path(rel_file)
+    elsif File.exist?(a=File.join(GEM_ROOT, rel_file))
+      File.expand_path(a)
+    else
+      raise Errno::ENOENT, rel_file
+    end
+  end
+
+  # Returns the absolute path of rel_file within the gem root directory.
+  #
+  # Raises Errno::ENOENT if it doesn't exist.
+  def gem_expand_file(rel_file)
+    if File.exist?(a=File.join(GEM_ROOT, rel_file))
+      File.expand_path(a)
+    else
+      raise Errno::ENOENT, rel_file
+    end
+  end
+
+  def eval_file(filename)
+    code = File.read(filename, encoding: "UTF-8")
+    instance_eval(code, filename)
+  end
+
+
+  def ovl_read_file(file_rel)
+    File.read(ovl_expand_file(file_rel), encoding: "UTF-8")
+  end
+
+  def ovl_compile_erb(erb_file_rel)
+    ErbCompiler.new(erb_file_rel).result
+  end
+
+  # Quote a string according to the rules of Inno-Setup
+  def q_inno(text)
+    '"' + text.to_s.gsub('"', '""') + '"'
+  end
+end
+end
+end

data/lib/ruby_installer/runtime.rb

@@ -0,0 +1,18 @@
+module RubyInstaller
+module Runtime
+  autoload :Colors, 'ruby_installer/runtime/colors'
+  autoload :ComponentsInstaller, 'ruby_installer/runtime/components_installer'
+  autoload :DllDirectory, 'ruby_installer/runtime/dll_directory'
+  autoload :Msys2Installation, 'ruby_installer/runtime/msys2_installation'
+  autoload :Ridk, 'ruby_installer/runtime/ridk'
+  autoload :PACKAGE_VERSION, 'ruby_installer/runtime/package_version'
+  autoload :GIT_COMMIT, 'ruby_installer/runtime/package_version'
+
+  module Components
+    autoload :Base, 'ruby_installer/runtime/components/base'
+  end
+
+  require 'ruby_installer/runtime/singleton'
+  BuildOrRuntime = self
+end
+end

data/lib/ruby_installer/runtime/ridk.rb

@@ -0,0 +1,195 @@
+module RubyInstaller
+module Runtime
+  # :nodoc:
+  module Ridk
+    class << self
+      include Colors
+
+      def run!(args)
+        enable_colors
+        case args[0]
+          when 'install'
+            print_logo
+            puts
+            install(args[1..-1])
+          when 'enable', 'exec'
+            puts Runtime.msys2_installation.enable_msys_apps_per_cmd
+          when 'disable'
+            puts Runtime.msys2_installation.disable_msys_apps_per_cmd
+          when 'enableps1', 'execps1'
+            puts Runtime.msys2_installation.enable_msys_apps_per_ps1
+          when 'disableps1'
+            puts Runtime.msys2_installation.disable_msys_apps_per_ps1
+          when 'version'
+            print_version
+          when 'help', '--help', '-?', '/?', nil
+            print_logo
+            print_help
+          else
+            $stderr.puts "Invalid option #{args[0].inspect}"
+        end
+      end
+
+      # The ASCII art is thankfully generated by:
+      # http://patorjk.com/software/taag/#p=display&f=Big&t=RubyInstaller2
+      # http://patorjk.com/software/taag/#p=display&f=Bigfig&t=for%20Windows
+LOGO = %q{
+ _____       _          r _____           _        _ _        ry ___  y
+|  __ \     | |         r|_   _|         | |      | | |       ry|__ \ y
+| |__) |   _| |__  _   _ r | |  _ __  ___| |_ __ _| | | ___ _ __ry ) |y
+|  _  / | | | '_ \| | | |r | | | '_ \/ __| __/ _` | | |/ _ \ '__ry/ / y
+| | \ \ |_| | |_) | |_| |r_| |_| | | \__ \ || (_| | | |  __/ | ry/ /_ y
+|_|  \_\__,_|_.__/ \__, r|_____|_| |_|___/\__\__,_|_|_|\___|_|ry|____|y
+                    __/ |   c        _                              c
+                   |___/    c      _|_ _  __   | | o __  _| _     _ c
+                            c       | (_) |    |^| | | |(_|(_)\^/_> c
+}[1..-1]
+
+      def print_logo
+        puts  LOGO.gsub(/r(.*?)r/){ magenta($1) }
+                  .gsub(/y(.*?)y/){ cyan($1) }
+                  .gsub(/c(.*?)c/){ yellow($1) }
+      end
+
+      DEFAULT_COMPONENTS = %w[1 3]
+
+      def install(args)
+        ci = ComponentsInstaller.new
+        inst_defaults = DEFAULT_COMPONENTS
+
+        if args.empty?
+          # Interactive installation
+          loop do
+            ci.installable_components.each do |comp|
+              puts format("  % 2d - %s", comp.task_index, comp.description)
+            end
+            puts
+            print "Which components shall be installed? If unsure press ENTER [#{inst_defaults.join(",")}] "
+
+            inp = STDIN.gets
+            inp = inp.tr(",", " ").strip if inp
+            if !inp
+              break
+            elsif inp.empty? && inst_defaults.empty?
+              break
+            elsif inp.empty?
+              inst_list = inst_defaults
+            elsif inp =~ /\A(?:(\d+|\w+)\s*)+\z/
+              inst_list = [inp]
+            else
+              puts red("Please enter a comma separated list of the components to be installed")
+            end
+
+            if inst_list
+              puts
+              begin
+                ci.install(args_to_tasks(ci, inst_list).map(&:name))
+              rescue => err
+                puts red("Installation failed: #{err}")
+              end
+
+              ci.reload
+              inst_defaults = []
+              puts
+            end
+          end
+
+        else
+          # Unattended installation
+          ci.install(args_to_tasks(ci, args).map(&:name))
+        end
+      end
+
+      private def args_to_tasks(ci, args)
+        tasks = args.join(" ").split(" ").map do |idx_or_name|
+          if idx_or_name =~ /\A\d+\z/ && (task=ci.installable_components.find{|c| idx_or_name.to_i == c.task_index })
+            task
+          elsif idx_or_name =~ /\A\w+\z/ && (task=ci.installable_components.find{|c| idx_or_name == c.name })
+            task
+          else
+            puts red("Can not find component #{idx_or_name.inspect}")
+          end
+        end.compact
+      end
+
+      def msys_version_info(msys_path)
+        require "rexml/document"
+        doc = File.open( File.join(msys_path, "components.xml") ) do |fd|
+          REXML::Document.new fd
+        end
+        {
+          "title" => doc.elements.to_a("//Packages/Package/Title").first.text,
+          "version" => doc.elements.to_a("//Packages/Package/Version").first.text,
+        }
+      end
+
+      private def ignore_err
+        orig_verbose, $VERBOSE = $VERBOSE, nil
+        begin
+          yield
+        rescue
+        end
+        $VERBOSE = orig_verbose
+      end
+
+      def print_version
+        require "yaml"
+        require "rbconfig"
+
+        h = {
+          "ruby" => { "path" => RbConfig::TOPDIR,
+                      "version" => RUBY_VERSION,
+                      "platform" => RUBY_PLATFORM },
+          "ruby_installer" => { "package_version" => RubyInstaller::Runtime::PACKAGE_VERSION,
+                                "git_commit" => RubyInstaller::Runtime::GIT_COMMIT },
+        }
+
+        ignore_err do
+          msys = Runtime.msys2_installation
+          msys.enable_msys_apps(if_no_msys: :raise)
+
+          msys_ver = ignore_err{ msys_version_info(msys.msys_path) }
+          h["msys2"] = { "path" => msys.msys_path }.merge(msys_ver || {})
+        end
+
+        ignore_err do
+          cc = RbConfig::CONFIG['CC_VERSION']
+          ver, _ = `#{cc}`.split("\n", 2)
+          h["cc"] = ver
+        end
+
+        # Add compiler used to build ruby, if different from current gcc
+        ruby_cc = RbConfig::CONFIG['CC_VERSION_MESSAGE'].split("\n", 2).first
+        h["ruby"]["cc"] = ruby_cc if ruby_cc.gsub(/\.exe/, "") != h["cc"]
+
+        ignore_err do
+          ver, _ = `sh --version`.split("\n", 2)
+          h["sh"] = ver
+        end
+
+        ignore_err do
+          h["os"] = `ver`.strip
+        end
+
+        puts h.to_yaml
+      end
+
+      def print_help
+        $stdout.puts <<-EOT
+Usage:
+    #{$0} [option]
+
+Option:
+    install                   Install MSYS2 and MINGW dev tools
+    exec <command>            Execute a command within MSYS2 context
+    enable                    Set environment variables for MSYS2
+    disable                   Unset environment variables for MSYS2
+    version                   Print RubyInstaller and MSYS2 versions
+    use                       Switch to a different ruby version
+    help | --help | -? | /?   Display this help and exit
+EOT
+      end
+    end
+  end
+end
+end