ruby-ext 0.2.16 → 0.4.0

data/lib/micon/micon.rb

@@ -0,0 +1,147 @@
+# Predefined scopes are: :application | :session | :thread | :instance | :"custom_name"
+#
+# Micons :"custom_name" are managed by 'scope_begin' / 'scope_end' methods
+# 
+# :"custom_name" can't be nested (it will destroy old and start new one) and always should be explicitly started!.
+
+class Micon
+  REGISTRY_SYNC = Monitor.new
+  APPLILCATION_SYNC = Monitor.new
+  
+  @application, @registry = {}, {}
+  
+  class << self
+    # 
+    # Scope Management
+    # 
+    def activate scope, container, &block
+      raise_without_self "Only custom scopes can be activated!" if scope == :application or scope == :instance  
+      container.must_be.a Hash  
+      
+      scope_with_prefix = add_prefix(scope)
+      raise_without_self "Scope '#{scope}' already active!" if Thread.current[scope_with_prefix]
+      
+      if block
+        begin          
+          Thread.current[scope_with_prefix] = container
+          block.call
+        ensure
+          deactivate scope
+        end
+      else        
+        Thread.current[scope_with_prefix] = container
+      end
+    end
+    
+    def deactivate scope
+      raise_without_self "Only custom scopes can be deactivated!" if scope == :application or scope == :instance
+      
+      scope_with_prefix = add_prefix(scope)      
+      raise_without_self "Scope '#{scope}' not active!" unless container = Thread.current[scope_with_prefix]
+      
+      Thread.current[scope_with_prefix] = nil      
+      container
+    end
+    
+    def active? scope
+      if scope == :application or scope == :instance
+        true
+      else
+        Thread.current.key?(add_prefix(scope))
+      end      
+    end
+    
+    def clear      
+      APPLILCATION_SYNC.synchronize{@application.clear}
+      Thread.current.keys.each do |key|
+        Thread.current[key] = nil if key.to_s =~ /^mc_/
+      end
+    end
+    
+    
+    # 
+    # Object Management
+    # 
+    def [] key
+      scope, initializer = nil
+      REGISTRY_SYNC.synchronize{scope, initializer = @registry[key]}
+      
+      case scope
+      when nil
+        raise_without_self "The '#{key}' Name is not Managed!", Micon        
+      when :instance
+        return initializer.call
+      when :application
+        APPLILCATION_SYNC.synchronize do
+          o = @application[key]
+          unless o
+            o = initializer.call
+            @application[key] = o
+          end
+          return o
+        end
+      else # custom
+        container = Thread.current[scope]
+        raise_without_self "Scope '#{scope}' not started!" unless container
+        o = container[key]
+        unless o
+          o = initializer.call
+          container[key] = o
+        end
+        return o
+      end
+    end
+    
+    def []= key, value
+      scope = nil
+      REGISTRY_SYNC.synchronize{scope, initializer = @registry[key]}
+      
+      case scope
+      when nil
+        raise_without_self "The '#{key}' Name is not Managed!", Micon
+      when :instance
+        raise_without_self "You can't outject variable with the 'instance' scope!"
+      when :application
+        APPLILCATION_SYNC.synchronize{@application[key] = value}
+      else # Custom
+        container = Thread.current[scope]
+        raise_without_self "Scope '#{scope}' not started!" unless container
+        container[key] = value
+      end
+    end    
+    
+
+    # 
+    # Registry
+    # 
+    def clear_registry
+      REGISTRY_SYNC.synchronize{@registry.clear}
+    end
+    
+    def register key, scope, &initializer
+      key.must_not_be.nil
+      scope.must_not_be.nil
+      scope = add_prefix(scope) unless scope == :application or scope == :instance
+      REGISTRY_SYNC.synchronize do
+        @registry[key] = [scope, (initializer || lambda{nil})]
+      end
+    end
+    
+    def unregister key
+      REGISTRY_SYNC.synchronize{@registry.delete key}
+    end
+    
+    def registry_get key
+      REGISTRY_SYNC.synchronize{@registry[key]}
+    end
+    
+    def include? key
+      REGISTRY_SYNC.synchronize{@registry.include? key}
+    end
+    
+    protected
+      def add_prefix scope
+        :"mc_#{scope}"
+      end
+  end
+end

data/lib/micon.rb

@@ -0,0 +1,6 @@
+require 'ruby_ext'
+
+%w{
+  micon
+  managed
+}.each{|f| require "micon/#{f}"}

data/lib/ruby_ext/class.rb

@@ -1,8 +1,8 @@
 Class.class_eval do
   def name_alias name = nil
     if name
-      name.should! :be_a, String
-      name.should_not_be! :blank
+      name.must_be.a String
+      name.must_not_be.blank
       @name_alias = name.to_s
     else
       @name_alias || self.name

data/lib/ruby_ext/declarative_cache.rb

@@ -1,79 +1,82 @@
 require 'monitor'
 
 class Module
-  def cache! *methods
-    DeclarativeCache.cache! self, *methods
-  end 
-  alias_method :cache, :cache!
+  def cache_method *methods
+    DeclarativeCache.cache_method self, *methods
+  end
   
-  def cache_with_params! *methods
-    DeclarativeCache.cache_with_params! self, *methods
+  def cache_method_with_params *methods
+    DeclarativeCache.cache_method_with_params self, *methods
+  end  
+end
+
+class Object
+  def clear_cache_method
+    instance_variables.each do |iv|
+      remove_instance_variable iv if iv =~ /^@cached_/
+    end
   end
-  alias_method :cache_with_params, :cache_with_params!
 end
 
-module DeclarativeCache		
-	DISABLED = false
+module DeclarativeCache    
+  DISABLED = false
 
-	warn "CASHE DISABLED" if DISABLED
+  warn "CASHE DISABLED" if DISABLED
   unless DISABLED    
-  	class << self  	    	    	  
-  	  def alias_counter
-  	    @alias_counter ||= 0
-  			@alias_counter += 1
-  			return "cached_method_#{@alias_counter}"
-  		end
-	
-  		def cache! klass, *methods
-  			methods.each do |method|
-  			  klass.class_eval do
-    				als = (method.to_s =~ /^[_a-zA-Z0-9]+$/) ? "cached_#{method}" : DeclarativeCache.alias_counter.to_sym
-    				iv_check = "@#{als}_check"
-  			    iv = "@#{als}"
-			    
-    				alias_method als, method
-    				
-    				define_method method do |*args|
-    				  args.should! :be_empty
-    				  unless cached = instance_variable_get(iv)
-    				    unless check = instance_variable_get(iv_check)
-    				      cached = send als
-    				      instance_variable_set iv, cached
-    				      instance_variable_set iv_check, true
-    				    end
-    				  end
-    				  cached
-    				end
-    			end
-  			end
-  		end
-  		alias_method :cache, :cache!
-  		
-  		def cache_with_params! klass, *methods  		  
-  			methods.each do |method|	
-  			  klass.class_eval do			
-    				als = (method.to_s =~ /^[_a-zA-Z0-9]+$/) ? "cached_#{method}" : DeclarativeCache.alias_counter.to_sym 
-  			    iv = "@#{als}"
-			    
-    				alias_method als, method
-  				  				
-    				define_method method do |*args| 
-    				  unless results = instance_variable_get(iv)
-    				    results = {}
-    				    instance_variable_set iv, results
-    				  end
-  				    				  
-    				  unless results.include? args
-    				    results[args] = send als, *args
-    				  end
-  				  
-    				  results[args]
-    				end
-    			end
-  			end
-  		end
-  		alias_method :cache_with_params, :cache_with_params!
-  		
-  	end
+    class << self
+                
+      def cache_method klass, *methods
+        methods.each do |method|
+          klass.class_eval do
+            als = "cached_#{escape_method(method)}"
+            iv_check = "@#{als}_check"
+            iv = "@#{als}"
+          
+            raise "Can't cache the #{method} twice!" if instance_methods.include?(als)
+            
+            alias_method als, method
+            
+            define_method method do |*args|
+              raise "You tried to use cache without params for method with params (use 'cache_method_with_params' instead)!" unless args.empty?
+              unless cached = instance_variable_get(iv)
+                unless check = instance_variable_get(iv_check)
+                  cached = send als
+                  instance_variable_set iv, cached
+                  instance_variable_set iv_check, true
+                end
+              end
+              cached
+            end
+          end
+        end
+      end
+      
+      def cache_method_with_params klass, *methods        
+        methods.each do |method|  
+          klass.class_eval do      
+            als = "cached_#{escape_method(method)}"
+            iv = "@#{als}"
+            
+            raise "Can't cache the '#{method}' twice!" if instance_methods.include?(als)
+            
+            alias_method als, method
+                    
+            define_method method do |*args| 
+              unless results = instance_variable_get(iv)
+                results = {}
+                instance_variable_set iv, results
+              end
+                        
+              unless results.include? args
+                results[args] = send als, *args
+              end
+            
+              results[args]
+            end
+          end
+        end
+      end
+      
+    end
   end
 end

data/lib/ruby_ext/extra_blank_slate.rb

