contraction 0.1.1 → 0.1.2

data/lib/contract.rb

@@ -0,0 +1,39 @@
+module Contraction
+  private
+
+  class Contract
+    attr_accessor :type, :name, :message, :contract
+    def initialize(args={})
+      @type = args[:type]
+      @name = args[:name]
+      @message = args[:message]
+      @contract = args[:contract] || ''
+
+      create_checkers!
+    end
+
+    def check!(value, named_args)
+      @type_checker.call(value, named_args) if @type_checker
+      if @contract_checker
+        raise ArgumentError.new(contract_message(value)) unless @contract_checker.call(value, named_args)
+      end
+    end
+
+    private
+
+    def create_checkers!
+      if type
+        @type_checker = lambda { |value, named_args| raise ArgumentError.new(type_message(value)) unless value.is_a?(type) }
+      end
+      @contract_checker = eval("lambda { |result, named_args| #{contract} }") unless contract == ''
+    end
+
+    def type_message(value)
+      "#{name} (#{value.inspect}) must be a #{type}"
+    end
+
+    def contract_message(value)
+      "#{name} (#{message}) must fullfill #{contract.inspect}, but is #{value.inspect}"
+    end
+  end
+end

data/lib/contraction.rb

@@ -1,92 +1,102 @@
 require 'string'
+require 'contract'
 module Contraction
-  def self.included(mod)
+  def self.patch_instance_method(mod, method_name)
     instance = mod.allocate
-    instance_methods = (mod.instance_methods - Object.instance_methods - Contraction.instance_methods)
+    args, returns = parse_comments(instance.method(method_name).source_location)
 
-    file_contents_by_filename = {}
-    instance_methods.each do |method_name|
-      file, line = instance.method(method_name).source_location
-      filename = File.expand_path(file)
-      file_contents = file_contents_by_filename[filename] || File.read(filename).split("\n")
-      file_contents_by_filename ||= file_contents
-
-      args    = []
-      returns = [Object, '', 'true']
-      file_contents[0..line-2].reverse.each do |line|
-        line = line.strip
-        next if line == ''
-        break unless line.start_with?('#')
-        break if line.start_with?('##')
-
-        # if m = /^#\s*@return\s+(?<type>\[[^\]]+\])?\s*(?<message>[^{]+)?(\{(?<contract>[^}]+)\})?/.match(line)
-        if m = /^#\s*@return\s+(\[[^\]]+\])?\s*([^{]+)?(\{([^}]+)\})?/.match(line)
-          type = m[1].to_s.gsub(/(\[|\])/, '')
-          type = type == '' ? Object : type.constantize
-          contract = m[4].to_s.strip.gsub('return', "result")
-          contract = contract == '' ? 'true' : contract
-          returns = [type, m[2], contract]
-        # elsif m = /^#\s*@param\s+(?<type>\[[^\]]+\])?\s*(?<name>[^\s]+)\s+(?<message>[^{]+)?(\{(?<contract>[^}]+)\})?/.match(line)
-        elsif m = /^#\s*@param\s+(\[[^\]]+\])?\s*([^\s]+)\s+([^{]+)?(\{([^}]+)\})?/.match(line)
-          type = m[1].to_s.gsub(/(\[|\])/, '')
-          type = type == '' ? Object : type.constantize
-          contract = m[5].to_s.strip.gsub(m[2], "named_args[#{m[2].inspect}]")
-          contract = contract == '' ? 'true' : contract
-          args << [type, m[2], m[3], contract]
-        end
+    arg_names = args.map(&:name)
+    arg_names.each do |name|
+      returns.contract = returns.contract.gsub(name, "named_args[#{name.inspect}]")
+    end
+
+    old_method = mod.instance_method(method_name)
+
+    mod.send(:define_method, method_name) do |*method_args|
+      named_args = args.each_with_index.inject({}) do |h, (arg, index)|
+        h[arg.name] = method_args[index]
+        h
       end
-      args.reverse!
-      arg_names = args.map { |a| a[1] }
-      arg_names.each do |name|
-        returns[-1] = returns[-1].gsub(name, "named_args[#{name.inspect}]")
+
+      args.each { |arg| arg.check!(named_args[arg.name], named_args) }
+      result = old_method.bind(self).call(*method_args)
+      returns.check!(result, named_args)
+
+      result
+    end
+  end
+
+  def self.patch_class_method(mod, method_name)
+    args, returns = parse_comments(mod.method(method_name).source_location)
+    arg_names = args.map(&:name)
+    arg_names.each do |name|
+      returns.contract = returns.contract.gsub(name, "named_args[#{name.inspect}]")
+    end
+
+    old_method = mod.method(method_name)
+
+    arg_checks = []
+    result_check = nil
+    mod.define_singleton_method(method_name) do |*method_args|
+      named_args = args.each_with_index.inject({}) do |h, (arg, index)|
+        h[arg.name] = method_args[index]
+        h
       end
 
