fastup 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 187041c365e33a8fb054fcbe1abec1dccf3b75e7
+  data.tar.gz: 9a8915b07b587b342f586f472c8abab0054d73ae
+SHA512:
+  metadata.gz: 6c36d9f60a561d1c701bee9c97658cfcf45babf0fd3bcd32226ddf0180c41ddc5d7a97868676c9068b4edf51fbf53da1369ac1bd2a064cbf1a5bc55d66e39ffd
+  data.tar.gz: 12b04e54a23dab14c32e26b84a5c7570e7764885430d01ab6979cf6f0a8d399baf89cb795fd9da1d80cb34a1d17f792fd9caca143417da35f56421bc6727c55d

data/COPYING

@@ -0,0 +1,30 @@
+The MIT License
+
+Copyright (c) 2018 Raise Marketplace, Inc. https://www.raise.com/
+
+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.
+
+------------------------------------------------------------
+
+Portions of this software are derived from third-party works licensed
+under terms compatible with the above MIT license:
+
+read_ipv4 function is Copyright © 2005-2014 Rich Felker, et al. and
+licensed under the MIT license (see ext/subnets/ipaddr.c). The
+function is a modified version of part of inet_pton from musl libc.

data/README.md

@@ -0,0 +1,56 @@
+# Fastup
+
+Fastup builds an index from `$LOAD_PATH` and patches `require` to use
+that index to significantly speed up booting up large Rails apps with
+many dependencies.
+
+```
+$ bundle show | wc -l
+375
+
+### before fastup
+
+$ time echo 'puts "loaded #{$LOADED_FEATURES.size} features"' | bundle exec rails c
+loaded 5095 features
+
+real    0m23.652s
+user    0m14.300s
+sys     0m9.237s
+
+### with fastup enabled
+
+$ time echo 'puts "loaded #{$LOADED_FEATURES.size} features"' | bundle exec rails c
+loaded 5097 features
+
+real    0m15.142s
+user    0m11.005s
+sys     0m4.058s
+```
+
+With fewer dependencies, the speedup is smaller. At some point, the
+overhead of building the index means `fastup` will cause a small
+slowdown. Test the speedup first, to see if `fastup` is worth it or
+not for any particular application.
+
+## Usage
+
+`fastup/autoapply` should be required after `bundler/setup` and before
+`Bundler.require`, or more generally, after `$LOAD_PATH` has been
+populated with all dependencies and before most of them have been
+`require`'d.
+
+For example in `config/boot.rb` of a Rails app:
+
+```
+require 'rubygems'
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
+require 'fastup/autoapply'
+```
+
+## Production Ready?
+
+This has not been used in production.

data/lib/fastup/autoapply.rb

@@ -0,0 +1,3 @@
+require 'fastup'
+Fastup.apply!
+

data/lib/fastup.rb

