tara 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 99f4bc434bfa007f054a82265445cd9846937302
+  data.tar.gz: 270a01f1559d5747ecc0d50834ba1b0b98336a39
+SHA512:
+  metadata.gz: dc93d8fc594db3d1c1f0a415166f3ac5b9151034b7f7d7fefff32b8f244c882a93c64709878b2f8d392659018592710a160457402efaafdd3b3e6819d2b43192
+  data.tar.gz: 156522d2729c5ca0ffe381d183030add5dd930ccda05eeb07d4efaae8cc4af147969b0397f4788231efdd694e8ec22c97a165adc33eec2a868ff4f0fa131bc8b

data/bin/tara

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'tara'
+
+
+exit(Tara::Cli.new(ARGV).run)

data/lib/tara.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'bundler'
+require 'pathname'
+require 'tmpdir'
+
+
+module Tara
+  TaraError = Class.new(StandardError)
+  ExecError = Class.new(TaraError)
+  NotFoundError = Class.new(TaraError)
+  TooManyRedirectsError = Class.new(TaraError)
+  UnknownResponseError = Class.new(TaraError)
+end
+
+require 'tara/archive'
+require 'tara/archiver'
+require 'tara/cli'
+require 'tara/executable'
+require 'tara/fetcher'
+require 'tara/installer'
+require 'tara/shell'

