entitlements 0.1.8 → 0.2.0

data/lib/contracts-ruby2/lib/contracts/method_handler.rb

@@ -0,0 +1,187 @@
+module Contracts
+  # Handles class and instance methods addition
+  # Represents single such method
+  class MethodHandler
+    METHOD_REFERENCE_FACTORY = {
+      :class_methods => SingletonMethodReference,
+      :instance_methods => MethodReference
+    }
+
+    RAW_METHOD_STRATEGY = {
+      :class_methods => lambda { |target, name| target.method(name) },
+      :instance_methods => lambda { |target, name| target.instance_method(name) }
+    }
+
+    # Creates new instance of MethodHandler
+    #
+    # @param [Symbol] method_name
+    # @param [Bool] is_class_method
+    # @param [Class] target - class that method got added to
+    def initialize(method_name, is_class_method, target)
+      @method_name = method_name
+      @is_class_method = is_class_method
+      @target = target
+    end
+
+    # Handles method addition
+    def handle
+      return unless engine?
+      return if decorators.empty?
+
+      validate_decorators!
+      validate_pattern_matching!
+
+      engine.add_method_decorator(method_type, method_name, decorator)
+      mark_pattern_matching_decorators
+      method_reference.make_alias(target)
+      redefine_method
+    end
+
+    private
+
+    attr_reader :method_name, :is_class_method, :target
+
+    def engine?
+      Engine.applied?(target)
+    end
+
+    def engine
+      Engine.fetch_from(target)
+    end
+
+    def decorators
+      @_decorators ||= engine.all_decorators
+    end
+
+    def method_type
+      @_method_type ||= is_class_method ? :class_methods : :instance_methods
+    end
+    # _method_type is required for assigning it to local variable with
+    # the same name. See: #redefine_method
+    alias_method :_method_type, :method_type
+
+    def method_reference
+      @_method_reference ||= METHOD_REFERENCE_FACTORY[method_type].new(method_name, raw_method)
+    end
+
+    def raw_method
+      RAW_METHOD_STRATEGY[method_type].call(target, method_name)
+    end
+
+    def ignore_decorators?
+      ENV["NO_CONTRACTS"] && !pattern_matching?
+    end
+
+    def decorated_methods
+      @_decorated_methods ||= engine.decorated_methods_for(method_type, method_name)
+    end
+
+    def pattern_matching?
+      return @_pattern_matching if defined?(@_pattern_matching)
+      @_pattern_matching = decorated_methods.any? { |x| x.method != method_reference }
+    end
+
+    def mark_pattern_matching_decorators
+      return unless pattern_matching?
+      decorated_methods.each(&:pattern_match!)
+    end
+
+    def decorator
+      @_decorator ||= decorator_class.new(target, method_reference, *decorator_args)
+    end
+
+    def decorator_class
+      decorators.first[0]
+    end
+
+    def decorator_args
+      decorators.first[1]
+    end
+
+    def redefine_method
+      return if ignore_decorators?
+
+      # Those are required for instance_eval to be able to refer them
+      name = method_name
+      method_type = _method_type
+      current_engine = engine
+
+      # We are gonna redefine original method here
+      method_reference.make_definition(target) do |*args, &blk|
+        engine = current_engine.nearest_decorated_ancestor
+
+        # If we weren't able to find any ancestor that has decorated methods
+        # FIXME : this looks like untested code (commenting it out doesn't make specs red)
+        unless engine
+          fail "Couldn't find decorator for method " + self.class.name + ":#{name}.\nDoes this method look correct to you? If you are using contracts from rspec, rspec wraps classes in it's own class.\nLook at the specs for contracts.ruby as an example of how to write contracts in this case."
+        end
+
+        # Fetch decorated methods out of the contracts engine
+        decorated_methods = engine.decorated_methods_for(method_type, name)
+
+        # This adds support for overloading methods. Here we go
+        # through each method and call it with the arguments.
+        # If we get a failure_exception, we move to the next
+        # function. Otherwise we return the result.
+        # If we run out of functions, we raise the last error, but
+        # convert it to_contract_error.
+
+        expected_error = decorated_methods[0].failure_exception
+        last_error = nil
+
+        decorated_methods.each do |decorated_method|
+          result = decorated_method.call_with_inner(true, self, *args, &blk)
+          return result unless result.is_a?(ParamContractError)
+          last_error = result
+        end
+
+        begin
+          if ::Contract.failure_callback(last_error.data, false)
+            decorated_methods.last.call_with_inner(false, self, *args, &blk)
+          end
+        rescue expected_error => final_error
+          raise final_error.to_contract_error
+        end
+      end
+    end
+
+    def validate_decorators!
+      return if decorators.size == 1
+
+      fail %{
+Oops, it looks like method '#{method_name}' has multiple contracts:
+#{decorators.map { |x| x[1][0].inspect }.join("\n")}
+
+Did you accidentally put more than one contract on a single function, like so?
+
+Contract String => String
+Contract Num => String
+def foo x
+end
+
+If you did NOT, then you have probably discovered a bug in this library.
+Please file it along with the relevant code at:
+https://github.com/egonSchiele/contracts.ruby/issues
+      }
+    end
+
+    def validate_pattern_matching!
+      new_args_contract = decorator.args_contracts
+      matched = decorated_methods.select do |contract|
+        contract.args_contracts == new_args_contract
+      end
+
+      return if matched.empty?
+
+      fail ContractError.new(%{
+It looks like you are trying to use pattern-matching, but
+multiple definitions for function '#{method_name}' have the same
+contract for input parameters:
+
+#{(matched + [decorator]).map(&:to_s).join("\n")}
+
+Each definition needs to have a different contract for the parameters.
+      }, {})
+    end
+  end
+end

