ruby-ext 0.2.0

data/lib/ruby_ext/should.rb

@@ -0,0 +1,150 @@
+class Object
+  def should_be! method
+    unless self.send("#{method}?") == true
+      raise RuntimeError, "
+  ASSERTION FAILED:
+  #{self.inspect} should be #{method}
+      ", caller
+    end
+    
+    return self
+  end
+  alias_method :should_have!, :should_be!
+  
+  def should_not_be! method
+    unless self.send("#{method}?") == false
+      raise RuntimeError, "
+  ASSERTION FAILED:
+  #{self.inspect} should not be #{method}
+      ", caller
+    end
+    
+    return self
+  end
+  alias_method :should_not_have!, :should_not_be!
+  
+  def should! cmd, arg = NotDefined
+    result = case cmd
+    when :be_never_called then
+      false
+      
+    when :be_nil then
+      self.equal? nil
+      
+    when :be_a
+      if arg.class == Array
+        arg.any?{|klass| self.is_a? klass}
+      else
+        self.is_a? arg
+      end
+      
+    when :be
+      if arg.class == Array
+        arg.any?{|klass| self.respond_to :is?, klass}
+      else
+        self.respond_to :is?, arg
+      end
+      
+    when :include then
+      self.include? arg
+      
+    when :be_in then
+      arg.include? self
+
+    when :be_true then
+      self
+
+    when :be_false then
+      !self
+
+    when :be_empty then
+      self.empty?
+
+    else
+      if arg.equal? NotDefined
+        self.send cmd
+      else
+        self.send cmd, arg
+      end
+    end
+
+    unless result
+      unless arg.equal? NotDefined
+        raise RuntimeError, "
+  ASSERTION FAILED:
+  #{self.inspect} should #{cmd} #{arg.inspect}
+        ", caller
+      else
+        raise RuntimeError, "
+  ASSERTION FAILED:
+  #{self.inspect} should #{cmd}
+        ", caller
+      end
+    end
+
+    return self
+  end
+
+  def should_not! cmd, arg = NotDefined
+    result =
+    case cmd
+      when :be_never_called then
+      false
+
+    when :be_nil then
+      self.equal? nil
+
+    when :be_a
+      if arg.class == Array
+        arg.any?{|klass| self.is_a? klass}
+      else
+        self.is_a? arg
+      end
+
+    when :be
+      if arg.class == Array
+        arg.any?{|klass| self.respond_to :is?, klass}
+      else
+        self.respond_to :is?, arg
+      end
+
+    when :include then
+      self.include? arg
+
+    when :be_in then
+      arg.include? self
+
+    when :be_true then
+      self
+
+    when :be_false then
+      !self
+
+    when :be_empty then
+      self.empty?
+
+    else
+      if arg.equal? NotDefined
+        self.send cmd
+      else
+        self.send cmd, arg
+      end
+    end
+
+    if result
+      unless arg.equal? NotDefined
+        raise RuntimeError, "
+  ASSERTION FAILED:
+  #{self.inspect} should not #{cmd} #{arg.inspect}
+        ", caller
+      else
+        raise RuntimeError, "
+  ASSERTION FAILED:
+  #{self.inspect} should not #{cmd}
+        ", caller
+      end
+    end
+
+    return self
+  end
+end

data/lib/ruby_ext/string.rb

