ruby-ext 0.2.0

data/.git/objects/81/6bb8c35fe2169fa9ecbcd40941c440e5d032e1

@@ -0,0 +1,2 @@
+x
��N�0ƽݞ�d^p!�-�I���;c�n;d5�Ŷ� ��v�}]�2�}���k!u
Yv�^|k�A�-��8���9��DF��o�|uw����&��NS���a�Kel*E15M��q�v���h%>�$q��U#H^�\UhK#
+���ۘ@��(�
ޝF����mY�FQz��ѐ{P��;ghT^������fΗ���p

data/.git/objects/82/8cab0a228a826cb346b6cf4ffffac84c674e4b

@@ -0,0 +1,3 @@
+x
]QmK�0�k�+�Mt�Va� *�����7�B��X Mf������-�hz�{��N����h����a�pVG�9/\^��O�枲_�9�V�2G�����Ж3�:�!L0�]Xw8c9� ���n�B�ĺ0C��;XZY��1i�� ��}|��듐��������eos� !��P�e��xI��I�eʕ6�o(>�4�t�i��8�%��_�к7l(TP^/"��=�N�J�j�]ak���z�
+EW�9ڼ����K-������"Ew��%$uЫ�)�硐�$Tg	hf��!J�Pt�����L9cP�jY,��,�S������;v�]�FLZ��5/��Z�N�0�=��[��W�:��𧋞
+��

data/.git/objects/9e/a37d9fc7e1ad1504b50da2a1ec639c523fb8b7

@@ -0,0 +1,2 @@
+x
��A
+�0@Q�9E���$q:E�(�d�BkK������=�e��G�(t蛙o�Fk� cH-s��EUSe�2�[u�g�![-�2IV�
%��Sˡ�f�����~_6���G�{��4-E���@�(Fa��������yu.�<�

data/.git/objects/ad/e1a70e7cf984a2f518d19ef625362d78a5fbd0

@@ -0,0 +1,3 @@
+x
�MN�0��&��E�n²j��h%$V���I���k���wg�$��
 R"g�}��\H]@�]g_aFv��(�+a`
k!��Q�-B��o�Vy����@���#yL~e�JQL�^���J|�I�x��F"�7�~���B[Q $��*G�p��.��[7e�E��FC�A	�9C�
+
+@?N�g>��(ʼnu)���Gw�^�P�S2o��nd�L�4O�`�Ӄ�W�mK�ι����jޮ�s�~Sz?
mp2�

data/.git/objects/c3/faad9ba42388a50a57acf9df88f6d2a64a4122

@@ -0,0 +1 @@
+x
}QMK�@���+��B�Ң�<X�y,e�m]�n�&K�w6&�h��0��{�m���������x����:�<72X�)�Nm�\<=?J�;nt~ �(B�l��/4M�5Z���K���*K�UDX�����P�b��LE=�;�O��H���40�j�su�(s���z�V�b~L�2%J���W"�5g]�3����P�;^L�v:VB�]~�,K`���@f����e��܀NS��r��lEP��dB�J��ƽr��	��(���=Ir�.g����-5��<$��,W��5�Ͷ�sF�8�F�J�F�F{�!��݈hO�1�W���_

data/.git/objects/f8/c960b12cbddb90f18123673e6778efdc822058

@@ -0,0 +1,2 @@
+x
}�OK1Žn?��^ZXO���A��
+���&��hvS�l����N�V���余oi���./��ãU�����c�0�Km0���`�)8��u�^)��(8d�]�.?�m`����X��g��$���S>��Ϧ�~�ϣ)�h$�`���⍨ѯ�@YؿG�}'Nt	?�#Cv��%�[�����VĆ��?w�a��:�^lT7�t;��D�#�ޠ���

data/.git/objects/fb/85b5793dcebae826b04cd8c37406504540d8a4

@@ -0,0 +1,2 @@
+x
��MK1��n~�P�PR؋X��(�x[J�fG6�&5�U����l�Tڃ�
+	��z��Ie\�Wř��V{�<,Q������ �O+BL�`}��|}�QJ[�������j�h�r6�o9?���U�E��ΗC�X��
�0�2m�ik����D^H�0�a�P�0~��E��f,�k\kj�V��F"H��-a�g�p/C�Q�(�����w�.��0��<��{���I���	�<��8�[���>3���Y�ز#���Y�����H�^k��[Rѓ���8'��rK�5t��B�-!��X\�M��'�s���)�p@����`r�������}5	�o�}�`ў���h�3K

data/.git/packed-refs

@@ -0,0 +1,2 @@
+# pack-refs with: peeled 
+1196367828af7cc11276833728accd41428b60df refs/remotes/origin/master

data/.git/refs/heads/master

@@ -0,0 +1 @@
+06864a068d188ab7ae17e39d58d6c25dc49a8ff3

data/.git/refs/remotes/origin/HEAD

@@ -0,0 +1 @@
+ref: refs/remotes/origin/master

data/.git/refs/remotes/origin/master

@@ -0,0 +1 @@
+06864a068d188ab7ae17e39d58d6c25dc49a8ff3

data/.gitignore

@@ -0,0 +1,5 @@
+*~
+.DS_Store
+.idea
+.idea/**/*
+Thumbs.db

data/README.rdoc

@@ -0,0 +1,3 @@
+Set of common Ruby language extensions.
+
+For docs go to spec.

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+Dir.chdir File.dirname(__FILE__)	
+
+# Specs
+task :default => :spec
+
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_files = FileList["spec/**/*_spec.rb"]
+	t.libs = ["lib", "spec"]
+end
+
+# Gem
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'fileutils'
+
+spec = Gem::Specification.new do |s|
+	s.name = "ruby-ext"
+	s.version = "0.2.0"
+	s.summary = "Set of common Ruby language extensions"
+	s.description = "Set of common Ruby language extensions"
+	s.author = "Alexey Petrushin"
+	#	s.email = ""
+	s.homepage = "http://www.bos-tec.com"
+  # s.rubyforge_project = "RubyExt"
+	
+	s.platform = Gem::Platform::RUBY
+	s.has_rdoc = true
+	s.extra_rdoc_files = ["README.rdoc"]
+	
+	s.files = (%w{Rakefile README.rdoc .gitignore} + Dir.glob("{lib,spec,.git}/**/*"))
+	#	s.executables = ['restclient']
+	#	s.add_dependency("BlueCloth", ">= 0.0.4")
+  # s.add_dependency "facets"
+	
+	s.require_path = "lib"
+end
+
+PACKAGE_DIR = "#{File.expand_path File.dirname(__FILE__)}/build"
+
+Rake::GemPackageTask.new(spec) do |p|
+	package_dir = PACKAGE_DIR
+#	FileUtils.mkdir package_dir unless File.exist? package_dir	
+	p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+	p.need_zip = true
+	p.package_dir = package_dir
+end
+
+# CLEAN.include [ 'pkg', '*.gem']
+
+task :push do
+  dir = Dir.chdir PACKAGE_DIR do
+    gem_file = Dir.glob("ruby-ext*.gem").first
+    system "gem push #{gem_file}"
+  end
+end
+
+task :clean do
+  system "rm -r #{PACKAGE_DIR}"
+end
+
+task :release => [:gem, :push, :clean]

data/lib/ruby_ext/declarative_cache.rb

@@ -0,0 +1,167 @@
+require 'monitor'
+
+module DeclarativeCache		
+	DISABLED = false
+
+	warn "CASHE DISABLED" if DISABLED 
+
+	# It's not a good idea to mix Business Logic and Performance optimization, 
+	# so i think these methods should be never used.
+	#	def cached *methods
+	#		DeclarativeCache.cached self, *methods
+	#	end	
+	#	
+	#	def cached_with_params *methods
+	#		DeclarativeCache.cached_with_params self, *methods
+	#	end
+
+	@versions, @alias_counter, @monitor = Hash.new{should! :be_never_called}, 0, Monitor.new
+	class << self
+	
+		def alias_counter
+			@alias_counter += 1
+			return :"m#{@alias_counter}"
+		end		
+	
+		def cached *arg
+			vnames, klass, methods = parse_and_check_arguments *arg
+		
+			return if DISABLED						
+			methods.each do |m|				
+				als = (m.to_s =~ /^[_a-zA-Z0-9]+$/) ? m : DeclarativeCache.alias_counter.to_sym 
+			
+				klass.class_eval{alias_method :"cached_#{als}", :"#{m}"}
+				unless vnames.is_a? Array
+					script = single_version_without_args.substitute binding					
+					@versions[vnames] = 0 unless @versions.include? vnames
+				else
+					vnames_str = vnames.collect{|vname| "'#{vname}' => nil"}.join(', ')
+					script = multiple_version_without_args.substitute binding
+					vnames.each{|vname| @versions[vname] = 0 unless @versions.include? vname}
+				end
+				klass.class_eval script, __FILE__, __LINE__								
+			end			
+		end
+	
+		def cached_with_params *arg
+			vnames, klass, methods = parse_and_check_arguments *arg
+		
+			return if DISABLED			
+			methods.each do |m|
+				als = (m.to_s =~ /^[_a-zA-Z0-9]+$/) ? m : DeclarativeCache.alias_counter
+			
+				klass.class_eval{alias_method :"cached_#{als}", :"#{m}"}
+				unless vnames.is_a? Array
+					script = single_version_with_args.substitute binding					
+					@versions[vnames] = 0 unless @versions.include? vnames
+				else
+					vnames_str = vnames.collect{|vname| "'#{vname}' => nil"}.join(', ')
+					script = multiple_version_with_args.substitute binding
+					vnames.each{|vname| @versions[vname] = 0 unless @versions.include? vname}
+				end
+				klass.class_eval script, __FILE__, __LINE__
+			end	
+		end
+	
+		def version name
+			@versions[name]
+		end
+	
+		def update *names
+			names.each do |n| 
+				n = n.to_s
+				@versions[n] = 0 unless @versions.include? n 
+				@versions[n] += 1
+			end
+		end
+	
+		attr_reader :monitor
+	
+		protected
+		def parse_and_check_arguments *arg
+			arg.size.should! :>=, 3
+		
+			version_names = arg[0]
+			if version_names.is_a? Array
+				version_names.size.should! :>, 0
+				version_names = version_names.collect{|n| n.to_s}
+			else
+				version_names = version_names.to_s
+			end
+		
+			klass = arg[1]
+			klass.class.should! :be, [Class, Module]
+		
+			methods = arg[2..arg.size]			
+			defined = klass.instance_methods
+			methods.each do |m|
+				raise "Invalid method_name '#{m}'!" unless defined.include? m.to_s
+			end
+			return version_names, klass, methods
+		end		
+	
+		def multiple_version_with_args
+		  <<-RUBY
+		    def \#{m} *params
+        	DeclarativeCache.monitor.synchronize do
+        		@cache_versions_\#{als} ||= {\#{vnames_str}}
+        		@cache_value_\#{als} ||= {}
+        		if @cache_versions_\#{als}.all?{|vname, v| v == DeclarativeCache.version(vname)} and @cache_value_\#{als}.include?(params) 
+        			return @cache_value_\#{als}[params]
+        		else
+        			@cache_versions_\#{als}.keys.each{|vname| @cache_versions_\#{als}[vname] = DeclarativeCache.version(vname)}
+        			return @cache_value_\#{als}[params] = cached_\#{als}(*params)
+        		end		
+        	end
+        end
+		  RUBY
+		end
+	
+	  def multiple_version_without_args
+	    <<-RUBY
+	      def \#{m}
+        	DeclarativeCache.monitor.synchronize do
+        		@cache_versions_\#{als} ||= {\#{vnames_str}}
+        		if @cache_versions_\#{als}.all?{|vname, v| v == DeclarativeCache.version(vname)}
+        			return @cache_value_\#{als}
+        		else
+        			@cache_versions_\#{als}.keys.each{|vname| @cache_versions_\#{als}[vname] = DeclarativeCache.version(vname)}
+        			return @cache_value_\#{als} = cached_\#{als}
+        		end		
+        	end
+        end
+	    RUBY
+	  end
+	  
+	  def single_version_with_args
+	    <<-RUBY
+	      def \#{m} *params
+        	DeclarativeCache.monitor.synchronize do
+        		@cache_value_\#{als} ||= {}
+        		if @cache_version_\#{als} == DeclarativeCache.version("\#{vnames}") and @cache_value_\#{als}.include?(params) 
+        			return @cache_value_\#{als}[params]
+        		else
+        			@cache_version_\#{als} = DeclarativeCache.version("\#{vnames}")
+        			return @cache_value_\#{als}[params] = cached_\#{als}(*params)
+        		end		
+        	end
+        end
+	    RUBY
+	  end
+	  
+	  def single_version_without_args
+	    <<-RUBY
+	      def \#{m}
+        	DeclarativeCache.monitor.synchronize do
+        		if @cache_version_\#{als} == DeclarativeCache.version("\#{vnames}")
+        			return @cache_value_\#{als}
+        		else
+        			@cache_version_\#{als} = DeclarativeCache.version("\#{vnames}")
+        			return @cache_value_\#{als} = cached_\#{als}
+        		end		
+        	end
+        end
+	    RUBY
+	  end
+	end
+end

data/lib/ruby_ext/file.rb

@@ -0,0 +1,23 @@
+class File
+	class << self
+		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
+		
+		def create_directory dir
+			Dir.mkdir 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

@@ -0,0 +1,21 @@
+module Kernel
+  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
+end

data/lib/ruby_ext/module.rb

@@ -0,0 +1,84 @@
+require 'set'
+
+class Module
+  def is?(base)
+    ancestors.include?(base)
+  end
+  
+  def wrap_method( sym, prefix = "old_", &blk )
+    old_method = "#{prefix}_#{sym}".to_sym
+    alias_method old_method, sym
+    define_method(sym) do |*args|
+      instance_exec(old_method, *args, &blk)
+    end
+  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
+  end
+  
+  def namespace
+    if @module_namespace_defined
+      @module_namespace
+    else
+      @module_namespace_defined = true
+      @module_namespace = Module.namespace_for name
+    end
+  end
+  
+  def each_namespace &block
+    current = namespace
+    while current do
+      block.call current
+      current = current.namespace
+    end
+  end
+  
+  def each_ancestor include_standard = false, &block
+    if include_standard
+      ancestors.each{|a| block.call a unless a == self}
+    else
+      exclude = [self, Object, Kernel]
+      ancestors.each do |a|
+        block.call a unless exclude.include? a
+      end
+    end
+  end
+  
+  def self_ancestors_and_namespaces &b
+    b.call self
+    each_ancestor &b
+    each_namespace &b
+  end
+  
+  def self.namespace_for class_name
+    list = class_name.split("::")
+    if list.size > 1
+      list.pop
+      return eval list.join("::"), TOPLEVEL_BINDING, __FILE__, __LINE__			
+    else
+      return nil
+    end
+  end
+  
+  def inherit *modules
+    modules.each do |amodule|
+      include amodule
+      
+      processed = []
+      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
+          extend class_methods
+        end
+      end
+    end
+  end
+end

data/lib/ruby_ext/not_defined.rb

@@ -0,0 +1,2 @@
+module NotDefined
+end

data/lib/ruby_ext/object.rb

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

data/lib/ruby_ext/open_constructor.rb

@@ -0,0 +1,51 @@
+module OpenConstructor
+	def set values, list = nil
+		unless list
+			if values.is_a? Hash
+				values.each do |k, v|					
+					self.respond_to k.to_writer, v
+				end
+			else
+				values.instance_variables.each do |name|
+					accessor = name[1..name.size].to_writer
+					if self.respond_to? accessor
+						self.send accessor, values.instance_variable_get(name)
+					end
+				end
+			end
+		else
+			if values.is_a? Hash
+				values.each do |k, v|					
+					self.respond_to k.to_writer, v if list.include? k
+				end
+			else
+				values.instance_variables.each do |name|
+					accessor = name[1..name.size]
+					if list.include?(accessor.to_sym) 
+						accessor = accessor.to_writer
+						if self.respond_to?(accessor)
+							self.send accessor, values.instance_variable_get(name)
+						end
+					end
+				end
+			end						
+		end
+		return self		
+	end 
+	
+	def set_with_check values
+		values.each do |k, v|
+			self.send k.to_writer, v			
+		end
+		return self
+	end
+	alias_method :set!, :set_with_check
+	
+	def to_hash
+		hash = {}
+		instance_variables.each do |name|
+			hash[name[1..name.size].to_sym] = instance_variable_get name
+		end
+		return hash
+	end
+end

data/lib/ruby_ext/prepare_arguments.rb

@@ -0,0 +1,105 @@
+class ArgumentsParser
+  class << self
+    def register method, arguments
+      # check and prepare metadata
+      arguments.collect!{|meta| meta.is_a?(Hash) ? meta : {:type => meta}}
+      arguments.each{|meta| meta.should! :include, :type}
+      
+      # register
+      @registry ||= {}
+      @registry[method] = arguments
+    end
+    
+    def parse_arguments_for method, *args, &block
+      metadata = @registry[method]
+      index = 0
+      parsed_args = metadata.collect do |options| 
+        send options[:type], args, block, options, index, (index == metadata.size - 1)
+      end
+      args.should_be! :empty
+      return parsed_args
+    end
+    
+    protected
+    def string args, block, options, index, last
+      object(args, block, options, index, last) || ""
+    end
+    
+    def object args, block, options, index, last
+      a = if range = options[:range]
+        if range == :except_last_hash
+          if args.size == 1 and args.last.is_a? Hash
+            nil
+          else
+            args.shift
+          end
+        else
+          should_be! :never_called
+        end
+      else
+        args.shift
+      end
+      
+      a = _common_options a, options
+      a
+    end
+    
+    def array args, block, options, index, last
+      a = if last
+        args
+      elsif range = options[:range]
+        if range == :except_last_hash
+          if args.last.is_a? Hash
+            tmp = args[0..-2]
+            args[0..-2] = nil
+            tmp
+          else
+            tmp = args[0..-1]
+            args.clear
+            tmp
+          end
+        else
+          should_be! :never_called
+        end
+      else
+        args.shift
+      end
+      
+      a = _common_options a, options
+      a ||= []
+      a = [a] unless a.is_a?(Array)
+      a
+    end
+
+    def hash args, block, options, index, last
+      a = object(args, block, options, index, last) || {}
+      a.should! :be_a, Hash
+      a
+    end
+    
+    def _common_options a, options
+      a.should_not! :be_nil if options[:require]
+      if (default = options[:default]) and a.eql?(nil)
+        a = default
+      end
+      a
+    end
+  end
+end
+
+class Object
+  def self.prepare_arguments_for method, *args
+    # Register parsers
+    ArgumentsParser.register method, args
+    
+    # Wrap method
+    old_method = :"#{method}_wparg"
+    alias_method old_method, method
+    code = <<END
+def #{method} *args, &block
+  #{old_method} *ArgumentsParser.parse_arguments_for(:#{method}, *args), &block
+end
+END
+    class_eval code, __FILE__, __LINE__
+  end
+end