-      old_method = mod.instance_method(method_name)
-
-      arg_checks = []
-      result_check = nil
-      mod.send(:define_method, method_name) do |*method_args|
-        named_args = args.each_with_index.inject({}) do |h, (arg, index)|
-          type, name, message, contract = arg
-          h[name] = method_args[index]
-          h
-        end
-
-        b = binding
-        if arg_checks.empty?
-          arg_checks = args.map do |arg|
-            type, name, message, contract = arg
-            value = named_args[name]
-            checker = nil
-            lambda { |named_args|
-              raise ArgumentError.new("#{name} (#{value.inspect}) must be a #{type}") unless value.is_a?(type)
-              checker = eval("lambda { |named_args| #{contract} }", b) if checker.nil?
-              unless checker.call(named_args)
-                raise ArgumentError.new("#{name} (#{message}) must fullfill #{contract.inspect}, but is #{value.inspect}")
-              end
-            }
-          end
-        end
-        arg_checks.each { |c| c.call(named_args) }
-
-        result = old_method.bind(self).call(*method_args)
-
-        if result_check.nil?
-          checker = nil
-          result_check = lambda { |named_args|
-            type, message, contract = returns
-            raise ArgumentError.new("Return value of #{method_name} must be a #{type}") unless result.is_a?(type)
-            checker = eval("lambda { |named_args| #{contract} }", b) if checker.nil?
-            unless checker.call(named_args)
-              raise ArgumentError.new("Return value of #{method_name} (#{message}) must fullfill #{contract.inspect}, but is #{result.inspect}")
-            end
-          }
-        end
-        result_check.call(named_args)
-
-        result
+      args.each { |arg| arg.check!(named_args[arg.name], named_args) }
+      result = old_method.call(*method_args)
+      returns.check!(result, named_args)
+
+      result
+    end
+  end
+
+  def self.file_content(filename)
+    @file_contents ||= {}
+    @file_contents[filename] ||= File.read(filename)
+  end
+
+  def self.parse_comments(location)
+    file, line = location
+    filename = File.expand_path(file)
+
+    args    = []
+    returns = Contraction::Contract.new()
+    file_content(filename).split("\n")[0..line-2].reverse.each do |line|
+      line = line.strip
+      next if line == ''
+      break unless line.start_with?('#')
+      break if line.start_with?('##')
+
+      if m = /^#\s*@return\s+(\[[^\]]+\])?\s*([^{]+)?(\{([^}]+)\})?/.match(line)
+        type = m[1].to_s.gsub(/(\[|\])/, '')
+        type = type == '' ? Object : type.constantize
+        contract = m[4].to_s.strip.gsub('return', "result")
+        contract = contract == '' ? 'true' : contract
+        returns = Contraction::Contract.new(type: type, name: 'returns', message: m[2], contract: contract)
+      elsif m = /^#\s*@param\s+(\[[^\]]+\])?\s*([^\s]+)\s+([^{]+)?(\{([^}]+)\})?/.match(line)
+        type = m[1].to_s.gsub(/(\[|\])/, '')
+        type = type == '' ? Object : type.constantize
+        contract = m[5].to_s.strip.gsub(m[2], "named_args[#{m[2].inspect}]")
+        contract = contract == '' ? 'true' : contract
+        args << Contraction::Contract.new(type: type, name: m[2], message: m[3], contract: contract)
       end
     end
+    args.reverse!
+    return [args, returns]
+  end
+
+  def self.included(mod)
+    instance_methods = (mod.instance_methods - Object.instance_methods - Contraction.instance_methods)
+
+    instance_methods.each do |method_name|
+      patch_instance_method(mod, method_name)
+    end
+
+    class_methods = (mod.methods - Object.methods - Contraction.methods)
+    class_methods.each do |method_name|
+      patch_class_method(mod, method_name)
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: contraction
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-18 00:00:00.000000000 Z
+date: 2013-04-19 00:00:00.000000000 Z
 dependencies: []
 description: Using RDoc documentation as your contract definition, you get solid code,
   and good docs. Win-win!
@@ -21,6 +21,7 @@ extra_rdoc_files:
 files:
 - README.md
 - contraction.rb
+- lib/contract.rb
 - lib/contraction.rb
 - lib/string.rb
 homepage: https://github.com/thomasluce/contraction
@@ -37,7 +38,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3590968264039948476
+      hash: 2360464299481397474
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: