call-me 0.0.1

data/lib/call-me/memoize.rb

@@ -0,0 +1,109 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'refining'
+
+class Module
+	refine_method :method_added, :prefix => '__memoize' do |name|
+		next if name == 'temporary method for refining'
+
+		memoize(name) if @__to_memoize__
+
+		__memoize_method_added(name)
+	end
+
+	refine_method :singleton_method_added, :prefix => '__memoize' do |name|
+		next if name == 'temporary method for refining'
+
+		singleton_memoize(name) if @__to_singleton_memoize__
+
+		__memoize_singleton_method_added(name)
+	end
+end
+
+class Object
+	def is_memoized? (name)
+		respond_to? "__memoize_#{name}"
+	end
+
+	# Memoize the method +name+.
+	def memoize (name = nil)
+		return if @__to_memoize__ = !name
+
+		to_call = "__memoize_#{name}"
+
+		begin; if instance_method(name).arity == 0
+			refine_method name, :prefix => '__memoize' do
+				(memoize_cache[name][nil] ||= [__send__(to_call)])[0]
+			end
+
+			return
+		end; rescue; end
+
+		refine_method name, :prefix => '__memoize' do |*args|
+			if tmp = memoize_cache[name][args]
+				tmp
+			else
+				memoize_cache[name][__memoize_try_to_clone__(args)] = [__send__(*([to_call] + args))]
+			end[0]
+		end
+
+		nil
+	end
+
+	# Memoize the singleton method +name+.
+	def singleton_memoize (name = nil)
+		return if @__to_singleton_memoize__ = !name
+
+		to_call = "__memoize_#{name}"
+
+		begin; if method(name).arity == 0
+			refine_singleton_method name, :prefix => '__memoize' do
+				(memoize_cache[name][nil] ||= [__send__(to_call)])[0]
+			end
+
+			return
+		end; rescue; end
+
+		refine_singleton_method name, :prefix => '__memoize' do |*args, &block|
+			if tmp = memoize_cache[name][args]
+				tmp
+			else
+				memoize_cache[name][__memoize_try_to_clone__(args)] = [__send__(*([to_call] + args))]
+			end[0]
+		end
+
+		nil
+	end; alias singleton_memoize singleton_memoize
+
+	# Clear the memoize cache completely or only for the method +name+
+	def memoize_clear (name = nil)
+		if name
+			memoize_cache.delete(name.to_sym)
+		else
+			memoize_cache.clear
+		end
+	end; alias memoize_clear memoize_clear
+
+	# Get the memoization cache
+	def memoize_cache
+		@__memoize_cache__ ||= Hash.new { |h, k| h[k] = {} }
+	end; alias memoize_cache memoize_cache
+
+	private
+
+	def __memoize_try_to_clone__ (value) # :nodoc:
+		begin
+			Marshal.load(Marshal.dump(value))
+		rescue Exception
+			value
+		end
+	end
+end

data/lib/call-me/named.rb

