entity_schema 0.1.0

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'entity_schema'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+Pry.start
+
+# require 'irb'
+# IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/entity_schema.gemspec

@@ -0,0 +1,49 @@
+
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'entity_schema/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'entity_schema'
+  spec.version       = EntitySchema::VERSION
+  spec.authors       = ['Captain Philipp']
+  spec.email         = ['ph-s@mail.ru']
+
+  spec.summary       = 'DSL for describe Entities'
+  spec.description   = 'DSL for describe Entities that can have value objects, ' \
+                       'associations and properties. Focused on performance and simplicity'
+  spec.homepage      = 'https://github.com/CaptainPhilipp/entity_schema'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'byebug'
+  spec.add_development_dependency 'overcommit'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-bundler'
+  spec.add_development_dependency 'guard-rspec'
+end

data/lib/entity_schema/class_methods.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'schema'
+
+module EntitySchema
+  # TODO: doc
+  module ClassMethods
+    # rubocop:disable Metrics/MethodLength:
+    def entity_schema
+      @entity_schema ||= begin
+        if superclass.respond_to?(:entity_schema)
+          superschema = superclass.entity_schema
+
+          unless superschema.is_a?(Schema)
+            raise Exception, "class-level method `#{superclass}.entity_schema` is required " \
+                              'by gem "entity_schema" and must return instance of ' \
+                              "`#{Schema}`, but returns a `#{superschema.class}`"
+          end
+
+          Schema.new(owner_name: to_s).extends(superschema)
+        else
+          Schema.new(owner_name: to_s)
+        end
+      end
+    end
+    # rubocop:enable Metrics/MethodLength:
+  end
+end

data/lib/entity_schema/dsl.rb

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

data/lib/entity_schema/dsl_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  # TODO: remove this shit
+  # TODO: doc
+  module DslHelper
+    def setup_field(field)
+      remove_method(field.name)           if method_defined?(field.name)
+      remove_method(field.predicate_name) if method_defined?(field.predicate_name)
+      remove_method(field.setter_name)    if method_defined?(field.setter_name)
+
+      entity_schema.add_field field
+
+      define_method(field.name) { field.get(self) }
+      private(field.name) unless field.public_getter?
+
+      if field.predicate?
+        define_method(field.predicate_name) { field.get(self) }
+        private(field.predicate_name) unless field.public_getter?
+      end
+
+      define_method(field.setter_name) { |value| field.set(self, value) }
+      private(field.setter_name) unless field.public_setter?
+    end
+  end
+end

data/lib/entity_schema/fields/abstract.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module EntitySchema
+  module Fields
+    # TODO: doc
+    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}"
+      end
+
+      # set from public caller
+      def public_set(obj, value)
+        raise_public_set unless public_setter?
+        set(obj, value)
+      end
+
+      def public_get(obj)
+        raise_public_get unless public_getter?
+        get(obj)
+      end
+
+      def given?(obj)
+        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
+
+      def get(_obj)
+        raise NotImplementedError
+      end
+
+      def predicate?
+        false
+      end
+
+      def serialize(obj, output)
+        output[src_key] = read(obj) if given?(obj)
+      end
+
+      def public_getter?
+        @public_getter
+      end
+
+      def public_setter?
+        @public_setter
+      end
+
+      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
+
+      def guard_unknown_options!(opts)
+        raise "Unknown options given: #{opts.inspect}" if opts.any?
+      end
+
+      def read(obj)
+        obj.instance_variable_get(ivar_name)
+      end
+
+      def write(obj, value)
+        obj.instance_variable_set(ivar_name, value)
+      end
+    end
+  end
+end

data/lib/entity_schema/fields/builders/.rubocop.yml

@@ -0,0 +1,7 @@
+inherit_from: ../../../../.rubocop.yml
+
+Metrics/AbcSize:
+  Max: 20
+
+Metrics/LineLength:
+  Max: 130

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative '../property'
+
+module EntitySchema
+  module Fields
+    module Builders
+      # TODO: doc
+      class Abstract
+        include Singleton
+
+        def self.call(*args)
+          instance.call(*args)
+        end
+
+        def call(name, owner_name, options)
+          options = options.dup
+          opts = extract_options(options)
+          guard_unknown_options!(options, name)
+          create_field(name, owner_name, opts)
+        end
+
+        private
+
+        def extract_options(o)
+          {
+            key:     check!(:key, o, [Symbol, nil]),
+            getter:  check!(:getter, o, [:private, nil]),
+            setter:  check!(:setter, o, [:private, nil]),
+            private: check!(:private, o, [true, false, :getter, :setter, nil])
+          }
+        end
+
+        def create_field(name, owner_name, opts)
+          field_klass.new(name, owner_name, **create_field_params(opts, name))
+        end
+
+        # rubocop:disable Metrics/AbcSize:
+        def create_field_params(o, name)
+          {
+            src_key:        first_of(o[:key], name),
+            public_getter: !first_of(true_(o[:getter] == :private), true_(o[:private] == :getter), true_(o[:private]), false),
+            public_setter: !first_of(true_(o[:setter] == :private), true_(o[:private] == :setter), true_(o[:private]), false)
+          }
+        end
+        # rubocop:enable Metrics/AbcSize:
+
+        def field_klass
+          raise NotImplementedError
+        end
+
+        # Helpers
+
+        # rubocop:disable Naming/UncommunicativeMethodParamName
+        def check!(key, h, allowed)
+          value = h.delete(key)
+          return value if allowed.any? do |v|
+            v.is_a?(Class) ? value.is_a?(v) : value == v
+          end
+          raise ArgumentError, "option `#{key}:` must be in #{allowed}, but '#{value.inspect}'"
+        end
+        # rubocop:enable Naming/UncommunicativeMethodParamName
+
+        # rubocop:disable Naming/UncommunicativeMethodParamName
+        def check_ducktype!(key, h, methods)
+          value = h.delete(key)
+          return value if value.nil? || methods.all? { |m| value.respond_to?(m) }
+          raise ArgumentError, "option `#{key}:` (#{value.inspect}) must respond to #{methods}"
+        end
+        # rubocop:enable Naming/UncommunicativeMethodParamName
+
+        def first_of(*alternatives)
+          alternatives.compact.first
+        end
+
+        def true_(value)
+          value == true ? true : nil
+        end
+
+        def not_bool(value)
+          case value
+          when true, false then nil
+          else value
+          end
+        end
+
+        def to_bool(value)
+          value ? true : false
+        end
+
+        def guard_unknown_options!(opts, name)
+          raise "Unknown options given to `#{name}:` #{opts.inspect}" if opts.any?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+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)
+          [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])
+          )
+        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
+
+        def create_fk_params(opts, name)
+          opts.slice(*fk_keys).merge!(key: name)
+        end
+
+        def create_object(name, schema, opts)
+          Fields::Builders::ObjectBelongsTo.(name, schema, opts.slice(*object_keys))
+        end
+
+        def create_observer(fk, object, opts)
+          observer = ObserverBelongsTo.new(fk, object, object_pk: opts[:pk] || :id)
+          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
+end