data/lib/contracts-ruby2/lib/contracts/method_reference.rb

@@ -0,0 +1,100 @@
+module Contracts
+  # MethodReference represents original method reference that was
+  # decorated by contracts.ruby. Used for instance methods.
+  class MethodReference
+    attr_reader :name
+
+    # name - name of the method
+    # method - method object
+    def initialize(name, method)
+      @name = name
+      @method = method
+    end
+
+    # Returns method_position, delegates to Support.method_position
+    def method_position
+      Support.method_position(@method)
+    end
+
+    # Makes a method re-definition in proper way
+    def make_definition(this, &blk)
+      is_private = private?(this)
+      is_protected = protected?(this)
+      alias_target(this).send(:define_method, name, &blk)
+      make_private(this) if is_private
+      make_protected(this) if is_protected
+    end
+
+    # Aliases original method to a special unique name, which is known
+    # only to this class. Usually done right before re-defining the
+    # method.
+    def make_alias(this)
+      _aliased_name = aliased_name
+      original_name = name
+
+      alias_target(this).class_eval do
+        alias_method _aliased_name, original_name
+      end
+    end
+
+    # Calls original method on specified `this` argument with
+    # specified arguments `args` and block `&blk`.
+    def send_to(this, *args, &blk)
+      this.send(aliased_name, *args, &blk)
+    end
+
+    private
+
+    # Makes a method private
+    def make_private(this)
+      original_name = name
+      alias_target(this).class_eval { private original_name }
+    end
+
+    def private?(this)
+      this.private_instance_methods.map(&:to_sym).include?(name)
+    end
+
+    def protected?(this)
+      this.protected_instance_methods.map(&:to_sym).include?(name)
+    end
+
+    # Makes a method protected
+    def make_protected(this)
+      original_name = name
+      alias_target(this).class_eval { protected original_name }
+    end
+
+    # Returns alias target for instance methods, subject to be
+    # overriden in subclasses.
+    def alias_target(this)
+      this
+    end
+
+    def aliased_name
+      @_original_name ||= construct_unique_name
+    end
+
+    def construct_unique_name
+      :"__contracts_ruby_original_#{name}_#{Support.unique_id}"
+    end
+  end
+
+  # The same as MethodReference, but used for singleton methods.
+  class SingletonMethodReference < MethodReference
+    private
+
+    def private?(this)
+      this.private_methods.map(&:to_sym).include?(name)
+    end
+
+    def protected?(this)
+      this.protected_methods.map(&:to_sym).include?(name)
+    end
+
+    # Return alias target for singleton methods.
+    def alias_target(this)
+      Support.eigenclass_of this
+    end
+  end
+end

data/lib/contracts-ruby2/lib/contracts/support.rb

@@ -0,0 +1,61 @@
+module Contracts
+  module Support
+    class << self
+      def method_position(method)
+        return method.method_position if method.is_a?(MethodReference)
+
+        file, line = method.source_location
+        if file.nil? || line.nil?
+          ""
+        else
+          file + ":" + line.to_s
+        end
+      end
+
+      def method_name(method)
+        method.is_a?(Proc) ? "Proc" : method.name
+      end
+
+      # Generates unique id, which can be used as a part of identifier
+      #
+      # Example:
+      #    Contracts::Support.unique_id   # => "i53u6tiw5hbo"
+      def unique_id
+        # Consider using SecureRandom.hex here, and benchmark which one is better
+        (Time.now.to_f * 1000).to_i.to_s(36) + rand(1_000_000).to_s(36)
+      end
+
+      def contract_id(contract)
+        contract.object_id
+      end
+
+      def eigenclass_hierarchy_supported?
+        RUBY_PLATFORM != "java" || RUBY_VERSION.to_f >= 2.0
+      end
+
+      def eigenclass_of(target)
+        class << target; self; end
+      end
+
+      def eigenclass?(target)
+        module_eigenclass?(target) ||
+          target <= eigenclass_of(Object)
+      end
+
+      def indent_string(string, amount)
+        string.gsub(
+          /^(?!$)/,
+          (string[/^[ \t]/] || " ") * amount
+        )
+      end
+
+      private
+
+      # Module eigenclass can be detected by its ancestor chain
+      # containing a Module
+      def module_eigenclass?(target)
+        target < Module
+      end
+    end
+  end
+end