@@ -0,0 +1,16 @@
+class ExtraBlankSlate
+  instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  
+  CUSTOM_UNDEFINE = [:p, :select, :puts]
+    
+  undefine = Kernel.instance_methods + Object.instance_methods + CUSTOM_UNDEFINE
+  ExtraBlankSlate.instance_methods.each{|m| undefine.delete m}
+  
+  undefine.each do |m|
+    script = %{\
+def #{m} *p, &b
+  method_missing :#{m}, *p, &b
+end}
+    class_eval script, __FILE__, __LINE__
+  end    
+end

data/lib/ruby_ext/file.rb

@@ -1,31 +1,20 @@
 require 'fileutils'
 
 File.class_eval do
-	class << self
-	  
-    # There is similar methods in ActiveSupport, that takes also second paramether buffer
-    # these methods 'as is' will broken rails app with passenger in production.
-    # 
-    # def write(path, data)
-    #   File.open(path, "wb") do |file|
-    #     return file.write(data)
-    #   end
-    # end
-    # 
-    # def read(path)
-    #   File.open(path, "rb") do |file|
-    #     return file.read
-    #   end
-    # end
+  class << self
     
+    def write(path, data)
+      File.open(path, "wb") do |file|
+        return file.write(data)
+      end
+    end
     
-		
-		def create_directory dir
-			FileUtils.mkdir_p dir unless File.exist? dir
-		end
-		
-		def delete_directory dir
-			FileUtils.rm_r dir, :force => true if File.exist? dir
-		end
-	end
+    def create_directory dir
+      FileUtils.mkdir_p dir unless File.exist? dir
+    end
+    
+    def delete_directory dir
+      FileUtils.rm_r dir, :force => true if File.exist? dir
+    end
+  end
 end

data/lib/ruby_ext/kernel.rb

@@ -1,21 +1,64 @@
 Kernel.class_eval do
   def respond_to sym, *args
