entity_schema 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f50c3e3066bc3902e03a7962e8357b1874807a036b396f51e8ca1557f11ead1f
-  data.tar.gz: bd598fe95948de6c1e50a96a8522f4a7a4fb07a8812292b6d1a7749c381f37d9
+  metadata.gz: 9ee8ab3545011ba2dd7016082e6c00bd3d371a789561657fb40f7747c43ab524
+  data.tar.gz: 94e051259093bb827d951e05be4b9175d40f103fd31f61fb2c35f6bcec73c5fa
 SHA512:
-  metadata.gz: 6a3acb18381e54bf08cff8007c3f26516e6232e5dbadce8cb22b1e168c0f6447f5ae561c6a8ee211f2e64b60a8b4906ad85b63f41b20678b0026bfeea7ce0527
-  data.tar.gz: 8fdca854597841e095bdd448e89dbc4cf5897591b11f97c5cc60b6bdeff6c78b96e8bbb932df130b69e3de23a933ea1fc84199507825e80a16a67721bddc3f3d
+  metadata.gz: f13cd0e8fdad2b33483131c2477f58218beff9160ad2d71c0a83bd083c966bb6d3de4d1878acc86e35c987d15d9f9b42c43c3035245482fa3515611133c2a096
+  data.tar.gz: 9abbe10cad5d6b48ee2836a83823d3c8ee6b45302c17085d86b732f4c1f53e15ea3d2bbf023b8c7f88f9f0bb78ab64c15a7bec8de0546afb434704e9b19ca450

data/.rubocop.yml

@@ -26,4 +26,4 @@ Style/Documentation:
     - 'spec/**/*'
     - 'test/**/*'
     - 'lib/entity_schema.rb'
-    - 'lib/entity_schema/specifications/*'
+    - 'lib/entity_schema/transformers/*'

data/Gemfile.lock

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

data/README.md

@@ -101,12 +101,10 @@ _TODO: description_
 
 ### `timestamps`
 
-_Not implemented_
-
 Just sugar, same as:
 ```ruby
-property :created_at, **opts
-property :updated_at, **opts
+property :created_at, private: :setter, **opts
+property :updated_at, private: :setter, **opts
 ```
 
 ### `object`

data/entity_schema.gemspec

@@ -12,8 +12,8 @@ Gem::Specification.new do |spec|
   spec.email         = ['ph-s@mail.ru']
 
   spec.summary       = 'DSL for describe Entities'
-  spec.description   = 'Simple DSL for describe schema of mapping Hash to entity Object, ' \
-                       'and then vice-versa'
+  spec.description   = 'Simple DSL for describe schema of mapping Hash to entity Object ' \
+                       'and vice-versa'
   spec.homepage      = 'https://github.com/CaptainPhilipp/entity_schema'
   spec.license       = 'MIT'
 

data/lib/entity_schema/contracts/belongs_to.rb

@@ -4,12 +4,10 @@ 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
+  module Contracts
+    BelongsTo = FkBelongsTo + ObjectBelongsTo + [
+      fk: { eq: [nil], type: Symbol },
+      pk: { eq: [nil], type: Symbol }
+    ]
   end
 end

data/lib/entity_schema/contracts/collection.rb

@@ -3,9 +3,7 @@
 require_relative 'object'
 
 module EntitySchema
-  module Fields
-    module Contracts
-      Collection = Object
-    end
+  module Contracts
+    Collection = Object
   end
 end

data/lib/entity_schema/contracts/common.rb

@@ -3,14 +3,13 @@
 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
+  module Contracts
+    Common = Contract.build(
+      { type: Symbol },
+      key:     { eq: [nil], type: Symbol },
+      getter:  { eq: [:private, nil] },
+      setter:  { eq: [:private, nil] },
+      private: { eq: [true, false, :getter, :setter, nil] }
+    )
   end
 end

data/lib/entity_schema/contracts/contract.rb

@@ -1,54 +1,98 @@
 # 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
+  module Contracts
+    # Check data with strict contract, described with Hash-based DSL
+    class Contract
+      class << self
+        def build(*arguments_arr)
+          params      = arguments_arr.to_a
+          options     = params.last.is_a?(Hash) ? params.pop : {}
+          new(to_params_hash(params).merge(options))
         end
 
-        def +(other)
-          self.class.new(rules.merge(other.to_h))
+        def to_params_hash(arr)
+          arr.each_with_object({}).with_index do |(value, params), i|
+            params["argument #{i + 1}"] = value
+          end
         end
+      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)
+      def initialize(rules)
+        @rules = rules.dup
+        @rules.each_value { |rule| rule.transform_values! { |v| v.nil? ? [nil] : Array(v) } }
+        @rules.each(&:freeze).freeze
+        freeze
+      end
 
-            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 +(other)
+        args        = other.to_a
+        options     = args.last.is_a?(Hash) ? args.pop : {}
+        other_rules = to_params_hash(args).merge(options)
+        merge(rules.merge(other_rules))
+      end
+
+      def merge(other)
+        other_rules = other.to_h
+        self.class.new(rules.merge(other_rules))
+      end
 
-        def to_h
-          rules
+      def call(*params, skip_unknown: false, **options) # rubocop:disable Metrics/AbcSize
+        keyvalue = to_params_hash(params).merge(options)
+        keyvalue.each do |key, value|
+          rules.key?(key) || skip_unknown || raise_unknown!(key, value)
+
+          r = rules[key]
+          next if r[:eq]&.any?         { |expectation| expectation == value }
+          next if r[:type]&.any?       { |type| value.is_a?(type) }
+          next if r[:respond_to]&.any? { |meth| value.respond_to?(meth) }
+          raise_unexpected_value(r, key, value)
         end
+        true
+      end
 
-        private
+      def to_h
+        rules
+      end
 
-        attr_reader :rules
+      def to_a
+        params, options = to_arguments(rules)
+        params << options
+      end
 
-        def raise_unknown!(key, value)
-          raise "Unknown option `#{key.inspect} => #{value.inspect}` given." \
-                "  Known options: #{rules.keys}"
-        end
+      private
+
+      attr_reader :rules
+
+      def to_params_hash(a)
+        self.class.to_params_hash(a)
+      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')
+      def to_arguments(hash)
+        arr = []
+        hash = hash.dup
+        hash.each_key do |k|
+          arr << hash.delete(k) if k.is_a?(String) && k.start_with?('argument ')
         end
+        [arr, hash]
+      end
+
+      def raise_unknown!(key, value)
+        raise "Unknown option `#{key.inspect} => #{value.inspect}` given." \
+              "  Known options: #{rules.keys}"
+      end
+
+      # rubocop:disable Metrics/LineLength
+      def raise_unexpected_value(rules, key, value) # rubocop:disable Metrics/AbcSize
+        msg  = "Unexpected #{key.inspect} value `#{value.inspect}`. \n" \
+               '  Expected to:'
+        msgs = []
+        msgs << "\n    be equal to the one of: #{rules[:eq]&.map(&:inspect)}" if rules.key?(:eq)
+        msgs << "\n    be one of: #{rules[:type]}" if rules[:type]
+        msgs << "\n    respond to one of the methods: #{rules[:respond_to]}" if rules.key?(:respond_to)
+        raise TypeError, (msg + msgs * ' OR')
       end
+      # rubocop:enable Metrics/LineLength
     end
   end
 end

data/lib/entity_schema/contracts/fk_belongs_to.rb

@@ -3,9 +3,7 @@
 require_relative 'common'
 
 module EntitySchema
-  module Fields
-    module Contracts
-      FkBelongsTo = Common
-    end
+  module Contracts
+    FkBelongsTo = Common
   end
 end

data/lib/entity_schema/contracts/object.rb

@@ -3,15 +3,15 @@
 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
