appbundler 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f04956c11e697c74391c55957f9ce53d481ad9af
-  data.tar.gz: 7d66500341fb6b45015bbfea43998925dc600a7a
+  metadata.gz: 3bdcdbca4e10ef8f04ec364fad2250690e062992
+  data.tar.gz: 4c0408acd0c32ab33376397d78616c1a50dcca7a
 SHA512:
-  metadata.gz: e59472334d62a6dd82717759c893c81fca8e83c89aea5fc9b3400f10a02b6da6fe6e46274e0d5a85533ede1bf07a2e2b2499df6e16405d52d5da33f9b1ddab01
-  data.tar.gz: f298914a231339920417481a451f795358e32079056d1ec6acb52994d3412ca1e740fa467675bdd1576910cfeff175de14c1ed7ef5b09072a9ec16b2aea42b4a
+  metadata.gz: 144df4d360bfebafd5b99730dfc428d7ecc409efcdcd54bb68c0f7c1624eeb913be17a575ee83aff3960d5aacace7f409c2593a11481932172abe75f0184eaba
+  data.tar.gz: 625f02ebeefb40ee421047c6c406f248b5d35bbe7ad7f43cd2711a8963cbf816ffe806acd1e47c74c2bf0ef5ded3816e711f6c5ae762ff4ebf5c51558d1d2bc0

data/.gitignore

@@ -1,6 +1,8 @@
 *.gem
 *.rbc
 /.bundle
+b
+binstubs
 .config
 .yardoc
 Gemfile.lock
@@ -14,4 +16,4 @@ rdoc
 spec/reports
 test/tmp
 test/version_tmp
-tmp
+tmp

data/lib/appbundler/app.rb

@@ -2,30 +2,33 @@ require 'bundler'
 require 'fileutils'
 require 'pp'
 
+
 module Appbundler
+
+  class AppbundlerError < StandardError; end
+
+  class InaccessibleGemsInLockfile < AppbundlerError; end
+
   class App
 
     BINSTUB_FILE_VERSION=1
 
-    attr_reader :app_root
+    attr_reader :bundle_path
     attr_reader :target_bin_dir
+    attr_reader :name
 
-    def self.demo
-      demo = new("/Users/ddeleo/oc/chef")
-
-      knife = demo.executables.grep(/knife/).first
-      puts demo.binstub(knife)
-    end
-
-    def initialize(app_root, target_bin_dir)
-      @app_root = app_root
+    def initialize(bundle_path, target_bin_dir, name)
+      @bundle_path = bundle_path
       @target_bin_dir = target_bin_dir
+      @name = name
     end
 
     # Copy over any .bundler and Gemfile.lock files to the target gem
     # directory.  This will let us run tests from under that directory.
     def copy_bundler_env
       gem_path = app_gemspec.gem_dir
+      # If we're already using that directory, don't copy (it won't work anyway)
+      return if gem_path == File.dirname(gemfile_lock)
       FileUtils.install(gemfile_lock, gem_path, :mode => 0644)
       if File.exist?(dot_bundle_dir) && File.directory?(dot_bundle_dir)
         FileUtils.cp_r(dot_bundle_dir, gem_path)
@@ -55,16 +58,12 @@ module Appbundler
       executables_to_create
     end
 
-    def name
-      File.basename(app_root)
-    end
-
     def dot_bundle_dir
-      File.join(app_root, ".bundle")
+      File.join(bundle_path, ".bundle")
     end
 
     def gemfile_lock
-      File.join(app_root, "Gemfile.lock")
+      File.join(bundle_path, "Gemfile.lock")
     end
 
     def ruby
@@ -118,6 +117,7 @@ E
     end
 
     def runtime_activate
+
       @runtime_activate ||= begin
         statements = runtime_dep_specs.map {|s| %Q|gem "#{s.name}", "= #{s.version}"|}
         activate_code = ""
@@ -173,8 +173,69 @@ E
       @parsed_gemfile_lock ||= Bundler::LockfileParser.new(IO.read(gemfile_lock))
     end
 
