jinterface 0.0.0

data/lib/jinterface/arg_range.rb

@@ -0,0 +1,38 @@
+module JInterface
+	class ArgRange
+		attr :min, :max
+		def initialize(meth)
+			reset(meth)
+		end
+		def +(range)
+			if range.is_a? self.class
+				@min = range.min if range.min < @min
+				@max = range.max if range.max > @max
+			end
+			return self
+		end
+		def cover?(range)
+			return range.is_a?(self.class) && 
+			@min <= range.min && @max >= range.max
+		end
+		def reset(meth)
+			@min, @max = getMethodRange(meth)
+		end
+		def to_s()
+			"(#{@min}, #{@max}#{@max == Float::INFINITY ? ']' : ')'}"
+		end
+		private
+		def getMethodRange(meth)
+			return 0, 0 unless meth.is_a?(UnboundMethod) or meth.is_a?(Method)
+			#Get min and max number of args for method
+			min = 0
+			params = meth.parameters
+			max = params.length
+			params.each do |type, |
+				++min if type == :req
+				max = Float::INFINITY if type == :rest
+			end
+			return min, max
+		end
+	end
+end

data/lib/jinterface/interface_class_methods.rb

@@ -0,0 +1,111 @@
+require 'jinterface/interface_class_methods'
+require 'jinterface/arg_range.rb'
+module JInterface
+	module InterfaceClassMethods
+		def include(*args)
+			#For each inclusion
+			args.each do |mod|
+				#Make sure it is an interface
+				raise TypeError.new(
+					"Cannot include non-interface module"\
+					" '#{mod.name}' in interface '#{self.name}'."
+				) unless JInterface.interface? mod
+				#Add the method arrays together
+				arg_ranges = mod.instance_variable_get(:@arg_ranges)
+				arg_ranges.each do |method_name, range|
+					@arg_ranges[method_name] = range + @arg_ranges[method_name]
+				end
+				#Include it
+				super mod
+			end
+		end
+		def included(obj)
+			#Ignore if included in an interface,
+			#include method will take care of checks
+			return if JInterface.interface?(obj)
+			#Cache public obj method names
+			obj_methods = Hash[obj.public_instance_methods.map.with_index.to_a]
+			#Check interface methods are implemented in obj
+			act_range = JInterface::ArgRange.new(nil)
+			self.public_instance_methods.each do |method_name|
+				#If method does not exist
+				if not obj_methods.key? method_name
+					#Raise error if under a different scope
+					[:private, :protected].each do |scope|
+						raise NameError.new(
+							"Method '#{method_name}' in class '#{obj.name}'"\
+							" must be declared as public, not #{scope},"\
+							" as declared in interface '#{self.name}'."
+						) if obj.send("#{scope}_method_defined?", method_name)
+					end
+					#If here, method does not exist. This is possible
+					#if the method was removed or made undefined
+					raise NotImplementedError.new(
+						"Method '#{method_name}' must be implemented in class"\
+						" '#{obj.name}' as declared in interface '#{self.name}'."
+					)
+				end
+				#Make sure method was overriden (implemented)
+				meth = obj.public_instance_method method_name
+				raise NotImplementedError.new(
+					"Method '#{method_name}' must be implemented in class"\
+					" '#{obj.name}' as declared in interface '#{meth.owner.name}'."
+				) if JInterface.interface? meth.owner
+				#Make sure method can handle number of args defined
+				act_range.reset(meth)
+				exp_range = @arg_ranges[method_name]
+				raise ArgumentError.new(
+					"Method '#{method_name}' in class '#{obj.name}'"\
+					" must handle #{exp_range} arguments, not #{act_range},"\
+					" as declared in included interface(s)."
+				) unless act_range.cover? exp_range
+			end
+		end
+		def method_added(method_name)
+			meth = self.public_instance_method(method_name)
+			@arg_ranges[method_name] = JInterface::ArgRange.new(meth) + @arg_ranges[method_name]
+		end
+		def private(*args)
+			raise SyntaxError.new(
+				"Interface '#{self.name}' cannot declare"\
+				" private methods, only public methods."
+			)
+		end
+		def protected(*args)
+			raise SyntaxError.new(
+				"Interface '#{self.name}' cannot declare"\
+				" protected methods, only public methods."
+			)
+		end
+		def singleton_method_added(*args)
+			raise SyntaxError.new(
+				"Interface '#{self.name}' cannot declare"\
+				" class methods, only instance methods."
+			)
+		end
+		def extend(*args)
+			raise SyntaxError.new(
+				"Interface '#{self.name}' cannot extend,"\
+				" only include other interfaces."
+			)
+		end
+		def extended(obj)
+			raise SyntaxError.new(
+				"Interface '#{self.name}' cannot be "\
+				" extended, only included, in '#{obj.name}'."
+			)
+		end
+		def prepend(*args)
+			raise SyntaxError.new(
+				"Interface '#{self.name}' cannot prepend,"\
+				" only include other interfaces."
+			)
+		end
+		def prepended(obj)
+			raise SyntaxError.new(
+				"Interface '#{self.name}' cannot be "\
+				" prepended, only included, in '#{obj.name}'."
+			)
+		end
+	end
+end

data/lib/jinterface.rb

@@ -0,0 +1,82 @@
+require 'jinterface/interface_class_methods'
+module JInterface
+	class << self
+		def included(mod)
+			#Do not do anything if in production
+			return if production?
+			#Make sure JInterface used with module
+			raise TypeError.new(
+				"JInterface cannot be used with class"\
+				" '#{mod.name}', only with modules."
+			) if mod.instance_of? Class
+			#Extend module
+			mod.class_eval do
+				extend JInterface::InterfaceClassMethods
+				@arg_ranges = {
+					#method_name => ArgRange
+				}
+				#In case JInterface inclusion was
+				#not first thing in class declaration:
+				#Raise error if private method defined
+				private_instance_methods.each do |method_name|
+					private method_name
+				end
+				#Raise error if protected method defined
+				protected_instance_methods.each do |method_name|
+					protected method_name
+				end
+				#Raise error if class method defined
+				methods(false).each do |method_name|
+					singleton_method_added method_name
+				end
+				#Raise error if non-interface included
+				included_modules.each do |mod|
+					include mod unless JInterface.interface? mod
+				end
+				#Raise error if module prepended
+				prepended_modules.each do |mod|
+					prepend mod
+				end if defined? prepended_modules
+				#Raise error if module extended
+				(
+					(class << mod; self; end).included_modules - 
+					Module.included_modules -
+					[JInterface::InterfaceClassMethods]
+				).each do |mod|
+					extend mod
+				end
+				#Send each method through method_added method
+				public_instance_methods(false).each do |method_name|
+					method_added(method_name)
+				end
+			end
+		end
+		def extended(obj)
+			raise SyntaxError.new(
+				"Interface '#{self.name}' cannot be "\
+				" extended, only included, in '#{obj.name}'."
+			)
+		end
+		def prepended(obj)
+			raise SyntaxError.new(
+				"Interface '#{self.name}' cannot be "\
+				" prepended, only included, in '#{obj.name}'."
+			)
+		end
+		def interface?(obj)
+			(	obj == JInterface or 
+				(	obj.instance_of?(Module) and 
+					(class << obj; self end) < JInterface::InterfaceClassMethods
+				)
+			) ? true : false
+		end
+		def production=(flag)
+			@enabled = flag == true
+		end
+		def production?()
+			return @enabled ||= false
+		end
+	end
+end
+#Turn JInterface checking on or off
+JInterface.production = defined?(Rails) and Rails.is_a?(Class) ? Rails.env.production? : false

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: jinterface
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Michael Rojas
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDRDCCAiygAwIBAgIBADANBgkqhkiG9w0BAQUFADBIMRowGAYDVQQDDBFkZXYu
+  bWljaGFlbC5yb2phczEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
+  LGQBGRYDY29tMB4XDTE0MDQxMTIyMzM1M1oXDTE1MDQxMTIyMzM1M1owSDEaMBgG
+  A1UEAwwRZGV2Lm1pY2hhZWwucm9qYXMxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDET
+  MBEGCgmSJomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+  ggEBAKqba7uCWi7wkNCeUFLDa+Ql5fG75E8kGruxP5BBAWhOUwjWpKfUv/8Paqlk
+  7P3rtNMLnofentNQciXLgSlK0jwyO9Kuevi3nIPbFuVcQR5D58z9SLezYQSl1hPu
+  RaO2IFLfnakj2QjyH3RVdzBDq3+merqkI0qmDvWCs6aJljHsAOBjk5DftY5elCDP
+  ooks39ZVpsdwpoAewmtq9uvMivCRz+Vf1yJYVoRuVUSczoOPgN4PW/MJfLQhih5b
+  FrsDqGQdNgSjgL7rTZMd0/tiUdo9GaGYG/Rl3TtzlyxB9pJTTc1rDmi/1A2G6Weo
+  UX97pHPgP+0WEl3e41jbYkClSfMCAwEAAaM5MDcwHQYDVR0OBBYEFDWsnI/cwObC
+  XU3Yf8T0vyKp9Wb+MAsGA1UdDwQEAwIEsDAJBgNVHRMEAjAAMA0GCSqGSIb3DQEB
+  BQUAA4IBAQAcCK9Sfoae8T+Sw7xY5ZMUAt55IO8Ldq61J+V8+Q49vgXb7/m379DC
+  FZhia4pj4n1g//M0nHm2/yQblXK7qwkYpGB3uEK5yedaY5fCGZlRe67rcPJ4No1x
+  tHpBaYknGBP3ITEt1Btw5HhPpccirBk8cBIP9vEN/k9yNn9jpVRRBLXiXaKusDRy
+  NccuJexQuG86gK8tnQh1kN2t+MA5UkDeHWsysJrEsT1/p6UChw60MhlQ2gFTrIvu
+  EBm0ICzl7th3TQgzeiWbMUiUx7k5B+Oi/btCNjCIGkpWyWC+nL1SweWtOFGQGuGm
+  UX363H4LFf3sXXUY2b+Nf5+zMlVQADoL
+  -----END CERTIFICATE-----
+
+date: 2014-04-09 00:00:00 Z
+dependencies: []
+
+description: Simulate java interfaces in ruby to enforce public class implementation
+email: dev.michael.rojas@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/jinterface.rb
+- lib/jinterface/arg_range.rb
+- lib/jinterface/interface_class_methods.rb
+homepage: https://github.com/havelessbemore/JInterface
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: JInterface
+test_files: []
+