contracts-lite 0.14.0

data/lib/contracts/call_with.rb

@@ -0,0 +1,97 @@
+module Contracts
+  module CallWith
+    def call_with(this, *args, &blk)
+      args << blk if blk
+
+      # Explicitly append blk=nil if nil != Proc contract violation anticipated
+      nil_block_appended = maybe_append_block!(args, blk)
+
+      # Explicitly append options={} if Hash contract is present
+      maybe_append_options!(args, blk)
+
+      # Loop forward validating the arguments up to the splat (if there is one)
+      (@args_contract_index || args.size).times do |i|
+        contract = args_contracts[i]
+        arg = args[i]
+        validator = @args_validators[i]
+
+        unless validator && validator[arg]
+          return unless Contract.failure_callback(:arg => arg,
+                                                  :contract => contract,
+                                                  :class => klass,
+                                                  :method => method,
+                                                  :contracts => self,
+                                                  :arg_pos => i+1,
+                                                  :total_args => args.size,
+                                                  :return_value => false)
+        end
+
+        if contract.is_a?(Contracts::Func)
+          args[i] = Contract.new(klass, arg, *contract.contracts)
+        end
+      end
+
+      # If there is a splat loop backwards to the lower index of the splat
+      # Once we hit the splat in this direction set its upper index
+      # Keep validating but use this upper index to get the splat validator.
+      if @args_contract_index
+        splat_upper_index = @args_contract_index
+        (args.size - @args_contract_index).times do |i|
+          arg = args[args.size - 1 - i]
+
+          if args_contracts[args_contracts.size - 1 - i].is_a?(Contracts::Args)
+            splat_upper_index = i
+          end
+
+          # Each arg after the spat is found must use the splat validator
+          j = i < splat_upper_index ? i : splat_upper_index
+          contract = args_contracts[args_contracts.size - 1 - j]
+          validator = @args_validators[args_contracts.size - 1 - j]
+
+          unless validator && validator[arg]
+            return unless Contract.failure_callback(:arg => arg,
+                                                    :contract => contract,
+                                                    :class => klass,
+                                                    :method => method,
+                                                    :contracts => self,
+                                                    :arg_pos => i-1,
+                                                    :total_args => args.size,
+                                                    :return_value => false)
+          end
+
+          if contract.is_a?(Contracts::Func)
+            args[args.size - 1 - i] = Contract.new(klass, arg, *contract.contracts)
+          end
+        end
+      end
+
+      # If we put the block into args for validating, restore the args
+      # OR if we added a fake nil at the end because a block wasn't passed in.
+      args.slice!(-1) if blk || nil_block_appended
+      result = if method.respond_to?(:call)
+                 # proc, block, lambda, etc
+                 method.call(*args, &blk)
+               else
+                 # original method name referrence
+                 method.send_to(this, *args, &blk)
+               end
+
+      unless @ret_validator[result]
+        Contract.failure_callback(:arg => result,
+                                  :contract => ret_contract,
+                                  :class => klass,
+                                  :method => method,
+                                  :contracts => self,
+                                  :return_value => true)
+      end
+
+      this.verify_invariants!(method) if this.respond_to?(:verify_invariants!)
+
+      if ret_contract.is_a?(Contracts::Func)
+        result = Contract.new(klass, result, *ret_contract.contracts)
+      end
+
+      result
+    end
+  end
+end

data/lib/contracts/core.rb

@@ -0,0 +1,52 @@
+module Contracts
+  module Core
+    def self.included(base)
+      common(base)
+    end
+
+    def self.extended(base)
+      common(base)
+    end
+
+    def self.common(base)
+      base.extend(MethodDecorators)
+
+      base.instance_eval do
+        def functype(funcname)
+          contracts = Engine.fetch_from(self).decorated_methods_for(:class_methods, funcname)
+          if contracts.nil?
+            "No contract for #{self}.#{funcname}"
+          else
+            "#{funcname} :: #{contracts[0]}"
+          end
+        end
+      end
+
+      # NOTE: Workaround for `defined?(super)` bug in ruby 1.9.2
+      # source: http://stackoverflow.com/a/11181685
+      # bug: https://bugs.ruby-lang.org/issues/6644
+      base.class_eval <<-RUBY
+        # TODO: deprecate
+        # Required when contracts are included in global scope
+        def Contract(*args)
+          if defined?(super)
+            super
+          else
+            self.class.Contract(*args)
+          end
+        end
+      RUBY
+
+      base.class_eval do
+        def functype(funcname)
+          contracts = Engine.fetch_from(self.class).decorated_methods_for(:instance_methods, funcname)
+          if contracts.nil?
+            "No contract for #{self.class}.#{funcname}"
+          else
+            "#{funcname} :: #{contracts[0]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contracts/decorators.rb

