entity_schema 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb6af17a67827a528cf8e5ed2bd486bec9454cfb615e0165fbb324391b9edebb
-  data.tar.gz: a09a8843994a3417b06fc484b78d90266b9354e5853b32ec48cf7bdeda3f3fad
+  metadata.gz: 5c8d4ea3758bc4fc8c7b1d77707e8fa4dbb1b109d3d7c1e4222e6f8b2033e49a
+  data.tar.gz: c1391072f91aebc7c6b9bf928e1d068066333603fc99a81529700cf1ba3c3b23
 SHA512:
-  metadata.gz: 981e2337ac115f3bf97f734a5f42fdcdbb0cf1bd217f195db591e9fa79009a06fe9d9b73d8c0f59778a5729d324efaf619584a45e0e4ed609ecdd8f4c0942638
-  data.tar.gz: 1b46da351f08c9208fa4c023c5c01a9f619713cc720e2b71c42c80f22a738329798874750cd970a8606a4be518eaccfd83d909ba2f4ad843f72f98dc18344d19
+  metadata.gz: b1c215d77421ee842d7ff67a02d4f6f96bde80f337925796d3fd50e06815bb53c8577b7adc8ca27c96d9b00d7420efcadcc308e5f5cd3080a47a9f0db3e58db7
+  data.tar.gz: 0d1aff21c0d460cf190ea7f54501dc894202546dbb8e934e85b862f40fed5134c56f521d9a743332f102a100fa196a9ae101781bbb3b2a06f16c6836f4b9c786

data/.rubocop.yml

@@ -13,37 +13,22 @@ Naming/ConstantName:
   Exclude:
     - 'lib/entity_schema.rb'
 
-Style/Documentation:
-  Exclude:
-    - 'lib/entity_schema.rb'
-
 Metrics/BlockLength:
   Exclude:
     - 'entity_schema.gemspec'
 
 Metrics/AbcSize:
   Exclude:
-    - 'lib/entity_schema/dsl_helper.rb'
-
-Metrics/CyclomaticComplexity:
-  Exclude:
-    - 'lib/entity_schema/dsl_helper.rb'
-
-Metrics/PerceivedComplexity:
-  Exclude:
-    - 'lib/entity_schema/dsl_helper.rb'
-
-Metrics/MethodLength:
-  Exclude:
-    - 'lib/entity_schema/dsl_helper.rb'
+    - 'lib/entity_schema/setup_field.rb'
 
 Style/Documentation:
   Exclude:
     - 'lib/entity_schema.rb'
     - 'lib/entity_schema/class_methods.rb'
-    - 'lib/entity_schema/dsl_helper.rb'
+    - 'lib/entity_schema/setup_field.rb'
     - 'lib/entity_schema/fields/abstract.rb'
     - 'lib/entity_schema/fields/builders/abstract.rb'
+    - 'lib/entity_schema/fields/builders/base.rb'
     - 'lib/entity_schema/fields/builders/belongs_to.rb'
     - 'lib/entity_schema/fields/builders/collection.rb'
     - 'lib/entity_schema/fields/builders/fk_belongs_to.rb'
@@ -54,3 +39,8 @@ Style/Documentation:
     - 'lib/entity_schema/fields/object.rb'
     - 'lib/entity_schema/fields/property.rb'
     - 'lib/entity_schema/instance_methods.rb'
+    - 'lib/entity_schema/fields/specifications/belongs_to.rb'
+    - 'lib/entity_schema/fields/specifications/common.rb'
+    - 'lib/entity_schema/fields/specifications/fk_belongs_to.rb'
+    - 'lib/entity_schema/fields/specifications/object.rb'
+    - 'lib/entity_schema/fields/specifications/property.rb'

data/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [0.1.4]
+### Improved
++ unknown options calling with `:[]`, `:[]=` now constrainted without additional check `raise if`
+
+### Refactored
++ mechanism of fields building: Builder separated to Contract and Specification
+
 ## [0.1.2]
 ### Added
 + added `.object serializer:` and `mapper:` options

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    entity_schema (0.1.2)
+    entity_schema (0.1.4)
 
 GEM
   remote: https://rubygems.org/

data/lib/entity_schema/class_methods.rb

@@ -3,7 +3,7 @@
 require_relative 'schema'
 
 module EntitySchema
-  # TODO: doc
+  # Define empty schema or child schema from superchass schema
   module ClassMethods
     # rubocop:disable Metrics/MethodLength:
     def entity_schema

data/lib/entity_schema/dsl.rb

@@ -1,40 +1,62 @@
 # frozen_string_literal: true
 
-require_relative 'fields/builders/property'
-require_relative 'fields/builders/object'
-require_relative 'fields/builders/collection'
+require_relative 'fields/specifications/property'
+require_relative 'fields/specifications/object'
+require_relative 'fields/specifications/collection'
+require_relative 'fields/specifications/belongs_to'
+
+require_relative 'fields/contracts/property'
+require_relative 'fields/contracts/object'
+require_relative 'fields/contracts/collection'
+require_relative 'fields/contracts/belongs_to'
+
+require_relative 'fields/property'
+require_relative 'fields/object'
+require_relative 'fields/collection'
 require_relative 'fields/builders/belongs_to'
-require_relative 'dsl_helper'
+
+require_relative 'setup_field'
 
 module EntitySchema
   # class-level methods for define entity_schema
   module Dsl
-    include DslHelper
+    include SetupField
 
     def property?(name, **opts)
       property(name, opts.merge!(predicate: true))
     end
 
     def property(name, **opts)
-      setup_field Fields::Builders::Property.(name, self, opts)
+      Fields::Contracts::Property.(opts)
+      specicifation = Fields::Specifications::Property.new(name, to_s, opts)
+      field         = Fields::Property.new(specicifation)
+      setup_field(field, specicifation)
     end
 
     def object(name, **opts)
-      setup_field Fields::Builders::Object.(name, self, opts)
+      Fields::Contracts::Object.(opts)
+      specicifation = Fields::Specifications::Object.new(name, to_s, opts)
+      field         = Fields::Object.new(specicifation)
+      setup_field(field, specicifation)
     end
 
     alias has_one object
 
     def collection(name, **opts)
-      setup_field Fields::Builders::Collection.(name, self, opts)
+      Fields::Contracts::Collection.(opts)
+      specicifation = Fields::Specifications::Collection.new(name, to_s, opts)
+      field         = Fields::Collection.new(specicifation)
+      setup_field(field, specicifation)
     end
 
     alias has_many collection
 
     def belongs_to(name, **opts)
-      fk, object = Fields::Builders::BelongsTo.(name, self, opts)
-      setup_field object
-      setup_field fk
+      Fields::Contracts::BelongsTo.(opts)
+      specicifation = Fields::Specifications::BelongsTo.new(name, to_s, opts)
+      fk, object = Fields::Builders::BelongsTo.(specicifation)
+      setup_field(object, specicifation)
+      setup_field(fk, specicifation)
     end
   end
 end

data/lib/entity_schema/fields/abstract.rb

@@ -2,30 +2,29 @@
 
 module EntitySchema
   module Fields
-    # TODO: doc
+    # Specification for fiend behaviour: internal and external
+    #   will be used for build Field object and for setup Field object
     class Abstract
-      attr_reader :src_key, :name, :predicate_name, :setter_name, :ivar_name
-
-      def initialize(name, owner_name, options)
-        @name = name.to_sym
-        @owner_name = owner_name
-        @src_key       = options.delete(:src_key)
-        @public_getter = options.delete(:public_getter)
-        @public_setter = options.delete(:public_setter)
-
-        @predicate_name = :"#{name}?"
-        @setter_name    = :"#{name}="
-        @ivar_name      = :"@#{name}"
+      attr_reader :src_key, :name
+
+      def initialize(specification)
+        @name       ||= specification.name
+        @owner_name   = specification.owner_name
+        @src_key    ||= specification.src_key
+
+        @public_getter = specification.public_getter?
+        @public_setter = specification.public_setter?
+
+        @ivar_name = :"@#{name}"
       end
 
-      # set from public caller
       def public_set(obj, value)
-        raise_public_set unless public_setter?
+        raise_public('Setter') unless @public_setter
         set(obj, value)
       end
 
       def public_get(obj)
-        raise_public_get unless public_getter?
+        raise_public('Getter') unless @public_getter
         get(obj)
       end
 
@@ -33,10 +32,6 @@ module EntitySchema
         obj.instance_variable_defined?(ivar_name)
       end
 
-      def delete(obj)
-        obj.remove_instance_variable(ivar_name)
-      end
-
       def set(obj, value)
         write(obj, value)
       end
@@ -47,10 +42,6 @@ module EntitySchema
       end
       # :nocov:
 
-      def predicate?
-        false
-      end
-
       def serialize(obj, output)
         output[src_key] = read(obj) if given?(obj)
       end
@@ -65,18 +56,10 @@ module EntitySchema
 
       private
 
-      attr_reader :owner_name, :serialize_method
-
-      def raise_public_set
-        raise NameError, "Private Setter called for field `#{name}` of `#{owner_name}`"
-      end
-
-      def raise_public_get
-        raise NameError, "Private Getter called for field `#{name}` of `#{owner_name}`"
-      end
+      attr_reader :ivar_name, :owner_name, :serialize_method
 
-      def guard_unknown_options!(opts)
-        raise "Unknown options given: #{opts.inspect}" if opts.any?
+      def raise_public(subject)
+        raise NameError, "Private #{subject} called for field `#{name}` of `#{owner_name}`"
       end
 
       def read(obj)

data/lib/entity_schema/fields/builders/belongs_to.rb

@@ -1,49 +1,38 @@
 # frozen_string_literal: true
 
-require_relative 'abstract'
-require_relative 'fk_belongs_to'
-require_relative 'object_belongs_to'
+require 'singleton'
+
+require_relative '../fk_belongs_to'
+require_relative '../object_belongs_to'
 require_relative '../observer_belongs_to'
 
 module EntitySchema
   module Fields
     module Builders
-      # TODO: doc
-      class BelongsTo < Abstract
-        def call(name, schema, options)
-          options = options.dup
-          opts = extract_options(options)
-          guard_unknown_options!(options, name)
-
-          fk     = create_fk(name, schema, opts)
-          object = create_object(name, schema, opts)
-
-          create_observer(fk, object, opts)
+      # Build two fields: for foreign key property and for related object
+      #   link foreign key with his object for interaction
+      class BelongsTo
+        include Singleton
+
+        def call(options)
+          fk     = create_fk(options)
+          object = create_object(options)
+          create_observer(fk, object, options)
           [fk, object]
         end
 
-        private
-
-        # rubocop:disable Naming/UncommunicativeMethodParamName
-        def extract_options(h)
-          delete_keys(h, all_keys).merge!(
-            pk: check!(:pk, h, [Symbol, nil]),
-            fk: check!(:fk, h, [Symbol, nil])
-          )
+        def self.call(options)
+          instance.call(options)
         end
-        # rubocop:enable Naming/UncommunicativeMethodParamName
 
-        def create_fk(object_name, schema, opts)
-          name = fk_name(opts[:fk], object_name)
-          Fields::Builders::FkBelongsTo.(name, schema, create_fk_params(opts, name))
-        end
+        private
 
-        def create_fk_params(opts, name)
-          opts.slice(*fk_keys).merge!(key: name)
+        def create_fk(opts)
+          Fields::FkBelongsTo.new(opts)
         end
 
-        def create_object(name, schema, opts)
-          Fields::Builders::ObjectBelongsTo.(name, schema, opts.slice(*object_keys))
+        def create_object(opts)
+          Fields::ObjectBelongsTo.new(opts)
         end
 
         def create_observer(fk, object, opts)
@@ -51,40 +40,6 @@ module EntitySchema
           fk.observer_belongs_to     = observer
           object.observer_belongs_to = observer
         end
-
-        def all_keys
-          common_keys + only_object_keys + only_fk_keys
-        end
-
-        def object_keys
-          common_keys + only_object_keys
-        end
-
-        def fk_keys
-          common_keys + only_fk_keys
-        end
-
-        def only_object_keys
-          %i[mapper map_to map_method serialize_method serializer serialize]
-        end
-
-        def only_fk_keys
-          [:predicate]
-        end
-
-        def common_keys
-          %i[key getter setter private]
-        end
-
-        def fk_name(fk_name, object_name)
-          fk_name || :"#{object_name}_id"
-        end
-
-        def delete_keys(input_hash, keys)
-          input_hash.slice(*keys).tap do
-            keys.each { |k| input_hash.delete(k) }
-          end
-        end
       end
     end
   end

data/lib/entity_schema/fields/collection.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'abstract'
+
 module EntitySchema
   module Fields
-    # TODO: doc
+    # associated array of objects
     class Collection < Object
       def set(obj, collection)
-        return super if collection.is_a?(Array) || collection.nil?
-        raise ArgumentError, 'collection field must be Array'
+        case collection
+        when Array, nil then super
+        else raise ArgumentError, 'collection field must be Array'
+        end
       end
 
       def get(obj)

data/lib/entity_schema/fields/contracts/belongs_to.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'fk_belongs_to'
+require_relative 'object_belongs_to'
+
+module EntitySchema
+  module Fields
+    module Contracts
+      BelongsTo = FkBelongsTo + ObjectBelongsTo + {
+        fk: { eq: nil, type: Symbol },
+        pk: { eq: nil, type: Symbol }
+      }
+    end
+  end
+end

data/lib/entity_schema/fields/contracts/collection.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'object'
+
+module EntitySchema
+  module Fields
+    module Contracts
+      Collection = Object
+    end
+  end
+end

data/lib/entity_schema/fields/contracts/common.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'contract'
+
+module EntitySchema
+  module Fields
+    module Contracts
+      Common = Contract.new(
+        key:     { eq: nil, type: Symbol },
+        getter:  { eq: [:private, nil] },
+        setter:  { eq: [:private, nil] },
+        private: { eq: [true, false, :getter, :setter, nil] }
+      )
+    end
+  end
+end

data/lib/entity_schema/fields/contracts/contract.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  module Fields
+    module Contracts
+      # Check data with strict contract, described with Hash-based DSL
+      class Contract
+        def initialize(rules)
+          @rules = rules
+        end
+
+        def +(other)
+          self.class.new(rules.merge(other.to_h))
+        end
+
+        def call(raw_options, skip_unknown: false) # rubocop:disable Metrics/AbcSize
+          raw_options.each do |key, value|
+            rules.key?(key) || skip_unknown || raise_unknown!(key, value)
+
+            r = rules[key]
+            next if Array(r[:eq]).any?         { |expectation| expectation == value }
+            next if Array(r[:type]).any?       { |type| value.is_a?(type) }
+            next if Array(r[:respond_to]).any? { |meth| value.respond_to?(meth) }
+            raise_unexpected_value(r, key, value)
+          end
+          true
+        end
+
+        def to_h
+          rules
+        end
+
+        private
+
+        attr_reader :rules
+
+        def raise_unknown!(key, value)
+          raise "Unknown option `#{key.inspect} => #{value.inspect}` given." \
+                "  Known options: #{rules.keys}"
+        end
+
+        def raise_unexpected_value(rules, key, value)
+          msg  = "Unexpected option value `#{value.inspect}` of option `#{key.inspect}`. \n" \
+                 '  Expected to:'
+          msgs = []
+          msgs << "\n    be equal to the one of #{rules[:eq]}" if rules.key?(:eq)
+          msgs << "\n    be one of #{rules[:type]}" if rules.key?(:ty)
+          msgs << "\n    respond to one of the methods #{rules[:respond_to]}"
+          raise TypeError, (msg + msgs * ' OR')
+        end
+      end
+    end
+  end
+end

data/lib/entity_schema/fields/contracts/fk_belongs_to.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module EntitySchema
+  module Fields
+    module Contracts
+      FkBelongsTo = Common
+    end
+  end
+end

data/lib/entity_schema/fields/contracts/object.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module EntitySchema
+  module Fields
+    module Contracts
+      Object = Common + {
+        mapper:     { type: Symbol, eq: nil, respond_to: :call },
+        map_to:     { type: Class,  eq: nil },
+        map_method: { type: Symbol, eq: nil },
+        serializer: { type: Symbol, eq: nil, respond_to: :call },
+        serialize:  { type: Symbol, eq: nil }
+      }
+    end
+  end
+end

data/lib/entity_schema/fields/contracts/object_belongs_to.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'object'
+
+module EntitySchema
+  module Fields
+    module Contracts
+      ObjectBelongsTo = Object
+    end
+  end
+end

data/lib/entity_schema/fields/contracts/property.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module EntitySchema
+  module Fields
+    module Contracts
+      Property = Common + {
+        predicate: { eq: [true, false, nil] }
+      }
+    end
+  end
+end

data/lib/entity_schema/fields/fk_belongs_to.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require_relative 'abstract'
+
 module EntitySchema
   module Fields
     # Fk
     class FkBelongsTo < Property
       attr_accessor :observer_belongs_to
 
+      def initialize(options)
+        @name    = options.fk
+        @src_key = options.fk
+        super(options)
+      end
+
       def set(obj, value, notify_observer: true)
         super(obj, value).tap do |fk|
           observer_belongs_to.fk_changed(fk, obj) if notify_observer

data/lib/entity_schema/fields/object.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'abstract'
+
 module EntitySchema
   module Fields
-    # TODO: doc
+    # Associated object
     class Object < Abstract
-      def initialize(name, schema, options)
-        @mapper     = options.delete(:mapper)
-        @serializer = options.delete(:serializer)
-        super(name, schema, options)
-        guard_unknown_options!(options)
+      def initialize(specification)
+        @mapper     = specification.mapper
+        @serializer = specification.serializer
+        super(specification)
       end
 
       def get(obj)

data/lib/entity_schema/fields/object_belongs_to.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'abstract'
+
 module EntitySchema
   module Fields
     # Withoutfk

data/lib/entity_schema/fields/property.rb

@@ -2,18 +2,15 @@
 
 require_relative 'abstract'
 
+require_relative 'abstract'
+
 module EntitySchema
   module Fields
-    # TODO: doc
+    # Simple field with any value
     class Property < Abstract
-      def initialize(name, schema, options)
-        @predicate = options.delete(:predicate)
-        super(name, schema, options)
-        guard_unknown_options!(options)
-      end
-
-      def predicate?
-        @predicate
+      def initialize(options)
+        @predicate = options.predicate
+        super(options)
       end
 
       def get(obj)