-		return nil if not respond_to? sym
-		send sym, *args
-	end
-	
-	#	def _ &b
-	#		raise "Block isn't provided!" unless b
-	#		return b 
-	#	end
-	
-	def singleton_class(&block)
-		if block_given?
-		(class << self; self; end).class_eval(&block)
-		self
-		else
-		(class << self; self; end)
-		end
-	end
-	alias_method :metaclass, :singleton_class
+    return nil if not respond_to? sym
+    send sym, *args
+  end
+  
+  #  def _ &b
+  #    raise "Block isn't provided!" unless b
+  #    return b 
+  #  end
+  
+  def singleton_class(&block)
+    if block_given?
+    (class << self; self; end).class_eval(&block)
+    self
+    else
+    (class << self; self; end)
+    end
+  end
+  alias_method :metaclass, :singleton_class
+  
+  # Removes the namespace (exact match and underscored) of given class (or self) from stacktrace
+  def raise_without_self *args
+    error, message, klasses = nil
+    if args.size == 1
+      error = RuntimeError
+      message = args[0]
+      klasses = [self]
+    elsif args.size == 2
+      message, klasses = args
+      error = RuntimeError
+      
+      klasses = Array(klasses)
+      klasses << self
+    elsif args.size == 3
+      error, message, klasses = args
+      
+      klasses = Array(klasses)
+      klasses << self
+    else
+      raise RuntimeError, "Invalid arguments!", caller
+    end
+    
+    klasses.collect!{|c| (c.class == Class or c.class == Module) ? c : c.class}
+    
+    # obtaining the namespace of each class
+    klasses.collect! do |c|
+      c = c.namespace while c.namespace
+      c
+    end
+    
+    # building regexp
+    skip = []
+    klasses.each do |c|
+      skip.push(/\/#{c.to_s}/) # exact match
+      skip.push(/\/#{c.to_s.underscore}/) # underscored
+    end
+
+    # cleaning stacktrace
+    stack = caller.select{|path| !skip.any?{|re| re =~ path}}
+    
+    raise error, message, stack
+  end
 end

data/lib/ruby_ext/module.rb

@@ -14,12 +14,12 @@ Module.class_eval do
   end
   
   def inherited_instance_methods
-  	im = Set.new
-  	ancestors.each do |a| 
-  		next if a == self
-  		im.merge a.instance_methods
-  	end
-  	return im.to_a
+    im = Set.new
+    ancestors.each do |a| 
+      next if a == self
+      im.merge a.instance_methods
+    end
+    return im.to_a
   end
   
   def namespace
@@ -71,8 +71,8 @@ Module.class_eval do
       include amodule
       
       processed = []
-      amodule.ancestors.each do |a|			
-        if a.const_defined? :ClassMethods				
+      amodule.ancestors.each do |a|      
+        if a.const_defined? :ClassMethods        
           class_methods = a.const_get :ClassMethods
           next if processed.include? class_methods
           processed << class_methods
@@ -81,4 +81,30 @@ Module.class_eval do
       end
     end
   end
+  
+  raise "Internal error, it shouldn't be loaded twice!" if defined? ESCAPE_METHOD_SYMBOLS # some tricky error when runing spec with rake  
+  ESCAPE_METHOD_SYMBOLS = [
+    ['==', 'assign'],
+    ['>', 'gt'],
+    ['<', 'lt'],
+    ['>=', 'gte'],
+    ['<=', 'lte'],
+    ['?', 'qst'],
+    ['!', 'imp'],
+    ['<=>', 'lorg'],
+    ['*', 'mp'],
+    ['+', 'add'],
+    ['-', 'sub'],
+    ['=', 'assign'],
+    ['**', 'pw'],
+    ['=~', 'sim'],
+    ['[]', 'sb'],
+  ]  
+  
+  def escape_method method
+    m = method.to_s.clone
+    ESCAPE_METHOD_SYMBOLS.each{|from, to| m.gsub! from, to}
+    raise "Invalid method name '#{method}'!" unless m =~ /^[_a-zA-Z0-9]+$/
+    m
+  end
 end

data/lib/ruby_ext/must.rb

@@ -0,0 +1,149 @@
+class AssertionError < RuntimeError; end
+
+class MustAssertions < ExtraBlankSlate
+  def initialize obj
+    @obj = obj
+  end
+  
+  def == o
+    @obj == o
+  end
+  
+  def never_called
+    false
+  end
+  
+  def nil
+    @obj.equal? nil
+  end
+    
+  def a klass
+    if klass.class == Array
+      klass.any?{|k| @obj.is_a? k}
+    else
+      @obj.is_a? klass
+    end
+  end
+  alias_method :an, :a
+        
+  # def be klass = nil
+  #   if klass.class == Array
+  #     klass.any?{|k| @obj.respond_to :is?, k}
+  #   else
+  #     @obj.respond_to :is?, klass
+  #   end
+  # end
+    
+  def include o
+    @obj.include? o
+  end
+    
+  def in *enum
+    Array(enum).include? @obj
+  end
+
+  def true
+    !!@obj
+  end
+
+  def false
+    !@obj
+  end
+
+  def empty
+    @obj.empty?
+  end
+  
+  def blank
+    @obj.blank?
+  end
+  
+  def > o
+    @obj > o
+  end
+  
+  def < o
+    @obj < o
+  end
+  
+  def be
+    @prefix = 'be'
+    self
+  end
+  
+  def have
+    @prefix = 'have'
+    self
+  end
+  
+  def self.assertions
+    special = %w{be have}
+    instance_methods.select{|m| m !~ /^__/ and m != 'be'}
+  end
+
+  protected
+    def method_missing m, *args, &b
+      raise RuntimeError, "Assertion '#{m}' is unknown!", caller[1..-1]
+    end
+  
+    def failed method, negative, *args
+      unless args.empty?
+        Kernel.raise AssertionError, "
+  ASSERTION FAILED (#{caller[1]}):
+  #{@obj.inspect} must #{'not ' if negative}#{"#{@prefix} " if @prefix}#{method} #{args.first}
+        ", caller[3..-1]
+      else
+        Kernel.raise AssertionError, "
+  ASSERTION FAILED (#{caller[1]}):
+  #{@obj.inspect} must #{'not ' if negative}#{"#{@prefix} " if @prefix}#{method}
+        ", caller[3..-1]
+      end
+    end
+end
+
+class Must < MustAssertions
+  assertions.each do |m|
+    desition = "_#{m}"
+    alias_method desition, m
+    define_method m do |*args|
+      failed m, false, *args unless __send__(desition, *args)      
+    end
+  end
+end
+
+class MustNot < MustAssertions
+  assertions.each do |m|
+    desition = "_#{m}"
+    alias_method desition, m
+    define_method m do |*args|
+      failed m, true, *args if __send__(desition, *args)      
+    end
+  end
+end
+
+Object.class_eval do
+  
+  def must
+    Must.new self
+  end
+  
+  def must_not
+    MustNot.new self
+  end
+  
+  def must_be
+    must.be
+  end
+  
+  def must_not_be
+    must_not.be
+  end
+  
+  # def must_have
+  #   must.have
+  # end
+  # 
+  # def must_not_have
+  #   must_not.have
+  # end
+end

data/lib/ruby_ext/object.rb

@@ -1,7 +1,7 @@
 Object.class_eval do
-  def self; self end  	
-  	
+  def self; self end    
+    
 #  def copy
-#  	Marshal.load(Marshal.dump self) # Stub
+#    Marshal.load(Marshal.dump self) # Stub
 #  end
 end