+    # Bundler stores gems loaded from git in locations like this:
+    # `lib/ruby/gems/2.1.0/bundler/gems/chef-b5860b44acdd`. Rubygems cannot
+    # find these during normal (non-bundler) operation. This will cause
+    # problems if there is no gem of the same version installed to the "normal"
+    # gem location, because the appbundler executable will end up containing a
+    # statement like `gem "foo", "= x.y.z"` which fails.
+    #
+    # However, if this gem/version has been manually installed (by building and
+    # installing via `gem` commands), then we end up with the correct
+    # appbundler file, even if it happens somewhat by accident.
+    #
+    # Therefore, this method lists all the git-sourced gems in the
+    # Gemfile.lock, then it checks if that version of the gem can be loaded via
+    # `Gem::Specification.find_by_name`. If there are any unloadable gems, then
+    # the InaccessibleGemsInLockfile error is raised.
+    def verify_deps_are_accessible!
+      inaccessable_gems = inaccessable_git_sourced_gems
+      return true if inaccessable_gems.empty?
+
+      message = <<-MESSAGE
+Application '#{name}' contains gems in the lockfile which are
+not accessible by rubygems. This usually occurs when you fetch gems from git in
+your Gemfile and do not install the same version of the gems beforehand.
+
+MESSAGE
+
+      message << "The Gemfile.lock is located here:\n- #{gemfile_lock}\n\n"
+
+      message << "The offending gems are:\n"
+      inaccessable_gems.each do |gemspec|
+        message << "- #{gemspec.name} (#{gemspec.version}) from #{gemspec.source}\n"
+      end
+
+      message << "\n"
+
+      message << "Rubygems is configured to search the following paths:\n"
+      Gem.paths.path.each { |p| message << "- #{p}\n" }
+
+      message << "\n"
+      message << "If these seem wrong, you might need to set GEM_HOME or other environment\nvariables before running appbundler\n"
+
+      raise InaccessibleGemsInLockfile, message
+    end
+
     private
 
+    def git_sourced_gems
+      runtime_dep_specs.select { |i| i.source.kind_of?(Bundler::Source::Git) }
+    end
+
+    def inaccessable_git_sourced_gems
+      git_sourced_gems.reject do |spec|
+        gem_available?(spec)
+      end
+    end
+
+    def gem_available?(spec)
+      Gem::Specification.find_by_name(spec.name, "= #{spec.version}")
+      true
+    rescue Gem::LoadError
+      false
+    end
+
     def add_dependencies_from(spec, collected_deps=[])
       spec.dependencies.each do |dep|
         next if collected_deps.any? {|s| s.name == dep.name }

data/lib/appbundler/cli.rb

@@ -7,10 +7,14 @@ module Appbundler
     include Mixlib::CLI
 
     banner(<<-BANNER)
-Usage: appbundler APPLICATION_DIR BINSTUB_DIR
+* appbundler #{VERSION} *
 
-  APPLICATION_DIR is the root directory to a working copy of your app
+Usage: appbundler BUNDLE_DIR BINSTUB_DIR [GEM_NAME] [GEM_NAME] ...
+
+  BUNDLE_DIR is the root directory to the bundle containing your app
   BINSTUB_DIR is the directory where you want generated executables to be written
+  GEM_NAME is the name of a gem you want to appbundle. Default is the directory name
+           of BUNDLE_DIR (e.g. /src/chef -> chef)
 
 Your bundled application must already be gem installed.  Generated binstubs
 will point to the gem, not your working copy.
@@ -42,8 +46,9 @@ BANNER
 
     attr_reader :argv
 
-    attr_reader :app_path
+    attr_reader :bundle_path
     attr_reader :bin_path
+    attr_reader :gems
 
     def initialize(argv)
       @argv = argv
@@ -55,23 +60,26 @@ BANNER
     end
 
     def validate!
-      if cli_arguments.size != 2
+      if cli_arguments.size < 2
         usage_and_exit!
       else
-        @app_path = File.expand_path(cli_arguments[0])
+        @bundle_path = File.expand_path(cli_arguments[0])
         @bin_path = File.expand_path(cli_arguments[1])
-        verify_app_path
+        @gems = cli_arguments[2..-1]
+        @gems = [ File.basename(@bundle_path) ] if @gems.empty?
+        verify_bundle_path
         verify_bin_path
-        verify_gem_installed
+        verify_gems_installed
+        verify_deps_are_accessible
       end
     end
 
-    def verify_app_path
-      if !File.directory?(app_path)
-        err("APPLICATION_DIR `#{app_path}' is not a directory or doesn't exist")
+    def verify_bundle_path
+      if !File.directory?(bundle_path)
+        err("BUNDLE_DIR `#{bundle_path}' is not a directory or doesn't exist")
         usage_and_exit!
-      elsif !File.exist?(File.join(app_path, "Gemfile.lock"))
-        err("APPLICATION_DIR does not contain required Gemfile.lock")
+      elsif !File.exist?(File.join(bundle_path, "Gemfile.lock"))
+        err("BUNDLE_DIR does not contain required Gemfile.lock")
         usage_and_exit!
       end
     end
@@ -83,22 +91,40 @@ BANNER
       end
     end
 
-    def verify_gem_installed
-      app = App.new(app_path, bin_path)
-      app.app_gemspec
-    rescue Gem::LoadError
-      err("Unable to find #{app.app_spec.name} #{app.app_spec.version} installed as a gem")
-      err("You must install the top-level app as a gem before calling app-bundler")
-      usage_and_exit!
+    def verify_gems_installed
+      gems.each do |g|
+        begin
+          app = App.new(bundle_path, bin_path, g)
+          app.app_gemspec
+        rescue Gem::LoadError
+          err("Unable to find #{app.app_spec.name} #{app.app_spec.version} installed as a gem")
+          err("You must install the top-level app as a gem before calling app-bundler")
+          usage_and_exit!
+        end
+      end
+    end
+
+    def verify_deps_are_accessible
+      gems.each do |g|
+        begin
+          app = App.new(bundle_path, bin_path, g)
+          app.verify_deps_are_accessible!
+        rescue InaccessibleGemsInLockfile => e
+          err(e.message)
+          exit 1
+        end
+      end
     end
 
     def run
-      app = App.new(app_path, bin_path)
-      created_stubs = app.write_executable_stubs
-      created_stubs.each do |real_executable_path, stub_path|
-        $stdout.puts "Generated binstub #{stub_path} => #{real_executable_path}"
+      gems.each do |g|
+        app = App.new(bundle_path, bin_path, g)
+        created_stubs = app.write_executable_stubs
+        created_stubs.each do |real_executable_path, stub_path|
+          $stdout.puts "Generated binstub #{stub_path} => #{real_executable_path}"
+        end
+        app.copy_bundler_env
       end
-      app.copy_bundler_env
     end
 
     def err(message)

data/lib/appbundler/version.rb

@@ -1,3 +1,3 @@
 module Appbundler
-  VERSION = "0.7.0"
+  VERSION = "0.9.0"
 end

data/spec/appbundler/app_spec.rb

@@ -12,7 +12,8 @@ describe Appbundler do
 
   def double_spec(name, version, dep_names)
     deps = dep_names.map {|n| double("Bundler::Dependency #{n}", :name => n.to_s) }
-    spec = double("Bundler::LazySpecification '#{name}'", :name => name.to_s, :version => version, :dependencies => deps)
+    source = double("Bundler::Source::Rubygems")
+    spec = double("Bundler::LazySpecification '#{name}'", :name => name.to_s, :version => version, :dependencies => deps, :source => source)
     all_specs << spec
     spec
   end
@@ -59,7 +60,7 @@ describe Appbundler do
     let(:app_root) { "/opt/app/embedded/apps/app" }
 
     let(:app) do
-      Appbundler::App.new(app_root, target_bindir)
+      Appbundler::App.new(app_root, target_bindir, File.basename(app_root))
     end
 
     before do
@@ -137,6 +138,48 @@ E
 
     end
 
+    context "when there are git-sourced gems in the Gemfile.lock" do
+
+      let!(:second_level_dep_b_a) do
+        source = double("Bundler::Source::Git")
+        allow(source).to receive(:kind_of?).with(Bundler::Source::Git).and_return(true)
+        spec = double_spec(:second_level_dep_b_a, "2.2.0", [])
+        allow(spec).to receive(:source).and_return(source)
+        spec
+      end
+
+      # Ensure that the behavior we emulate in our stubs is correct:
+      it "sanity checks rubygems behavior" do
+        expect { Gem::Specification.find_by_name("there-is-no-such-gem-named-this", "= 999.999.999") }.
+          to raise_error(Gem::LoadError)
+      end
+
+      context "and the gems are not accessible by rubygems" do
+
+        before do
+          allow(Gem::Specification).to receive(:find_by_name).with("second_level_dep_b_a", "= 2.2.0").and_raise(Gem::LoadError)
+        end
+
+        it "raises an error validating gem accessibility" do
+          expect { app.verify_deps_are_accessible! }.to raise_error(Appbundler::InaccessibleGemsInLockfile)
+        end
+
+      end
+
+      context "and the gems are accessible by rubygems" do
+
+        before do
+          allow(Gem::Specification).to receive(:find_by_name).with("second_level_dep_b_a", "= 2.2.0").and_return(true)
+        end
+
+        it "raises an error validating gem accessibility" do
+          expect { app.verify_deps_are_accessible! }.to_not raise_error
+        end
+
+      end
+
+    end
+
   end
 
   context "when created with the example application" do
@@ -147,7 +190,7 @@ E
     let(:app_root) { APP_ROOT }
 
     let(:app) do
-      Appbundler::App.new(APP_ROOT, target_bindir)
+      Appbundler::App.new(APP_ROOT, target_bindir, File.basename(APP_ROOT))
     end
 
     before(:all) do
@@ -331,6 +374,7 @@ E
     end
 
     it "generates executable stubs for all executables in the app" do
+      app.verify_deps_are_accessible!
       app.write_executable_stubs
       binary_1 = File.join(target_bindir, "app-binary-1")
       binary_2 = File.join(target_bindir, "app-binary-2")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appbundler
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - danielsdeleo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-28 00:00:00.000000000 Z
+date: 2016-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -133,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.3
 signing_key: 
 specification_version: 4
 summary: Extracts a dependency solution from bundler's Gemfile.lock to speed gem activation
@@ -149,3 +149,4 @@ test_files:
 - spec/fixtures/appbundler-example-app/bin/app-binary-2
 - spec/fixtures/appbundler-example-app/lib/example_app.rb
 - spec/spec_helper.rb
+has_rdoc: