cldwalker-local_gem 0.1.1

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2009 Gabriel Horner
+
+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.

data/README.rdoc

@@ -0,0 +1,63 @@
+== Description
+
+You have the beginnings of a ruby library and you want to access it quick.
+You don't want to bother making a gemspec for it and uninstalling/reinstalling its gem
+while you mess with it. Simply tell LocalGem what paths it should load for
+your local gem and they will be loaded. Note that it doesn't matter how gem-like
+your project is ie lib and bin directories etc. LocalGem *only* needs to know
+the full path to your gem/library.
+
+== Setup
+
+Install the gem with:
+
+    sudo gem install cldwalker-local_gem -s http://gems.github.com
+
+To setup your local gem paths, give LocalGem a hash of gem names pointing
+to a path or an array of paths to load. You can do this with LocalGem.setup_config
+
+    LocalGem.setup_config do |c|
+      c.gems = {'gem1'=>"/gem1/path/lib", 'gem2'=> ["/gem2/path/lib", "/gem2/path/bin"] }
+    end
+
+Or a config file at either a local local_gem.yml or ~/.local_gem.yml .
+See local_gem.yml.example for an example config file.
+
+== Usage
+
+The two main methods that LocalGem provides are local_gem() and local_require()
+which map to gem() and require() respectively. Both methods will attempt
+to load local gems that you have defined. If no gem is found than they resort to default gem/require
+behavior.
+
+There are 3 ways to use this library:
+
+  1. Mild: Call LocalGem with its class methods.
+      
+      require 'local_gem'
+      LocalGem.local_gem 'alias' 
+
+  2. Hot: Call methods directly having included it into your Kernel namespace.
+
+      require 'local_gem'
+      include LocalGem
+      local_gem 'alias'
+
+  3. Spicy: Override require() and gem() with local_require() and local_gem() respectively.
+      
+      require 'local_gem'
+      require 'local_gem/override'
+      gem 'alias'
+
+All three ways would add my local alias library to $LOAD_PATH. These three ways
+also apply to local_require().
+
+
+== Motivation
+
+Got tired of installing/uninstalling the latest version of a gem I'm actively working on. This
+also makes it easy to treat any random directory of ruby files as a gem.
+
+== Limitations
+
+The override and rcov don't play nicely.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.rcov_opts = ["-T -x '/Library/Ruby/*'"]
+    t.verbose = true
+  end
+rescue LoadError
+  puts "Rcov not available. Install it for rcov-related tasks with: sudo gem install rcov"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "local_gem"
+    s.description = "Loads any gem/library simply given its path. Great for nascent gems and/or for trying the latest code on a gem."
+    s.summary = s.description
+    s.email = "gabriel.horner@gmail.com"
+    s.homepage = "http://github.com/cldwalker/local_gem"
+    s.authors = ["Gabriel Horner"]
+    s.has_rdoc = true
+    s.files = FileList["VERSION.yml","Rakefile", "README.rdoc", "LICENSE.txt", "{bin,lib,test}/**/*"]
+  end
+
+rescue LoadError
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'test'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 1

data/lib/config_struct.rb

@@ -0,0 +1,18 @@
+require 'ostruct'
+
+class ConfigStruct < OpenStruct
+  # Converts the data within the given block to hash
+  def self.block_to_hash(block=nil)
+    config = self.new
+    if block
+      block.call(config)
+      config.to_hash
+    else
+      {}
+    end
+  end
+
+  def to_hash #:nodoc:
+    @table
+  end
+end

data/lib/local_gem/override.rb

@@ -0,0 +1,19 @@
+module Kernel
+  alias_method :old_require, :require
+  alias_method :old_gem, :gem
+
+  # Overrides gem() to behave like LocalGem::Singleton.local_gem().
+  def gem(*args)
+    LocalGem::Singleton.load_local_gem(args[0]) || old_gem(*args)
+  end
+
+  # Overrides require() to behave like LocalGem::Singleton.local_require().
+  def require(lib)
+    LocalGem::Singleton.load_local_gem(lib)
+    old_require(lib)
+  end
+
+  private :old_require, :old_gem
+end
+
+self.send :include, LocalGem

data/lib/local_gem.rb

@@ -0,0 +1,65 @@
+$:.unshift(File.dirname(__FILE__)) unless 
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'config_struct'
+
+module LocalGem
+  extend self
+  def local_require(path) #:nodoc:
+    Singleton.local_require(path)
+  end
+
+  def local_gem(*args) #:nodoc:
+    Singleton.local_gem(*args)
+  end
+
+  def setup_config(config, &block) #:nodoc:
+    Singleton.setup_config(config, &block)
+  end
+
+  module Singleton
+    extend self
+    attr_accessor :config, :config_file
+
+    # Holds the mapping of local gems and their paths to load.
+    def config
+      @config ||= read_config
+    end
+
+    # Reads config from @config_file and returns a hash.
+    # @config_file can be set via its accessor. Otherwise it defaults to a local local_gem.yml or
+    # ~/.local_gem.yml.
+    def read_config
+      @config_file ||= ['local_gem.yml', File.join("~", ".local_gem.yml")].detect {|e| File.exists?(File.expand_path(e)) }
+      @config_file ? YAML::load(File.new(File.expand_path(@config_file))) : {:gems=>{}}
+    end
+
+    # Takes either a hash or a block and initializes config().
+    def setup_config(config=nil, &block)
+      @config = config || ConfigStruct.block_to_hash(block)
+    end
+
+    # Loads the local gem if found or defaults to a normal gem call.
+    def local_gem(*args)
+      load_local_gem(args[0]) || gem(*args)
+    end
+
+    # Loads the local gem if found and then does a normal require on it.
+    def local_require(lib)
+      load_local_gem(lib)
+      require(lib)
+    end
+
+    # Adds a given library's path (specified in config) to the beginning of $LOAD_PATH.
+    def load_local_gem(library)
+      if path = config[:gems][library]
+        path = [path] unless path.is_a?(Array)
+        path.map {|e| File.expand_path(e) }.each do |f|
+          $:.unshift(f) unless $:.include?(f)
+        end
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/test/local_gem_test.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class LocalGem::Test < Test::Unit::TestCase
+  before(:each) {
+    LocalGem::Singleton.config = { :gems=>{
+    'gem1'=>'path1', 'gem2'=>['path2','path3']}
+    }
+  }
+
+  test "local_gem adds gem's one path to $:" do
+    full_gem_path = File.expand_path(LocalGem::Singleton.config[:gems]['gem1'])
+    assert !$:.include?(full_gem_path)
+    LocalGem.local_gem('gem1')
+    assert $:.include?(full_gem_path)
+  end
+
+  test "local_gem adds gem's multiple paths to $:" do
+    full_gem_paths = LocalGem::Singleton.config[:gems]['gem2'].map {|e| File.expand_path(e) }
+    assert ($: & full_gem_paths).empty?
+    LocalGem.local_gem('gem2')
+    assert !($: & full_gem_paths).empty?
+  end
+
+  test "local_gem defaults to gem if no local gem found" do
+    LocalGem::Singleton.expects(:gem).once
+    LocalGem.local_gem('invalid')
+  end
+
+  test "local_gem calls load_local_gem for a valid gem" do
+    LocalGem::Singleton.expects(:load_local_gem).once.returns(true)
+    LocalGem.local_gem('blah')
+  end
+
+  test "local_require calls load_local_gem and require" do
+    LocalGem::Singleton.expects(:require).once
+    LocalGem::Singleton.expects(:load_local_gem).once
+    LocalGem.local_require('blah')
+  end
+
+  test "setup_config with hash initializes config" do
+    config = {:gems=>{'blah_gem'=>'blah_path'}}
+    LocalGem::Singleton.setup_config(config)
+    assert_equal config, LocalGem::Singleton.config
+  end
+
+  test "setup_config with block initializes config" do
+    config = {:gems=>{'blah_gem'=>'blah_path'}}
+    LocalGem::Singleton.setup_config do |c|
+      c.gems = config[:gems]
+    end
+    assert_equal config, LocalGem::Singleton.config
+  end
+
+  test "read_config uses existing config_file" do
+    LocalGem::Singleton.config_file = 'blah'
+    File.expects(:new)
+    YAML::expects(:load)
+    LocalGem::Singleton.read_config
+    assert_equal 'blah', LocalGem::Singleton.config_file
+  end
+
+  test "read_config uses config_file it detects" do
+    LocalGem::Singleton.config_file = nil
+    File.expects(:new)
+    YAML::expects(:load)
+    File.expects(:exists?).times(2).returns(false, true)
+    LocalGem::Singleton.read_config
+    assert 'local_gem.yml', File.basename(LocalGem::Singleton.config_file)
+  end
+end

data/test/override_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class LocalGem::OverrideTest < Test::Unit::TestCase
+  before(:all) { require 'local_gem/override' }
+  test "gem calls old_gem and load_local_gem" do
+    LocalGem::Singleton.expects(:load_local_gem).once
+    self.expects(:old_gem).once
+    gem('blah')
+  end
+
+  test "require calls old_require and load_local_gem" do
+    LocalGem::Singleton.expects(:load_local_gem).once
+    self.expects(:old_require).once
+    require('blah')
+  end
+
+  test "loading override should have included LocalGem in self" do
+   assert self.instance_eval("class<<self; self; end").ancestors.include?(LocalGem)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+require 'context' #gem install jeremymcanally-context -s http://gems.github.com
+require 'mocha'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'local_gem'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: cldwalker-local_gem
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Gabriel Horner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-01 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Loads any gem/library simply given its path. Great for nascent gems and/or for trying the latest code on a gem.
+email: gabriel.horner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- Rakefile
+- README.rdoc
+- LICENSE.txt
+- lib/config_struct.rb
+- lib/local_gem
+- lib/local_gem/override.rb
+- lib/local_gem.rb
+- test/local_gem_test.rb
+- test/override_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/cldwalker/local_gem
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Loads any gem/library simply given its path. Great for nascent gems and/or for trying the latest code on a gem.
+test_files: []
+