+  module Contracts
+    Object = Common + [
+      { type: Symbol },
+      { type: Class, eq: [nil] },
+      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

data/lib/entity_schema/contracts/object_belongs_to.rb

@@ -3,9 +3,7 @@
 require_relative 'object'
 
 module EntitySchema
-  module Fields
-    module Contracts
-      ObjectBelongsTo = Object
-    end
+  module Contracts
+    ObjectBelongsTo = Object
   end
 end

data/lib/entity_schema/contracts/property.rb

@@ -3,11 +3,9 @@
 require_relative 'common'
 
 module EntitySchema
-  module Fields
-    module Contracts
-      Property = Common + {
-        predicate: { eq: [true, false, nil] }
-      }
-    end
+  module Contracts
+    Property = Common + [
+      predicate: { eq: [true, false, nil] }
+    ]
   end
 end

data/lib/entity_schema/dsl.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'specifications/property'
-require_relative 'specifications/object'
-require_relative 'specifications/collection'
-require_relative 'specifications/belongs_to'
+require_relative 'transformers/property'
+require_relative 'transformers/object'
+require_relative 'transformers/collection'
+require_relative 'transformers/belongs_to'
 
 require_relative 'contracts/property'
 require_relative 'contracts/object'
@@ -27,36 +27,39 @@ module EntitySchema
     end
 
     def property(name, **opts)
-      Fields::Contracts::Property.(opts)
-      specicifation = Fields::Specifications::Property.new(name, to_s, opts)
-      field         = Fields::Property.new(specicifation)
-      setup_field(field, specicifation)
+      Contracts::Property.(name, **opts)
+      options =   Transformers::Property.(name, to_s, nil, opts)
+      setup_field Fields::Property.new(options)
     end
 
-    def object(name, **opts)
-      Fields::Contracts::Object.(opts)
-      specicifation = Fields::Specifications::Object.new(name, to_s, opts)
-      field         = Fields::Object.new(specicifation)
-      setup_field(field, specicifation)
+    def object(name, type = nil, **opts)
+      Contracts::Object.(name, type, **opts)
+      options =   Transformers::Object.(name, to_s, type, opts)
+      setup_field Fields::Object.new(options)
     end
 
     alias has_one object
 
-    def collection(name, **opts)
-      Fields::Contracts::Collection.(opts)
-      specicifation = Fields::Specifications::Collection.new(name, to_s, opts)
-      field         = Fields::Collection.new(specicifation)
-      setup_field(field, specicifation)
+    def collection(name, type = nil, **opts)
+      Contracts::Collection.(name, type, **opts)
+      options =   Transformers::Collection.(name, to_s, type, opts)
+      setup_field Fields::Collection.new(options)
     end
 
     alias has_many collection
 
-    def belongs_to(name, **opts)
-      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)
+    def belongs_to(name, type = nil, **opts)
+      Contracts::BelongsTo.(name, type, **opts)
+      options    = Transformers::BelongsTo.(name, to_s, type, opts)
+      fk, object = Fields::Builders::BelongsTo.(options)
+      setup_field(object)
+      setup_field(fk)
+    end
+
+    private
+
+    def __merge(opts, other)
+      opts.merge(other) { |_, old, new| new.nil? ? old : new }
     end
   end
 end

data/lib/entity_schema/fields/abstract.rb

@@ -5,26 +5,28 @@ module EntitySchema
     # 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
+      Specification = Struct.new(:public_getter, :public_setter, :predicate)
 
-      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?
+      attr_reader :src_key, :name, :specification
 
+      def initialize(options)
+        @name       ||= options[:name]
+        @owner_name   = options[:owner_name]
+        @src_key    ||= options[:src_key]
         @ivar_name = :"@#{name}"
+
+        @specification = Specification.new
+        @specification.public_getter = options[:public_getter]
+        @specification.public_setter = options[:public_setter]
       end
 
       def public_set(obj, value)
-        raise_public('Setter') unless @public_setter
+        raise_public('Setter') unless specification.public_setter
         set(obj, value)
       end
 
       def public_get(obj)
-        raise_public('Getter') unless @public_getter
+        raise_public('Getter') unless specification.public_getter
         get(obj)
       end
 
@@ -46,14 +48,6 @@ module EntitySchema
         output[src_key] = read(obj) if given?(obj)
       end
 
-      def public_getter?
-        @public_getter
-      end
-
-      def public_setter?
-        @public_setter
-      end
-
       private
 
       attr_reader :ivar_name, :owner_name, :serialize_method

data/lib/entity_schema/fields/fk_belongs_to.rb

@@ -9,8 +9,8 @@ module EntitySchema
       attr_accessor :observer_belongs_to
 
       def initialize(options)
-        @name    = options.fk
-        @src_key = options.fk
+        @name    = options[:fk]
+        @src_key = options[:fk]
         super(options)
       end
 

data/lib/entity_schema/fields/object.rb

@@ -7,8 +7,8 @@ module EntitySchema
     # Associated object
     class Object < Abstract
       def initialize(specification)
