rails_packager 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 496700d2c25783048dddb01349963eb88ac182ae
+  data.tar.gz: 6d14489090ca004941521543918efa1d859980ae
+SHA512:
+  metadata.gz: 7f3ee49843a6fc52874788e9e88c16d3374e0d4051693cc8423c1393125d8cc8a28ae7fe12f47940ec1fce9717731afc191c11f27a08ad9a1fbcd1d7aaadd73d
+  data.tar.gz: 5dcc909d6791bd0f3ddcc650f413fd72e702a185b3729cf816e6a7de9590d6a1c86fca4ab5dec5e43c1d45149f593dad633beeb2907243cadfeb8a7c73c9f33c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Mike Virata-Stone
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RailsPackager'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/exe/rails_package

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require "pathname"
+require "optparse"
+require "rails_packager"
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: rails_package [options]"
+
+  opts.on("-v", "--verbose", "Include verbose output") do |v|
+    options[:verbose] = v
+  end
+
+  opts.on("-n", "--name NAME", "Change the NAME used for packaging the app") do |name|
+    options[:name] = name
+  end
+end.parse!
+
+abort "No Gemfile detected, are you in the root of a Rails project?" unless File.exist?("Gemfile")
+abort "The 'rails' gem is missing from the Gemfile, are you in the root of a Rails project?" unless File.read("Gemfile") =~ /\brails\b/
+dir = Pathname.new(".").realpath
+config_path = dir.join(".rails-package")
+config_file = config_path if config_path.exist?
+runner = RailsPackager::Runner.new(config_file: config_file, dir: dir, name: options[:name])
+runner.execute(verbose: options[:verbose])

data/lib/rails_packager.rb

@@ -0,0 +1,8 @@
+require "rails_packager/engine" if defined?(Rails)
+
+module RailsPackager
+  autoload :Command,       "rails_packager/command"
+  autoload :CommandParser, "rails_packager/command_parser"
+  autoload :Runner,        "rails_packager/runner"
+  autoload :Util,          "rails_packager/util"
+end

data/lib/rails_packager/command.rb

@@ -0,0 +1,84 @@
+require "active_support/core_ext/object/blank"
+
+module RailsPackager
+  class Command
+    def self.replace_variables(runner, value, allow_files: false)
+      return nil if value.nil?
+      result = value.dup
+      result.gsub!(/\$\{(\w+)\}/) { |m| ENV.fetch($1, "") }
+      result["@{name}"] = runner.name if result["@{name}"]
+
+      if allow_files
+        raise ArgumentError, "@{files} must be a singular argument" if result["@{files}"] && result != "@{files}"
+        raise ArgumentError, "@{files_file} must be a singular argument" if result["@{files_file}"] && result != "@{files_file}"
+
+        if result == "@{files}"
+          result = runner.files
+        elsif result == "@{files_file}"
+          result = runner.files_file
+        end
+      end
+
+      result
+    end
+
+    def self.parse(runner, value)
+      parsed = CommandParser.parse(value)
+      new(parsed.name, *parsed.args, runner: runner, env: parsed.env)
+    end
+
+    def initialize(name, *args, runner:, env: {})
+      @runner = runner
+      @name = replace_variables(name)
+      @args = args
+      @env = env
+    end
+
+    def name
+      raise ArgumentError, "Invalid command: empty command name is not valid" if @name.blank?
+      @name
+    end
+
+    def dir
+      @runner.dir
+    end
+
+    def env
+      @runner.env.merge(@env).inject({}) do |result, (key, value)|
+        result[key] = replace_variables(value)
+        result
+      end
+    end
+
+    def args
+      @args.map do |arg|
+        replace_variables(arg, allow_files: true)
+      end.flatten
+    end
+
+    def execute(verbose: false)
+      command_name = name
+      command_args = args
+      command_line = ([command_name] + command_args).join(" ")
+      puts "$ #{command_line}" if verbose
+      system(env, command_name, *command_args, chdir: dir)
+      @status = $?
+      STDERR.puts "ERROR: '#{command_line}' returned error code: #{exit_code}" unless successful?
+      successful?
+    end
+
+    def exit_code
+      @status.exitstatus
+    end
+
+    def successful?
+      @status.success?
+    end
+
+    private
+
+    def replace_variables(value, allow_files: false)
+      RailsPackager::Command.replace_variables(@runner, value, allow_files: allow_files)
+    end
+  end
+end