@@ -0,0 +1,113 @@
+module Fastup
+  extend self
+
+  def apply!
+    warn "fastup: building load path index"
+    sp = SearchPath.new($LOAD_PATH)
+    suffixes = Gem.suffixes.lazy
+
+    warn "fastup: patching require"
+    mod = Module.new do
+      define_method(:require) do |name|
+        path = suffixes.map{ |s| sp.lookup(name.to_s + s) rescue nil }.find do |p|
+          p && File.file?(p)
+        end
+
+        # require the absolute path if found, otherwise fallback to original name
+        ret = super(path || name)
+
+        if ret && ENV['FASTUP_DEBUG']
+          if path
+            warn "fastup: loaded #{name} => #{path}"
+          else
+            warn "fastup: super #{name}"
+          end
+        end
+
+        ret
+      end
+    end
+    Object.prepend mod
+  end
+
+  module XFile
+    def directory?(path)
+      File.directory?(path)
+    end
+
+    def each_entry(dir, &block)
+      Dir.new(dir).each do |e|
+        next if e == '.' || e == '..'
+        yield(e)
+      end
+    end
+  end
+
+  class SearchPath
+    include XFile
+
+    # Flatten the search path +paths+ by creating a tree of symlinks
+    # at +dest+. For example, if the paths include +/usr/bin+, and
+    # +/usr/lib+, then +dest+ will be a directory with symlinks +bin+
+    # and +lib+ to the respective directories.
+    def initialize(paths)
+      @root = {}
+      paths.each{ |path| @root = insert!(path) }
+    end
+
+    # given a path like 'a/b/c', determine if it exists in the tree, by trying root['a']['b']['c']
+    #
+    # if root['a'] is a string, then it should be 'somedir/a'
+    #
+    # if root['a']['b'] is a string, then it should be 'somedir/a/b'
+    #
+    # if root['a']['b']['c'] is a string, then it should be 'somedir/a/b/c'
+    #
+    # in all cases, the return value is 'somedir/a/b/c'
+    def lookup(path, root=@root)
+      case root
+      when String
+        if path.nil?
+          return root
+        else
+          File.join(root, path)
+        end
+      when Hash
+        head, rest = path.split(File::SEPARATOR, 2)
+        lookup(rest, root[head])
+      end
+    end
+
+    private
+    
+    # Assumption: target is the shortest path not yet tried. If the
+    # shortest path cannot be linked directly, then if it's a
+    # directory, each element of the directory will be inserted,
+    # recursively.
+    def insert!(target, root=@root)
+      case root
+      when String
+        # conflict; can't insert ontop of non-directory
+        return root unless directory?(root) && directory?(target)
+
+        newroot = {}
+        each_entry(root) do |entry|
+          newroot[entry] = File.join(root, entry)
+        end
+        insert! target, newroot
+      when Hash
+        # conflict; can't insert non-directory ontop of directory
+        return root unless directory?(target)
+
+        each_entry(target) do |entry|
+          if root.has_key?(entry)
+            root[entry] = insert! File.join(target, entry), root[entry]
+          else
+            root[entry] = File.join(target, entry)
+          end
+        end
+        root
+      end
+    end
+  end
+end

data/test/app/boot.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+require 'fastup/autoapply' if ENV['USE_FASTUP']
+Bundler.require
+
+puts $LOADED_FEATURES.join("\n")

data/test/fastup_test.rb