data/lib/tara/archive.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+module Tara
+  class Archive
+    def initialize(config={})
+      @config = config
+      @config[:app_dir] ||= Dir.pwd
+      @config[:app_name] ||= File.basename(@config[:app_dir])
+      @config[:build_dir] ||= File.join(@config[:app_dir], 'build')
+      @config[:target_dir] ||= @config[:build_dir]
+      @config[:download_dir] ||= File.join(@config[:build_dir], 'downloads')
+      @config[:archive_name] ||= @config[:app_name] + '.tgz'
+      @config[:files] ||= %w[lib/**/*.rb]
+      @config[:executables] ||= %w[bin/*]
+      @config[:target] ||= 'linux-x86_64'
+      @config[:traveling_ruby_version] ||= '20150210'
+      @config[:without_groups] ||= %w[development test]
+    end
+
+    def self.create(config={})
+      new(config).create
+    end
+
+    def create
+      Dir.mktmpdir do |tmp_dir|
+        project_dir = Pathname.new(@config[:app_dir])
+        package_dir = Pathname.new(tmp_dir)
+        target_dir = Pathname.new(@config[:target_dir])
+        install_dependencies(package_dir, fetcher)
+        copy_source(project_dir, package_dir)
+        copy_executables(project_dir, package_dir)
+        Dir.chdir(tmp_dir) do
+          create_archive(target_dir)
+        end
+        File.join(target_dir, @config[:archive_name])
+      end
+    end
+
+    private
+
+    DOT_PATH = Pathname.new('.')
+
+    def copy_source(project_dir, package_dir)
+      @config[:files].each do |glob_string|
+        Pathname.glob(project_dir.join(glob_string)).each do |file|
+          copy_file(project_dir, package_dir, file)
+        end
+      end
+    end
+
+    def copy_executables(project_dir, package_dir)
+      @config[:executables].each do |executable_glob|
+        Pathname.glob(project_dir.join(executable_glob)).each do |executable|
+          copy_file(project_dir, package_dir, executable)
+          FileUtils.chmod(0755, package_dir.join(executable))
+          create_exec_wrapper(package_dir, executable)
+        end
+      end
+    end
+
+    def create_archive(target_dir)
+      Shell.exec('tar -czf %s %s' % [@config[:archive_name], Dir['*'].join(' ')])
+      FileUtils.mkdir_p(target_dir)
+      FileUtils.cp(@config[:archive_name], target_dir)
+    end
+
+    def fetcher
+      @fetcher ||= Fetcher.new(@config[:download_dir], @config[:target], @config[:traveling_ruby_version], @config).setup
+    end
+
+    def install_dependencies(package_dir, fetcher)
+      Installer.new(package_dir, fetcher, @config).execute
+    end
+
+    def copy_file(project_dir, package_dir, file)
+      rel_file = file.relative_path_from(project_dir)
+      unless rel_file.dirname == DOT_PATH
+        FileUtils.mkdir_p(package_dir.join(rel_file.dirname))
+      end
+      FileUtils.cp(project_dir.join(rel_file), package_dir.join(rel_file))
+    end
+
+    def create_exec_wrapper(package_dir, executable)
+      wrapper_path = package_dir.join(executable.basename)
+      ex = Executable.new(executable.basename)
+      File.open(wrapper_path, 'w') { |f| ex.write(f) }
+      FileUtils.chmod(0755, wrapper_path)
+    end
+  end
+end

data/lib/tara/archiver.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Tara
+  class Archiver
+    def initialize(options={})
+      @options = options
+    end
+
+    def create(options={})
+      Archive.create(@options.merge(options))
+    end
+
+    def extension
+      @options[:extension] || 'tgz'
+    end
+
+    def content_type
+      'application/x-gzip'
+    end
+
+    def metadata
+      @options[:metadata] || {}
+    end
+  end
+end

data/lib/tara/cli.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'optparse'
+
+
+module Tara
+  class Cli
+    def initialize(argv=ARGV, io=$stderr)
+      @argv = argv
+      @io = io
+    end
+
+    def run
+      Archive.new(parse_argv).create
+      0
+    rescue => e
+      @io.puts(%(Error during packaging: #{e.message} (#{e.class})))
+      1
+    end
+
+    private
+
+    def parse_argv(options={})
+      parser = OptionParser.new do |opts|
+        opts.on('--app-name NAME', 'Name of the app') do |app_name|
+          options[:app_name] = app_name
+        end
+
+        opts.on('--app-dir APP_DIR', 'Root directory of the app') do |app_dir|
+          options[:app_dir] = app_dir
+        end
+
+        opts.on('--download-dir DOWNLOAD_DIR', 'Where to store Traveling Ruby archives') do |download_dir|
+          options[:download_dir] = download_dir
+        end
+
+        opts.on('--target TARGET', 'Target platform for archive') do |target|
+          options[:target] = target
+        end
+      end
+      parser.parse(@argv)
+      options
+    end
+  end
+end

data/lib/tara/executable.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Tara
+  class Executable
+    def initialize(name)
+      @name = name
+    end
+
+    def write(io)
+      io.puts(script(@name))
+    end
+
+    private
+
+    def script(name)
+      <<-EOH.gsub(/^\s+/, '')
+        #!/bin/bash
+        set -e
+        SELF_DIR=$(dirname "$0")
+        export BUNDLE_GEMFILE="$SELF_DIR/lib/vendor/Gemfile"
+        unset BUNDLE_IGNORE_CONFIG
+        exec "$SELF_DIR/lib/ruby/bin/ruby" -rbundler/setup "$SELF_DIR/bin/#{name}" "$@"
+      EOH
+    end
+  end
+end

data/lib/tara/fetcher.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require 'net/http'
+
+
+module Tara
+  class Fetcher
+    def initialize(download_dir, target, tr_version, options={})
+      @download_dir = download_dir
+      @target = target
+      @tr_version = tr_version
+      @ruby_version = options[:ruby_version] || RUBY_VERSION
+      @release_url = options[:tr_release_url] || 'http://d6r77u77i8pq3.cloudfront.net/releases'
+      @shell = options[:shell] || Shell
+    end
+
+    def setup
+      FileUtils.mkdir_p(@download_dir)
+      self
+    end
+
+    def fetch_ruby
+      local_uri = %(#{@download_dir}/ruby-#{@tr_version}-#{@ruby_version}-#{@target}.tar.gz)
+      fetch(ruby_remote_uri, local_uri)
+    end
+
+    def fetch_native_gem(name, version)
+      remote_uri = native_gem_remote_uri(name, version)
+      local_uri = %(#{@download_dir}/#{name}-#{version}-#{@tr_version}-#{@ruby_version}-#{@target}.tar.gz)
+      fetch(remote_uri, local_uri)
+    end
+
+    private
+
+    def ruby_remote_uri
+      @ruby_remote_uri ||= [@release_url, %(traveling-ruby-#{@tr_version}-#{@ruby_version}-#{@target}.tar.gz)].join('/')
+    end
+
+    def native_gem_remote_uri(name, version)
+      [@release_url, %(traveling-ruby-gems-#{@tr_version}-#{@ruby_version}-#{@target}/#{name}-#{version}.tar.gz)].join('/')
+    end
+
+    def fetch(remote_uri, local_uri, limit=10)
+      unless File.exist?(local_uri)
+        uri = URI(remote_uri)
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request(Net::HTTP::Get.new(uri)) do |response|
+            case response
+            when Net::HTTPSuccess
+              File.open(local_uri, 'w') do |f|
+                response.read_body do |chunk|
+                  f.write(chunk)
+                end
+              end
+            when Net::HTTPRedirection
+              if limit > 0
+                fetch(response['location'], local_uri, limit - 1)
+              else
+                raise TooManyRedirectsError, %(Exhausted redirect limit, ended up at #{remote_uri})
+              end
+            when Net::HTTPNotFound
+              raise NotFoundError, %(#{remote_uri} doesn't exist)
+            else
+              raise UnknownResponseError, %(#{response.code} '#{response.body}' returned when fetching #{remote_uri})
+            end
+          end
+        end
+      end
+      local_uri
+    end
+  end
+end

data/lib/tara/installer.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+module Tara
+  class Installer
+    def initialize(package_dir, fetcher, options={})
+      @package_dir = package_dir
+      @fetcher = fetcher
+      @without_groups = options[:without_groups]
+      @app_dir = Pathname.new(options[:app_dir])
+      @shell = options[:shell] || Shell
+    end
+
+    def execute
+      bundle_gems
+      extract_ruby
+      extract_native_gems
+      strip_tests
+      strip_docs
+      strip_leftovers
+      strip_java_files
+      strip_git_files
+      create_bundler_config
+    end
+
+    private
+
+    def bundler_command
+      @bundler_command ||= begin
+        command = 'BUNDLE_IGNORE_CONFIG=1 bundle install --jobs 4 --path vendor'
+        command << %( --without #{@without_groups.join(' ')}) if @without_groups.any?
+        command
+      end
+    end
+
+    def bundle_gems
+      FileUtils.mkdir_p(lib_path)
+      Dir.mktmpdir do |tmpdir|
+        copy_gem_files(Pathname.new(tmpdir))
+        Dir.chdir(tmpdir) do
+          Bundler.with_clean_env do
+            @shell.exec(bundler_command)
+          end
+          Dir['vendor/*/*/cache/*'].each do |cached_file|
+            FileUtils.rm_rf(cached_file)
+          end
+          Dir['vendor/ruby/*/extensions/*'].each do |ext_file|
+            FileUtils.rm_rf(ext_file)
+          end
+          @shell.exec('find vendor/ruby/*/gems -name "*.o" -exec rm {} \; 2>&1 || true')
+          @shell.exec('find vendor/ruby/*/gems -name "*.so" -exec rm {} \; 2>&1 || true')
+          @shell.exec('find vendor/ruby/*/gems -name "*.bundle" -exec rm {} \; 2>&1 || true')
+          FileUtils.cp_r('vendor', lib_path, preserve: true)
+        end
+      end
+    end
+
+    def extract_ruby
+      FileUtils.mkdir_p(ruby_path)
+      FileUtils.mkdir_p(ruby_vendor_path)
+      ruby_archive_path = @fetcher.fetch_ruby
+      @shell.exec(%(tar -xzf #{ruby_archive_path} -C #{ruby_path}))
+    end
+
+    def extract_native_gems
+      native_gems = find_native_gems
+      native_gems.each do |name, version|
+        gem_archive_path = @fetcher.fetch_native_gem(name, version)
+        @shell.exec %(tar -xzf #{gem_archive_path} -C #{ruby_vendor_path})
+      end
+    end
+
+    def find_native_gems
+      gemspecs = Dir[ruby_vendor_path.join('*/specifications/*.gemspec')]
+      specs = gemspecs.map { |gemspec| Gem::Specification.load(gemspec) }
+      with_ext = specs.select { |s| s.extensions.any? }
+      with_ext.each_with_object({}) do |spec, hash|
+        hash[spec.name] = spec.version.to_s
+      end
+    end
+
+    def copy_gem_files(path)
+      Dir['Gemfile', 'Gemfile.lock', '*.gemspec'].each do |file|
+        if File.exist?(@app_dir.join(file))
+          FileUtils.cp(@app_dir.join(file), path.join(File.basename(file)))
+        end
+      end
+    end
+
+    def create_bundler_config
+      copy_gem_files(vendor_path)
+      FileUtils.mkdir_p(bundle_path)
+      File.open(bundle_path.join('config'), 'w+') do |f|
+        f.puts(%(BUNDLE_PATH: .))
+        f.puts(%(BUNDLE_WITHOUT: #{@without_groups.join(':')})) if @without_groups.any?
+        f.puts(%(BUNDLE_DISABLE_SHARED_GEMS: '1'))
+      end
+    end
+
+    def strip_tests
+      strip_from_gems(%w[tests test spec])
+    end
+
+    def strip_docs
+      strip_from_gems(%w[doc* example* *.txt *.md *.rdoc])
+    end
+
+    def strip_leftovers
+      %w[c cpp h rl].each do |ext|
+        @shell.exec(%(find #{ruby_vendor_path} -name "*.#{ext}" -exec rm {} \\; 2>&1))
+      end
+      @shell.exec(%(find #{ruby_vendor_path} -name "extconf.rb" -exec rm {} \\;))
+      @shell.exec(%(find #{vendor_gems_glob.join('*', 'ext')} -name "Makefile" -exec rm {} \\; 2>&1))
+      @shell.exec(%(find #{vendor_gems_glob.join('*', 'ext')} -name "tmp" -type d 2>&1 | xargs rm -rf))
+    end
+
+    def strip_java_files
+      @shell.exec(%(find #{vendor_gems_glob} -name "*.java" -exec rm {} \\;))
+    end
+
+    def strip_git_files
+      @shell.exec(%(find #{vendor_gems_glob} -name ".git" -type d | xargs rm -rf))
+      @shell.exec(%(find #{bundler_gems_glob} -name ".git" -type d | xargs rm -rf))
+    end
+
+    def strip_from_gems(things)
+      things.each do |thing|
+        FileUtils.rm_r(Dir[vendor_gems_glob.join('*', thing)])
+        FileUtils.rm_r(Dir[bundler_gems_glob.join('*', thing)])
+      end
+    end
+
+    def lib_path
+      @lib_path ||= Pathname.new(@package_dir).join('lib')
+    end
+
+    def vendor_path
+      @vendor_path ||= lib_path.join('vendor')
+    end
+
+    def ruby_vendor_path
+      @ruby_vendor_path ||= vendor_path.join('ruby')
+    end
+
+    def bundle_path
+      @bundle_path ||= vendor_path.join('.bundle')
+    end
+
+    def ruby_path
+      @ruby_path ||= lib_path.join('ruby')
+    end
+
+    def bundler_gems_glob
+      @bundler_gems_glob ||= ruby_vendor_path.join('*', 'bundler', 'gems')
+    end
+
+    def vendor_gems_glob
+      @vendor_gems_glob ||= ruby_vendor_path.join('*', 'gems')
+    end
+  end
+end

data/lib/tara/shell.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Tara
+  class Shell
+    def self.exec(command)
+      output = %x(#{command})
+      $stderr.puts(%(#{command}: #{output})) if ENV['TARA_DEBUG']
+      unless $?.success?
+        raise ExecError, %(Command `#{command}` failed with output: #{output})
+      end
+      output
+    end
+  end
+end

data/lib/tara/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Tara
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: tara
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mathias Söderberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-20 00:00:00.000000000 Z
+dependencies: []
+description: Tara packs your Ruby app into a standalone archive with gems and a Ruby
+  runtime
+email:
+- mths@sdrbrg.se
+executables:
+- tara
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/tara
+- lib/tara.rb
+- lib/tara/archive.rb
+- lib/tara/archiver.rb
+- lib/tara/cli.rb
+- lib/tara/executable.rb
+- lib/tara/fetcher.rb
+- lib/tara/installer.rb
+- lib/tara/shell.rb
+- lib/tara/version.rb
+homepage: http://github.com/mthssdrbrg/tara
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.5
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Packs your Ruby app as a standalone archive
+test_files: []
+has_rdoc: