tool 0.1.1 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 725ca5923dffd3a0ae1191c35fd80011f341750b
+  data.tar.gz: a09be4b173b7bd8aa8a8d2281ef2b2e274714ca8
+SHA512:
+  metadata.gz: c28c6074f6bbb5827825f4376ad9c4866661988fbc9247a74488122cb71faf30ce46e26a6e84cdea20259c000acf9d49bdbe70aef7c375d30e112fec1bf1e2fd
+  data.tar.gz: bfc3a87def2d13a293ded338fc9e4c3f3a2e6ebe3cc3faaf71ed922c8c69e4499a58eda3d08f59e1d22cffae6c7e842bf2a9e34332bd11d3a31bd670fe8c1efd

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+.coverage

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--tty
+-r support/coverage

data/.travis.yml

@@ -0,0 +1,2 @@
+rvm: [2.0.0, 2.1.0]
+script: bundle exec rspec

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013, 2014 Konstantin Haase
+
+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.md

@@ -1,65 +1,10 @@
-Sane tools for Ruby without monkey-patching. This is basically code usually
-copy from one project to another.
+*Make sure you view the correct docs: [latest release](http://rubydoc.info/gems/tool/frames), [master](http://rubydoc.info/github/rkh/tool/master/frames).*
 
-Goal of this library is to be lightweight and unobtrusive, so you don't have
-to feel guilty for using it. Mixins are lazy-loaded.
+General purpose Ruby library used by Sinatra 2.0, Mustermann and related projects.
 
-# Included Tools
+Included:
 
-## Tool::Autoloader
-
-Sets up `autoload` directives for nested constants. Has the advantage of
-setting these up when included instead of hooking into `const_missing`, like
-ActiveSupport does. The means it is fast, transparent, and does not alter
-constant lookup in any way.
-
-``` ruby
-module Foo
-  include Tool::Autoloader
-end
-```
-
-If you don't want to include the module, use `setup`:
-
-``` ruby
-Tool::Autoloader.setup Foo
-```
-
-## Tool::Lock
-
-Adds a `synchronize` method that behaves like `Rubinius.synchronize(self)`,
-i.e. recursively going through the lock will not result in a deadlock:
-
-``` ruby
-class Foo
-  include Tool::Lock
-
-  def recursive_fun(i = 0)
-    return i if i == 5
-    # THIS NEEDS TO BE THREAD-SAFE!!!
-    synchronize { recursive_fun(i + 1) }
-  end
-end
-```
-
-It will use `Rubinius.synchronize` when on Rubinius.
-
-## Tool.set
-
-Simplified version of Sinatra's set:
-
-``` ruby
-class Foo
-  Tool.set(self, :foo, :foo)
-end
-
-class Bar < Foo
-end
-
-Bar.foo # => :foo
-
-Bar.foo = :bar
-Bar.foo # => :bar
-
-Foo.foo # => :foo
-```
+* **Decoration** - Mixin for easy method decorations.
+* **EqualityMap** - Weak reference caching based on key equality.
+* **ThreadLocal** - True thread locals that are properly garbage collected.
+* **WarningFilter** - Enable Ruby's warnings, but filter out caused by third party gems.

data/examples/frank.rb

@@ -0,0 +1,21 @@
+require 'tool/decoration'
+
+class Frank
+  extend Tool::Decoration
+  def self.get(path, &block)
+    decorate(block) do |method|
+      puts "mapping GET #{path} to #{method}"
+    end
+  end
+end
+
+class MyApp < Frank
+  get '/hi' do
+    "Hello World"
+  end
+
+  get '/'; get '/index.php'
+  def index
+    "This is the index page."
+  end
+end

data/lib/tool/decoration.rb

@@ -0,0 +1,103 @@
+require 'tool/thread_local'
+
+module Tool
+  # Mixin for easy method decorations.
+  #
+  # @example
+  #   class Frank
+  #     extend Tool::Decoration
+  #     def self.get(path, &block)
+  #       decorate(block) do |method|
+  #         puts "mapping GET #{path} to #{method}"
+  #       end
+  #     end
+  #   end
+  #
+  #   # Output:
+  #   #   mapping GET /hi to __generated1
+  #   #   mapping GET / to index
+  #   #   mapping GET /index.php to index
+  #   class MyApp < Frank
+  #     get '/hi' do
+  #       "Hello World"
+  #     end
+  #
+  #     get '/'; get '/index.php'
+  #     def index
+  #       "This is the index page."
+  #     end
+  #   end
+  module Decoration
+    module Initializer
+      # Make sure decorations list is initializsed upon instantiation.
+      # @!visibility private
+      def initialize(*)
+        setup_decorations
+        super
+      end
+    end
+
+    module Setup
+      # Make sure decorations list is initializsed if Decoration is included.
+      # @!visibility private
+      def included(object)
+        case object
+        when Class  then object.send(:include, Initializer)
+        when Module then object.extend(Setup)
+        end
+        super
+      end
+
+      # Make sure decorations list is initializsed if Decoration extends an object.
+      # @!visibility private
+      def extended(object)
+        object.send(:setup_decorations)
+        super
+      end
+    end
+
+    extend Setup
+
+    # Set up a decoration.
+    #
+    # @param [Proc, UnboundMethod, nil] block used for defining a method right away
+    # @param [String, Symbol] name given to the generated method if block is given
+    # @yield callback called with method name once method is defined
+    # @yieldparam [Symbol] method name of the method that is to be decorated
+    def decorate(block = nil, name: "generated", &callback)
+      @decorations << callback
+
+      if block
+        alias_name = "__" << name.to_s.downcase.gsub(/[^a-z]+/, ?_) << ?1
+        alias_name = alias_name.succ while respond_to? alias_name, true
+        without_decorations { define_method(name, &block) }
+        alias_method(alias_name, name)
+        remove_method(name)
+        private(alias_name)
+      end
+    end
+
+    # Runs a given block without applying decorations defined outside of the block.
+    # Decorations defined before the block will still be registered after the block.
+    #
+    # @yield block to run without decorations
+    def without_decorations
+      @decorations.clear if was = @decorations.to_a.dup
+      yield
+    ensure
+      @decorations.replace(was) if was
+    end
+
+    def method_added(name)
+      @decorations.each { |d| d.call(name) }.clear
+      super
+    end
+
+    def setup_decorations
+      @decorations = Tool::ThreadLocal.new([])
+    end
+
+    private :method_added, :setup_decorations
+    private_constant :Initializer, :Setup
+  end
+end

data/lib/tool/equality_map.rb

@@ -0,0 +1,56 @@
+module Tool
+  # A simple wrapper around ObjectSpace::WeakMap that allows matching keys by equality rather than identity.
+  # Used for caching. Note that `fetch` is not guaranteed to return the object, even if it has not been
+  # garbage collected yet, especially when used concurrently. Therefore, the block passed to `fetch` has to
+  # be idempotent.
+  #
+  # @example
+  #   class ExpensiveComputation
+  #     @map = Tool::EqualityMap.new
+  #
+  #     def self.new(*args)
+  #       @map.fetch(*args) { super }
+  #     end
+  #   end
+  #
+  # @see #fetch
+  class EqualityMap
+    attr_reader :map
+
+    def initialize
+      @keys = {}
+      @map  = ObjectSpace::WeakMap.new
+    end
+
+    # @param [Array<#hash>] key for caching
+    # @yield block that will be called to populate entry if missing (has to be idempotent)
+    # @return value stored in map or result of block
+    def fetch(*key)
+      identity = @keys[key.hash]
+      key      = identity == key ? identity : key
+
+      # it is ok that this is not thread-safe, worst case it has double cost in
+      # generating, object equality is not guaranteed anyways
+      @map[key] ||= track(key, yield)
+    end
+
+    # @param [#hash] key for identifying the object
+    # @param [Object] object to be stored
+    # @return [Object] same as the second parameter
+    def track(key, object)
+      ObjectSpace.define_finalizer(object, finalizer(key.hash))
+      @keys[key.hash] = key
+      object
+    end
+
+    # Finalizer proc needs to be generated in different scope so it doesn't keep a reference to the object.
+    #
+    # @param [Fixnum] hash for key
+    # @return [Proc] finalizer callback
+    def finalizer(hash)
+      proc { @keys.delete(hash) }
+    end
+
+    private :track, :finalizer
+  end
+end

data/lib/tool/thread_local.rb

@@ -0,0 +1,45 @@
+require 'delegate'
+require 'weakref'
+require 'thread'
+
+module Tool
+  # Have thread local values without them actually being thread global.
+  #
+  # Advantages:
+  # * values for all threads are garbage collected when ThreadLocal instance is
+  # * values for specific thread are garbage collected when thread is
+  # * no hidden global state
+  # * supports other data types besides hashes.
+  #
+  # @example To replace Thread.current hash access
+  #   local = Tool::ThreadLocal.new
+  #   local[:key] = "value"
+  #
+  #   Thread.new do
+  #     local[:key] = "other value"
+  #     puts local[:key] # other value
+  #   end.join
+  #
+  #   puts local[:key] # value
+  #
+  # @example Usage with Array
+  #   local = Tool::ThreadLocal.new([:foo])
+  #   local << :bar
+  #
+  #   Thread.new { p local }.join # [:foo]
+  #   p local # [:foo, :bar]
+  class ThreadLocal < Delegator
+    def initialize(default = {})
+      @mutex = Mutex.new
+      @default = default.dup
+      @map = {}
+    end
+
+    # @!visibility private
+    def __getobj__
+      ref = Thread.current[:weakref] ||= WeakRef.new(Thread.current)
+      @map.delete_if { |key, value| !key.weakref_alive? }
+      @mutex.synchronize { @map[ref] ||= @default.dup }
+    end
+  end
+end

data/lib/tool/version.rb

@@ -1,3 +1,3 @@
 module Tool
-  VERSION = '0.1.1'
-end
+  VERSION = '0.2.0'
+end

data/lib/tool/warning_filter.rb

@@ -0,0 +1,21 @@
+require 'delegate'
+
+module Tool
+  # Enables Ruby's built-in warnings (-w) but filters out those caused by third-party gems.
+  # Does not invlove any manual set up.
+  #
+  # @example
+  #   require 'tool/warning_filter'
+  #   Foo = 10
+  #   Foo = 20
+  class WarningFilter < DelegateClass(IO)
+    $stderr  = new($stderr)
+    $VERBOSE = true
+
+    # @!visibility private
+    def write(line)
+      super if line !~ /^\S+gems\/ruby\-\S+:\d+: warning:/
+    end
+  end
+end
+

data/spec/decoration_spec.rb

@@ -0,0 +1,57 @@
+require 'tool/decoration'
+
+describe Tool::Decoration do
+  shared_examples :decorate do
+    specify "with block" do
+      method = nil
+      subject.decorate(-> { 42 }) { |m| method = m }
+      expect(method).not_to be_nil
+      expect(subject.new.send(method)).to be == 42
+    end
+
+    specify "without block" do
+      method = nil
+      subject.decorate { |m| method = m }
+      expect(method).to be_nil
+      subject.send(:define_method, :foo) { }
+      expect(method).to be == :foo
+    end
+
+    specify "multiple decorations" do
+      calls = []
+      subject.decorate { |m| calls << :a }
+      subject.decorate { |m| calls << :b }
+      expect(calls).to be_empty
+      subject.send(:define_method, :foo) { }
+      expect(calls).to be == [:a, :b]
+    end
+
+    specify "multiple methods" do
+      calls = []
+      subject.decorate { |m| calls << :a }
+      subject.send(:define_method, :foo) { }
+      subject.send(:define_method, :bar) { }
+      expect(calls).to be == [:a]
+    end
+  end
+
+  context "extending a class" do
+    subject { Class.new.extend(Tool::Decoration) }
+    include_examples(:decorate)
+  end
+
+  context "including in a module" do
+    subject { Class.new.extend(Module.new { include Tool::Decoration }) }
+    include_examples(:decorate)
+  end
+
+  context "including in a module" do
+    subject do
+      Class.new(Module) do
+        def new(*) Object.new.extend(self) end
+        include Tool::Decoration
+      end.new
+    end
+    include_examples(:decorate)
+  end
+end

data/spec/equality_map_spec.rb

@@ -0,0 +1,21 @@
+require 'tool/equality_map'
+
+describe Tool::EqualityMap do
+  before { GC.disable }
+  after { GC.enable }
+
+  describe :fetch do
+    specify 'with existing entry' do
+      subject.fetch("foo") { "foo" }
+      result = subject.fetch("foo") { "bar" }
+      expect(result).to be == "foo"
+    end
+
+    specify 'with GC-removed entry' do
+      subject.fetch("foo") { "foo" }
+      expect(subject.map).to receive(:[]).and_return(nil)
+      result = subject.fetch("foo") { "bar" }
+      expect(result).to be == "bar"
+    end
+  end
+end

data/spec/support/coverage.rb

@@ -0,0 +1,17 @@
+require 'tool/warning_filter'
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  project_name 'tool'
+  minimum_coverage 100
+  coverage_dir '.coverage'
+
+  add_filter '/spec/'
+  add_group 'Library', 'lib'
+end

data/spec/thread_local_spec.rb

@@ -0,0 +1,26 @@
+require 'tool/thread_local'
+
+describe Tool::ThreadLocal do
+  specify 'normal access' do
+    subject[:foo] = 'bar'
+    expect(subject[:foo]).to be == 'bar'
+  end
+
+  specify 'concurrent access' do
+    subject[:foo] = 'bar'
+    value = Thread.new { subject[:foo] = 'baz' }.value
+    expect(value).to be == 'baz'
+    expect(subject[:foo]).to be == 'bar'
+  end
+
+  specify 'with an array as value' do
+    list = Tool::ThreadLocal.new([])
+    foo  = Thread.new { 10.times { list << :foo; sleep(0.01) }; list.to_a }
+    bar  = Thread.new { 10.times { list << :bar; sleep(0.01) }; list.to_a }
+    expect(list).to be_empty
+    list << :list
+    expect(list)      .to be == [ :list ]
+    expect(foo.value) .to be == [ :foo  ] * 10
+    expect(bar.value) .to be == [ :bar  ] * 10
+  end
+end

data/tool.gemspec

@@ -1,16 +1,22 @@
-$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
-require 'tool/version'
+$:.unshift File.expand_path("../lib", __FILE__)
+require "tool/version"
 
-Gem::Specification.new 'tool', Tool::VERSION do |s|
-  s.description = "This is basically code usually copy from one project to another"
-  s.summary     = "Sane tools for Ruby without monkey-patching"
+Gem::Specification.new do |s|
+  s.name                  = "tool"
+  s.version               = Tool::VERSION
+  s.author                = "Konstantin Haase"
+  s.email                 = "konstantin.mailinglists@googlemail.com"
+  s.homepage              = "https://github.com/rkh/tool"
+  s.summary               = %q{general purpose library}
+  s.description           = %q{general purpose Ruby library used by Sinatra 2.0, Mustermann and related projects}
+  s.license               = 'MIT'
+  s.files                 = `git ls-files`.split("\n")
+  s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables           = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.extra_rdoc_files      = `git ls-files -- *.md`.split("\n")
+  s.required_ruby_version = '>= 2.0.0'
 
-  s.authors     = ["Konstantin Haase"]
-  s.email       = "konstantin.mailinglists@googlemail.com"
-  s.homepage    = "http://github.com/rkh/tool"
-
-  s.files       = `git ls-files`.split("\n") - %w[Gemfile .gitignore .travis.yml]
-  s.test_files  = s.files.select { |p| p =~ /^spec\/.*_spec.rb/ }
-
-  s.add_development_dependency 'rspec', '~> 2.7'
+  s.add_development_dependency 'rspec', '~> 3.0.0.beta'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'coveralls'
 end

metadata

@@ -1,78 +1,109 @@
 --- !ruby/object:Gem::Specification
 name: tool
 version: !ruby/object:Gem::Version
-  version: 0.1.1
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Konstantin Haase
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-27 00:00:00.000000000Z
+date: 2014-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2152865200 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: 3.0.0.beta
   type: :development
   prerelease: false
-  version_requirements: *2152865200
-description: This is basically code usually copy from one project to another
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: general purpose Ruby library used by Sinatra 2.0, Mustermann and related
+  projects
 email: konstantin.mailinglists@googlemail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
 - README.md
-- Rakefile
-- lib/tool.rb
-- lib/tool/autoloader.rb
-- lib/tool/lock.rb
+- examples/frank.rb
+- lib/tool/decoration.rb
+- lib/tool/equality_map.rb
+- lib/tool/thread_local.rb
 - lib/tool/version.rb
-- spec/autoloader/foo.rb
-- spec/autoloader/foo/answer.rb
-- spec/autoloader/foo/bar.rb
-- spec/autoloader/foo/baz/bar.rb
-- spec/autoloader/foo/baz/foo.rb
-- spec/autoloader/foo/blah.rb
-- spec/autoloader/foo/blah/boom.rb
-- spec/autoloader/foo/cli.rb
-- spec/autoloader/foo/foo_bar.rb
-- spec/autoloader/foo/version.rb
-- spec/autoloader_spec.rb
-- spec/lock_spec.rb
-- spec/tool_spec.rb
+- lib/tool/warning_filter.rb
+- spec/decoration_spec.rb
+- spec/equality_map_spec.rb
+- spec/support/coverage.rb
+- spec/thread_local_spec.rb
 - tool.gemspec
-homepage: http://github.com/rkh/tool
-licenses: []
+homepage: https://github.com/rkh/tool
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
-summary: Sane tools for Ruby without monkey-patching
+specification_version: 4
+summary: general purpose library
 test_files:
-- spec/autoloader_spec.rb
-- spec/lock_spec.rb
-- spec/tool_spec.rb
+- spec/decoration_spec.rb
+- spec/equality_map_spec.rb
+- spec/support/coverage.rb
+- spec/thread_local_spec.rb
+has_rdoc: 

data/Rakefile

@@ -1,21 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
-require 'tool/version'
-
-def gem(*args) sh("gem", *args.map(&:to_s)) end
-def git(*args) sh("git", *args.map(&:to_s)) end
-  
-gem_file = "tool-#{Tool::VERSION}.gem"
-version  = "v#{Tool::VERSION}"
-message  = "Release #{version}"
-
-task(:spec)                { ruby "-S rspec spec"                        }
-task(:build)               { gem :build, 'tool.gemspec'                  }
-task(:install => :build)   { gem :install, gem_file                      }
-task(:publish => :install) { gem :push, gem_file                         }
-task(:commit)              { git :commit, '--allow-empty', '-m', message }
-task(:tag)                 { git :tag, '-s', '-m', message, version      }
-task(:push)                { git(:push) and git(:push, '--tags')         }
-
-task :release => [:spec, :commit, :publish, :tag, :push]
-task :default => :spec
-task :test    => :spec

data/lib/tool.rb

@@ -1,17 +0,0 @@
-module Tool
-  autoload :Autoloader, 'tool/autoloader'
-  autoload :Lock,       'tool/lock'
-  autoload :VERSION,    'tool/version'
-
-  def self.set(object, key, value = (no_value = true), &block)
-    return key.each_pair { |k,v| set(object, k, v) } if no_value and not block
-
-    block  = proc { value } unless no_value
-    sclass = (class << object; self; end)
-    setter = self
-
-    sclass.send(:define_method, key, &block)
-    sclass.send(:define_method, "#{key}=") { |v| setter.set(self, key, v) }
-    sclass.send(:define_method, "#{key}?") { !!__send__(key) }
-  end
-end

data/lib/tool/autoloader.rb

@@ -1,60 +0,0 @@
-module Tool
-  module Autoloader
-    CAPITALIZE = %w[version cli] unless defined? CAPITALIZE
-
-    def self.setup(container, path = caller_dir)
-      prefix      = path_for(container)
-      full_prefix = path_for(container, true)
-      path        = File.expand_path(prefix, path)
-      directories = []
-
-      Dir.glob("#{path}/*") do |file|
-        base  = File.basename(file, '.rb')
-        const = constant_for(base)
-        lib   = "#{full_prefix}/#{base}"
-
-        if File.directory? file
-          directories << const
-        elsif file.end_with? '.rb'
-          container.autoload const, lib
-        end
-      end
-
-      directories.each do |const|
-        next if container.const_defined? const
-        nested = container.const_set(const, Module.new)
-        setup nested, path
-      end
-    end
-
-    def self.path_for(constant, full = false)
-      name = constant.name.dup
-      name = name[/[^:]+$/] unless full
-      name.gsub! /([A-Z]+)([A-Z][a-z])/,'\1_\2'
-      name.gsub! /([a-z\d])([A-Z])/,'\1_\2'
-      name.gsub! '::', '/'
-      name.tr("-", "_").downcase
-    end
-
-    def self.constant_for(file)
-      return file.upcase if CAPITALIZE.include? file
-      file.split('.', 2).first.split(/[_-]/).map(&:capitalize).join
-    end
-
-    def self.capitalize(*args)
-      CAPITALIZE.concat(args)
-    end
-
-    def self.append_features(base)
-      setup(base)
-    end
-
-    def self.caller_dir
-      caller.each do |line|
-        file = File.expand_path(line.split(':', 2).first)
-        return File.dirname(file) if file != File.expand_path(__FILE__)
-      end
-      File.dirname($0)
-    end
-  end
-end

data/lib/tool/lock.rb

@@ -1,33 +0,0 @@
-module Tool
-  module Lock
-    if defined? Rubinius
-      def synchronize
-        Rubinius.synchronize(self) { yield }
-      end
-    else
-      require 'thread'
-      @lock = Mutex.new
-
-      def self.synchronize(&block)
-        @lock.synchronize(&block)
-      end
-
-      def synchronize(&block)
-        Lock.synchronize { @lock, @locked_by = Mutex.new, nil unless lock? } unless lock?
-        return yield if @locked_by == Thread.current
-        @lock.synchronize do
-          @locked_by = Thread.current
-          result     = yield
-          @locked_by = nil
-          result
-        end
-      end
-
-      private
-
-      def lock?
-        instance_variable_defined? :@lock
-      end
-    end
-  end
-end

data/spec/autoloader/foo.rb

@@ -1,6 +0,0 @@
-module Autoloader
-  module Foo
-    Answer = 42
-    include Tool::Autoloader
-  end
-end

data/spec/autoloader/foo/answer.rb

@@ -1,3 +0,0 @@
-module Autoloader::Foo
-  Answer = 23
-end

data/spec/autoloader/foo/bar.rb

@@ -1,2 +0,0 @@
-class Autoloader::Foo::Bar
-end

data/spec/autoloader/foo/baz/bar.rb

@@ -1,2 +0,0 @@
-class Autoloader::Foo::Baz::Bar
-end

data/spec/autoloader/foo/baz/foo.rb

@@ -1,2 +0,0 @@
-module Autoloader::Foo::Baz::Foo
-end

data/spec/autoloader/foo/blah.rb

@@ -1,2 +0,0 @@
-class Autoloader::Foo::Blah
-end

data/spec/autoloader/foo/blah/boom.rb

@@ -1,2 +0,0 @@
-class Autoloader::Foo::Blah::Boom
-end

data/spec/autoloader/foo/cli.rb

@@ -1,2 +0,0 @@
-class Autoloader::Foo::CLI
-end

data/spec/autoloader/foo/foo_bar.rb

@@ -1,2 +0,0 @@
-class Autoloader::Foo::FooBar
-end

data/spec/autoloader/foo/version.rb

@@ -1,3 +0,0 @@
-module Autoloader::Foo
-  VERSION = 1337
-end

data/spec/autoloader_spec.rb

@@ -1,47 +0,0 @@
-require 'tool'
-require 'autoloader/foo'
-
-describe Tool::Autoloader do
-  # poor man's matchers
-  def autoload(const) be_autoload(const) end
-  def start_with(str) be_start_with(str) end
-
-  it 'sets up autoloading' do
-    Autoloader::Foo.should autoload(:Bar)
-    Autoloader::Foo::Bar.name.should start_with("Autoloader::Foo::")
-  end
-
-  it 'creates modules for subdirectories' do
-    Autoloader::Foo.should_not autoload(:Baz)
-    Autoloader::Foo::Baz.should autoload(:Bar)
-  end
-
-  it 'handles nested constants with same name' do
-    Autoloader::Foo::Baz::Foo.should_not be == Autoloader::Foo
-  end
-
-  it 'does not automatically set up autoloading for autoloaded constants' do
-    Autoloader::Foo::Blah.should_not autoload(:Boom)
-    expect { Autoloader::Foo::Blah::Boom }.to raise_error(NameError)
-  end
-
-  it 'does not override existing constants' do
-    Autoloader::Foo::Answer.should be == 42
-  end
-
-  it 'loads VERSION' do
-    Autoloader::Foo.should autoload(:VERSION)
-    Autoloader::Foo.should_not autoload(:Version)
-    Autoloader::Foo::VERSION.should be == 1337
-  end
-
-  it 'loads CLI' do
-    Autoloader::Foo.should autoload(:CLI)
-    Autoloader::Foo.should_not autoload(:Cli)
-  end
-
-  it 'loads camel-cased constants' do
-    Autoloader::Foo.should autoload(:FooBar)
-    Autoloader::Foo.should_not autoload(:Foo_bar)
-  end
-end

data/spec/lock_spec.rb

@@ -1,45 +0,0 @@
-require 'tool'
-
-describe Tool::Lock do
-  before do
-    Thread.abort_on_exception = true
-  end
-
-  let(:object) { Object.new.extend(Tool::Lock) }
-  let(:track) { [] }
-
-  def synchronize(&block)
-    object.synchronize(&block)
-  end
-
-  it 'runs the given block' do
-    synchronize { track << :ran }
-    track.should be == [:ran]
-  end
-
-  it 'locks for other threads' do
-    a = Thread.new { synchronize { sleep(0.2) and track << :first } }
-
-    sleep 0.1
-    b = Thread.new { synchronize { track << :second } }
-
-    a.join
-    b.join
-
-    track.should be == [:first, :second]
-  end
-
-  it 'is no global lock' do
-    a = Thread.new { Object.new.extend(Tool::Lock).synchronize { sleep(0.1) and track << :first } }
-    b = Thread.new { Object.new.extend(Tool::Lock).synchronize { track << :second } }
-
-    a.join
-    b.join
-
-    track.should be == [:second, :first]
-  end
-
-  it 'has no issue with recursion' do
-    synchronize { synchronize { } }
-  end
-end

data/spec/tool_spec.rb

@@ -1,91 +0,0 @@
-require 'tool'
-
-describe Tool do
-  describe :set do
-    let(:object) { Object.new }
-
-    it 'defines a getter' do
-      Tool.set(object, :foo, :bar)
-      object.foo.should be == :bar
-    end
-
-    it 'defines a setter' do
-      Tool.set(object, :foo, :bar)
-      object.foo = :foo
-      object.foo.should be == :foo
-    end
-
-    it 'defines a flag' do
-      Tool.set(object, :foo, :bar)
-      object.should be_foo
-      object.foo = false
-      object.should_not be_foo
-    end
-
-    it 'takes a block' do
-      Tool.set(object, :foo) { :bar }
-      object.foo.should be == :bar
-      object.should be_foo
-    end
-
-    it 'adds a setter, even with a block' do
-      Tool.set(object, :foo) { :bar }
-      object.foo = false
-      object.should_not be_foo
-    end
-
-    it 'uses the blocks value as flag' do
-      Tool.set(object, :foo) { false }
-      object.should_not be_foo
-    end
-
-    it 'runs the block more than once' do
-      counter = 0
-      Tool.set(object, :foo) { counter += 1 }
-      object.foo.should be == 1
-      object.foo.should be == 2
-    end
-
-    it 'wraps a block passed to the setter' do
-      Tool.set(object, :foo) { :bar }
-      object.foo = proc { false }
-      object.should be_foo
-      object.foo.should be_a(Proc)
-    end
-
-    it 'allows passing in a hash' do
-      Tool.set(object, :foo => :bar)
-      object.foo.should be == :bar
-    end
-
-    it 'allows passing in nil' do
-      Tool.set(object, :foo, nil)
-      object.foo.should be_nil
-    end
-
-    it 'does not use the passed block if nil is given' do
-      Tool.set(object, :foo, nil) { :bar }
-      object.foo.should be_nil
-      object.should_not be_foo
-    end
-
-    it 'inherits class settings' do
-      a = Class.new
-      b = Class.new(a)
-
-      Tool.set(a, :foo, :bar)
-      b.foo.should be == :bar
-    end
-
-    it 'allows overriding class settings in subclasses' do
-      a = Class.new
-      b = Class.new(a)
-
-      Tool.set(a, :foo, :bar)
-      b.foo = :foo
-
-      a.foo.should be == :bar
-      b.foo.should be == :foo
-    end
-  end
-end