data/lib/rails_packager/command_parser.rb

@@ -0,0 +1,66 @@
+module RailsPackager
+  class CommandParser
+    attr_reader :env, :name, :args
+
+    def self.parse(command)
+      new(command).tap(&:parse)
+    end
+
+    def initialize(command)
+      @parsed = false
+      @unparsed = command
+    end
+
+    def parse
+      return if @parsed
+      @parsed = true
+
+      result =
+        if @unparsed.is_a?(Array)
+          @env = parse_env(@unparsed.last)
+          parse_command(@unparsed.first)
+        else
+          @env = {}
+          parse_command(@unparsed)
+        end
+
+      raise ArgumentError, "Empty command is not allowed" if result.empty?
+      @name = result.shift
+      @args = result
+    end
+
+    private
+
+    def parse_env(options)
+      {}.tap do |result|
+        if options.include?("unsetenv")
+          options["unsetenv"].each do |var|
+            result[var] = nil
+          end
+        end
+
+        if options.include?("env")
+          result.merge!(options["env"])
+        end
+      end
+    end
+
+    def parse_command(command, result = [])
+      command = command.strip
+      return result if command.empty?
+
+      if command[0] == "'"
+        value, remaining = command[1..-1].split("'", 2)
+        raise ArgumentError, "Mismatched single quote" unless remaining
+      elsif command[0] == '"'
+        value, remaining = command[1..-1].split('"', 2)
+        raise ArgumentError, "Mismatched single quote" unless remaining
+      else
+        value, remaining = command.split(" ", 2)
+      end
+
+      result << value
+      parse_command(remaining || "", result)
+    end
+  end
+end

data/lib/rails_packager/engine.rb

@@ -0,0 +1,4 @@
+module RailsPackager
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/rails_packager/runner.rb

@@ -0,0 +1,138 @@
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/object/blank"
+require "tempfile"
+require "yaml"
+
+module RailsPackager
+  class Runner
+    attr_reader :includes, :excludes, :env, :dir, :name, :before, :package, :after
+
+    # This command is inserted after bundle install when jbundler usage is detected
+    JBUNDLE_COMMAND = "jbundle install --vendor".freeze
+
+    DEFAULT_CONFIG = RailsPackager::Util.deep_freeze(
+      env: {},
+      exclude: ["**/.git", "tmp"],
+      before: [
+        ["bundle install --deployment --without development test", {
+           "unsetenv" => ["RUBYOPT", "RUBYLIB", "BUNDLER_ORIG_GEM_PATH", "BUNDLER_ORIG_PATH"],
+           "env" => { "GEM_PATH" => "${BUNDLER_ORIG_GEM_PATH}" }
+         }],
+        "gem install bundler --install-dir vendor/bundle",
+        ["bundle exec rake assets:precompile", {
+           "unsetenv" => ["RUBYOPT", "RUBYLIB", "BUNDLER_ORIG_GEM_PATH", "BUNDLER_ORIG_PATH"],
+           "env" => {
+             "RAILS_ENV" => "production",
+             "GEM_PATH" => "${BUNDLER_ORIG_GEM_PATH}"
+           }
+         }]
+      ],
+      package: "tar --no-recursion --files-from @{files_file} -zcvf @{name}.tar.gz"
+    )
+
+    def initialize(dir:, name: nil, config_file: nil)
+      @files_file_tempfile = nil
+      @dir = dir
+      @name = name
+
+      config =
+        if config_file
+          YAML.load_file(config_file)
+        else
+          {}
+        end
+
+      load_config(config)
+    end
+
+    def files
+      result = Dir.glob(File.join(dir, "**/*"), File::FNM_DOTMATCH).map do |file|
+        file.sub(File.join(dir, "/"), "")
+      end
+
+      # Drop special directory files
+      result.reject! { |f| f =~ %r{/\.\.?\z} || f =~ /\A\.\.?\z/ }
+
+      result.select! { |f| includes.any? { |i| RailsPackager::Util.glob_match?(i, f) } } if includes
+      result.reject! { |f| excludes.any? { |e| RailsPackager::Util.glob_match?(e, f) } } if excludes
+      result
+    end
+
+    def files_file
+      @files_file_tempfile ||=
+        begin
+          Tempfile.new("rails_packager_file_names").tap do |tempfile|
+            files.each { |f| tempfile.puts f }
+            tempfile.close
+          end
+        end
+
+      @files_file_tempfile.path
+    end
+
+    def commands
+      before + [package] + after
+    end
+
+    def execute(verbose: false)
+      commands.each { |cmd| break unless cmd.execute(verbose: verbose) }
+    ensure
+      close
+    end
+
+    def close
+      if @files_file_tempfile
+        @files_file_tempfile.unlink
+        @files_file_tempfile = nil
+      end
+    end
+
+    def successful?
+      commands.all?(&:successful?)
+    end
+
+    def exit_code
+      errored = commands.find { |cmd| !cmd.successful? }
+
+      if errored
+        errored.exit_code
+      else
+        0
+      end
+    end
+
+    private
+
+    def replace_variables(value)
+      RailsPackager::Command.replace_variables(self, value)
+    end
+
+    def load_config(config)
+      config = config.symbolize_keys
+      customized_before = config.include?(:before)
+      config = DEFAULT_CONFIG.merge(config)
+
+      if !customized_before && jbundler_in_use?
+        config[:before] = config[:before].dup
+        config[:before].insert(2, JBUNDLE_COMMAND)
+      end
+
+      @includes = config[:include]
+      @excludes = config[:exclude]
+
+      @env = config[:env].inject({}) do |result, (key, value)|
+        result[key] = replace_variables(value)
+        result
+      end
+
+      @name = name.presence || replace_variables(config.fetch(:name) { File.basename(File.realpath(dir)) })
+      @before = config.fetch(:before, []).map { |x| RailsPackager::Command.parse(self, x) }
+      @after = config.fetch(:after, []).map { |x| RailsPackager::Command.parse(self, x) }
+      @package = RailsPackager::Command.parse(self, config[:package])
+    end
+
+    def jbundler_in_use?
+      File.exist? File.join(dir, "Jarfile")
+    end
+  end
+end

data/lib/rails_packager/util.rb

@@ -0,0 +1,30 @@
+module RailsPackager
+  module Util
+    module_function
+
+    def deep_freeze(object)
+      case object
+      when Hash
+        object.freeze
+        object.each { |k, v| deep_freeze(k); deep_freeze(v) }
+      when Array
+        object.freeze
+        object.each { |y| deep_freeze(y) }
+      when Symbol
+      # Unneeded
+      else
+        object.freeze
+      end
+    end
+
+    TERMINAL_FILES = deep_freeze([".", "/", ""])
+
+    def glob_match?(glob, file)
+      if File.fnmatch(glob, file, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+        true
+      elsif !TERMINAL_FILES.include?(file)
+        glob_match?(glob, File.dirname(file))
+      end
+    end
+  end
+end

data/lib/rails_packager/version.rb

@@ -0,0 +1,3 @@
+module RailsPackager
+  VERSION = "0.0.1"
+end

data/lib/tasks/rails_packager_tasks.rake

@@ -0,0 +1,8 @@
+desc "Package this Rails project"
+task :package, [:name] => :environment do |t, args|
+  require "rails_packager"
+  config_path = Rails.root.join(".rails-package")
+  config_file = config_path if config_path.exist?
+  runner = RailsPackager::Runner.new(config_file: config_file, dir: Rails.root, name: args[:name].presence)
+  runner.execute(verbose: ENV["verbose"] == "true")
+end