detach 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b5f072cc4f0f35c933ba67ede12f20dbd8bcb258
+  data.tar.gz: f442b9baf99c44c4a49ec2f8af5bc6bce365f50a
+SHA512:
+  metadata.gz: 9d6f1eeb94dc88d3db16390ef1c802fb9421bee7c4fe17d06fce3ca7e3b9a50c247c7599b82254e34090d558f76d31d36f94c76968aed339557a5645a6ba54f6
+  data.tar.gz: 0bddec8616d667425cdae4b0c6c775cc8dadea9b863bc307125ddfd068bdeaa788fcd0b88a0660e948aeb61820f870a09514f56d0c6df2d0d5a86c935ffe0db0

data/lib/detach.rb

@@ -0,0 +1,106 @@
+# The Detach mixin provides method dispatch according to argument types.
+# Method definitions are separated by name and signatue, allowing for
+# C++ or Java style overloading.
+#
+# Example:
+#   class Bar
+#     include Detach
+#     taking['String','String']
+#     def foo(a,b)
+#       a.upcase + b.upcase
+#     end
+#     taking['Integer','Integer']
+#     def foo(a=42,b)
+#       a * b
+#     end
+#     taking['Object','String']
+#     def foo(a,*b)
+#       b.map {|s| s.upcase + a.to_s}.join
+#     end
+#   end
+module Detach
+	# Extends the base class with the module Detach::Types.
+	def self.included(base)
+		base.extend(Types)
+	end
+	# Provides run-time method lookup according to the types of the args.
+	#
+	# All methods matching the name are scored according to both arity and type.
+	# Varargs and default values are interpolated with actual values. Predefined classes
+	# are compared to actual classes using equality and inheritence checks.
+	def method_missing(name, *args, &block)
+		(score,best) = (public_methods+protected_methods+private_methods).grep(/^#{name}\(/).collect {|candidate|
+			# extract paramters
+			params = /\((.*)\)/.match(candidate.to_s)[1].scan(/(\w+)-([\w:)]+)/).collect {|s,t|
+				[s.to_sym, t.split(/::/).inject(Kernel) {|m,c| m = m.const_get(c)}]
+			}
+			# form the list of all required argument classes
+			ctypes = params.values_at(*params.each_index.select {|i| params[i].first == :req}).map(&:last)
+
+			# NOTE: ruby only allows a single *args, or a list of a=1, b=2--not both together--
+			# only one of the following will execute
+
+			# (A) insert any optional argument classes for as many extra are present
+			params.each_index.select {|i| params[i].first == :opt}.each {|i|
+				ctypes.insert(i, params[i].last) if args.size > ctypes.size
+			}
+			# (B) insert the remaining arguments by exploding the appropriate class by the number extra
+			params.each_index.select {|i| params[i].first == :rest}.each {|i|
+				ctypes.insert(i, *([params[i].last] * (args.size - ctypes.size))) if args.size > ctypes.size
+			}
+
+			# now score the given args by comparing their actual classes to the predefined classes
+			if args.empty? and ctypes.empty?
+				score = 1
+			elsif ctypes.size == args.size
+				score = args.map(&:class).zip(ctypes).inject(0) {|s,t| 
+					# apply each class comparison and require nonzero matches
+					s and ->(n) {s += n if n > 0}[ [ :==, :<=, ].select {|op| ->(a,&b) {b[*a]}[t, &op]}.size ]
+				} || 0
+			else
+				score = 0
+			end
+
+			[ score, candidate ]
+
+		}.max {|a,b| a[0] <=> b[0]}
+
+		(not score or score == 0) ? super : method(best)[*args, &block]
+	end
+
+	# The Detach::Types module is inserted as a parent of the class which includes the
+	# Detach mixin. This module handles inspection and aliasing of instance methods
+	# as they are added.
+	#
+	# Detach::Types does not need to be extended directly.
+	module Types
+		# Decorator method for defining argument signature.
+		#
+		# Example:
+		#   taking['String']
+		#   def foo(a)
+		#   end
+		def taking
+			self
+		end
+		# :stopdoc:
+		def [](*types)
+			@@types = types.flatten
+		end
+		def method_added(name)
+			return unless @@types
+
+			# query the parameter info for the method just added
+			p = instance_method(name).parameters.map &:first
+			raise ArgumentError.new('type and parameter mismatch') unless p.size == @@types.size
+
+			# encode our defined types with parameter info into a new name and remove the original
+			n = (name.to_s + '(' + p.zip(@@types).collect {|p,t| "#{p}-#{t}" }.join(',') + ')').to_sym
+			@@types = nil
+
+			alias_method n, name unless method_defined?(n)
+			define_method(name) {|*args, &block| method_missing(name, *args, &block)}
+		end
+	end
+end
+

data/test/test_detach.rb

@@ -0,0 +1,142 @@
+require 'test/unit'
+require 'detach'
+
+class TestDetach < Test::Unit::TestCase
+
+	def testBasicTypes
+		assert_equal "String hello", Foo.new.foo('hello')
+		assert_equal "Integer 42", Foo.new.foo(42)
+		assert_equal "Strings helloworld", Foo.new.foo('hello', 'world')
+		assert_equal "Integers 42", Foo.new.foo(40, 2)
+		assert_equal "Floats 4.7", Foo.new.foo(3.1, 1.6)
+		assert_equal "Numbers 4.7", Foo.new.foo(3, 1.7)
+	end
+
+	def testNoArgs
+		assert_equal "Nonce", Foo.new.foo
+	end
+
+	def testLists
+		assert_equal "Object List [\"one\", 2, 3.0, \"4\"]", Foo.new.foo('one', 2, 3.0, '4')
+		assert_equal "String List [\"one\", \"two\", \"three\", \"four\"]", Foo.new.foo('one', 'two', 'three', 'four')
+
+	end
+
+	def testMixedLists
+		assert_equal "Int-String List-String 1 [] guy", Foo.new.foo(1, 'guy')
+		assert_equal "Int-String List-String 1 [\"is\", \"the\", \"lonliest\"] number", Foo.new.foo(1, 'is', 'the', 'lonliest', 'number')
+	end
+
+	def testOptional
+		assert_equal "Int-String-Int 7 ate 9", Foo.new.foo(7, 'ate', 9)
+		assert_equal "Int-String-Int 42 < 99", Foo.new.foo('<', 99)
+	end
+
+	def testCustomObject
+		assert_equal "P::M 42", Foo.new.foo(P::M.new)
+	end
+
+	def testConstructor
+		assert_equal "hello world", Wow.new("hello", "world").to_s
+		assert_equal "11", Wow.new(5, 6).to_s
+	end
+
+
+	#
+	#  helper definitions
+	#
+
+	module P
+		class M
+			def wow
+				42
+			end
+		end
+	end
+
+	class Foo
+		include Detach
+
+		taking[String, String]
+		def foo(a, b)
+			"Strings #{a + b}"
+		end
+
+		taking[Integer, Integer]
+		def foo(a, b)
+			"Integers #{a + b}"
+		end
+
+		taking[Float, Float]
+		def foo(a, b)
+			"Floats #{a + b}"
+		end
+
+		taking[Numeric, Numeric]
+		def foo(a, b)
+			"Numbers #{a + b}"
+		end
+
+		taking[String]
+		def foo(a)
+			"String #{a}"
+		end
+
+		taking[Integer]
+		def foo(a)
+			"Integer #{a}"
+		end
+
+		taking[]
+		def foo
+			"Nonce"
+		end
+
+		taking[Object]
+		def foo(*a)
+			"Object List #{a}"
+		end
+
+		taking[String]
+		def foo(*a)
+			"String List #{a}"
+		end
+
+		taking[Integer, String, String]
+		def foo(a, *b, c)
+			"Int-String List-String #{a} #{b} #{c}"
+		end
+
+		taking[Integer, String, Integer]
+		def foo(a=42, b, c)
+			"Int-String-Int #{a} #{b} #{c}"
+		end
+
+		taking[P::M]
+		def foo(m)
+			"P::M #{m.wow}"
+		end
+	end
+
+	class Wow
+		include Detach
+
+		taking[String,String]
+		def initialize(a,b)
+			@s = "#{a} #{b}"
+		end
+
+		taking[Integer,Integer]
+		def initialize(a,b)
+			@s = a + b
+		end
+
+		def to_s
+			@s.to_s
+		end
+	end
+
+
+end
+
+

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: detach
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan Calhoun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-19 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/detach.rb
+- test/test_detach.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Separate methods by argument types
+test_files: []