@@ -0,0 +1,47 @@
+module Contracts
+  module MethodDecorators
+    def self.extended(klass)
+      Engine.apply(klass)
+    end
+
+    def inherited(subclass)
+      Engine.fetch_from(subclass).set_eigenclass_owner
+      super
+    end
+
+    def method_added(name)
+      MethodHandler.new(name, false, self).handle
+      super
+    end
+
+    def singleton_method_added(name)
+      MethodHandler.new(name, true, self).handle
+      super
+    end
+  end
+
+  class Decorator
+    # an attr_accessor for a class variable:
+    class << self; attr_accessor :decorators; end
+
+    def self.inherited(klass)
+      name = klass.name.gsub(/^./) { |m| m.downcase }
+
+      return if name =~ /^[^A-Za-z_]/ || name =~ /[^0-9A-Za-z_]/
+
+      # the file and line parameters set the text for error messages
+      # make a new method that is the name of your decorator.
+      # that method accepts random args and a block.
+      # inside, `decorate` is called with those params.
+      MethodDecorators.module_eval <<-ruby_eval, __FILE__, __LINE__ + 1
+        def #{klass}(*args, &blk)
+          ::Contracts::Engine.fetch_from(self).decorate(#{klass}, *args, &blk)
+        end
+      ruby_eval
+    end
+
+    def initialize(klass, method)
+      @method = method
+    end
+  end
+end

data/lib/contracts/engine.rb

@@ -0,0 +1,26 @@
+require "contracts/engine/base"
+require "contracts/engine/target"
+require "contracts/engine/eigenclass"
+
+require "forwardable"
+
+module Contracts
+  # Engine facade, normally you shouldn't refer internals of Engine
+  # module directly.
+  module Engine
+    class << self
+      extend Forwardable
+
+      # .apply(klass)      - enables contracts engine on klass
+      # .applied?(klass)   - returns true if klass has contracts engine
+      # .fetch_from(klass) - returns contracts engine for klass
+      def_delegators :base_engine, :apply, :applied?, :fetch_from
+
+      private
+
+      def base_engine
+        Base
+      end
+    end
+  end
+end

data/lib/contracts/engine/base.rb

@@ -0,0 +1,136 @@
+module Contracts
+  module Engine
+    # Contracts engine
+    class Base
+      # Enable contracts engine for klass
+      #
+      # @param [Class] klass - target class
+      def self.apply(klass)
+        Engine::Target.new(klass).apply
+      end
+
+      # Returns true if klass has contracts engine
+      #
+      # @param [Class] klass - target class
+      # @return [Bool]
+      def self.applied?(klass)
+        Engine::Target.new(klass).applied?
+      end
+
+      # Fetches contracts engine out of klass
+      #
+      # @param [Class] klass - target class
+      # @return [Engine::Base or Engine::Eigenclass]
+      def self.fetch_from(klass)
+        Engine::Target.new(klass).engine
+      end
+
+      # Creates new instance of contracts engine
+      #
+      # @param [Class] klass - class that owns this engine
+      def initialize(klass)
+        @klass = klass
+      end
+
+      # Adds provided decorator to the engine
+      # It validates that decorator can be added to this engine at the
+      # moment
+      #
+      # @param [Decorator:Class] decorator_class
+      # @param args - arguments for decorator
+      def decorate(decorator_class, *args)
+        validate!
+        decorators << [decorator_class, args]
+      end
+
+      # Sets eigenclass' owner to klass
+      def set_eigenclass_owner
+        eigenclass_engine.owner_class = klass
+      end
+
+      # Fetches all accumulated decorators (both this engine and
+      # corresponding eigenclass' engine)
+      # It clears all accumulated decorators
+      #
+      # @return [ArrayOf[Decorator]]
+      def all_decorators
+        pop_decorators + eigenclass_engine.all_decorators
+      end
+
+      # Fetches decorators of specified type for method with name
+      #
+      # @param [Or[:class_methods, :instance_methods]] type - method type
+      # @param [Symbol] name - method name
+      # @return [ArrayOf[Decorator]]
+      def decorated_methods_for(type, name)
+        Array(decorated_methods[type][name])
+      end
+
+      # Returns true if there are any decorated methods
+      #
+      # @return [Bool]
+      def decorated_methods?
+        !decorated_methods[:class_methods].empty? ||
+          !decorated_methods[:instance_methods].empty?
+      end
+
+      # Adds method decorator
+      #
+      # @param [Or[:class_methods, :instance_methods]] type - method type
+      # @param [Symbol] name - method name
+      # @param [Decorator] decorator - method decorator
+      def add_method_decorator(type, name, decorator)
+        decorated_methods[type][name] ||= []
+        decorated_methods[type][name] << decorator
+      end
+
+      # Returns nearest ancestor's engine that has decorated methods
+      #
+      # @return [Engine::Base or Engine::Eigenclass]
+      def nearest_decorated_ancestor
+        current = klass
+        current_engine = self
+        ancestors = current.ancestors[1..-1]
+
+        while current && current_engine && !current_engine.decorated_methods?
+          current = ancestors.shift
+          current_engine = Engine.fetch_from(current)
+        end
+
+        current_engine
+      end
+
+      private
+
+      attr_reader :klass
+
+      def decorated_methods
+        @_decorated_methods ||= { :class_methods => {}, :instance_methods => {} }
+      end
+
+      # No-op because it is safe to add decorators to normal classes
+      def validate!
+      end
+
+      def pop_decorators
+        decorators.tap { clear_decorators }
+      end
+
+      def eigenclass
+        Support.eigenclass_of(klass)
+      end
+
+      def eigenclass_engine
+        Eigenclass.lift(eigenclass, klass)
+      end
+
+      def decorators
+        @_decorators ||= []
+      end
+
+      def clear_decorators
+        @_decorators = []
+      end
+    end
+  end
+end

data/lib/contracts/engine/eigenclass.rb

@@ -0,0 +1,50 @@
+module Contracts
+  module Engine
+    # Special case of contracts engine for eigenclasses
+    # We don't care about eigenclass of eigenclass at this point
+    class Eigenclass < Base
+      # Class that owns this eigenclass
+      attr_accessor :owner_class
+
+      # Automatically enables eigenclass engine if it is not
+      # Returns its engine
+      # NOTE: Required by jruby in 1.9 mode. Otherwise inherited
+      # eigenclasses don't have their engines
+      #
+      # @param [Class] eigenclass - class in question
+      # @param [Class] owner - owner of eigenclass
+      # @return [Engine::Eigenclass]
+      def self.lift(eigenclass, owner)
+        return Engine.fetch_from(eigenclass) if Engine.applied?(eigenclass)
+
+        Target.new(eigenclass).apply(Eigenclass)
+        eigenclass.extend(MethodDecorators)
+        # FIXME; this should detect what user uses `include Contracts` or
+        # `include Contracts;;Core`
+        eigenclass.send(:include, Contracts)
+        Engine.fetch_from(owner).set_eigenclass_owner
+        Engine.fetch_from(eigenclass)
+      end
+
+      # No-op for eigenclasses
+      def set_eigenclass_owner
+      end
+
+      # Fetches just eigenclasses decorators
+      def all_decorators
+        pop_decorators
+      end
+
+      private
+
+      # Fails when contracts are not included in owner class
+      def validate!
+        fail ContractsNotIncluded unless owner?
+      end
+
+      def owner?
+        !!owner_class
+      end
+    end
+  end
+end

data/lib/contracts/engine/target.rb

@@ -0,0 +1,70 @@
+module Contracts
+  module Engine
+    # Represents class in question
+    class Target
+      # Creates new instance of Target
+      #
+      # @param [Class] target - class in question
+      def initialize(target)
+        @target = target
+      end
+
+      # Enable contracts engine for target
+      # - it is no-op if contracts engine is already enabled
+      # - it automatically enables contracts engine for its eigenclass
+      # - it sets owner class to target for its eigenclass
+      #
+      # @param [Engine::Base:Class] engine_class - type of engine to
+      #   enable (Base or Eigenclass)
+      def apply(engine_class = Base)
+        return if applied?
+
+        apply_to_eigenclass
+
+        eigenclass.class_eval do
+          define_method(:__contracts_engine) do
+            @__contracts_engine ||= engine_class.new(self)
+          end
+        end
+
+        engine.set_eigenclass_owner
+      end
+
+      # Returns true if target has contracts engine already
+      #
+      # @return [Bool]
+      def applied?
+        target.respond_to?(:__contracts_engine)
+      end
+
+      # Returns contracts engine of target
+      #
+      # @return [Engine::Base or Engine::Eigenclass]
+      def engine
+        applied? && target.__contracts_engine
+      end
+
+      private
+
+      attr_reader :target
+
+      def apply_to_eigenclass
+        return unless meaningless_eigenclass?
+
+        self.class.new(eigenclass).apply(Eigenclass)
+        eigenclass.extend(MethodDecorators)
+        # FIXME; this should detect what user uses `include Contracts` or
+        # `include Contracts;;Core`
+        eigenclass.send(:include, Contracts)
+      end
+
+      def eigenclass
+        Support.eigenclass_of(target)
+      end
+
+      def meaningless_eigenclass?
+        !Support.eigenclass?(target)
+      end
+    end
+  end
+end