entity_schema 0.1.0

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+require_relative 'object'
+require_relative '../collection'
+
+module EntitySchema
+  module Fields
+    module Builders
+      # TODO: doc
+      class Collection < Builders::Object
+        private
+
+        def field_klass
+          Fields::Collection
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+require_relative '../fk_belongs_to'
+
+module EntitySchema
+  module Fields
+    module Builders
+      # TODO: doc
+      class FkBelongsTo < Abstract
+        def create_field_params(o, name)
+          super.merge!(predicate: false)
+        end
+
+        def field_klass
+          Fields::FkBelongsTo
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+require_relative '../object'
+
+module EntitySchema
+  module Fields
+    module Builders
+      # TODO: doc
+
+      class Object < Abstract
+        private
+
+        # rubocop:disable Naming/UncommunicativeMethodParamName
+        def extract_options(h)
+          super.merge!(
+            mapper:           check_ducktype!(:mapper, h, [:call]),
+            map_to:           check!(:map_to, h, [Class]),
+            map_method:       check!(:map_method, h, [Symbol, nil]),
+            serialize_method: check!(:serialize, h, [Symbol, nil]),
+            serializer:       check_ducktype!(:serializer, h, [:call])
+          )
+        end
+        # rubocop:enable Naming/UncommunicativeMethodParamName
+
+        def create_field_params(o, name)
+          super.merge!(
+            map_to:           o[:map_to],
+            map_method:       o[:map_method] || :new,
+            serialize_method: o[:serialize_method] || :to_h
+          )
+        end
+
+        def field_klass
+          Fields::Object
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'object'
+require_relative '../object_belongs_to'
+
+module EntitySchema
+  module Fields
+    module Builders
+      # TODO: doc
+      class ObjectBelongsTo < Builders::Object
+        def field_klass
+          Fields::ObjectBelongsTo
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+require_relative '../property'
+
+module EntitySchema
+  module Fields
+    module Builders
+      # TODO: doc
+      class Property < Abstract
+        private
+
+        # rubocop:disable Naming/UncommunicativeMethodParamName
+        def extract_options(h)
+          super.merge!(
+            predicate: check!(:predicate, h, [true, false, nil])
+          )
+        end
+
+        def create_field_params(o, name)
+          super.merge!(
+            predicate: to_bool(o[:predicate])
+          )
+        end
+        # rubocop:enable Naming/UncommunicativeMethodParamName
+
+        def field_klass
+          Fields::Property
+        end
+      end
+    end
+  end
+end

data/lib/entity_schema/fields/collection.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  module Fields
+    # TODO: doc
+    class Collection < Object
+      def set(obj, collection)
+        return super if collection.is_a?(Array) || collection.nil?
+        raise ArgumentError, 'collection field must be Array'
+      end
+
+      def get(obj)
+        values = read(obj)
+        values&.first.is_a?(Hash) ? write(obj, map(values)) : values
+      end
+
+      def serialize(obj, output)
+        values = read(obj)
+        output[src_key] = (values.first.is_a?(Hash) ? values : unwrap(values))
+      end
+
+      private
+
+      attr_reader :serialize_method
+
+      def map(tuples)
+        tuples.map { |tuple| map_to.public_send(map_method, tuple) }
+      end
+
+      def unwrap(objects)
+        objects.map { |obj| obj.public_send(serialize_method) }
+      end
+    end
+  end
+end

data/lib/entity_schema/fields/fk_belongs_to.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  module Fields
+    # Fk
+    class FkBelongsTo < Property
+      attr_accessor :observer_belongs_to
+
+      def set(obj, value, notify_observer: true)
+        super(obj, value).tap do |fk|
+          observer_belongs_to.fk_changed(fk, obj) if notify_observer
+        end
+      end
+    end
+  end
+end

data/lib/entity_schema/fields/object.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  module Fields
+    # TODO: doc
+    class Object < Abstract
+      def initialize(name, schema, options)
+        @map_to           = options.delete(:map_to)
+        @map_method       = options.delete(:map_method)
+        @serialize_method = options.delete(:serialize_method)
+        super(name, schema, options)
+        guard_unknown_options!(options)
+      end
+
+      def get(obj)
+        value = read(obj)
+        value.is_a?(Hash) ? write(obj, map(value)) : value
+      end
+
+      def serialize(obj, output)
+        return unless given?(obj)
+        value = read(obj)
+        return output[src_key] = value if value.is_a?(Hash)
+        output[src_key] = value.public_send(serialize_method)
+      end
+
+      private
+
+      attr_reader :map_to, :map_method, :serialize_method
+
+      def map(tuple)
+        map_to.public_send(map_method, tuple)
+      end
+    end
+  end
+end

data/lib/entity_schema/fields/object_belongs_to.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  module Fields
+    # Withoutfk
+    class ObjectBelongsTo < Object
+      attr_accessor :observer_belongs_to
+
+      def set(obj, value, notify_observer: true)
+        super(obj, value).tap do |new_object|
+          observer_belongs_to.object_changed(new_object, obj) if notify_observer
+        end
+      end
+    end
+  end
+end

data/lib/entity_schema/fields/observer_belongs_to.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  module Fields
+    # Doc
+    class ObserverBelongsTo
+      attr_reader :fk_field, :object_field, :object_pk
+
+      def initialize(fk_belongs_to, object_belongs_to, object_pk:)
+        @fk_field     = fk_belongs_to
+        @object_field = object_belongs_to
+        @object_pk    = object_pk
+      end
+
+      def fk_changed(new_fk, obj)
+        object = object_field.get(obj)
+        return if object.nil?
+        old_fk = object.public_send(object_pk)
+        object_field.set(obj, nil) if new_fk != old_fk
+      end
+
+      def object_changed(new_object, obj)
+        new_pk =
+          case new_object
+          when Hash then new_object[object_pk]
+          when nil  then nil
+          else           new_object.public_send(object_pk)
+          end
+        fk_field.set(obj, new_pk, notify_observer: false)
+      end
+    end
+  end
+end

data/lib/entity_schema/fields/property.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module EntitySchema
+  module Fields
+    # TODO: doc
+    class Property < Abstract
+      def initialize(name, schema, options)
+        @predicate = options.delete(:predicate)
+        super(name, schema, options)
+        guard_unknown_options!(options)
+      end
+
+      def predicate?
+        @predicate
+      end
+
+      def get(obj)
+        read(obj)
+      end
+    end
+  end
+end

data/lib/entity_schema/instance_methods.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  # TODO: doc
+  module InstanceMethods
+    def initialize(params = EMPTY_HASH)
+      update_attributes(params)
+    end
+
+    def update_attributes(params)
+      self.class.entity_schema.set_from_params(self, params)
+    end
+
+    def set(name, value)
+      self.class.entity_schema.public_set(self, name, value)
+    end
+
+    alias []= set
+
+    def get(name)
+      self.class.entity_schema.public_get(self, name)
+    end
+
+    alias [] get
+
+    def field?(name)
+      self.class.entity_schema.field?(name)
+    end
+
+    def given?(name)
+      self.class.entity_schema.given?(self, name)
+    end
+
+    def key?(name)
+      self.class.entity_schema.weak_given?(self, name)
+    end
+
+    def to_h
+      self.class.entity_schema.serialize(self)
+    end
+  end
+end

data/lib/entity_schema/schema.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  # aggregate of field resolvers
+  class Schema
+    attr_reader :owner_name
+
+    def initialize(owner_name:)
+      @owner_name = owner_name
+      @fields = {}
+      @fields_by_key = {}
+    end
+
+    def extends(other)
+      raise 'Cant extend not empty Schema' if fields.any?
+      @fields.merge!        other.fields
+      @fields_by_key.merge! other.fields_by_key
+      self
+    end
+
+    def add_field(field)
+      fields[field.name]           = field
+      fields_by_key[field.src_key] = field
+    end
+
+    def set_from_params(obj, params)
+      params.each { |key, value| fields_by_key[key]&.set(obj, value) }
+    end
+
+    def public_set(obj, name, value)
+      guard_unknown_field!(name)
+      fields[name].public_set(obj, value)
+    end
+
+    def public_get(obj, name)
+      guard_unknown_field!(name)
+      fields[name].public_get(obj)
+    end
+
+    def serialize(obj)
+      fields.values.each_with_object({}) { |field, output| field.serialize(obj, output) }
+    end
+
+    def field?(name)
+      fields.key?(name)
+    end
+
+    def given?(obj, name)
+      guard_unknown_field!(name)
+      fields[name].given?(obj)
+    end
+
+    def weak_given?(obj, name)
+      fields[name]&.given?(obj)
+    end
+
+    # TODO: use it
+    def deep_freeze
+      fields.each do |name, field|
+        name.freeze
+        field.freeze
+      end.freeze
+      freeze
+    end
+
+    protected
+
+    attr_reader :fields, :fields_by_key
+
+    private
+
+    def guard_unknown_field!(name)
+      return if field?(name)
+      raise NameError, "Unknown field '#{name}' for `#{owner_name}`"
+    end
+  end
+end

data/lib/entity_schema/version.rb

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

data/lib/entity_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'entity_schema/version'
+
+require 'entity_schema/class_methods'
+require 'entity_schema/dsl'
+require 'entity_schema/instance_methods'
+
+module EntitySchema
+  Undefined = :undefined
+  EMPTY_HASH = {}.freeze # TODO: EMPTY_HASH from Dry Core
+
+  def self.extended(base)
+    base.extend ClassMethods
+    base.extend Dsl
+    base.include InstanceMethods
+  end
+end