monkey-lib 0.2.1 → 0.3.0

data/README.rdoc

@@ -0,0 +1,12 @@
+Some description goes here.
+
+== Running the specs
+
+Run specs with all backends:
+  rake spec
+
+Run specs with active_support:
+  rake spec:active_support
+
+Run specs with backports and using mspec instead of rspec (so it might work on incomplete ruby implementations):
+  SPEC_RUNNER=mspec rake spec:backports

data/Rakefile

@@ -1,49 +1,113 @@
-require "spec/rake/spectask"
 require "rake/clean"
-require "rake/rdoctask"
-require "rake/gempackagetask"
-require "rubygems/specification"
-
-MONKEY_VERSION = "0.2.1"
-
-spec = Gem::Specification.new do |s|
-  s.name             = "monkey-lib"
-  s.version          = MONKEY_VERSION
-  s.authors          = ["Konstantin Haase"]
-  s.description      = "collection of sane ruby extensions"
-  s.email            = "konstantin.mailinglists@googlemail.com"
-  s.extra_rdoc_files = Dir["*.rdoc", "LICENSE", "lib/**/*.rb"]
-  s.files            = Dir["LICENSE", "Rakefile", "README.rdoc", "lib/**/*.rb", "spec/**/*.rb"]
-  s.has_rdoc         = true
-  s.homepage         = "http://github.com/rkh/monkey-lib"
-  s.require_paths    = ["lib"]
-  s.summary          = s.description
-  s.add_dependency "extlib"
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-end
-
-desc "install the gem locally"
-task :install => [:package] do
-  sh %{gem install pkg/monkey-lib-#{MONKEY_VERSION}.gem}
-end
- 
-desc "create a gemspec file"
-task :make_spec do
-  File.open("monkey-lib.gemspec", "w") do |file|
-    file.puts spec.to_ruby
+
+task :default => :spec
+
+backends = Dir.glob('lib/monkey/backend/*.rb').map { |f| File.basename f, ".rb" }
+modes = [:autodetect, :explicit]
+
+CLEAN.include "**/*.rbc"
+CLOBBER.include "monkey-lib*.gem"
+
+setup_rspec = proc do
+  require "spec/rake/spectask"
+  SPEC_RUNNER = "mspec"
+  def define_spec_task(name, ruby_cmd, pattern)
+    Spec::Rake::SpecTask.new name do |t|
+      t.spec_opts = %w[-c --format progress --loadby mtime --reverse]
+      t.ruby_cmd = ruby_cmd
+      t.pattern = pattern
+    end
   end
-end 
-  
-Rake::RDocTask.new("doc") do |rdoc|
-  rdoc.rdoc_dir = 'doc'
-  rdoc.options += %w[--all --inline-source --line-numbers --main README.rdoc --quiet
-    --tab-width 2 --title monkey-lib]
-  rdoc.rdoc_files.add ['*.rdoc', 'lib/**/*.rb']
-end
-
-Spec::Rake::SpecTask.new('spec') do |t|
-  t.spec_files = Dir.glob 'spec/**/*_spec.rb'
-end
+end
+
+setup_mspec = proc do
+  require "mspec"
+  SPEC_RUNNER = "mspec"
+  def define_spec_task(name, ruby_cmd, pattern)
+    task(name) { sh "#{ruby_cmd} -S mspec-run #{pattern}" }
+  end
+end
+
+case ENV['SPEC_RUNNER']
+when "rspec" then setup_rspec.call
+when "mspec" then setup_mspec.call
+when nil
+  # yes, this code is trying to be smart, but let me have some fun, please?
+  raise @spec_load_error unless [setup_rspec, setup_mspec].any? { |b| b.call || true rescue (@spec_load_error ||= $!) && false }
+else
+  puts "sorry, currently no #{ENV['SPEC_RUNNER']} support"
+  exit 1
+end
+
+def spec_task(name, backend = nil, mode = nil)
+  desc "runs specs #{"with backend #{backend} " if backend}#{"(#{mode} mode)" if mode}"
+  define_spec_task(name, "BACKEND=#{backend.to_s.inspect} BACKEND_SETUP=#{mode.to_s.inspect} #{ENV['RUBY'] || RUBY}", "spec/monkey/**/*_spec.rb")
+end
+
+task :environment do
+  $LOAD_PATH.unshift "lib"
+  require "monkey"
+end
+
+desc "run all specs"
+task :spec => "spec:all"
+namespace :spec do
+
+  desc "runs specs without explicitly setting a backend"
+  spec_task :autodetect
+
+  backends.each do |backend|
+    task :all => backend
+
+    desc "runs specs with backend #{backend}"
+    task backend => "#{backend}:all"
+
+    namespace backend do
+      modes.each do |mode|
+        task :all => mode
+        spec_task mode, backend, mode
+      end
+    end
+
+  end
+end
+
+namespace :backend do
+
+  desc "lists all available backends"
+  task(:list) { puts backends }
+
+  desc "lists expectations a backend has to meet"
+  task :expectations => :environment do
+    Monkey::Ext.expectations.each do |core_class, methods|
+      print "#{core_class}:".ljust(10)
+      puts methods.map { |n| "##{n}" }.join(", ")
+    end
+  end
+
+  desc "checks whether specs for expectations are present"
+  task :spec_check =>:environment do
+    Monkey::Ext.expectations.each do |core_class, methods|
+      path = "spec/monkey/ext/#{core_class.name.to_const_path}_spec.rb"
+      list = path.file_exists? ? %x[spec -d -fs #{path} -e "Monkey::Ext::#{core_class.name} backend expectations"] : ""
+      methods.each { |m| puts "missing specs for #{core_class.name}##{m}" unless list =~ /- imports #{m} from backend/ }
+    end
+  end
+
+end
+
+############
+# aliases
+
+namespace(:b) do
+  task :e => "backend:expectations"
+  task :l => "backend:list"
+  task :s => "backend:spec_check"
+end
+
+namespace(:s) do
+  task :as => "spec:active_support:explicit"
+  task :bp => "spec:backports:explicit"
+  task :ex => "spec:extlib:explicit"
+  task :fc => "spec:facets:explicit"
+end

data/lib/monkey.rb

@@ -1,6 +1,17 @@
 module Monkey
+
   Dir[File.dirname(__FILE__) + "/monkey/*.rb"].sort.each do |path|
     filename = File.basename(path, '.rb')
     require "monkey/#{filename}"
   end
+
+  def self.backend=(backend)
+    Backend.setup! backend
+    backend
+  end
+
+  def self.backend
+    Backend.backend
+  end
+
 end

data/lib/monkey/autoloader.rb

@@ -1,3 +1,5 @@
+require "monkey"
+
 module Monkey
   module Autoloader
     def const_missing(const_name)

data/lib/monkey/backend.rb

@@ -1,45 +1,110 @@
-require "set"
-
 module Monkey
   module Backend
-    
-    autoload :ActiveSupport,   "monkey/backend/active_support"
-    autoload :BackendDsl,      "monkey/backend/backend_dsl"
-    autoload :Backports,       "monkey/backend/backports"
-    autoload :Extlib,          "monkey/backend/extlib"
 
-    def self.register(definition, expected_name, backend_name = nil)
-      klass = definition.core_klass
-      add_hook klass, expected_name
-      add_hook klass, backend_name if backend_name
-      backend_name ||= expected_name
+    @available_backends = []
+
+    class << self
+      attr_reader :available_backends, :backend
     end
-    
-    def preferred_backend
-      available_backends.detect { |b| eval "defined? ::#{b}" }
+
+    module AbstractBackend
+      attr_accessor :backend_name, :backend_path
+
+      def available?
+        Object.const_defined? backend_name or $LOADED_FEATURES.any? { |l| l =~ /^#{backend_path}\// }
+      end
+
+      def setup_complete
+        require backend_path
+        setup
+      end
+
+      def load_libs(*data)
+        load_with_prefix backend_path, data
+      end
+
+      def load_with_prefix(prefix, libs = nil)
+        case libs
+        when String, Symbol then require File.join(prefix.to_s, libs.to_s)
+        when Array then libs.each { |lib| load_with_prefix prefix, lib }
+        when Hash then libs.each { |k, v| load_with_prefix File.join(prefix.to_s, k.to_s), v }
+        else raise ArgumentError, "cannot handle #{libs.inspect}"
+        end
+      end
+      
+      def missing(*libs)
+        load_with_prefix "monkey/backend/common", libs
+      end
+      
+      def expects_module(name)
+        name.split("::").inject(Object) do |parent, name|
+          if name.empty?
+            parent
+          else
+            parent.class_eval "module #{name}; self; end"
+          end
+        end
+      end
+
     end
     
-    def available_backends
-      @available_backends ||= Set[:ActiveSupport, :Extlib, :Backports]
+    def self.new(backend_name, backend_path = nil, &block)
+      mod = eval "module #{backend_name}; self; end"
+      mod.extend AbstractBackend
+      backend_path ||= backend_name.to_s.downcase
+      mod.backend_name, mod.backend_path = backend_name.to_s, backend_path.to_s
+      available_backends << mod
+      mod.class_eval(&block) if block
     end
-    
-    def backend
-      @backend || preferred_backend || available_backends.first
+
+    def self.preferred_backend
+      available_backends.detect { |b| b.available? } || @backend
     end
-    
-    private
-    
-    def self.add_hook(klass, name)
-      mod = module_for klass
-      mod.class_eval "def #{name}(*a, &b); Monkey::Backend.call(#{klass.name}, #{name}, *a, &b); end"
+
+    def self.setup?
+      !!@setup
     end
-    
-    def self.module_for(klass, &block)
-      mod = eval "module Monkey::Ext; module #{klass.name}; self; end; end"
-      klass.send :include, mod
-      mod.class_eval(&block) if block
-      mod
+
+    def self.setup!(backend)
+      if backend
+        @backend = detect_backend(backend)
+        @backend.setup
+        @setup = true
+        @backend
+      else
+        available_backends.each do |backend|
+          begin
+            return setup!(backend)
+          rescue LoadError => error
+            @load_error ||= error
+            @backend = nil
+          end
+        end  
+        raise @load_error
+      end
+    end
+
+    class << self
+      alias backend= setup!
+    end
+
+    def self.setup
+      setup! preferred_backend unless setup?
     end
     
+    def self.detect_backend(backend_or_name)
+      return backend_or_name if backend_or_name.respond_to? :setup
+      detected = available_backends.detect do |backend|
+        [backend.backend_name.to_s, backend.backend_path.to_s, backend.name.to_s].include? backend_or_name.to_s
+      end
+      raise ArgumentError, "cannot detect backend #{backend_or_name.inspect}" unless detected
+      detected
+    end
+
+    Dir[File.dirname(__FILE__) + "/backend/*.rb"].sort.each do |path|
+      filename = File.basename(path, '.rb')
+      require "monkey/backend/#{filename}"
+    end
+
   end
 end

data/lib/monkey/backend/active_support.rb

@@ -1,17 +1,12 @@
-module Monkey
-  module Backend
-    module ActiveSupport
-      def self.setup
-        require "active_support/core_ext/array/extract_options"
-        require "active_support/core_ext/object/metaclass"
-        require "active_support/core_ext/object/misc"
-        require "active_support/core_ext/string/inflection"
-        require "active_support/core_ext/module/introspection"
-        ::String.class_eval do
-          alias to_const_string camelcase
-          alias to_const_path underscore
-        end
-      end     
+Monkey::Backend.new :ActiveSupport, :active_support do
+  def self.setup
+    expects_module "::ActiveSupport::CoreExtensions::String::Inflections"
+    load_libs "core_ext/object" => [:metaclass, :misc], :core_ext => %w[array/extract_options string/inflections module/introspection]
+    Array.send :include, ActiveSupport::CoreExtensions::Array::ExtractOptions
+    Module.send :include, ActiveSupport::CoreExtensions::Module
+    ::String.class_eval do
+      alias to_const_string camelcase
+      alias to_const_path underscore
     end
-  end
+  end     
 end

data/lib/monkey/backend/backports.rb

@@ -1,17 +1,11 @@
-module Monkey
-  module Backend
-    module Backports
-      def setup
-        require "backports/1.8.7/kernel"
-        require "backports/rails/array"
-        require "backports/rails/string"
-        require "monkey/backend/common/parent"
-        require "monkey/backend/common/metaclass"
-        ::String.class_eval do
-          alias to_const_string camelcase
-          alias to_const_path underscore
-        end
-      end
+Monkey::Backend.new :Backports do
+  def self.setup
+    load_libs "tools", "1.8.7/kernel", :rails => [:array, :string]
+    missing :parent, :metaclass
+    ::String.class_eval do
+      alias camelcase camelize
+      alias to_const_string camelize
+      alias to_const_path underscore
     end
   end
 end

data/lib/monkey/backend/common/parent.rb

@@ -1,12 +1,10 @@
 module Monkey
   module Backend
     module Common
-      module Metaclass
-        ::Object.send :include, self
-        def metaclass
-          class << self
-            self
-          end
+      module Parent
+        ::Module.send :include, self
+        def parent
+          name =~ /^(.+)::[^:]+$/ ? $1.constantize : Object
         end
       end
     end

data/lib/monkey/backend/common/tap.rb

@@ -2,7 +2,7 @@ module Monkey
   module Backend
     module Common
       module Tap
-        ::Kernel.send :include, self
+        ::Object.send :include, self
         def tap
           yield self
           self

data/lib/monkey/backend/extlib.rb

@@ -1,21 +1,13 @@
-module Monkey
-  module Backend
-    module Extlib
-      def setup
-        require "extlib/object"
-        require "extlib/string"
-        require "extlib/constantize"
-        require "monkey/backend/common/parent"
-        require "monkey/backend/common/extract_options"
-        require "monkey/backend/common/tap"
-        ::Object.class_eval { alias metaclass meta_class }
-        ::String.class_eval do
-          alias camelcase to_const_string
-          alias underscore to_const_path
-          def constantize
-            Extlib::Inflection.constantize(self)
-          end
-        end
+Monkey::Backend.new :Extlib do
+  def self.setup
+    load_libs :object, :string, :inflection
+    missing :parent, :extract_options, :tap
+    ::Object.class_eval { alias metaclass meta_class }
+    ::String.class_eval do
+      alias camelcase to_const_string
+      alias underscore to_const_path
+      def constantize
+        Extlib::Inflection.constantize(self)
       end
     end
   end