@@ -0,0 +1,242 @@
+#--
+#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                   Version 2, December 2004
+#
+#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'refining'
+
+class Named
+	@warn = true
+
+	def self.warn (value)
+		@warn = value
+	end
+
+	def self.warn?
+		@warn
+	end
+
+	def initialize (name)
+		@name = name.to_sym
+	end
+
+	def to_sym
+		@name
+	end
+
+	def self.normalize (*args)
+		options = Hash[
+			:optional => [],
+			:alias    => {},
+			:rest     => []
+		].merge(args.last.is_a?(Hash) ? args.pop : {})
+
+		method = args.shift.to_sym
+		names  = args
+
+		options[:optional] = Hash[if options[:optional].is_a?(Range)
+			names[options[:optional]]
+		elsif options[:optional].is_a?(Hash)
+			[options[:optional]]
+		else
+			options[:optional]
+		end.map {|opt|
+			if opt.is_a?(Hash)
+				opt.to_a
+			else
+				[[opt, nil]]
+			end
+		}.flatten(1)]
+
+		return method, names, options
+	end
+
+	def self.arguments (names, options, *args)
+		return args if (args.length != 1 || !args.first.is_a?(Hash)) || (options[:rest] && !args.last.is_a?(Hash))
+
+		parameters = args.pop
+		rest       = args
+		args       = []
+
+		# fix alias parameters
+		parameters.dup.each {|name, value|
+			if options[:alias].has_key?(name)
+				parameters[options[:alias][name]] = value
+				parameters.delete(name)
+			elsif name.is_a?(Integer) && !parameters[names[name - 1]].is_a?(Integer)
+				parameters[names[name - 1]] = value
+				parameters.delete(name)
+			end
+		}
+
+		# check if there are unknown parameters
+		parameters.keys.each {|parameter|
+			raise ArgumentError, "#{parameter} is an unknown parameter" unless names.member?(parameter)
+		}
+
+		# check for missing required parameters
+		(names - parameters.keys - options[:optional].keys).tap {|required|
+			raise ArgumentError, "the following required parameters are missing: #{required.join(', ')}" unless required.empty?
+		} unless options[:optional] == true
+
+		all_optional_after = names.length - names.reverse.take_while {|name|
+			options[:optional].has_key?(name) && !parameters.has_key?(name)
+		}.length
+
+		# fill the arguments array
+		# TODO: try to not add nil for the last optional parameters
+		names.each_with_index {|name, index|
+			if parameters.has_key?(name)
+				if options[:rest].member?(name)
+					args.push(*parameters[name])
+				else
+					args << parameters[name]
+				end
+			else
+				if index < all_optional_after
+					warn 'keep in mind that optionals between two arguments will have nil as value' if Named.warn?
+				end
+
+				if options[:optional][name].nil? && index >= all_optional_after
+					break
+				end
+
+				args << options[:optional][name]
+			end
+		}
+
+		args
+	end
+
+	def self.definition (method)
+		names   = []
+		options = { :rest => [], :optional => [] }
+
+		if method.respond_to? :parameters
+			method.parameters.map {|how, name|
+				if name
+					names << name
+					
+					options[:optional] << name if how == :opt
+					options[:rest]     << name if how == :rest
+				else
+					names          << rand.to_s
+					options[:rest] << names.last
+				end
+			}
+		else
+			if method.arity > 0
+				names.push(*(1 .. method.arity))
+			end
+		end
+
+		[names, options]
+	end
+end
+
+module Kernel
+	def always_named!
+		@always_named = true
+	end
+
+	def always_named?
+		@always_named
+	end
+end
+
+class Module
+	refine_method :method_added, prefix: '__named' do |name|
+		next if name == 'temporary method for refining'
+
+		@__named_last_method__ = name
+	
+		if @__to_namedify__
+			named(Named.new(@__named_last_method__), *@__to_namedify__)
+		elsif always_named?
+			namedc(nil)
+		end
+		
+		__named_method_added(name)
+	end
+
+	refine_method :singleton_method_added, prefix: '__named' do |name|
+		next if name == 'temporary method for refining'
+
+		@__singleton_named_last_method__ = name
+	
+		if @__to_singleton_namedify__
+			singleton_named(Named.new(@__singleton_named_last_method__), *@__to_singleton_namedify__)
+		elsif always_named?
+			singleton_named(nil)
+		end
+		
+		__named_singleton_method_added(name)
+	end
+end
+
+class Object
+	def named (*args)
+		raise ArgumentError, 'you have to pass at least one argument' if args.length == 0
+
+		if args.first.nil?
+			if @__named_last_method__
+				names, options = Named.definition(instance_method(@__named_last_method__))
+
+				named(Named.new(@__named_last_method__), *(names + [options]))
+			end; true
+		elsif !args.first.is_a?(Named)
+			@__to_namedify__ = args
+		end and return
+
+		@__to_namedify__ = false
+
+		method, names, options = Named.normalize(*args)
+
+		instance_method(method).tap {|m|
+			raise ArgumentError, 'method arity mismatch' if m.arity > 0 && m.arity != names.length
+		}
+
+		to_call = "__named_#{method}"
+
+		refine_method method, :prefix => '__named' do |*args, &block|
+			__send__ *([to_call] + Named.arguments(names, options, *args)), &block
+		end
+
+		nil
+	end
+
+	def singleton_named (*args)
+		raise ArgumentError, 'you have to pass at least one argument' if args.length == 0
+
+		if args.first.nil?
+			if @__singleton_named_last_method__
+				names, options = Named.definition(method(@__singleton_named_last_method__))
+
+				singleton_named(Named.new(@__singleton_named_last_method__), *(names + [options]))
+			end; true
+		elsif !args.first.is_a?(Named)
+			@__to_singleton_namedify__ = args
+		end and return
+
+		@__to_singleton_namedify__ = false
+
+		method, names, options = Named.normalize(*args)
+
+		method(method).tap {|m|
+			raise ArgumentError, 'method arity mismatch' if m.arity > 0 && m.arity != names.length
+		}
+
+		to_call = "__named_#{method}"
+
+		refine_singleton_method method, :prefix => '__named' do |*args, &block|
+			__send__ *([to_call] + Named.arguments(names, options, *args)), &block
+		end
+
+		nil
+	end
+end

