design_by_contract 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2848a2d974ba0719cfde67f1869c159823ef7a5c
-  data.tar.gz: b09db1b0e27ffaa7fad9fa0367af71b7563cb69f
+  metadata.gz: 1e4752cf5928c7732b9687ce87e0bfa87fa6ac8d
+  data.tar.gz: 5a40db6dfc4a45d6e2128061acdf57f403d07d05
 SHA512:
-  metadata.gz: ae579964b09e3f8e096924837277a4c54a40c1896fabce5187402a70a7931ac04560b6f0e575354af5b892eb0c73a9ed8b70f05ea5ca3f597756071ed6cd4b04
-  data.tar.gz: 31ba66b25fda22e573e3358bd384174d7415428128b7e32a64c9c686b65f3617652097a2d44512b17eef472dcfbe8ce88b4ee9a28d8ad976bd35ae351618e12c
+  metadata.gz: ba4dd8a67eecfc5e034402091cc29fe502f363e9a00cd7f724227f34d3dd4460e9ade3e58105f1d17e90fff61f99d36ed00948b9b7d6ec185e2e9bc9be4a6cfa
+  data.tar.gz: a0ab745b6ac09a0aafb17c2c208f1cbf2ec3b1e0f7a6acc956b10e3675195f156dbe821423455f8d4630e2316cf0a6c29877194f243a45087cf7956fb7e77dde

data/README.md

@@ -20,23 +20,100 @@ Or install it yourself as:
 
 ## Usage
 
-### Interface
+### Design pattern fulfilling methods
 
-The most basic simple usecase for interface is to use it for simply validate a class
+This are created to increase productivity and, make test fail fast in order to eliminate unwanted hiccup
 
-```ruby
+#### Dependency Injection Pattern
+
+interfaces in dependency injection contract placed as last element in the argument description array.
+For key or keyreq arguments, it is required to specify the keyword as second parameter for argument description element.
 
-i = DesignByContract::Interface.new test: [:req, :opt, %i[keyreq keyword] ]
+```ruby
 
+require 'logger'
 class T
+
+  StoreInterface = DesignByContract::Interface.new(create: [:req, :req], read: [:req])
+
+  def initialize(store, logger: Logger.new(STDOUT))
+  end
+end
+
+DesignByContract.as_dependency_injection_for T, [
+    [:req, StoreInterface], # pass as predefined interfaces
+    [:key, :logger, {info: [:req, :block]}] # or as raw hash based signature
+]
+
+```
+
+### Under the Hood components
+
+#### Signature
+
+Signatures are the fingerprint of a function.
+It can describe how the method should look.
+This normally just part of the convention methods under the hood.
+
+
+```ruby
+
+s = DesignByContract::Signature.new [:req, :opt, %i[keyreq keyword] ]
+
+def test(value, value_with_default="def", keyword:)
+end
+
+s.match?(method(:test)) #=> true
+
+```
+
+#### Interface
+
+The most basic simple use case for interface is to use it for simply validate a class.
+Other than that it's also just only the part of the convention methods under the hood.
+
+```ruby
+
+i = DesignByContract::Interface.new test: [:req, %i[keyreq keyword] ]
+
+class Good1
   def test(value, value_with_default="def", keyword:)
   end
 end
 
-i.implemented_by?(T) #=> true
-i.implemented_by?(Class) #=> false
+class Good2
+  def test(value, keyword:)
+  end
+end
+
+class Good3
+  def test(value="with_def_still_ok_for_req", keyword:)
+  end
+end
+
+class Bad
+  def test(value1, value2, keyword:)
+  end
+end
+
+i.implemented_by?(Good1) #=> true
+i.fulfilled_by?(Good1.new) #=> true
+i.match?(Good1.new.method(:test)) #=> true
+
+i.implemented_by?(Good2) #=> true
+i.fulfilled_by?(Good2.new) #=> true
+i.match?(Good2.new.method(:test)) #=> true
+
+i.implemented_by?(Good3) #=> true
+i.fulfilled_by?(Good3.new) #=> true
+i.match?(Good3.new.method(:test)) #=> true
+
+i.implemented_by?(Bad) #=> false
+i.fulfilled_by?(Bad.new) #=> false
+i.match?(Bad.new.method(:test)) #=> false
 
 ```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/design_by_contract. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/design_by_contract.rb

@@ -1,3 +1,41 @@
 module DesignByContract
+  extend(self)
+
   autoload :Interface, 'design_by_contract/interface'
+  autoload :Pattern, 'design_by_contract/pattern'
+  autoload :Signature, 'design_by_contract/signature'
+
+  def forget_contract_specifications!
+    contracts.keys.each(&:down)
+    contracts.clear
+    nil
+  end
+
+  def enable_defensive_contract
+    @defensive_contract = true
+    fulfill_contracts!
+  end
+
+  def as_dependency_injection_for(klass, initialize_signature_spec)
+    register_contract DesignByContract::Pattern::DependencyInjection.new(klass, initialize_signature_spec)
+  end
+
+  private
+
+  def contracts
+    @__contracts__ ||= {}
+  end
+
+  def register_contract(contract)
+    contracts[contract] = :inactive
+    fulfill_contracts! if @defensive_contract
+  end
+
+  def fulfill_contracts!
+    contracts.each do |contract, state|
+      next if state == :active
+      contract.up
+      contracts[contract] = :active
+    end
+  end
 end

data/lib/design_by_contract/interface.rb

@@ -1,80 +1,49 @@
 class DesignByContract::Interface
-  REQUIRED_ARGUMENT = :req
-  OPTIONAL_ARGUMENT = :opt
-  REST_OF_THE_ARGUMENTS = :rest
-
-  REQUIRED_KEYWORD = :keyreq
-  OPTIONAL_KEYWORD = :key
-  AFTER_KEYWORD_ARGUMENTS = :keyrest
-
   def initialize(method_specifications)
-    @method_specifications = method_specifications
+    @method_specifications = method_specifications.reduce({}) do |ms, (name, raw_signature)|
+      ms.merge(name => DesignByContract::Signature.new(raw_signature))
+    end
   end
 
   def implemented_by?(implementator_class)
     @method_specifications.each do |name, signature|
       return false unless implementator_class.method_defined?(name)
-      return false unless signature_match?(implementator_class, name, signature)
+      return false unless signature.match?(implementator_class.instance_method(name))
     end
     true
   end
 
-  private
-
-  def signature_match?(klass, name, signature)
-    parameters = klass.instance_method(name).parameters
-
-    return false unless req_match?(parameters, signature)
-    return false unless opt_match?(parameters, signature)
-    return false unless rest_match?(parameters, signature)
-    return false unless keyreq_match?(parameters, signature)
-    return false unless key_match?(parameters, signature)
-    return false unless keyrest_match?(parameters, signature)
-
+  def fulfilled_by?(object)
+    @method_specifications.each do |name, signature|
+      return false unless object.respond_to?(name)
+      return false unless signature.match?(object.method(name))
+    end
     true
   end
 
-  def keyrest_match?(parameters, signature)
-    return true unless signature.include?(:keyrest)
+  def match?(method)
+    signature = @method_specifications[method.original_name]
 
-    parameters.any? { |k, _| k == :keyrest }
+    signature.match?(method)
   end
 
-  def key_match?(parameters, signature)
-    optional_keys = signature.select { |k| k.is_a?(Array) && k[0] == :key }.map(&:last)
-    return true if optional_keys.empty?
-    actual_keys = parameters.select { |k, _| k == :key }.map(&:last)
-    (optional_keys - actual_keys).empty?
-  end
+  def ==(oth_interface)
+    return false unless @method_specifications.length == oth_interface.method_specifications.length
 
-  def keyreq_match?(parameters, signature)
-    expected_keys = signature.select { |k| k.is_a?(Array) && k[0] == :keyreq }.sort
-    return true if expected_keys.empty?
-    actual_keys = parameters.select { |k, _| k == :keyreq }.sort
-    expected_keys == actual_keys
-  end
+    @method_specifications.each do |name, spec|
+      return false unless oth_interface.method_specifications[name] && oth_interface.method_specifications[name] == spec
+    end
 
-  def req_match?(parameters, signature)
-    expected, actually = arg_counts_for(parameters, signature, :req)
-    return true if expected == 0
-    expected == actually
+    return true
   end
 
-  def opt_match?(parameters, signature)
-    expected, actually = arg_counts_for(parameters, signature, :opt)
-    return true if expected == 0
-    expected <= actually
+  def raw
+    @method_specifications.reduce({}) do |hash, (k,v)|
+      hash.merge(k => v.raw)
+    end
   end
 
-  def rest_match?(parameters, signature)
-    return true unless signature.include?(:rest)
+  protected
 
-    parameters.any? { |k, _| k == :rest }
-  end
-
-  def arg_counts_for(parameters, signature, type)
-    expected_req_count = signature.select { |v| v == type }.length
-    actual_req_count = parameters.map(&:first).select { |v| v == type }.length
-    [expected_req_count, actual_req_count]
-  end
+  attr_reader :method_specifications
 end

data/lib/design_by_contract/pattern.rb

@@ -0,0 +1,3 @@
+module DesignByContract::Pattern
+    autoload :DependencyInjection, 'design_by_contract/pattern/dependency_injection'
+end

data/lib/design_by_contract/pattern/dependency_injection.rb

@@ -0,0 +1,48 @@
+class DesignByContract::Pattern::DependencyInjection
+  def initialize(target_class, initialize_signature_spec)
+    @target_class = target_class
+    @signature = DesignByContract::Signature.new(initialize_signature_spec)
+    @teardowns = []
+  end
+
+  def up
+    validate_initialize_method_signature
+    add_on_call_validation_hook
+  end
+
+  def down
+    @teardowns.each(&:call)
+    @teardowns.clear
+  end
+
+  private
+
+  def add_on_call_validation_hook
+    initialize_checker = Module.new
+    signature = @signature
+
+    initialize_checker.module_eval do
+      define_method(:initialize) do |*args|
+        raise(ArgumentError, 'argument signature missmatch') unless signature.valid?(*args)
+
+        super(*args) if defined?(super)
+      end
+    end
+
+    @target_class.__send__(:prepend, initialize_checker)
+    @teardowns << lambda{ initialize_checker.__send__(:remove_method, :initialize) }
+  end
+
+  # TODO: signature inspect
+  def validate_initialize_method_signature
+    unless @signature.match?(@target_class.instance_method(:initialize))
+      raise(NotImplementedError, ':initialize method signature mismatch')
+    end
+  rescue NameError
+    unless @signature.empty?
+      error_message = ":initialize method is not implemented, but contract requires one for #{@target_class}"
+
+      raise(NotImplementedError, error_message)
+    end
+  end
+end

data/lib/design_by_contract/signature.rb

@@ -0,0 +1,100 @@
+class DesignByContract::Signature
+  autoload :Spec, 'design_by_contract/signature/spec'
+
+  def initialize(raw_method_specs)
+    @method_args_specs = raw_method_specs.map do |spec|
+      DesignByContract::Signature::Spec.new(spec)
+    end
+  end
+
+  def valid?(*args)
+    method_args_specs.each_with_index do |spec, index|
+      return false unless spec.interface.fulfilled_by?(args[index])
+    end
+    return true
+  end
+
+  def match?(parametered_object)
+    parameters_match?(parametered_object.parameters)
+  end
+
+  def ==(oth_signature)
+    return false unless method_args_specs.length == oth_signature.method_args_specs.length
+
+    method_args_specs.each_with_index do |spec, index|
+      return false unless spec == oth_signature.method_args_specs[index]
+    end
+
+    true
+  end
+
+  def empty?
+    method_args_specs.empty?
+  end
+
+  def raw
+    @method_args_specs.map(&:raw)
+  end
+
+  protected
+
+  attr_reader :method_args_specs
+
+  private
+
+  def parameters_match?(parameters)
+    req_match?(parameters) &&
+      opt_match?(parameters) &&
+      rest_match?(parameters) &&
+      keyreq_match?(parameters) &&
+      key_match?(parameters) &&
+      keyrest_match?(parameters)
+  end
+
+  def keyrest_match?(parameters)
+    return true unless @method_args_specs.any? { |s| s.type == :keyrest }
+
+    parameters.any? { |k, _| k == :keyrest }
+  end
+
+  def key_match?(parameters)
+    optional_keywords = method_args_specs.select { |s| s.type == :key }.map(&:keyword)
+
+    return true if optional_keywords.empty?
+    actual_keys = parameters.select { |k, _| k == :key }.map { |arg_spec| arg_spec[1] }
+    (optional_keywords - actual_keys).empty?
+  end
+
+  def keyreq_match?(parameters)
+    expected_keys = method_args_specs.select { |s| s.type == :keyreq }.map { |s| [s.type, s.keyword] }.sort
+
+    return true if expected_keys.empty?
+    actual_keys = parameters.select { |k, _| k == :keyreq }.sort
+    expected_keys == actual_keys
+  end
+
+  def req_match?(parameters)
+    expected_req, actually_req = arg_counts_for(parameters, :req)
+    expected_opt, actually_opt = arg_counts_for(parameters, :opt)
+    return true if expected_req.zero?
+    expected_req <= actually_req + actually_opt && actually_req <= expected_req
+  end
+
+  def opt_match?(parameters)
+    expected, actually = arg_counts_for(parameters, :opt)
+    return true if expected.zero?
+    expected <= actually
+  end
+
+  def rest_match?(parameters)
+    return true unless method_args_specs.any? { |s| s.type == :rest }
+
+    parameters.any? { |k, _| k == :rest }
+  end
+
+  def arg_counts_for(parameters, type)
+    expected_req_count = method_args_specs.select { |s| s.type == type }.length
+    actual_req_count = parameters.map(&:first).select { |v| v == type }.length
+    [expected_req_count, actual_req_count]
+  end
+end

data/lib/design_by_contract/signature/spec.rb

@@ -0,0 +1,69 @@
+class DesignByContract::Signature::Spec
+  attr_reader :type, :keyword, :interface
+
+  def initialize(method_args_spec)
+    @type, @keyword, @interface = format(method_args_spec)
+  end
+
+  def ==(oth_spec)
+    type == oth_spec.type &&
+      keyword == oth_spec.keyword &&
+      interface == oth_spec.interface
+  end
+
+  def raw
+    [type, keyword, interface.raw]
+  end
+
+  private
+
+  def format(spec)
+    spec = [spec] if spec.is_a?(::Symbol)
+    raise(ArgumentError) unless spec.is_a?(::Array)
+
+    case spec.length
+    when 1
+      return parse_type(spec[0]), nil, parse_interface(nil)
+    when 2
+      return parse_type(spec[0]), parse_keyword(spec[1]), parse_interface(spec[1])
+    when 3
+      return parse_type(spec[0]), parse_keyword(spec[1]), parse_interface(spec[2])
+    else
+      raise(NotImplementedError)
+    end
+  end
+
+  ACCEPTED_TYPES = %i[req opt rest keyreq key keyreq keyrest block].freeze
+
+  def parse_type(object)
+    unless ACCEPTED_TYPES.include?(object)
+      raise(ArgumentError, 'only the following types are accepted: ' + ACCEPTED_TYPES.join(', '))
+    end
+
+    object
+  end
+
+  def parse_keyword(object)
+    case object
+    when ::Symbol, ::NilClass
+      return object
+    when ::Hash, DesignByContract::Interface
+      return nil
+    else
+      raise(ArgumentError, 'keyword can only be symbol')
+    end
+  end
+
+  def parse_interface(object)
+    case object
+    when DesignByContract::Interface
+      object
+    when ::Hash
+      DesignByContract::Interface.new(object)
+    when ::NilClass, ::Symbol
+      DesignByContract::Interface.new({})
+    else
+      raise(ArgumentError, 'interface can only be hash or interface type')
+    end
+  end
+end

data/spike/super_method.rb

@@ -0,0 +1,35 @@
+module T
+  def t
+    puts 'T'
+    super
+ end
+end
+
+class Z
+  def t
+    puts 'Z'
+ end
+end
+
+p Z.instance_method(:t).source_location
+Z.prepend(T)
+p Z.instance_method(:t).source_location
+p Z.instance_method(:t).super_method
+
+Z.new.t
+
+p Z.instance_method(:t).source_location
+
+class M
+  def initialize(i_am_just_an_illusion); end
+
+  def method1(what_the_fuck); end
+end
+
+p M.method_defined?(:initialize) #=> false
+p M.method_defined?(:method1) #=> true
+
+# method_defined?
+# Returns true if the named method is defined by mod
+# (or its included modules and, if mod is a class, its ancestors).
+# Public and protected methods are matched.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: design_by_contract
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-21 00:00:00.000000000 Z
+date: 2017-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,6 +73,11 @@ files:
 - design_by_contract.gemspec
 - lib/design_by_contract.rb
 - lib/design_by_contract/interface.rb
+- lib/design_by_contract/pattern.rb
+- lib/design_by_contract/pattern/dependency_injection.rb
+- lib/design_by_contract/signature.rb
+- lib/design_by_contract/signature/spec.rb
+- spike/super_method.rb
 homepage: https://github.com/adamluzsi/design_by_contract.rb
 licenses:
 - MIT