data/lib/contracts-ruby2/lib/contracts/validators.rb

@@ -0,0 +1,139 @@
+module Contracts
+  module Validators
+    DEFAULT_VALIDATOR_STRATEGIES = {
+      # e.g. lambda {true}
+      Proc => lambda { |contract| contract },
+
+      # e.g. [Num, String]
+      # TODO: account for these errors too
+      Array => lambda do |contract|
+        lambda do |arg|
+          return false unless arg.is_a?(Array) && arg.length == contract.length
+          arg.zip(contract).all? do |_arg, _contract|
+            Contract.valid?(_arg, _contract)
+          end
+        end
+      end,
+
+      # e.g. { :a => Num, :b => String }
+      Hash => lambda do |contract|
+        lambda do |arg|
+          return false unless arg.is_a?(Hash)
+          contract.keys.all? do |k|
+            Contract.valid?(arg[k], contract[k])
+          end
+        end
+      end,
+
+      Range => lambda do |contract|
+        lambda do |arg|
+          contract.include?(arg)
+        end
+      end,
+
+      Regexp => lambda do |contract|
+        lambda do |arg|
+          arg =~ contract
+        end
+      end,
+
+      Contracts::Args => lambda do |contract|
+        lambda do |arg|
+          Contract.valid?(arg, contract.contract)
+        end
+      end,
+
+      Contracts::Func => lambda do |_|
+        lambda do |arg|
+          arg.is_a?(Method) || arg.is_a?(Proc)
+        end
+      end,
+
+      :valid => lambda do |contract|
+        lambda { |arg| contract.valid?(arg) }
+      end,
+
+      :class => lambda do |contract|
+        lambda { |arg| arg.is_a?(contract) }
+      end,
+
+      :default => lambda do |contract|
+        lambda { |arg| contract == arg }
+      end
+    }.freeze
+
+    # Allows to override validator with custom one.
+    # Example:
+    #   Contract.override_validator(Array) do |contract|
+    #     lambda do |arg|
+    #       # .. implementation for Array contract ..
+    #     end
+    #   end
+    #
+    #   Contract.override_validator(:class) do |contract|
+    #     lambda do |arg|
+    #       arg.is_a?(contract) || arg.is_a?(RSpec::Mocks::Double)
+    #     end
+    #   end
+    def override_validator(name, &block)
+      validator_strategies[name] = block
+    end
+
+    # This is a little weird. For each contract
+    # we pre-make a proc to validate it so we
+    # don't have to go through this decision tree every time.
+    # Seems silly but it saves us a bunch of time (4.3sec vs 5.2sec)
+    def make_validator!(contract)
+      klass = contract.class
+      key = if validator_strategies.key?(klass)
+              klass
+            else
+              if contract.respond_to? :valid?
+                :valid
+              elsif klass == Class || klass == Module
+                :class
+              else
+                :default
+              end
+            end
+
+      validator_strategies[key].call(contract)
+    end
+
+    def make_validator(contract)
+      contract_id = Support.contract_id(contract)
+
+      if memoized_validators.key?(contract_id)
+        return memoized_validators[contract_id]
+      end
+
+      memoized_validators[contract_id] = make_validator!(contract)
+    end
+
+    # @private
+    def reset_validators
+      clean_memoized_validators
+      restore_validators
+    end
+
+    # @private
+    def validator_strategies
+      @_validator_strategies ||= restore_validators
+    end
+
+    # @private
+    def restore_validators
+      @_validator_strategies = DEFAULT_VALIDATOR_STRATEGIES.dup
+    end
+
+    # @private
+    def memoized_validators
+      @_memoized_validators ||= clean_memoized_validators
+    end
+
+    # @private
+    def clean_memoized_validators
+      @_memoized_validators = {}
+    end
+  end
+end

data/lib/contracts-ruby2/lib/contracts/version.rb

@@ -0,0 +1,3 @@
+module Contracts
+  VERSION = "0.16.1"
+end