nakajima-nakajima 0.0.4 → 0.0.5

data/lib/nakajima.rb

@@ -1,18 +1,14 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), 'nakajima')
-$LOAD_PATH << File.join(File.dirname(__FILE__), 'nakajima', 'core_ext')
+$LOAD_PATH << File.dirname(__FILE__)
 
 # gems
-require 'rubygems'
 require 'colored'
 require 'metaid'
 
 # core ruby extensions
-require 'basic_object'
-require 'array'
-require 'symbol'
-require 'proc'
-require 'object'
+require 'nakajima/core_ext/array'
+require 'nakajima/core_ext/kernel'
+require 'nakajima/core_ext/object'
+require 'nakajima/core_ext/proc'
+require 'nakajima/core_ext/symbol'
 
-module Nakajima
-  VERSION = '0.0.4'
-end
+module Nakajima; end

data/lib/nakajima/core_ext/kernel.rb

@@ -0,0 +1,19 @@
+module Kernel
+  def blank_context(*args, &block)
+    ivars = args.extract_options!
+    
+    args.push(/^__/)
+    
+    klass = Class.new do
+      instance_methods.each do |m|
+        undef_method(m) unless args.any? { |pattern| m =~ pattern }
+      end
+    end
+    
+    klass.class_eval(&block) if block_given?
+    instance = klass.new
+    setter = Object.instance_method(:instance_variable_set).bind(instance)
+    ivars.each { |key, value| setter.call("@#{key}", value) }
+    instance
+  end
+end

data/lib/nakajima/core_ext/object.rb

@@ -1,62 +1,60 @@
 module Nakajima
   module Object
-    module InstanceMethods
-      def try(method_id, *args, &block)
-        respond_to?(method_id) ? send(method_id, *args, &block) : nil
-      end
-    
-      # Like JavaScript, but in Ruby...
-      def with(hash)
-        hash.each do |key, value|
-          meta_def(key) { hash[key] }
-          meta_def("#{key}=") { |v| hash[key] = v }
-        end
+    def try(method_id, *args, &block)
+      respond_to?(method_id) ? send(method_id, *args, &block) : nil
+    end
 
-        return unless block_given?
+    # Like JavaScript, but in Ruby...
+    def with(hash)
+      hash.each do |key, value|
+        meta_def(key) { hash[key] }
+        meta_def("#{key}=") { |v| hash[key] = v }
+      end
 
-        result = yield
+      return unless block_given?
 
-        hash.each do |key, value|
-          meta_eval { remove_method(key) }
-          meta_eval { remove_method("#{key}=") }
-        end
+      result = yield
 
-        result
-      end
-      
-      unless respond_to?(:instance_exec)
-        def instance_exec(*arguments, &block)
-          block.bind(self)[*arguments]
-        end
+      hash.each do |key, value|
+        meta_eval { remove_method(key) }
+        meta_eval { remove_method("#{key}=") }
       end
-      
-      # A proxy that returns its target after invoking the method you
-      # invoke. Useful for #me
-      class ProxyReturningMe < BasicObject
-        def initialize(me)
-          super()
-          @me = me
+
+      result
+    end
+
+    unless respond_to?(:instance_exec)
+      module InstanceExecHelper; end
+      include InstanceExecHelper
+      def instance_exec(*args, &block)
+        begin
+          old_critical, Thread.critical = Thread.critical, true
+          n = 0
+          n += 1 while respond_to?(mname="__instance_exec#{n}")
+          InstanceExecHelper.module_eval{ define_method(mname, &block) }
+        ensure
+          Thread.critical = old_critical
         end
-        def method_missing(sym, *args, &block)
-          @me.__send__(sym, *args, &block)
-          @me
+        begin
+          ret = send(mname, *args)
+        ensure
+          InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
         end
+        ret
       end
-      
-      # plucked from raganwald's andand
-      def tap(p = nil)
-        if block_given?
-          yield(self)
-          self
-        elsif p
-          p.to_proc.call(self)
-          self
-        else
-          ProxyReturningMe.new(self)
+    end
+
+    def tap
+      block_given? ? (yield(self); self) : begin
+        blank_context(:me => self) do
+          def method_missing(sym, *args, &block)
+            @me.__send__(sym, *args, &block)
+            @me
+          end
         end
       end
     end
   end
 end
 
-Object.send :include, Nakajima::Object::InstanceMethods
+Object.send :include, Nakajima::Object

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nakajima-nakajima
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Pat Nakajima
@@ -49,12 +49,11 @@ extra_rdoc_files: []
 
 files: 
 - lib/nakajima
-- lib/nakajima/bench.rb
 - lib/nakajima/core_ext
-- lib/nakajima/core_ext/basic_object.rb
 - lib/nakajima/core_ext/array.rb
-- lib/nakajima/core_ext/proc.rb
+- lib/nakajima/core_ext/kernel.rb
 - lib/nakajima/core_ext/object.rb
+- lib/nakajima/core_ext/proc.rb
 - lib/nakajima/core_ext/symbol.rb
 - lib/nakajima/ui
 - lib/nakajima/ui/progress.rb

data/lib/nakajima/bench.rb

@@ -1,10 +0,0 @@
-def bench(*args, &block)
-  options = args.extract_options!
-  
-  times = options[:times] || 1000
-  label = args.first || "running:"
-  
-  t = Benchmark.measure { times.times(&block) }
-  
-  puts "#{label} #{t.real}"
-end

data/lib/nakajima/core_ext/basic_object.rb

@@ -1,5 +0,0 @@
-module Nakajima
-  class BasicObject
-    instance_methods.reject { |m| m =~ /^__/ }.each { |m| undef_method m }
-  end
-end