data/lib/call-me/overload.rb

@@ -0,0 +1,76 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'refining'
+
+class Module
+	private
+
+	def __overload (name)
+		overloaded = (__overloaded__[name] ||= {})
+		overloaded[@__to_overload__ || :default] = instance_method(name)
+
+		remove_instance_variable :@__to_overload__
+
+		define_method name do |*args, &block|
+			overloaded.each {|signature, body|
+				next if signature == :default || signature.each_with_index.any? {|klass, index|
+					!args[index].is_a?(klass)
+				}
+
+				return body.bind(self).call(*args, &block)
+			}
+
+			return overloaded[:default].bind(self).call(*args, &block) if overloaded[:default]
+
+			raise ArgumentError, "the arguments don't match any signature"
+		end
+	end
+
+	def __overloaded__
+		@__overloaded__ ||= {}
+	end
+
+	public
+
+	def is_overloaded? (name)
+		__overloaded__.has_key?(name)
+	end
+
+	def def_signature (*sign)
+		@__to_overload__ = sign
+	end
+
+	def define_overloadable (name, default = nil, matchers)
+		define_method name do |*args|
+			matchers.each {|signature, body|
+				return instance_exec *args, &body if (signature.is_a?(Array) ? signature : [signature]).each_with_index.all? {|klass, index|
+					args[index].is_a?(klass)
+				}
+			}
+
+			return instance_exec *args, &default if default
+
+			raise ArgumentError, "the arguments don't match any signature"
+		end
+	end
+
+	refine_method :method_added, :prefix => '__overload' do |name|
+		next if name == 'temporary method for refining'
+
+		if !@__overloading__ && (@__to_overload__ || is_overloaded?(name))
+			@__overloading__ = true
+			__overload(name)
+			remove_instance_variable :@__overloading__
+		end
+
+		__overload_method_added(name)
+	end
+end

data/lib/call-me/pattern-matching.rb

@@ -0,0 +1,43 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+class Module
+	private
+
+	public
+
+	def define_pattern_matched (name, default = nil, matchers)
+		define_method name do |*args|
+			matchers.each {|signature, body|
+				if signature.is_a?(Proc)
+					return instance_exec *args, &body if signature.call(*args)
+				else
+					return instance_exec *args, &body if (signature.is_a?(Array) ? signature : [signature]) == args
+				end
+			}
+
+			return instance_exec *args, &default if default
+
+			raise ArgumentError, "non-exhaustive patterns"
+		end
+	end
+
+	refine_method :method_added, :prefix => '__pattern_match' do |name|
+		next if name == 'temporary method for refining'
+
+		if !@__pattern_matching__ && (@__to_pattern_match__ || is_pattern_matched?(name))
+			@__pattern_matching__ = true
+			__pattern_match(name)
+			remove_instance_variable :@__pattern_matching__
+		end
+
+		__pattern_match_method_added(name)
+	end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: call-me
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- meh.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: refining
+  requirement: &9935540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *9935540
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &9934600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9934600
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &9933640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9933640
+description: 
+email: meh@paranoici.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/call-me/pattern-matching.rb
+- lib/call-me/named.rb
+- lib/call-me/overload.rb
+- lib/call-me/memoize.rb
+homepage: http://github.com/meh/ruby-call-me
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Various calling things, overload, pattern matching, memoization and such.
+test_files: []