@@ -0,0 +1,150 @@
+require 'benchmark'
+require 'tmpdir'
+
+require 'minitest/autorun'
+
+require 'fastup'
+
+module Fastup
+  class TestAppBoot < Minitest::Test
+    def test_app_boot
+      results = {}
+
+      Bundler.with_original_env do
+        Dir.chdir(File.expand_path('../app', __FILE__)) do
+          results[:setup] = `bundle --quiet`
+          raise "bundle exited with error: #{results[:setup]}" unless $?.success?
+
+          results[:total_fastup] = Benchmark.measure {
+            out = `USE_FASTUP=1 bundle exec ruby boot.rb 2>/dev/null`
+            raise "fastup exited with error: #{out}" unless $?.success?
+            results[:output_fastup] = out.lines.reject{ |p| p =~ %r{fastup/lib/fastup} }
+          }
+          results[:total_nofastup] = Benchmark.measure {
+            out = `bundle exec ruby boot.rb`
+            raise "nofastup exited with error: #{out}" unless $?.success?
+            results[:output_nofastup] = out.lines.reject{ |p| p =~ %r{fastup/lib/fastup} }
+          }
+        end
+      end
+
+      results[:output_fastup].reject!{ |p| p =~ %r{fastup/lib/fastup} }
+      results[:output_nofastup].reject!{ |p| p =~ %r{fastup/lib/fastup} }
+
+      # warn("\nfastup: %.2f nofastup: %.2f" % [results[:total_fastup].total, results[:total_nofastup].total])
+
+      assert results[:total_fastup].total < results[:total_nofastup].total,
+             "expected fastup (#{results[:total_fastup]}) to be faster than without (#{results[:total_nofastup]})"
+
+      assert_equal results[:output_fastup], results[:output_nofastup]
+    end
+  end
+
+  class TestSearchPath < Minitest::Test
+    def setup
+    end
+
+    Scenario = Struct.new(:name, :source, :paths, :links)
+    Source = Array
+    Paths = Array
+    Links = Hash
+
+    Scenarios = [
+
+      Scenario.new(
+        'simple_one_binary',
+        Source[
+          'ls/bin/ls',
+        ],
+        Paths['ls/bin'],
+        Links[
+          'ls' => 'ls/bin/ls'
+        ]),
+
+      Scenario.new(
+        'simple_nested',
+        Source[
+          'ls/bin/a/b/c/ls',
+        ],
+        Paths['ls/bin'],
+        Links[
+          'a' => 'ls/bin/a'
+        ]),
+
+      Scenario.new(
+        'simple_two_binaries',
+        Source[
+          'ls/bin/ls',
+          'ps/bin/ps'
+        ],
+        Paths['ls/bin', 'ps/bin'],
+        Links[
+          'ls' => 'ls/bin/ls',
+          'ps' => 'ps/bin/ps'
+        ]),
+
+      Scenario.new(
+        'simple_overlap',
+        Source[
+          'gems/rspec/lib/rspec.rb',
+          'gems/rspec/lib/rspec/something.rb',
+
+          'gems/rspec-core/lib/rspec/core.rb'
+        ],
+        Paths['gems/rspec/lib', 'gems/rspec-core/lib'],
+        Links[
+          'rspec.rb' => 'gems/rspec/lib/rspec.rb',
+          'rspec/something.rb' => 'gems/rspec/lib/rspec/something.rb',
+          'rspec/core.rb' => 'gems/rspec-core/lib/rspec/core.rb'
+        ]),
+
+      Scenario.new(
+        'conflict',
+        Source[
+          'rspec-1.0/lib/rspec.rb',
+          'rspec-2.0/lib/rspec.rb'
+        ],
+        Paths['rspec-1.0/lib', 'rspec-2.0/lib'],
+        Links['rspec.rb' => 'rspec-1.0/lib/rspec.rb']),
+
+      Scenario.new(
+        'conflict_file_vs_directory',
+        Source[
+          'a/lib/something',
+          'b/lib/something/sub'
+        ],
+        Paths['a/lib', 'b/lib'],
+        Links['something' => 'a/lib/something']),
+
+      Scenario.new(
+        'conflict_directory_vs_file',
+        Source[
+          'a/lib/something/sub',
+          'b/lib/something'
+        ],
+        Paths['a/lib/', 'b/lib'],
+        Links['something' => 'a/lib/something']),
+
+    ]
+
+    Scenarios.each do |s|
+      define_method("test_scenario_#{s.name}") do
+        Dir.mktmpdir do |source|
+          s.source.each do |path|
+            FileUtils.mkdir_p(File.join(source, File.dirname(path)))
+            FileUtils.touch(File.join(source, path))
+          end
+
+          paths = s.paths.map{ |p| File.join(source, p) }
+
+          sp = Fastup::SearchPath.new(paths)
+
+          s.links.each do |(key, target)|
+            actual_target = sp.lookup(key).slice(source.length+1..-1)
+            assert_equal target, actual_target, "expected #{key} -> #{target} but found #{key} -> #{actual_target}"
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: fastup
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Patrick Mahoney
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: index load path to accelerate boot of bundler-based apps with lots of
+  gem dependencies
+email: patrick.mahoney@raise.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- COPYING
+files:
+- COPYING
+- README.md
+- lib/fastup.rb
+- lib/fastup/autoapply.rb
+- test/app/boot.rb
+- test/fastup_test.rb
+homepage: https://github.com/raisemarketplace/fastup
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: index load path to accelerate boot
+test_files: []