gemist 0.0.4

data/HISTORY.md

@@ -0,0 +1,23 @@
+v0.0.4 - May 15, 2011
+---------------------
+
+### Fixed:
+  * Apps now exit with an exit code when it can't load certain gems
+
+### Added:
+  * Allow multiple version requirements
+  * Passthru require errors
+  * Show gem loading errors that aren't the usual 'can't load X'
+
+### Changed:
+  * Use plain old gemspecs instead of joe
+  * Use the more-canonical Gem.activate
+
+v0.0.3 - May 04, 2011
+---------------------
+
+### Fixed:
+  * Fix the missing gems list print.
+
+### Added:
+  * Allow multiple requires.

data/README.md

@@ -0,0 +1,173 @@
+# Gemist
+#### An extremely minimal solution to gem isolation
+
+**Bundler + faster + smaller (<4kb) = Gemist**
+
+You don't need Bundler for gem management. Rubygems can do it already. Let me 
+show you what I mean:
+
+## Getting started
+
+Make a file in your project called `Gemfile`.
+
+``` ruby
+# Gemfile
+gem "sinatra"
+gem "ohm", "0.1.3"
+
+# These will only be for the development environment
+group :development do
+  gem "json-pure", require: "json"
+end
+
+# You may specify multiple files to be required
+gem "rails", ">= 3.0", require: ['rails', 'action_controller']
+```
+
+In your project file, do this.
+This `require`s the gems defined in the Gemfile.
+
+``` ruby
+require 'gemist'
+Gemist.require
+```
+
+When you run your app, and some gems are not present, a message will show:
+
+    $ ruby init.rb
+    Some gems cannot be loaded. Try:
+
+    gem install ohm -v 0.1.3
+    gem install json-pure
+
+## How does it work?
+
+Gemist uses Rubygems to load specific gems. Did you know you can specify a gem 
+version using Rubygems's `Gem.activate`? Gemist is merely a light bridge that 
+does that for you by reading your Gemfile.
+
+For example, if your project has this Gemfile:
+
+``` ruby
+gem "sinatra", "~> 1.2.0", require: "sinatra/base"
+gem "nokogiri", ">= 1.2"
+```
+
+Then you do:
+
+``` ruby
+Gemist.require
+````
+
+All `Gemist.require` does in the background is:
+
+``` ruby
+require 'rubygems'
+
+::Gem.activate "sinatra", "~> 1.2.0"
+::Gem.activate "nokogiri", ">= 1.2"
+require "sinatra/base"
+require "nokogiri"
+```
+
+## How to do other things
+
+Gemist doesn't have some of Bundler's conveniences that Rubygems can already 
+handle.
+
+### Freezing gem versions
+
+Gemist doesn't care about your `Gemfile.lock`.
+
+This means that to ensure your app will work with future gem releases, you
+should add versions like so (using `~>` is highly recommended):
+
+``` ruby
+# Gemfile
+gem "sinatra", "~> 1.1"
+```
+
+If you need a Gemfile.lock for whatever reason, use `bundle update --local`.
+
+### Vendoring gems
+
+Gemist does NOT vendor gems for you. Rubygems helps you with that already!
+
+First, don't specify your vendored gems in your Gemfile.
+
+Second, freeze your gems like so:
+
+    $ mkdir vendor
+    $ cd vendor
+    $ gem unpack sinatra
+
+Then load them manually:
+
+``` ruby
+# init.rb
+$:.unshift *Dir['./vendor/*/lib']
+require 'sinatra/base'
+```
+
+### More common usage
+
+If you prefer to `require` gems individually yourself, use `Gemist.setup`.
+
+``` ruby
+require 'gemist'
+Gemist.setup
+```
+
+Alternatively, you may also use the syntactic sugar (does the same thing as 
+above):
+
+``` ruby
+require 'gemist/setup'
+```
+
+To require gems from a specific group, use `Gemist.require <group>`.
+(By default, Gemist assumes whatever is in `RACK_ENV`.)
+
+``` ruby
+require 'gemist'
+Gemist.require :development
+```
+
+There's also syntactic sugar for `Gemist.require ENV['RACK_ENV']`:
+
+``` ruby
+require 'gemist/require'
+```
+
+## Benchmarks
+
+Informal benchmarks with a Gemfile of one of my projects on Ruby 1.9.2:
+
+``` ruby
+Benchmark.measure { require 'bundler'; Bundler.require }  #=> 2.5s average
+Benchmark.measure { require 'gemist';  Gemist.require }   #=> 1.6s average
+```
+
+## Don't use this
+
+This is merely a proof-of-concept. It works (very well), but:
+
+1. The world has enough gem management tools, it doesn't need another.
+
+2. Bundler is better (though it's more bloated and does more things).
+
+## Not going to happen
+
+Gemist will never have:
+
+- **Dependency resolution.**  
+If there are conflicts in your gems's requirements, just manually specify the 
+gem version that will satisfy both.  Alternatively, stop using too many gems.
+
+- **An installer (like 'bundle install').**  
+Seriously, just install the gems yourself! Gemist even gives you the exact 
+command to do it.
+
+## Authors
+
+Done by Rico Sta. Cruz and released under the MIT license.

data/Rakefile

@@ -0,0 +1,4 @@
+desc "Run tests"
+task(:test) {
+  Dir['./test/*_test.rb'].each { |f| load f }
+}

data/lib/gemist/require.rb

@@ -0,0 +1,3 @@
+# Sugar for Gemist.require
+require 'gemist'
+Gemist.require

data/lib/gemist/setup.rb

@@ -0,0 +1,3 @@
+# Sugar for Gemist.require
+require 'gemist'
+Gemist.setup

data/lib/gemist.rb

@@ -0,0 +1,183 @@
+require 'ostruct'
+
+# Gem environment manager.
+module Gemist
+  VERSION = "0.0.4"
+
+  def self.version
+    VERSION
+  end
+
+  # Loads the gems via +require+.
+  def self.require(env=ENV['RACK_ENV'])
+    load_rubygems
+    setup env
+    gemfile.gems_for(env).each { |g| g.require! }
+  end
+
+  # Loads the gems for a given environment.
+  def self.setup(env=ENV['RACK_ENV'])
+    @fail = Array.new
+
+    gemfile.gems_for(env).each do |g|
+      g.load! or @fail << g
+    end
+
+    if @fail.any?
+      commands = @fail.map { |g| g.to_command }.compact
+      list     = commands.map { |cmd| "gem install #{cmd}" }
+
+      if list.any?
+        $stderr << "Some gems failed to load. Try:\n\n"
+        $stderr << "#{list.join("\n")}\n\n"
+      end
+
+      print_errors_for(@fail)
+      exit 256
+    end
+  end
+
+  # Returns the Gemfile for the current project.
+  def self.gemfile
+    @@gemfile ||= Gemfile.load
+  end
+
+private
+  # Prints errors for failed gems
+  def self.print_errors_for(gems)
+    # Remove those
+    gems = gems.reject { |g| g.error.name == g.name }
+
+    if gems.any?
+      $stderr << "These errors occured:\n"
+      gems.each { |gem| $stderr << "  [#{gem.name}] #{gem.error.to_s}\n" }
+    end
+  end
+
+  # Loads rubygems. Skips if it's not needed (like in Ruby 1.9)
+  def self.load_rubygems
+    Kernel.require 'rubygems'  unless Object.const_defined?(:Gem)
+  end
+end
+
+# A definition of a project Gemfile manifest.
+class Gemist::Gemfile
+  # Returns the path of the project's Gemfile manifest, or +nil+ if
+  # not available.
+  def self.path
+    %w(GEMFILE BUNDLER_GEMFILE).each do |spec|
+      return ENV[spec]  if ENV[spec] && File.exists?(ENV[spec])
+    end
+
+    Dir["./{Gemistfile,Gemfile,Isolate}"].first
+  end
+
+  # Checks if the project has a Gemfile manifest.
+  def self.exists?
+    !!path
+  end
+
+  # Returns a Gemfile instance made from the project's manifest.
+  def self.load
+    new File.read(path)  if exists?
+  end
+
+  def initialize(contents)
+    instance_eval contents
+  end
+
+  # The list of gems the Gemfile. Returns an array of Gem instances.
+  def gems()
+    @gems ||= Array.new
+  end
+
+  # Returns a list of Gem instances for the given environment.
+  def gems_for(env)
+    gems.select { |g| g.group == nil || g.group.include?(env.to_s.to_sym) }
+  end
+
+private
+  # (DSL) Adds a gem.
+  #
+  # == Example
+  #
+  #   # Gemfile
+  #   gem "sinatra"
+  #   gem "sinatra", "1.1"
+  #   gem "sinatra", "1.1", :require => "sinatra/base"
+  #
+  def gem(name, *args)
+    options = args.last.is_a?(Hash) ? args.pop : Hash.new
+
+    options[:name]    ||= name
+    options[:version] ||= args
+    options[:group]   ||= @group
+
+    self.gems << Gemist::Gem.new(options)
+  end
+
+  # (DSL) Defines a group.
+  #
+  # == Example
+  #
+  #   # Gemfile
+  #   group :test do
+  #     gem "capybara"
+  #   end
+  #
+  def group(*names, &blk)
+    @group = names.map { |s| s.to_sym }
+    yield
+    @group = nil
+  end
+
+  # Does nothing. Here for Bundler compatibility.
+  def source(src)
+  end
+end
+
+# A Gem in the gemfile.
+class Gemist::Gem
+  attr_accessor :name
+  attr_accessor :versions
+  attr_accessor :require
+  attr_accessor :group
+  attr_reader :error
+
+  def initialize(options)
+    self.name     ||= options[:name]
+    self.versions ||= options[:version]
+    self.group    ||= options[:group]
+    self.require  ||= options[:require] || self.name
+  end
+
+  # Activates the gem; returns +false+ if it's not available.
+  def load!
+    ::Gem.activate name, *versions
+    true
+  rescue ::Gem::LoadError => e
+    @error = e
+    false
+  end
+
+  # Loads the gem via +require+. Make sure you load! it first.
+  # Returns true if loaded.
+  def require!
+    [*require].each { |r| Kernel.require r }
+  end
+
+  # Returns the +gem install+ paramaters needed to install the gem.
+  def to_command
+    if error
+      [error.name, *version_join(error.requirement.to_s.split(', '))].join(' ')  if error.name
+    else
+      [name, version_join(versions)].compact.join ' '
+    end
+  end
+
+private
+  def version_join(vers)
+    versions = [*vers].sort.map { |v| "-v #{v.to_s.inspect}"  unless v.to_s == '>= 0' }.compact
+    versions.join(' ')  unless versions.empty?
+  end
+end

data/test/bogus_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class BogusTest < Test::Unit::TestCase
+  test "bogus - print requirements" do
+    Gemist.expects(:exit).returns(true)
+
+    use_gemfile 'bogus.gemfile'
+
+    Gemist.setup
+    assert err.include?("gem install xyzzyabc\n")
+    assert err.include?("gem install aoeuidhtns\n")
+    assert err.include?("gem install pyfgcrl -v \">= 3.0\"\n")
+    assert err.include?("gem install qjkxbmwvz -v \"<= 4.0\" -v \">= 3.0\"\n")
+  end
+end

data/test/fixtures/bogus.gemfile

@@ -0,0 +1,4 @@
+gem "xyzzyabc"
+gem "aoeuidhtns"
+gem "pyfgcrl", ">= 3.0"
+gem "qjkxbmwvz", ">= 3.0", "<= 4.0"

data/test/fixtures/sample.gemfile

@@ -0,0 +1,6 @@
+source "rubygems"
+
+gem "sinatra", ">= 1.0", "<= 1.3"
+gem "yard"
+gem "test-unit", "~> 0.5", require: 'test/unit'
+gem "ffaker", ">= 1.0", "<= 1.3", require: 'faker'

data/test/gemist_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class GemistTest < Test::Unit::TestCase
+  setup do
+    Gem.expects(:activate).with('sinatra', '>= 1.0', '<= 1.3').returns(true)
+    Gem.expects(:activate).with('yard').returns(true)
+    Gem.expects(:activate).with('test-unit', '~> 0.5').returns(true)
+    Gem.expects(:activate).with('ffaker', '>= 1.0', '<= 1.3').returns(true)
+
+    use_gemfile 'sample.gemfile'
+  end
+
+  test "sample - setup" do
+    Gemist.setup
+  end
+
+  test "sample - require" do
+    Kernel.expects(:require).with('sinatra').returns(true)
+    Kernel.expects(:require).with('yard').returns(true)
+    Kernel.expects(:require).with('test/unit').returns(true)
+    Kernel.expects(:require).with('faker').returns(true)
+
+    Gemist.require
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'contest'
+require 'mocha'
+
+require File.expand_path('../../lib/gemist', __FILE__)
+
+class Test::Unit::TestCase
+  setup do
+    $_stderr = $stderr
+    $stderr  = StringIO.new
+  end
+
+  teardown do
+    ENV.delete 'GEMFILE'
+    $stderr = $_stderr
+  end
+
+  def err
+    $stderr.string
+  end
+
+  def fixture(path)
+    File.expand_path("../fixtures/#{path}", __FILE__)
+  end
+
+  def use_gemfile(what)
+    ENV['GEMFILE'] = fixture(what)
+    Gemist.class_variable_set :@@gemfile, nil
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: gemist
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Rico Sta. Cruz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-15 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: Gemist leverages on purely Rubygems to require the correct gem versions in a project.
+email: 
+- rico@sinefunc.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/gemist/require.rb
+- lib/gemist/setup.rb
+- lib/gemist.rb
+- test/bogus_test.rb
+- test/fixtures/bogus.gemfile
+- test/fixtures/sample.gemfile
+- test/gemist_test.rb
+- test/test_helper.rb
+- HISTORY.md
+- README.md
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/rstacruz/gemist
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: An extremely minimal solution to gem isolation
+test_files: []
+