@@ -0,0 +1,21 @@
+class String
+	def to_reader
+		self.to_sym
+	end
+	
+	def to_writer
+		"#{self}=".to_sym
+	end
+	
+	def to_iv
+		"@#{self}"
+	end
+	
+	def substitute binding
+		binding.should! :be_a, Binding
+		return gsub(/\#\{.+?\}/) do |term|
+			identifier = term.slice(2 .. term.size-2)
+			binding.eval identifier
+		end
+	end
+end

data/lib/ruby_ext/symbol.rb

@@ -0,0 +1,21 @@
+class Symbol
+  def <=> other
+    self.to_s <=> other.to_s
+  end
+  
+  def to_reader
+    self
+  end
+  
+  def to_writer
+		"#{self}=".to_sym
+	end
+ 
+ 	def to_iv
+		"@#{self}"
+	end
+
+  def + other
+    (self.to_s + other.to_s).to_sym
+  end
+end

data/lib/ruby_ext/synchronizer.rb

@@ -0,0 +1,31 @@
+require 'monitor'
+
+module Synchronizer
+	include MonitorMixin
+	
+	module ClassMethods								
+		def synchronize *methods
+			methods.each do |name|							
+				als = (name.to_s =~ /^[_a-zA-Z0-9]+$/) ? name : DeclarativeCache.alias_counter.to_sym
+				
+				alias_method :"sync_#{als}", name
+				script = "\
+def #{name} *p, &b
+	synchronize{sync_#{als} *p, &b}
+end"
+				class_eval script, __FILE__, __LINE__
+			end
+		end
+		
+		def synchronize_all
+			methods = self.instance_methods(false).collect{|m| m.to_sym}
+			synchronize *methods
+		end
+		
+		protected
+		def alias_counter
+			@alias_counter += 1
+			return :"m#{@alias_counter}"
+		end
+	end
+end

data/lib/ruby_ext.rb

@@ -0,0 +1,17 @@
+%w{
+  kernel 
+  module
+  not_defined
+  object
+  string
+  symbol
+  
+  should
+  declarative_cache
+  file
+  open_constructor
+  prepare_arguments
+  synchronizer
+}.each do |f|
+  require "#{File.dirname __FILE__}/ruby_ext/#{f}"
+end

data/spec/assert_spec.rb

@@ -0,0 +1,27 @@
+require 'spec'
+
+dir = File.dirname __FILE__
+require "#{dir}/spec_require"
+require "#{dir}/../lib/ruby_ext/should"
+
+describe 'Assert' do
+	it 'should! & should_not!' do
+		lambda{should! :be_never_called}.should raise_error(/ever/)
+		lambda{nil.should_not! :be_nil}.should raise_error(/nil/)
+		1.should_not! :be_nil
+		1.should! :==, 1
+		lambda{1.should! :==, 2}.should raise_error(%r{==})
+		1.should! :be_in, [1, 2]
+		"".should! :be_a, String
+    String.should! :be, String      
+		1.should! :<, 2
+	end		
+	
+	it 'should_be! & should_not_be!' do
+	  [].should_be! :empty
+	  [''].should_not_be! :empty
+	  
+	  lambda{[''].should_be! :empty}.should raise_error(/should be/)
+	  lambda{[].should_not_be! :empty}.should raise_error(/should not be/)
+	end
+end

data/spec/declarative_cache_spec.rb

@@ -0,0 +1,97 @@
+require 'spec'
+
+dir = File.dirname __FILE__
+require "#{dir}/spec_require"
+require "#{dir}/../lib/ruby_ext/should"
+require "#{dir}/../lib/ruby_ext/declarative_cache"
+
+describe 'DeclarativeCache' do
+	class CachedClass
+		attr_accessor :value
+		def value_get; @value end
+		
+		attr_accessor :value2
+		def value2_get; @value2 end
+		
+		attr_accessor :params
+		def params_get param; @params[param] end 				
+	end						
+	
+	DeclarativeCache.cached CachedClass, CachedClass, :value_get
+	DeclarativeCache.cached :cache_version_name, CachedClass, :value2_get
+	DeclarativeCache.cached_with_params CachedClass, CachedClass, :params_get
+	
+	it "Simple Cache" do
+		o = CachedClass.new
+		o.value = 0
+		o.value2 = 0
+		o.value_get.should == 0
+		o.value2_get.should == 0
+		o.value = 1
+		o.value2 = 1
+		o.value_get.should == 0
+		o.value2_get.should == 0
+		DeclarativeCache.update CachedClass
+		o.value_get.should == 1
+		o.value2_get.should == 0
+		DeclarativeCache.update :cache_version_name
+		o.value2_get.should == 1
+		DeclarativeCache.update CachedClass, :cache_version_name
+	end
+	
+	it "Cache With Params" do
+		o = CachedClass.new
+		o.params = {:a => :b}
+		o.params_get(:a).should == :b
+		o.params = {:a => :c}
+		o.params_get(:a).should == :b
+		DeclarativeCache.update CachedClass
+		o.params_get(:a).should == :c
+	end
+	
+	class CachedClass2
+		class << self
+			attr_accessor :value
+			def value_get; @value end 								
+		end
+	end				
+	
+	DeclarativeCache.cached CachedClass2, CachedClass2.singleton_class, :value_get				
+	
+	it "Simple Cache" do
+		CachedClass2.value = 0
+		CachedClass2.value_get.should == 0
+		CachedClass2.value = 1
+		CachedClass2.value_get.should == 0
+		DeclarativeCache.update CachedClass2
+		CachedClass2.value_get.should == 1
+	end
+	
+	class MultipleCacheVersions
+		attr_accessor :value
+		def value_get; @value end 								
+			
+		attr_accessor :value2
+		def value2_get params; @value2 end
+	end
+	
+	DeclarativeCache.cached [:class, :resource_update, :security_update], MultipleCacheVersions, :value_get				
+	DeclarativeCache.cached_with_params [:class, :resource_update, :security_update], MultipleCacheVersions, :value2_get				
+	
+	it "Multiple cache versions" do
+		o = MultipleCacheVersions.new
+		o.value, o.value2 = 0, 0
+		
+		o.value_get.should == 0
+		o.value = 1
+		o.value_get.should == 0			
+		DeclarativeCache.update :class
+		o.value_get.should == 1
+		o.value = 2
+		o.value_get.should == 1
+		DeclarativeCache.update :resource_update, :security_update
+		o.value_get.should == 2
+		
+		o.value2_get("params").should == 0
+	end
+end

data/spec/kernel_spec.rb

@@ -0,0 +1,16 @@
+require 'spec'
+
+dir = File.dirname __FILE__
+require "#{dir}/../lib/ruby_ext/kernel"
+
+describe 'Kernel' do
+	class Respond
+		def test; 2 end
+	end
+
+	it "respond_to" do
+		r = Respond.new
+		r.respond_to(:not_exist).should be_nil
+		r.respond_to(:test).should == 2
+	end
+end

data/spec/module_spec.rb

@@ -0,0 +1,127 @@
+require 'spec'
+
+dir = File.dirname __FILE__
+require "#{dir}/../lib/ruby_ext/module"
+
+
+describe "Module" do
+	class A
+		class B
+			class C
+				
+			end
+		end
+	end
+	
+	it "Namespace" do
+		File.namespace.should == nil
+		A::B::C.namespace.should == A::B
+	end
+	
+	class AnonymousClass
+		class << self
+			def anonymous_name
+				self.name
+			end
+		end
+	end
+	
+	
+	it "name" do
+		A::B::C.name.should == "A::B::C"
+	end
+	
+	class X; end
+	class Y < X; end
+	class Z < Y; end
+	
+	
+	it "each_ancestor" do
+		list = []
+		Z.each_ancestor{|a| list << a}
+		list.should include Y
+		list.should include X
+		list.should_not include Z
+		list.should_not include Object
+		list.should_not include Kernel
+		
+		list = []
+		Z.each_ancestor(true){|a| list << a}
+		list.should include Y
+		list.should include X
+		list.should_not include Z
+		list.should include Object
+		list.should include Kernel
+	end
+	
+	it "each_namespace" do
+		list = []
+		A::B::C.each_namespace{|n| list << n}
+		list.should == [A::B, A]
+	end
+	
+	it "is?" do
+		File.is?(IO).should be_true
+	end
+	
+	class WrapMethod
+		def method_name value
+			10*value
+		end
+	end
+	
+	it "wrap_method" do
+		WrapMethod.wrap_method :method_name do |old, value|
+			send(old, value)*value
+		end
+		WrapMethod.new.method_name(10).should == 1000
+	end
+	
+	module M
+		def m_m; end				
+		module ClassMethods
+			def cm_m; end
+		end
+	end						
+	
+	class C
+		inherit M
+	end
+	
+	it "inherit" do
+		C.respond_to?(:cm_m).should be_true
+		C.new.respond_to?(:m_m).should be_true				
+	end
+	
+	module M2
+		include M
+		
+		module ClassMethods
+			def cm2_m; end
+		end
+	end
+	
+	class D
+		inherit M2
+	end
+	
+	it "should inherit all ancestors class methods" do
+		D.respond_to?(:cm_m).should be_true
+		D.respond_to?(:cm2_m).should be_true
+		D.new.respond_to?(:m_m).should be_true
+	end
+	
+	class C2
+		inherit M
+	end
+	
+	it "Shouldn't redefine ancestors class methods" do
+		C2.respond_to?(:cm2_m).should be_false
+	end
+	
+	it "inherited_instance_methods" do
+		im = Set.instance_methods - Set.inherited_instance_methods
+		im.should include("union")
+		im.should_not include("object_id")
+	end
+end

data/spec/open_constructor_spec.rb

@@ -0,0 +1,39 @@
+require 'spec'
+
+dir = File.dirname __FILE__
+require "#{dir}/spec_require"
+require "#{dir}/../lib/ruby_ext/open_constructor"
+
+describe 'OpenConstructor' do
+	class Test
+		include OpenConstructor
+		attr_accessor :name, :value
+  end
+
+	it 'should initialize atributes from Hash' do
+		t = Test.new.set(:name => 'name', :value => 'value')
+		[t.name, t.value].should == ['name', 'value']
+	end
+	
+	it 'should initialize atributes from any Object' do
+		t = Test.new.set(:name => 'name', :value => 'value')
+		t2 = Test.new.set t
+		[t2.name, t2.value].should == ['name', 'value']
+	end
+	
+	it 'restrict copied values' do
+		t = Test.new.set(:name => 'name', :value => 'value')
+		t2 = Test.new.set t, [:name]
+		[t2.name, t2.value].should == ['name', nil]
+		
+		t = {:name => 'name', :value => 'value'}
+		t2 = Test.new.set t, [:name]
+		[t2.name, t2.value].should == ['name', nil]
+	end
+	
+	it 'to_hash' do
+		h = {:name => 'name', :value => 'value'}
+		t = Test.new.set h
+		t.to_hash.should == h
+	end
+end

data/spec/prepare_arguments_spec.rb

@@ -0,0 +1,50 @@
+require 'spec'
+
+dir = File.dirname __FILE__
+require "#{dir}/spec_require"
+require "#{dir}/../lib/ruby_ext/should"
+require "#{dir}/../lib/ruby_ext/prepare_arguments"
+
+describe "Prepare Arguments" do
+  
+  it "basic parsing" do
+    ArgumentsParser.register :m, [:object, :array, :hash]
+    ArgumentsParser.parse_arguments_for(:m, :o, 1).should == [:o, [1], {}]
+  end
+  
+  it "basic method wrapping" do
+    class BMWTest
+      def add content, options
+        :ok
+      end
+      prepare_arguments_for :add, {:type => :object, :required => true}, :hash
+    end
+    
+    BMWTest.new.add('text').should == :ok
+  end
+  
+  it "except_last_hash for array" do
+    ArgumentsParser.register :m, [{:type => :array, :range => :except_last_hash}, :hash]
+    ArgumentsParser.parse_arguments_for(:m, 1, 2, 3, :a => :b).should == [[1, 2, 3], {:a => :b}]
+    ArgumentsParser.parse_arguments_for(:m, :a => :b).should == [[], {:a => :b}]
+    ArgumentsParser.parse_arguments_for(:m, 1, 2, 3).should == [[1, 2, 3], {}]
+  end
+  
+  it "except_last_hash for object" do
+    ArgumentsParser.register :m, [{:type => :object, :range => :except_last_hash}, :hash]
+    ArgumentsParser.parse_arguments_for(:m, 1, :a => :b).should == [1, {:a => :b}]
+    ArgumentsParser.parse_arguments_for(:m, :a => :b).should == [nil, {:a => :b}]
+    ArgumentsParser.parse_arguments_for(:m, 1).should == [1, {}]
+  end
+  
+  it "default value" do
+    ArgumentsParser.register :m, [{:type => :object, :default => ""}]
+    ArgumentsParser.parse_arguments_for(:m).should == [""]
+  end
+  
+  it "string" do
+    ArgumentsParser.register :m, [:string]
+    ArgumentsParser.parse_arguments_for(:m).should == [""]
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--reverse
+--backtrace

data/spec/spec_require.rb

@@ -0,0 +1,10 @@
+%w{
+  kernel 
+  module
+  not_defined
+  object
+  string
+  symbol
+}.each do |f|
+  require "#{File.dirname __FILE__}/../lib/ruby_ext/#{f}"
+end

data/spec/synchronizer_spec.rb

@@ -0,0 +1,69 @@
+require 'spec'
+
+dir = File.dirname __FILE__
+require "#{dir}/spec_require"
+require "#{dir}/../lib/ruby_ext/synchronizer"
+
+module RubyExt
+	describe "Synchronize" do
+		it "synchronize" do
+			class Account
+				inherit Synchronizer
+				attr_reader :from, :to
+				
+				def initialize
+					super
+					@from, @to = 0, 0
+				end
+				
+				def transfer
+					@from -= 1
+					@to += 1
+				end
+				synchronize :transfer
+			end
+			
+			a, threads = Account.new, []
+			100.times do 
+				t = Thread.new do
+					100.times{a.transfer}
+				end
+				threads << t
+			end				
+			threads.each{|t| t.join}
+			
+			a.from.should == -10_000
+			a.to.should == 10_000
+		end
+		
+		it "synchronize_all" do
+			class Account
+				inherit Synchronizer
+				attr_reader :from, :to
+				
+				def initialize
+					super
+					@from, @to = 0, 0
+				end
+				
+				def transfer
+					@from -= 1
+					@to += 1
+				end
+				synchronize_all
+			end
+			
+			a, threads = Account.new, []
+			100.times do 
+				t = Thread.new do
+					100.times{a.transfer}
+				end
+				threads << t
+			end				
+			threads.each{|t| t.join}
+			
+			a.from.should == -10_000
+			a.to.should == 10_000
+		end
+	end
+end