callsite 0.0.1

data/README.rdoc

@@ -0,0 +1,66 @@
+= Callsite
+
+Caller/backtrace parser with some useful utilities for manipulating the load path, and doing other relative things.
+
+== Usage
+
+The primary thing you can do is parse a caller line(s).
+
+  pp Callsite.parse(caller)
+  
+Gives back
+  
+  => [#<struct Callsite::Line
+    filename="/opt/local/lib/ruby/1.8/irb/workspace.rb",
+    line=52,
+    method="irb_binding">,
+   #<struct Callsite::Line filename="", line=0, method=nil>]
+
+This is also suitable for parsing a backtrace, to get detailed information about it.
+
+There are also five methods which patch existing objects to give you powerful usage of the caller.
+
+=== Callsite.activate_string_methods
+
+This gives you the ~@ method on +String+, which takes any string, and gives you a relative version of it, treating it as a file path. For example,
+
+  ~'lib/callsite.rb'
+  
+Gives you (on my laptop)
+
+  => "/Users/joshua/Development/callsite/lib/callsite.rb"
+
+=== Callsite.activate_file_methods
+
+This adds the +File.relative+ method. File.relative(file_path) has the same effect as ~file_path.
+
+=== Callsite.activate_module_methods
+
+This adds +autoload_relative+ onto Module. This allows you to do the following.
+
+  module MyModule
+    autoload_relative :Whatever, "lib/whatever"
+  end
+  
+In this case, lib/whatever will be treated as a relative path from the definition of the module.
+
+=== Callsite.activate_kernel_dir_methods
+
+This adds the __DIR_REL__ and optionally __DIR__ and require_relative methods to Kernel. __DIR__ or __DIR_REL__ will give you your current directory, much like
+__FILE__ gives you the current __FILE__ you're in. +require_relative+ is like +require+ .. only, it's relative.
+
+=== Callsite.activate_kernel_require_methods
+
+This adds a couple of weird methods to Kernel, require_next and require_all. There search your current $LOAD_PATH, and require the next file (ingoring the current one you're in on the load_path) or require all files of a given name.
+
+=== Callsite.activate_load_path_methods
+
+This adds some super useful methods to $LOAD_PATH. There are find_file (finds a single file on your load path), find_all_files (finds all of em), add_current (adds to the end of the load path your current dir) and add_current! (adds it to the beginning).
+
+== I lied
+
+I said there were 5, I meant 6. There are 5 lights.
+
+== This deprecates +dirge+ and +load_path_find+
+
+Once you have this installed, you can use require 'dirge' and require 'load_path_find' to get exactly the functionality you had before.

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "callsite"
+    s.description = s.summary = "Caller/backtrace parser with some useful utilities for manipulating the load path, and doing other relative things."
+    s.email = "joshbuddy@gmail.com"
+    s.homepage = "http://github.com/joshbuddy/callsite"
+    s.authors = ["Joshua Hull"]
+    s.files = FileList["[A-Z]*", "{lib}/**/*"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec'
+require 'spec/rake/spectask'
+task :spec => ['spec:dirge', 'spec:load_path_find']
+namespace(:spec) do
+  Spec::Rake::SpecTask.new(:dirge) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << '-rlib/dirge'
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/dirge_spec.rb']
+  end
+
+  Spec::Rake::SpecTask.new(:load_path_find) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << '-rlib/load_path_find'
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/load_path_find_spec.rb']
+  end
+
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/callsite.rb

@@ -0,0 +1,105 @@
+$LOAD_PATH << File.dirname(__FILE__)
+
+module Callsite
+  UnparsableCallLine = Class.new(RuntimeError)
+  Line = Struct.new(:filename, :line, :method)
+
+  def self.__DIR_REL__(called_from = nil)
+    called_from ||= caller.first
+    caller_path = parse(called_from).filename
+    caller_path = '.' if caller_path == ''
+    File.expand_path(File.dirname(caller_path))
+  end
+
+  def self.parse(input)
+    if input.is_a?(Array)
+      block_given? ?
+        input.each{|line| yield parse(line)} :
+        input.map{|line| parse(line)}
+    else
+      if match = input.match(/^(.*?)(:(\d+))(:in `(.*)')?$/)
+        Line.new(match[1], match[3].to_i, match[5])
+      else
+        raise UnparsableCallLine.new("unable to parse #{input}")
+      end
+    end
+  end
+  
+  def self.activate_string_methods
+    activate_kernel_dir_methods
+    ::String.send(:include, StringMethods)
+  end
+  
+  def self.activate_file_methods
+    activate_kernel_dir_methods
+    ::File.send(:extend, FileMethods)
+  end
+  
+  def self.activate_module_methods
+    activate_kernel_dir_methods
+    ::Module.send(:include, ModuleMethods)
+  end
+  
+  def self.activate_kernel_dir_methods
+    require 'loaders/kernel_dir'
+  end
+  
+  def self.activate_kernel_require_methods
+    activate_loadpath_methods
+    require 'loaders/kernel_require'
+  end
+  
+  def self.activate_loadpath_methods
+    activate_kernel_dir_methods
+    require 'loaders/load_path'
+  end
+  
+  module StringMethods
+    unless method_defined?(:~@)
+      def ~@
+        File.expand_path(File.join(Kernel.__DIR_REL__(caller.first), self))
+      end
+    end
+  end
+
+  module FileMethods
+    def relative(path)
+      File.expand_path(File.join(Kernel.__DIR_REL__(caller.first), path))
+    end
+  end
+
+  module ModuleMethods
+    unless method_defined?(:autoload_relative)
+      def autoload_relative(name, filename)
+        autoload name, File.join(Kernel.__DIR_REL__(caller.first), filename)
+      end
+    end
+  end
+  
+  module LoadPathMethods
+    def find_file(file)
+      find_all_files(file){|f| return f}
+      nil
+    end
+
+    def find_all_files(file, ext = nil)
+      file += ext if ext and File.extname(file) != ext
+      inject([]){|ary, path| 
+        target = File.expand_path(file, path)
+        if File.readable?(target)
+          ary << target
+          yield target if block_given?
+        end
+        ary
+      }
+    end
+
+    def add_current
+      self << __DIR_REL__(caller.first)
+    end
+
+    def add_current!
+      self.unshift(__DIR_REL__(caller.first))
+    end
+  end
+end

data/lib/dirge.rb

@@ -0,0 +1,6 @@
+require 'callsite'
+Callsite.activate_kernel_require_methods
+Callsite.activate_kernel_dir_methods
+Callsite.activate_string_methods
+Callsite.activate_file_methods
+Callsite.activate_module_methods

data/lib/load_path_find.rb

@@ -0,0 +1,7 @@
+require 'callsite'
+Callsite.activate_loadpath_methods
+Callsite.activate_kernel_require_methods
+Callsite.activate_kernel_dir_methods
+Callsite.activate_string_methods
+Callsite.activate_file_methods
+Callsite.activate_module_methods

data/lib/loaders/kernel_dir.rb

@@ -0,0 +1,17 @@
+module Kernel
+  def __DIR_REL__(called_from = nil)
+    parsed_line = Callsite.parse(called_from || caller.first)
+    parsed_line && File.expand_path(File.dirname(parsed_line.filename))
+  end
+
+  unless method_defined?(:__DIR__)
+    alias_method :__DIR__, :__DIR_REL__
+  end
+
+  unless method_defined?(:require_relative)
+    def require_relative(path)
+      require File.join(__DIR_REL__(caller.first), path)
+    end
+  end
+end
+  

data/lib/loaders/kernel_require.rb

@@ -0,0 +1,18 @@
+module Kernel
+  def require_all(req)
+    $LOAD_PATH.find_all_files(req, ".rb") { |file| require file }
+  end
+
+  def require_next(req)
+    found, current = false, File.expand_path(caller.first[/^[^:]+/])
+    $LOAD_PATH.find_all_files(req, ".rb") do |file|
+      if found
+        $LOADED_FEATURES << req
+        return require(file)
+      else
+        found = current == file
+      end
+    end
+    require req
+  end
+end

data/lib/loaders/load_path.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH.instance_eval do
+  def find_file(file)
+    find_all_files(file){|f| return f}
+    nil
+  end
+
+  def find_all_files(file, ext = nil)
+    file += ext if ext and File.extname(file) != ext
+    inject([]){|ary, path| 
+      target = File.expand_path(file, path)
+      if File.readable?(target)
+        ary << target
+        yield target if block_given?
+      end
+      ary
+    }
+  end
+
+  def add_current
+    self << __DIR_REL__(caller.first)
+  end
+
+  def add_current!
+    self.unshift(__DIR_REL__(caller.first))
+  end
+end

data/spec/data/dir1/test.rb

@@ -0,0 +1 @@
+$state1 = true

data/spec/data/dir1/test2.rb

@@ -0,0 +1,2 @@
+$test2 = 1
+require_next "test2"

data/spec/data/dir2/test.rb

@@ -0,0 +1 @@
+$state2 = true

data/spec/data/dir2/test2.rb

@@ -0,0 +1 @@
+$test2 = 2 if $test2 == 1

data/spec/dirge_spec.rb

@@ -0,0 +1,33 @@
+describe 'Dirge' do
+  it "should resolve a path through String#~" do
+    (~'test:2test/test').should == File.expand_path(File.join(File.dirname(__FILE__), 'test:2test', 'test'))
+  end
+  
+  it "should resolve a path through File#relative" do
+    File.relative('test:2test/test').should == File.expand_path(File.join(File.dirname(__FILE__), 'test:2test', 'test'))
+  end
+  
+  it 'should require a relative path' do
+    proc {
+      require_relative 'test:2test/test'
+    }.should raise_error(RuntimeError, 'okay okay, you included me')
+  end
+  
+  it 'should autoload a relative path' do
+    proc {
+      mod = Module.new do
+        autoload_relative :TestingTime, 'test:2test/test'
+      end
+      mod::TestingTime
+    }.should raise_error(RuntimeError, 'okay okay, you included me')
+  end
+  
+  it "should define __DIR__" do
+    __DIR__.should == File.expand_path(File.dirname(__FILE__))
+  end
+  
+  it "should define __DIR__ with a custom caller" do
+    __DIR__('testing/test.rb:3').should == File.expand_path('testing')
+  end
+  
+end

data/spec/load_path_find_spec.rb

@@ -0,0 +1,62 @@
+require 'lib/load_path_find'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), 'data', 'dir1'))
+$: << File.expand_path(File.join(File.dirname(__FILE__), 'data', 'dir2'))
+
+describe 'load path find' do
+  it "should find a file on the load path" do
+    target = File.join('file1')
+    $:.find_file(target)[-target.size, target.size].should == target
+  end
+
+  it "should find a directory on the load path" do
+    target = "data/dir1"
+    $:.find_file("../dir1")[-target.size, target.size].should == target
+  end
+
+  it "should find the first file when its ambigious" do
+    target = File.join('file1')
+    expected_target = File.join('dir1', 'file1')
+    $:.find_file(target)[-expected_target.size, expected_target.size].should == expected_target
+  end
+
+  it "should find all files that match" do
+    target = File.join('file1')
+    expected_target = File.join('dir1', 'file1')
+    $:.find_all_files(target).should == [
+      File.expand_path(File.join(File.dirname(__FILE__), 'data', 'dir1', 'file1')),      
+      File.expand_path(File.join(File.dirname(__FILE__), 'data', 'dir2', 'file1'))
+    ]
+  end
+
+  it "should yield all files that match if a block is given" do
+    target = File.join('file1')
+    mock = Object.new
+    mock.should_receive(:hello).exactly(2).times
+    $:.find_all_files(target) { mock.hello }
+  end
+  
+  it "should add the current path" do
+    $LOAD_PATH.add_current
+    $LOAD_PATH.last.should == __DIR__
+  end
+
+  it "should add the current path to the start" do
+    $LOAD_PATH.add_current!
+    $LOAD_PATH.first.should == __DIR__
+  end
+
+  it "should require_all" do
+    $state1.should be_nil
+    $state2.should be_nil
+    require_all('test')
+    $state1.should be_true
+    $state2.should be_true
+  end
+  
+  it "should require_next" do
+    require 'test2'
+    $test2.should == 2
+  end
+
+end

data/spec/test:2test/test.rb

@@ -0,0 +1 @@
+raise 'okay okay, you included me'

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: callsite
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Joshua Hull
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-20 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Caller/backtrace parser with some useful utilities for manipulating the load path, and doing other relative things.
+email: joshbuddy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/callsite.rb
+- lib/dirge.rb
+- lib/load_path_find.rb
+- lib/loaders/kernel_dir.rb
+- lib/loaders/kernel_require.rb
+- lib/loaders/load_path.rb
+has_rdoc: true
+homepage: http://github.com/joshbuddy/callsite
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Caller/backtrace parser with some useful utilities for manipulating the load path, and doing other relative things.
+test_files: 
+- spec/data/dir1/test.rb
+- spec/data/dir1/test2.rb
+- spec/data/dir2/test.rb
+- spec/data/dir2/test2.rb
+- spec/dirge_spec.rb
+- spec/load_path_find_spec.rb
+- spec/test:2test/test.rb