-        @mapper     = specification.mapper
-        @serializer = specification.serializer
+        @mapper     = specification[:mapper]
+        @serializer = specification[:serializer]
         super(specification)
       end
 

data/lib/entity_schema/fields/property.rb

@@ -9,8 +9,8 @@ module EntitySchema
     # Simple field with any value
     class Property < Abstract
       def initialize(options)
-        @predicate = options.predicate
         super(options)
+        specification.predicate = options[:predicate]
       end
 
       def get(obj)

data/lib/entity_schema/setup_field.rb

@@ -3,34 +3,34 @@
 module EntitySchema
   # Define or redefine methods for work with Entity fields
   module SetupField
-    def setup_field(field, spec)
+    def setup_field(field)
       entity_schema.add_field(field)
 
       setup_getter(field)
       setup_setter(field)
-      setup_predicate(field) if spec.predicate?
+      setup_predicate(field) if field.specification.predicate
     end
 
     def setup_getter(field)
       m = field.name
       define_method(m) { field.get(self) }
-      public(m)  if     field.public_getter?
-      private(m) unless field.public_getter?
+      public(m)  if     field.specification.public_getter
+      private(m) unless field.specification.public_getter
     end
 
     def setup_setter(field)
       m = :"#{field.name}="
       define_method(m) { |value| field.set(self, value) }
-      public(m)  if     field.public_setter?
-      private(m) unless field.public_setter?
+      public(m)  if     field.specification.public_setter
+      private(m) unless field.specification.public_setter
     end
 
     def setup_predicate(field)
       m = :"#{field.name}?"
       remove_method(m) if method_defined?(m)
       define_method(m) { field.get(self) }
-      public(m)  if     field.public_getter?
-      private(m) unless field.public_getter?
+      public(m)  if     field.specification.public_getter
+      private(m) unless field.specification.public_getter
     end
   end
 end

data/lib/entity_schema/transformers/abstract.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module EntitySchema
+  module Transformers
+    # Transform raw valid options to usefull options
+    class Abstract
+      include Singleton
+
+      def self.call(*args)
+        instance.call(*args)
+      end
+
+      def call(name, owner_name, type, raw_options)
+        transform_options(name: name, owner_name: owner_name, map_to: type, **raw_options)
+      end
+
+      private
+
+      # Hook for ancestors
+      def transform_options(_options)
+        new_strict_hash
+      end
+
+      def bool_key?(key)
+        [true, false].include? options.fetch(key, nil)
+      end
+
+      def without_predicate(key)
+        key.to_s.delete('?').to_sym
+      end
+
+      def new_strict_hash
+        Hash.new do |h, k|
+          raise "Gem works wrong: missed option `#{k.inspect}` called. Options is: #{h.keys}"
+        end
+      end
+
+      def find(*alternatives)
+        alternatives.compact.first
+      end
+
+      # eql(hash, a: 1, b: [1, 2, :value])
+      def eql(input, pairs)
+        pairs.each do |k, values|
+          Array(values).each do |v|
+            return true if input[k] == v
+          end
+        end
+        nil
+      end
+
+      def callable(subject)
+        subject if subject.respond_to?(:call)
+      end
+
+      def owner_meth(option)
+        return unless option.is_a?(Symbol)
+        owner.method(option)
+      end
+
+      def truth(subject)
+        subject == true ? true : nil
+      end
+
+      def to_bool(subject)
+        subject ? true : false
+      end
+    end
+  end
+end

data/lib/entity_schema/transformers/belongs_to.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+require_relative 'fk_belongs_to'
+require_relative 'object_belongs_to'
+
+module EntitySchema
+  module Transformers
+    class BelongsTo < Object
+      private
+
+      def transform_options(opts)
+        super.merge!(
+          fk:         opts[:fk] || :"#{opts[:name]}_id",
+          pk:         opts[:pk] || :id
+        )
+      end
+    end
+  end
+end

data/lib/entity_schema/{specifications → transformers}/collection.rb

@@ -4,10 +4,8 @@ require_relative 'common'
 require_relative 'object'
 
 module EntitySchema
-  module Fields
-    module Specifications
-      class Collection < Specifications::Object
-      end
+  module Transformers
+    class Collection < Transformers::Object
     end
   end
 end

data/lib/entity_schema/transformers/common.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module EntitySchema
+  module Transformers
+    class Common < Abstract
+      private
+
+      def transform_options(input)
+        super.merge!(
+          name:           input[:name],
+          src_key:        input[:key] || input[:name],
+          owner_name:     input[:owner_name],
+          public_getter: !eql(input, getter: :private, private: [:getter, true]),
+          public_setter: !eql(input, setter: :private, private: [:setter, true]),
+          predicate:      false
+        )
+      end
+    end
+  end
+end

data/lib/entity_schema/transformers/fk_belongs_to.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module EntitySchema
+  module Transformers
+    class FkBelongsTo < Common
+      def transform_options(_name, _owner, _options)
+        super.merge!(predicate: false)
+      end
+    end
+  end
+end

data/lib/entity_schema/transformers/object.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module EntitySchema
+  module Transformers
+    class Object < Common
+      private
+
+      def transform_options(o)
+        super.merge!(
+          mapper:     find(callable(o[:mapper]),
+                           owner_meth(o[:mapper]),
+                           mapper(o[:map_to], o[:map_method]),
+                           default_mapper),
+          serializer: find(o[:serializer],
+                           serializer(o))
+        )
+      end
+
+      def mapper(map_to, map_method)
+        return if map_to.nil?
+        map_method ||= :new
+        ->(hash) { map_to.public_send(map_method, hash) }
+      end
+
+      def default_mapper
+        ->(hash) { hash }
+      end
+
+      def serializer(opts)
+        map_method = opts[:serialize] || :to_h
+        ->(object) { object.public_send(map_method) }
+      end
+    end
+  end
+end

data/lib/entity_schema/transformers/object_belongs_to.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module EntitySchema
+  module Transformers
+    class ObjectBelongsTo < Transformers::Object
+    end
+  end
+end

data/lib/entity_schema/transformers/property.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'common'
+
+module EntitySchema
+  module Transformers
+    class Property < Common
+      private
+
+      def transform_options(o)
+        super.merge!(
+          predicate: to_bool(o[:predicate])
+        )
+      end
+    end
+  end
+end

data/lib/entity_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EntitySchema
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: entity_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Captain Philipp
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-23 00:00:00.000000000 Z
+date: 2018-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -178,8 +178,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Simple DSL for describe schema of mapping Hash to entity Object, and
-  then vice-versa
+description: Simple DSL for describe schema of mapping Hash to entity Object and vice-versa
 email:
 - ph-s@mail.ru
 executables: []
@@ -226,14 +225,14 @@ files:
 - lib/entity_schema/instance_methods.rb
 - lib/entity_schema/schema.rb
 - lib/entity_schema/setup_field.rb
-- lib/entity_schema/specifications/abstract.rb
-- lib/entity_schema/specifications/belongs_to.rb
-- lib/entity_schema/specifications/collection.rb
-- lib/entity_schema/specifications/common.rb
-- lib/entity_schema/specifications/fk_belongs_to.rb
-- lib/entity_schema/specifications/object.rb
-- lib/entity_schema/specifications/object_belongs_to.rb
-- lib/entity_schema/specifications/property.rb
+- lib/entity_schema/transformers/abstract.rb
+- lib/entity_schema/transformers/belongs_to.rb
+- lib/entity_schema/transformers/collection.rb
+- lib/entity_schema/transformers/common.rb
+- lib/entity_schema/transformers/fk_belongs_to.rb
+- lib/entity_schema/transformers/object.rb
+- lib/entity_schema/transformers/object_belongs_to.rb
+- lib/entity_schema/transformers/property.rb
 - lib/entity_schema/version.rb
 homepage: https://github.com/CaptainPhilipp/entity_schema
 licenses:

data/lib/entity_schema/specifications/abstract.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module EntitySchema
-  module Fields
-    module Specifications
-      # Transform raw valid options to usefull options
-      class Abstract
-        def initialize(name, owner_name, raw_options)
-          @options = transform_options(name: name,
-                                       owner_name: owner_name,
-                                       **raw_options)
-        end
-
-        def [](key)
-          options.fetch(key, nil)
-        end
-
-        def to_h
-          options.dup
-        end
-
-        def method_missing(key, *_args, **_opts)
-          return options[key] if options.key?(key)
-          root = without_predicate(key)
-          return options[root] if bool_key?(root)
-          super
-        end
-
-        def respond_to_missing?(key)
-          options.key?(key) || bool_key?(without_predicate(key))
-        end
-
-        private
-
-        attr_reader :options
-
-        # Hook for ancestors
-        def transform_options(_options)
-          new_strict_hash
-        end
-
-        def bool_key?(key)
-          [true, false].include? options.fetch(key, nil)
-        end
-
-        def without_predicate(key)
-          key.to_s.delete('?').to_sym
-        end
-
-        def new_strict_hash
-          Hash.new do |h, k|
-            raise "Gem works wrong: missed option `#{k.inspect}` called. Options is: #{h.keys}"
-          end
-        end
-
-        def find(*alternatives)
-          alternatives.compact.first
-        end
-
-        # eql(hash, a: 1, b: [1, 2, :value])
-        def eql(input, pairs)
-          pairs.each do |k, values|
-            Array(values).each do |v|
-              return true if input[k] == v
-            end
-          end
-          nil
-        end
-
-        def callable(subject)
-          subject if subject.respond_to?(:call)
-        end
-
-        def owner_meth(option)
-          return unless option.is_a?(Symbol)
-          owner.method(option)
-        end
-
-        def truth(subject)
-          subject == true ? true : nil
-        end
-
-        def to_bool(subject)
-          subject ? true : false
-        end
-      end
-    end
-  end
-end

data/lib/entity_schema/specifications/belongs_to.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'common'
-require_relative 'fk_belongs_to'
-require_relative 'object_belongs_to'
-
-module EntitySchema
-  module Fields
-    module Specifications
-      class BelongsTo < Object
-        private
-
-        def transform_options(opts)
-          super.merge!(
-            fk:         opts[:fk] || :"#{opts[:name]}_id",
-            pk:         opts[:pk] || :id
-          )
-        end
-      end
-    end
-  end
-end

data/lib/entity_schema/specifications/common.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'abstract'
-
-module EntitySchema
-  module Fields
-    module Specifications
-      class Common < Abstract
-        private
-
-        def transform_options(input)
-          super.merge!(
-            name:           input[:name],
-            src_key:        input[:key] || input[:name],
-            owner_name:     input[:owner_name],
-            public_getter: !eql(input, getter: :private, private: [:getter, true]),
-            public_setter: !eql(input, setter: :private, private: [:setter, true]),
-            predicate:      false
-          )
-        end
-      end
-    end
-  end
-end

data/lib/entity_schema/specifications/fk_belongs_to.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'common'
-
-module EntitySchema
-  module Fields
-    module Specifications
-      class FkBelongsTo < Common
-        def transform_options(_name, _owner, _options)
-          super.merge!(predicate: false)
-        end
-      end
-    end
-  end
-end

data/lib/entity_schema/specifications/object.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'common'
-
-module EntitySchema
-  module Fields
-    module Specifications
-      class Object < Common
-        private
-
-        def transform_options(o)
-          super.merge!(
-            mapper:     find(callable(o[:mapper]),
-                             owner_meth(o[:mapper]),
-                             mapper(o[:map_to], o[:map_method]),
-                             default_mapper),
-            serializer: find(o[:serializer],
-                             serializer(o))
-          )
-        end
-
-        def mapper(map_to, map_method)
-          return if map_to.nil?
-          map_method ||= :new
-          ->(hash) { map_to.public_send(map_method, hash) }
-        end
-
-        def default_mapper
-          ->(hash) { hash }
-        end
-
-        def serializer(opts)
-          map_method = opts[:serialize] || :to_h
-          ->(object) { object.public_send(map_method) }
-        end
-      end
-    end
-  end
-end

data/lib/entity_schema/specifications/object_belongs_to.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'common'
-
-module EntitySchema
-  module Fields
-    module Specifications
-      class ObjectBelongsTo < Specifications::Object
-      end
-    end
-  end
-end

data/lib/entity_schema/specifications/property.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'common'
-
-module EntitySchema
-  module Fields
-    module Specifications
-      class Property < Common
-        private
-
-        def transform_options(o)
-          super.merge!(
-            predicate: to_bool(o[:predicate])
-          )
-        end
-      end
-    end
-  end
-end