contraction 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 220fc1b815a36a3a46425136e5b786d63b2554fc
-  data.tar.gz: 7039c53c01ba20210aa97c7e256a4ab891c0c007
+  metadata.gz: d949e8e0f90ac9a867b0bc500c174af356f714e2
+  data.tar.gz: 7946c533f8690b04dfb4a6f41f0e50e12b8b6f89
 SHA512:
-  metadata.gz: a025c0cd5aff6fc22d6129dbf61b7d3bfff7038b662e215f944e42379fbfa457c742f1659f73985c12e89ae0440485e1dddc657f7574ec6133225edfad79db7a
-  data.tar.gz: dfb2ac55e0dc3784be7338a097a18889b4ba0e27d1d6f0d45ed7e2f33f51a88d16dc397a284d4ad141b8ba5586836beb0fcb8c62ea53289a75d93c0b681a862d
+  metadata.gz: 178ca20aa78e13a2bcb22906f40e93667fcffd29ddf0e13e362a894f38c0d2769269f5e8e203aceda27567148f08abe1c8f8d53efbbe687df2fa96e4b5dcba4f
+  data.tar.gz: c2fb6d2cba4457341109c9b6d96c244ceee9316f19137398a8ca645ef3f2fac218a35ef6214389dae97c4957a9beb8628e8a66ceda451a902605e17115b78d3b

data/lib/contract.rb

@@ -4,13 +4,13 @@ module Contraction
 
     # @params [Array<TypedLine>] rules The individual lines that define the
     # contract.
-    def initialize(rules, mod, method_name)
+    def initialize(rules, mod, method_name, type)
       @rules       = rules
       @mod         = mod
       @method_name = method_name
 
       update_rule_values
-      get_method_definition
+      get_method_definition(type)
     end
 
     # Test weather the arguments to a method are of the correct type, and meet
@@ -57,8 +57,13 @@ module Contraction
       @param_rules ||= @rules.select { |r| r.is_a?(Contraction::Parser::ParamLine) }
     end
 
-    def get_method_definition
-      @params = mod.instance_method(method_name).parameters.map(&:last)
+    def get_method_definition(type)
+      @params = []
+      if type == :class
+        @params = mod.method(method_name.to_sym).parameters.map(&:last)
+      else
+        @params = mod.instance_method(method_name.to_sym).parameters.map(&:last)
+      end
     end
 
     def update_rule_values

data/lib/contraction.rb

@@ -9,14 +9,14 @@ module Contraction
   # @param [Class] mod The module or class to update contracts for.
   def self.update_contracts(mod)
     instance = mod.allocate
-    instance_methods = (mod.instance_methods - Object.instance_methods - Contraction.instance_methods)
 
-    # FIXME: Deal with weather it is an instance or class method a bit nicer.
-    instance_methods.each do |method_name|
-      file_contents, line_no = read_file_for_method(instance, method_name)
+    methods_for(mod).each do |(type, methods)|
+      methods.each do |method_name|
+        file_contents, line_no = read_file_for_method(instance, method_name, type)
 
-      contract = Contraction::Parser.parse(file_contents[0..line_no-2].reverse, mod, method_name)
-      define_wrapped_method(mod, method_name, contract)
+        contract = Contraction::Parser.parse(file_contents[0..line_no-2].reverse, mod, method_name, type)
+        define_wrapped_method(mod, method_name, contract, type)
+      end
     end
   end
 
@@ -25,10 +25,44 @@ module Contraction
     update_contracts(mod)
   end
 
+  # Get all the public instance methods for a given class, that are unique to
+  # class (ie, not built-ins)
+  # @param [Class] klass The class to get the methods from
+  # @return [Array<Symbol>] The method names
   def self.instance_methods_for(klass)
     klass.public_instance_methods - Object.public_instance_methods - Module.public_instance_methods
   end
 
+  # Get all the public class methods for a given class that are unique to the
+  # class (ie, not built-ins). NOTE: doing something like the following _doesn't_
+  # make a class method private:
+  # class Foo
+  #     private
+  #     def self.foobar
+  #     end
+  # end
+  #
+  # That's because defining a method on an object, even `self`, re-opens the
+  # object to define the method on it. It's the same as saying `def
+  # some_object.foobar`, only in this case `some_object` is the handy-dandy
+  # `self`. To make that really private, you can do:
+  # class Foo
+  #     private
+  #     def self.foobar
+  #     end
+  #     private_class_method :foobar
+  # end
+  #
+  # ... or ...
+  # class Foo
+  #     private
+  #     class << self
+  #         def self.foobar
+  #         end
+  #     end
+  # end
+  # @param [Class] klass The class to get the methods from
+  # @return [Array<Symbol>] The method names
   def self.class_methods_for(klass)
     klass.public_methods - Object.public_methods - Module.public_methods
   end
@@ -39,21 +73,34 @@ module Contraction
 
   private
 
-  def self.read_file_for_method(instance, method_name)
-    file, line = instance.method(method_name).source_location
+  def self.read_file_for_method(instance, method_name, type)
+    file, line = nil, nil
+    if type == :class
+      file, line = instance.class.method(method_name).source_location
+    elsif type == :instance
+      file, line = instance.method(method_name).source_location
+    else
+      raise ArgumentError.new("Unknown method type, #{type.inspect}")
+    end
     filename = File.expand_path(file)
     file_contents = File.read(filename).split("\n")
     return [file_contents, line]
   end
 
-  def self.define_wrapped_method(mod, method_name, contract)
-    old_method = mod.instance_method(method_name)
+  def self.define_wrapped_method(mod, method_name, contract, type)
+    old_method = type == :instance ? mod.instance_method(method_name) : mod.method(method_name)
 
     arg_checks = []
     result_check = nil
-    mod.send(:define_method, method_name) do |*method_args|
+    type = type == :class ? :define_singleton_method : :define_method
+    mod.send(type, method_name) do |*method_args|
       contract.valid_args?(*method_args)
-      result = old_method.bind(self).call(*method_args)
+      result = nil
+      if old_method.respond_to?(:bind)
+        result = old_method.bind(self).call(*method_args)
+      else
+        result = old_method.call(*method_args)
+      end
       contract.valid_return?(*method_args, result)
       result
     end

data/lib/parser.rb

@@ -17,7 +17,7 @@ module Contraction
     # contracts/docs apply to
     # @return [Contract] A Contract object that can be used to evaluate
     # correctness at run-time.
-    def self.parse(text, mod, method_name)
+    def self.parse(text, mod, method_name, type)
       lines = text.is_a?(String) ? text.split(/$/) : text
       results = []
       lines.each do |line|
@@ -28,7 +28,7 @@ module Contraction
       end
       results.compact!
 
-      Contract.new(results, mod, method_name)
+      Contract.new(results, mod, method_name, type)
     end
 
     # Parse a single line of text for @param and @return statements.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: contraction
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Thomas Luce