bundler_ext 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18929e0e577a996fe29aab583a44ff3dc47f70ee
-  data.tar.gz: 8b5fc498ef3304ec5370c3a79226e764514a6f9c
+  metadata.gz: 909210bc887e62015bf713baa415cd3570274817
+  data.tar.gz: 8b4e28226559a24052a0d0b8b4ad372d9beede2a
 SHA512:
-  metadata.gz: 6947df0c40f5c52fe75e5fc194b40278449485255205e6961a1d09026693c166b7d88e3ac877d7ac9cf276287c78d0e0279600439909db26b868da7d261d23d8
-  data.tar.gz: 171b367e5382260a075546f96ce30cf600fa67b6981013a21dff99a7e1326fd173e5dcc62db343b901eff484eef12fdfe355e115c438300efb362613c423b239
+  metadata.gz: e0595bc52ef0163d7517c185775696ebdb65e1baa056ec0ae1b4bb99690f3cd3f4231729558d94d75ffa53fc309f64370d9cdbfb3dac869ec0b8057e2acbf6e8
+  data.tar.gz: 471f6ed58e11b9aa49c025a62ff14bb48ac8797a32ce61079960cf7c75fab2a037665549d96909ce7ed5984aa841e62a12f081fea0c7f5b2c0fecef3d44f23a2

data/README.md

@@ -2,75 +2,73 @@ bundler_ext
 ===========
 
 Simple library leveraging the Bundler Gemfile DSL to load gems already
-on the system and managed by the systems package manager
-(like yum/apt).
+on the system and those managed by the systems package manager
+(like yum/apt/homebrew/other).
 
-The purpose of this library is to allow, for instance, yum and rpm to
-manage the dependencies for a project, and simply reuse the Gemfile
-to get the list of directly required gems for (in initial use case) a
-Rails 3.x application. It would be useful in such cases for there to
-be a big switch in Bundler that would allow the user to tell it 'You
-are allevaiated of the responsibility of resolving dependencies, that
-has been taken care of for you. Understandably, since Bundler's
-primary goal is exactly to resolve those dependencies, that project
-has to date not been interested in supporting such functionality.
-However, this is the use case for many linux systems, and this library
-is an initial attempt to get the two approaches to not step on each
-other.
+### API ###
 
-### Example usage ###
+- BundlerExt#system_require is analogous to
+  [Bundler#require](http://rubydoc.info/github/bundler/bundler/Bundler#require-class_method)
+  and will auto-require the gems loaded in the Gemfile wherever they
+  are installed / can be found.
+  
+  
+- BundlerExt#system_setup is analogous to
+  [Bundler#setup](http://bundler.io/v1.5/bundler_setup.html)
+  and will setup the Ruby LOAD_PATH to only incorporate the gemfile
+  dependency include paths wherever they are installed.
+  
 
-If you want to load ALL Gemfile groups, use the following statement:
+- If either case if the BEXT_ACTIVATE_VERSIONS env var is set true,
+  the specific versions of the gem installed via yum/apt/other will be
+  detected and activated.
 
-    BundlerExt.system_require(File.expand_path('../../Gemfile.in', __FILE__), :all)
+- Specify the BEXT_GROUPS env var to insert additional groups to be loaded
+  (separated by whitespace, eg BEXT_GROUPS='group1 group2 ...')
 
-When you want to load only the default one, use:
+- Specify BEXT_NOSTRICT to disable fail-on-error, otherwise BundlerExt will
+  raise a critical error if a dependency fails to load. If set true, BundlerExt
+  will simply print the msg to stdout and continue on.
 
-    BundlerExt.system_require(File.expand_path('../../Gemfile.in', __FILE__), :default)
+### Show Me The Code! ##
 
-You can provide multiple parameters to the system_require function
-of course. Finally, you will be likely requiring default group and
-group named as the current Rails environment; use this:
-    
-    BundlerExt.system_require(File.expand_path('../../Gemfile.in', __FILE__), :default, Rails.env)
+Assuming gemfile_in is defined as
 
-You may also want to wrap your call in some kind of check, to allow
-non-platform users (ie, mac, or any developer not installing as a
-sysadmin) to still use bundler if they want to.  One example would be
-to simply change the name of the Gemfile for rpm setups, something
-like:
+    gemfile_in = File.expand_path('../../Gemfile.in', __FILE__)
 
-    mv Gemfile Gemfile.in
+To load & require ALL Gemfile groups, use the following statement:
+
+    BundlerExt.system_require(gemfile_in, :all)
 
-Then, just look for a Gemfile, otherwise, load deps via
-Gemfile.in/BundlerExt.
+To load only the default one, use:
 
-Note there is a reason for the 2 files names (for now at least) -
-Some libraries, like Rspec, Cucumber, and Rails, try to be smart and
-load up dependencies via Bundler themselves if they see a Gemfile in
-the working directory.  In some cases this can be overriden, but not
-all, so for now at least, it is safer to just look for a different
-file (and this is easily scripted as well) In the linux deployment
-case, this is not the desired behavior, we explicitly want to say
-'just use what the package manager has installed'.
+    BundlerExt.system_require(gemfile_in, :default)
 
-### Additional configuration ###
+BundlerExt#system_require function takes a list of parameters corresponding to all the
+environments the invoker intends to use.
+
+To require the default group and the group specified
+by the Rails environment, use:
+    
+    BundlerExt.system_require(gemfile_in, :default, Rails.env)
 
-There are special environment variables you can use. You may need to 
-insert additional groups to be required, e.g. when developing and you
-want to restart the system in development mode once. Use 
-BEXT_GROUPS variable (separate with whitespace):
+To setup the LOAD_PATH to only reference the default Gemfile deps:
 
-    BEXT_GROUPS="group1 group2 group3" rails server ...
+    BundlerExt.system_setup(gemfile_in, :default)
 
-Also, by default bundler_ext raises an error when dependency cannot
-be loaded. You can turn off this behavior (e.g. for installers when
-you want to do rake db:migrate) with setting BEXT_NOSTRICT:
+And so on....
 
-    BEXT_NOSTRICT=1 rake db:migrate ...
+### Other Considerations ###
+
+You may want to wrap your call in some kind of check, to allow
+non-platform users to still use bundler if they want to.
+
+One way to accomplish this would be to simply change the name of
+the Gemfile for native package system scenarios, eg
+
+    mv Gemfile Gemfile.in
 
-In this mode bundler_ext prints out error messages on the stdout, 
-but does not terminate the process.
+Then, just look for a Gemfile, otherwise, load deps via Gemfile.in/BundlerExt.
 
 Some rubygems require HOME environment variable to be set, threfore
 not running daemonized. For this purposes there is BEXT_HOME

data/lib/bundler_ext.rb

@@ -1 +1,36 @@
-require 'bundler_ext/bundler_ext'
+require 'pathname'
+require 'bundler_ext/runtime'
+require 'bundler_ext/gemfile'
+require 'bundler_ext/system'
+
+module BundlerExt
+  def self.runtime
+    @runtime ||= BundlerExt::Runtime.new
+  end
+
+  def self.system_require(gemfile, *groups)
+    runtime.setup_env
+
+    Gemfile.parse(gemfile, *groups).each do |name, gem_dep|
+      if System.activate?
+        System.activate!(name)
+      end
+
+      runtime.system_require(gem_dep[:files])
+    end
+  end
+
+  def self.system_setup(gemfile, *groups)
+    Gemfile.setup_env(gemfile)
+    runtime.gemfile(Pathname.new(gemfile))
+    runtime.setup_env
+    runtime.clear
+    Gemfile.parse(gemfile, *groups).each do |name, gem_dep|
+      if System.activate?
+        System.activate!(name)
+      end
+
+      runtime.add_spec(gem_dep[:dep].to_spec())
+    end
+  end
+end

data/lib/bundler_ext/gemfile.rb

@@ -0,0 +1,50 @@
+require "bundler"
+
+module BundlerExt
+  class Gemfile
+    def self.setup_env(gemfile)
+      ENV['BUNDLE_GEMFILE'] = gemfile
+    end
+
+    def self.parse_env(groups)
+      extra_groups = ENV['BEXT_GROUPS'] ||
+                     ENV['BUNDLER_EXT_GROUPS']
+      extra_groups.split(/\s/).each {|g| groups << g.to_sym} if extra_groups
+      all_groups = groups.size == 1 && groups.first == :all && (!extra_groups || extra_groups.empty?)
+      {:groups       => groups.map { |g| g.to_sym},
+       :extra_groups => extra_groups,
+       :all_groups   => all_groups}
+    end
+
+    def self.dependency_in_env?(dep, env)
+      in_group = (env[:groups] & dep.groups).any? || env[:all_groups]
+      in_group && dep.current_platform?
+    end
+
+    def self.files_for_dependency(dep, env)
+      files = []
+      if self.dependency_in_env?(dep, env)
+        Array(dep.autorequire || dep.name).each do |file|
+          files << file
+        end
+      end
+      files
+    end
+
+    def self.process(bundler_gemfile, env)
+      deps = {}
+      bundler_gemfile.dependencies.each do |dep|
+        files = self.files_for_dependency(dep, env)
+        deps[dep.name] = {:dep => dep, :files => files} unless files.empty?
+      end
+      deps
+    end
+
+    def self.parse(gemfile, *groups)
+      setup_env(gemfile)
+      env = parse_env(groups)
+      gemfile = Bundler::Dsl.evaluate(gemfile, nil, true)
+      process(gemfile, env)
+    end
+  end
+end

data/lib/bundler_ext/output.rb

@@ -0,0 +1,16 @@
+module BundlerExt
+  class Output
+    def self.parse_env
+      @nostrict = ENV['BEXT_NOSTRICT'] || ENV['BUNDLER_EXT_NOSTRICT']
+    end
+
+    def self.strict_err(msg)
+      parse_env
+      if @nostrict
+        puts msg
+      else
+        raise msg
+      end
+    end
+  end
+end

data/lib/bundler_ext/runtime.rb

@@ -0,0 +1,66 @@
+require "bundler_ext/output"
+
+module BundlerExt
+  class Runtime
+    def gemfile(new_val = nil)
+      @bext_gemfile ||= Bundler.default_gemfile
+      @bext_gemfile   = new_val unless new_val.nil?
+      @bext_gemfile
+    end
+
+    def root
+      gemfile.dirname.expand_path
+    end
+
+    def bundler
+      @bundler_runtime ||= Bundler::Runtime.new(root, gemfile)
+    end
+
+    def rubygems
+      @bundler_rubygems ||= Bundler::RubygemsIntegration.new
+    end
+
+
+    def setup_env
+      # some rubygems do not play well with daemonized processes ($HOME is empty)
+      ENV['HOME'] = ENV['BEXT_HOME']        if ENV['BEXT_HOME']
+      ENV['HOME'] = ENV['BUNDLER_EXT_HOME'] if ENV['BUNDLER_EXT_HOME']
+    end
+
+    # Helper to generate, taken from bundler_ext
+    def self.namespaced_file(file)
+      return nil unless file.to_s.include?('-')
+      file.respond_to?(:name) ? file.name.gsub('-', '/') : file.to_s.gsub('-', '/')
+    end
+
+    def system_require(files)
+      files.each do |dep|
+        # this part also take from lib/bundler/runtime.rb (github/master)
+        begin
+          #puts "Attempting to require #{dep}"
+          require dep
+        rescue LoadError => e
+          namespaced_file = self.class.namespaced_file(dep)
+          begin
+            require namespaced_file unless namespaced_file.nil?
+          rescue LoadError => e2
+            e = e2
+          end
+
+          Output.strict_err "Gem loading error: #{e.message}"
+        end
+      end
+    end
+
+    def clear
+      bundler.send :clean_load_path
+    end
+
+    def add_spec(spec)
+      # copied from Bundler::Runtime#setup
+      rubygems.mark_loaded spec
+      load_paths = spec.load_paths.reject {|path| $LOAD_PATH.include?(path)}
+      $LOAD_PATH.unshift(*load_paths)
+    end
+  end
+end

data/lib/bundler_ext/setup.rb

@@ -0,0 +1,2 @@
+gemfile = ENV['BEXT_GEMFILE'] || 'Gemfile.in'
+BundlerExt.system_setup gemfile, :all

data/lib/bundler_ext/system.rb

@@ -0,0 +1,61 @@
+require 'rubygems/requirement'
+
+# ruby compat fix
+Gem::Requirement::BadRequirementError = ArgumentError if RUBY_VERSION < '2'
+
+module BundlerExt
+  class System
+    class << self
+      attr_accessor :pkg_prefix
+      attr_accessor :activate_versions
+    end
+
+    def self.parse_env
+      @pkg_prefix        = ENV['BEXT_PKG_PREFIX'] || ''
+      @activate_versions = ENV['BEXT_ACTIVATE_VERSIONS']
+    end
+
+    def self.activate?
+      parse_env
+      # TODO support other package system activations, eg deb, homebrew, etc
+      @activate_versions && self.is_rpm_system?
+    end
+
+    def self.system_name_for(name)
+      parse_env
+      "#{@pkg_prefix}#{name}"
+    end
+
+    def self.is_rpm_system?
+      File.executable?(self.rpm_cmd)
+    end
+
+    def self.rpm_cmd(new_val=nil)
+      @rpm_cmd ||= '/usr/bin/rpm'
+      @rpm_cmd   = new_val unless new_val.nil?
+      @rpm_cmd
+    end
+
+    def self.system_version_for(name)
+      if is_rpm_system?
+        out = `#{rpm_cmd} -qi #{name}`
+        version = out =~ /.*Version\s*:\s*([^\s]*)\s+.*/ ?
+          $1 : nil
+      else
+        # TODO support debian, other platforms
+        version = nil
+      end
+
+      version
+    end
+
+    def self.activate!(name)
+      begin
+        sys_name = system_name_for(name)
+        version  = system_version_for(sys_name)
+        gem name, "=#{version}"
+      rescue LoadError, Gem::Requirement::BadRequirementError
+      end
+    end
+  end
+end

data/lib/bundler_ext/version.rb

@@ -1,3 +1,3 @@
 module BundlerExt
-  VERSION = '0.3.2'
+  VERSION = '0.4.0'
 end

data/spec/bundler_ext/bundler_ext_spec.rb

@@ -1,146 +1,98 @@
 require 'spec_helper'
+require 'bundler_ext'
 
-# skip system specs unless we can load linux_admin
-skip_system = false
-begin
-  require 'linux_admin'
-rescue LoadError
-  skip_system = true
-end
-
-  describe BundlerExt do
-    before(:each) do
-      @gemfile = 'spec/fixtures/Gemfile.in'
+describe BundlerExt do
+  describe "#runtime" do
+    it "returns handle to runtime instance" do
+      described_class.runtime.should be_an_instance_of(BundlerExt::Runtime)
+      described_class.runtime.should == described_class.runtime
     end
-    after(:each) do
-      ENV['BUNDLER_PKG_PREFIX'] = nil
-      ENV['BEXT_ACTIVATE_VERSIONS'] = nil
-      ENV['BEXT_PKG_PREFIX'] = nil
-      ENV['BEXT_NOSTRICT'] = nil
-      ENV['BEXT_GROUPS'] = nil
+  end
+
+  describe "#system_require" do
+    it "sets up runtime env" do
+      described_class.runtime.should_receive(:setup_env)
+      described_class.system_require('spec/fixtures/Gemfile.in')
     end
 
-    describe "#parse_from_gemfile" do
-      describe "with no group passed in" do
-        it "should return nothing to require" do
-          libs = BundlerExt.parse_from_gemfile(@gemfile)
-          libs.should be_an(Hash)
-          libs.keys.should_not include('deltacloud-client')
-          libs.keys.should_not include('vcr')
-        end
-      end
-      describe "with :all passed in" do
-        it "should return the list of system libraries in all groups to require" do
-          libs = BundlerExt.parse_from_gemfile(@gemfile, :all)
-          libs.should be_an(Hash)
-          libs.keys.should include('deltacloud-client')
-          libs['deltacloud-client'][:files].should == ['deltacloud']
-          libs.keys.should include('vcr')
-        end
-      end
-      describe "with group passed in" do
-        it "should not return any deps that are not in the 'development' group" do
-          libs = BundlerExt.parse_from_gemfile(@gemfile,'development')
-          libs.should be_an(Hash)
-          libs.keys.should_not include('deltacloud-client')
-        end
-        it "should return only deps that are in the :test group" do
-          libs = BundlerExt.parse_from_gemfile(@gemfile, :test)
-          libs.should be_an(Hash)
-          libs.keys.should_not include('deltacloud-client')
-          libs.keys.should include('vcr')
-        end
-        it "should return deps from both the :default and :test groups" do
-          libs = BundlerExt.parse_from_gemfile(@gemfile, :default, :test)
-          libs.should be_an(Hash)
-          libs.keys.should include('deltacloud-client')
-          libs.keys.should include('vcr')
-        end
-      end
-      it "should only return deps for the current platform" do
-        libs = BundlerExt.parse_from_gemfile(@gemfile)
-        libs.should be_an(Hash)
-        if RUBY_VERSION < "1.9"
-          libs.keys.should_not include('cinch')
-        else
-          libs.keys.should_not include('fastercsv')
-        end
-      end
+    it "parses specified gemfile" do
+      BundlerExt::Gemfile.should_receive(:parse).
+        with('spec/fixtures/Gemfile.in', *['mygroups']).
+        and_call_original
+      described_class.system_require('spec/fixtures/Gemfile.in', 'mygroups')
     end
-    describe "#system_require" do
-      it "strict mode should fail loading non existing gem" do
-        expect { BundlerExt.system_require(@gemfile, :fail) }.to raise_error
-      end
 
-      it "non-strict mode should load the libraries in the gemfile" do
-        ENV['BEXT_NOSTRICT'] = 'true'
-        BundlerExt.system_require(@gemfile)
-        defined?(Gem).should be_true
+    context "System.activate? is true" do
+      it "activates system dependencies" do
+        BundlerExt::Gemfile.should_receive(:parse).
+          and_return({'rails' => {:files => []}})
+        BundlerExt::System.should_receive(:activate?).and_return(true)
+        BundlerExt::System.should_receive(:activate!).with('rails')
+        described_class.system_require('my_gemfile')
       end
+    end
 
-      it "non-strict mode should load the libraries in the gemfile" do
-        ENV['BUNDLER_EXT_NOSTRICT'] = 'true'
-        BundlerExt.system_require(@gemfile)
-        defined?(Gem).should be_true
-      end
+    it "requires dependency files" do
+      files = ['rails-includes']
+      BundlerExt::Gemfile.should_receive(:parse).
+        and_return({'rails' => {:files => files}})
+      described_class.runtime.should_receive(:system_require).with(files)
+      described_class.system_require('my_gemfile')
+    end
+  end
 
-      it "non-strict mode should load the libraries in the gemfile" do
-        ENV['BEXT_NOSTRICT'] = 'true'
-        BundlerExt.system_require(@gemfile, :fail)
-        defined?(Gem).should be_true
-      end
+  describe "#system_setup" do
+    it "sets up gemfile env" do
+      BundlerExt::Gemfile.should_receive(:setup_env).
+        with('spec/fixtures/Gemfile.in').at_least(:once)
+      described_class.runtime.should_receive(:clear) # stub out clear
+      described_class.system_setup('spec/fixtures/Gemfile.in')
+    end
 
-      it "non-strict mode should load the libraries in the gemfile" do
-        ENV['BUNDLER_EXT_NOSTRICT'] = 'true'
-        BundlerExt.system_require(@gemfile, :fail)
-        defined?(Gem).should be_true
-      end
-      it "non-strict mode should load the libraries using env var list" do
-        ENV['BEXT_GROUPS'] = 'test development blah'
-        ENV['BEXT_NOSTRICT'] = 'true'
-        BundlerExt.system_require(@gemfile)
-        defined?(Gem::Command).should be_true
-      end
+    it "sets runtime gemfile" do
+      described_class.runtime.should_receive(:clear) # stub out clear
+      described_class.system_setup('spec/fixtures/Gemfile.in')
+      described_class.runtime.gemfile.to_s.should == 'spec/fixtures/Gemfile.in'
+    end
 
-      it "non-strict mode should load the libraries using env var list" do
-        ENV['BUNLDER_EXT_GROUPS'] = 'test development blah'
-        ENV['BEXT_NOSTRICT'] = 'true'
-        BundlerExt.system_require(@gemfile)
-        defined?(Gem::Command).should be_true
-      end
+    it "sets up runtime env" do
+      described_class.runtime.should_receive(:clear) # stub out clear
+      described_class.runtime.should_receive(:setup_env)
+      described_class.system_setup('spec/fixtures/Gemfile.in')
+    end
 
-      unless skip_system
-        context "ENV['BEXT_ACTIVATE_VERSIONS'] is true" do
-          before(:each) do
-            ENV['BUNDLER_EXT_NOSTRICT'] = 'true'
-            ENV['BEXT_ACTIVATE_VERSIONS'] = 'true'
-          end
+    it "clears runtime" do
+      described_class.runtime.should_receive(:clear) # stub out clear
+      described_class.runtime.should_receive(:setup_env)
+      described_class.system_setup('spec/fixtures/Gemfile.in')
+    end
 
-          it "activates the version of the system installed package" do
-            gems = BundlerExt.parse_from_gemfile(@gemfile, :all)
-            gems.each { |gem,gdep|
-              version = rand(100)
-              BundlerExt.should_receive(:system_gem_name_for).with(gem).
-                         and_return(gem)
-              BundlerExt.should_receive(:system_gem_version_for).with(gem).
-                         and_return(version)
-              BundlerExt.should_receive(:gem).with(gem, "=#{version}")
-            }
-            BundlerExt.system_require(@gemfile, :all)
-          end
+    it "parses specified gemfile" do
+      described_class.runtime.should_receive(:clear) # stub out clear
+      BundlerExt::Gemfile.should_receive(:parse).
+        with('spec/fixtures/Gemfile.in', *['mygroups']).
+        and_call_original
+      described_class.system_setup('spec/fixtures/Gemfile.in', 'mygroups')
+    end
 
-          context "ENV['BEXT_PKG_PREFIX'] is specified" do
-            it "prepends bundler pkg prefix onto system package name to load" do
-              ENV['BEXT_PKG_PREFIX'] = 'rubygem-'
-              gems = BundlerExt.parse_from_gemfile(@gemfile, :all)
-              gems.each { |gem,gdep|
-                BundlerExt.should_receive(:system_gem_version_for).with("rubygem-#{gem}").
-                           and_return('0')
-              }
-              BundlerExt.system_require(@gemfile, :all)
-            end
-          end
-        end
+    context "System.activate? is true" do
+      it "activates system dependencies" do
+        described_class.runtime.should_receive(:clear) # stub out clear
+        BundlerExt::Gemfile.should_receive(:parse).
+          and_return({'rails' => {:dep => ::Gem::Dependency.new('rails')}})
+        BundlerExt::System.should_receive(:activate?).and_return(true)
+        BundlerExt::System.should_receive(:activate!).with('rails')
+        described_class.system_setup('spec/fixtures/Gemfile.in')
       end
     end
+
+    it "adds dependency specs to runtime" do
+      dep = ::Gem::Dependency.new('rails')
+      described_class.runtime.should_receive(:clear) # stub out clear
+      BundlerExt::Gemfile.should_receive(:parse).
+        and_return({'rails' => {:dep => dep}})
+      described_class.runtime.should_receive(:add_spec).with(dep.to_spec())
+      described_class.system_setup('spec/fixtures/Gemfile.in')
+    end
   end
+end