isomorfeus-data 1.0.0.zeta25 → 2.0.0.rc1

data/lib/isomorfeus_data/lucid_data/hash/mixin.rb

@@ -1,427 +0,0 @@
-module LucidData
-  module Hash
-    module Mixin
-      def self.included(base)
-        base.include(Enumerable)
-        base.include(Isomorfeus::Data::AttributeSupport)
-        base.extend(Isomorfeus::Data::GenericClassApi)
-        base.include(Isomorfeus::Data::GenericInstanceApi)
-
-        attr_accessor :default
-        attr_accessor :default_proc
-
-        base.instance_exec do
-          def valid_attribute?(attr_name, attr_value)
-            return true unless attribute_conditions.any?
-            Isomorfeus::Props::Validator.new(self.name, attr_name, attr_value, attribute_conditions[attr_name]).validate!
-          rescue
-            false
-          end
-
-          def _relaxed_validate_attribute(attr_name, attr_val)
-            Isomorfeus::Props::Validator.new(@class_name, attr_name, attr_val, attribute_conditions[attr_name]).validate!
-          end
-
-          def _relaxed_validate_attributes(attrs)
-            attribute_conditions.each_key do |attr|
-              if attribute_conditions[attr].key?(:required) && attribute_conditions[attr][:required] && !attrs.key?(attr)
-                Isomorfeus.raise_error(message: "Required attribute #{attr} not given!")
-              end
-            end
-            attrs.each { |attr, val| _relaxed_validate_attribute(attr, val) } if attribute_conditions.any?
-          end
-        end
-
-        def composition
-          @_composition
-        end
-
-        def composition=(c)
-          @_composition = c
-        end
-
-        def changed!
-          @_composition.changed! if @_composition
-          @_changed = true
-        end
-
-        def to_transport
-          hash = { 'attributes' => to_h }
-          hash['revision'] = revision if revision
-          result = { @class_name => { @key => hash }}
-          result.deep_merge!(@class_name => { @previous_key => { new_key: @key}}) if @previous_key
-          result
-        end
-
-        def _relaxed_validate_attribute(attr_name, attr_val)
-          self.class._relaxed_validate_attribute(attr_name, attr_val)
-        end
-
-        def _relaxed_validate_attributes(attrs)
-          self.class._relaxed_validate_attributes(attrs)
-        end
-
-        if RUBY_ENGINE == 'opal'
-          base.instance_exec do
-            def attribute(name, options = {})
-              attribute_conditions[name] = options
-
-              define_method(name) do
-                result = _get_attribute(name)
-                if result
-                  result
-                elsif !@_default_proc
-                  @_default
-                else
-                  @_default_proc.call(self, name)
-                end
-              end
-
-              define_method("#{name}=") do |val|
-                _relaxed_validate_attribute(name, val) if @_validate_attributes
-                @_changed_attributes[name] = val
-              end
-            end
-          end
-
-          def initialize(key:, revision: nil, attributes: nil, default: nil, composition: nil, &block)
-            @_default = default
-            @_default_proc = block
-            @key = key.to_s
-            @class_name = self.class.name
-            @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-            _update_paths
-            @_revision = revision ? revision : Redux.fetch_by_path(:data_state, @class_name, @key, :revision)
-            @_changed = false
-            @_changed_attributes = {}
-            @_composition = composition
-            @_validate_attributes = self.class.attribute_conditions.any?
-            attributes = {} unless attributes
-            _relaxed_validate_attributes(attributes) if @_validate_attributes
-            raw_attributes = Redux.fetch_by_path(*@_store_path)
-            if `raw_attributes === null`
-              @_changed_attributes = !attributes ? {} : attributes
-            elsif raw_attributes && !attributes.nil? && ::Hash.new(raw_attributes) != attributes
-              @_changed_attributes = attributes
-            end
-          end
-
-          def _get_attribute(name)
-            return @_changed_attributes[name] if @_changed_attributes.key?(name)
-            path = @_store_path + [name]
-            result = Redux.fetch_by_path(*path)
-            return nil if `result === null`
-            result
-          end
-
-          def attributes
-            raw_attributes = Redux.fetch_by_path(*@_store_path)
-            hash = ::Hash.new(raw_attributes)
-            hash.merge!(@_changed_attributes) if @_changed_attributes
-            hash
-          end
-
-          def _load_from_store!
-            @_changed = false
-            @_changed_attributes = {}
-          end
-
-          def _update_paths
-            @_store_path = [:data_state, @class_name, @key, :attributes]
-          end
-
-          def changed?
-            @_changed || @_changed_attributes.any?
-          end
-
-          def each(&block)
-            attributes.each(&block)
-          end
-
-          def [](name)
-            result = _get_attribute(name)
-            return result if result
-            return @_default unless @_default_proc
-            @_default_proc.call(self, name)
-          end
-
-          def []=(name, val)
-            _relaxed_validate_attribute(name, val) if @_validate_attributes
-            changed!
-            @_changed_attributes[name] = val
-          end
-
-          def compact!
-            result = attributes.compact!
-            return nil if result.nil?
-            @_changed_attributes = result
-            changed!
-            self
-          end
-
-          def delete(name)
-            hash = attributes
-            result = hash.delete(name)
-            @_changed_attributes = hash
-            changed!
-            result
-          end
-
-          def delete_if(&block)
-            hash = attributes
-            result = hash.delete_if(&block)
-            @_changed_attributes = hash
-            changed!
-            result
-          end
-
-          def method_missing(method_name, *args, &block)
-            if method_name.end_with?('=')
-              val = args[0]
-              _relaxed_validate_attribute(method_name, val) if @_validate_attributes
-              changed!
-              @_changed_attributes[method_name] = val
-            elsif args.size == 0 && hash.key?(method_name)
-              result = _get_attribute(method_name)
-              return result if result
-              return @_default unless @_default_proc
-              @_default_proc.call(self, method_name)
-            else
-              hash = attributes
-              hash.send(name, *args, &block)
-            end
-          end
-
-          def key?(name)
-            _get_attribute(name) ? true : false
-          end
-          alias has_key? key?
-
-          def keep_if(&block)
-            raw_hash = attributes
-            raw_hash.keep_if(&block)
-            @_changed_attributes = raw_hash
-            changed!
-            self
-          end
-
-          def merge!(*args)
-            @_changed_attributes = attributes.merge!(*args)
-            changed!
-            self
-          end
-
-          def reject!(&block)
-            hash = attributes
-            result = hash.reject!(&block)
-            return nil if result.nil?
-            @_changed_attributes = hash
-            changed!
-            self
-          end
-
-          def select!(&block)
-            hash = attributes
-            result = hash.select!(&block)
-            return nil if result.nil?
-            @_changed_attributes = hash
-            changed!
-            self
-          end
-          alias filter! select!
-
-          def shift
-            hash = attributes
-            result = hash.shift
-            @_changed_attributes = hash
-            changed!
-            result
-          end
-
-          def store(name, val)
-            _relaxed_validate_attribute(name, val) if @_validate_attributes
-            @_changed_attributes[name] = val
-            changed!
-            val
-          end
-
-          def to_h
-            attributes.dup
-          end
-
-          def transform_keys!(&block)
-            @_changed_attributes = attributes.transform_keys!(&block)
-            changed!
-            self
-          end
-
-          def transform_values!(&block)
-            @_changed_attributes = attributes.transform_values!(&block)
-            changed!
-            self
-          end
-
-          def update(*args)
-            @_changed_attributes = attributes.update(*args)
-            changed!
-            self
-          end
-        else # RUBY_ENGINE
-          Isomorfeus.add_valid_data_class(base) unless base == LucidData::Hash::Base
-
-          base.instance_exec do
-            def attribute(name, options = {})
-              attribute_conditions[name] = options
-
-              define_method(name) do
-                @_raw_attributes[name]
-              end
-
-              define_method("#{name}=") do |val|
-                _relaxed_validate_attribute(name, val) if @_validate_attributes
-                changed!
-                @_raw_attributes[name] = val
-              end
-            end
-
-            def instance_from_transport(instance_data, _included_items_data)
-              key = instance_data[self.name].keys.first
-              revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-              attributes = instance_data[self.name][key].key?('attributes') ? instance_data[self.name][key]['attributes'].transform_keys!(&:to_sym) : nil
-              new(key: key, revision: revision, attributes: attributes)
-            end
-          end
-
-          def initialize(key:, revision: nil, attributes: nil, composition: nil)
-            @key = key.to_s
-            @class_name = self.class.name
-            @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-            @_revision = revision
-            @_composition = composition
-            @_changed = false
-            @_validate_attributes = self.class.attribute_conditions.any?
-            attributes = {} unless attributes
-            _relaxed_validate_attributes(attributes) if @_validate_attributes
-            @_raw_attributes = attributes
-          end
-
-          def _unchange!
-            @_changed = false
-          end
-
-          def changed?
-            @_changed
-          end
-
-          def each(&block)
-            @_raw_attributes.each(&block)
-          end
-
-          def [](name)
-            @_raw_attributes[name]
-          end
-
-          def []=(name, val)
-            _relaxed_validate_attribute(name, val) if @_validate_attributes
-            changed!
-            @_raw_attributes[name] = val
-          end
-
-          def compact!(&block)
-            result = @_raw_attributes.compact!(&block)
-            return nil if result.nil?
-            changed!
-            self
-          end
-
-          def delete(element, &block)
-            result = @_raw_attributes.delete(element, &block)
-            changed!
-            result
-          end
-
-          def delete_if(&block)
-            @_raw_attributes.delete_if(&block)
-            changed!
-            self
-          end
-
-          def keep_if(&block)
-            @_raw_attributes.keep_if(&block)
-            changed!
-            self
-          end
-
-          def method_missing(method_name, *args, &block)
-            if method_name.end_with?('=')
-              val = args[0]
-              _relaxed_validate_attribute(name, val) if @_validate_attributes
-              changed!
-              @_raw_attributes[name] = val
-            elsif args.size == 0 && @_raw_attributes.key?(method_name)
-              @_raw_attributes[method_name]
-            else
-              @_raw_attributes.send(method_name, *args, &block)
-            end
-          end
-
-          def merge!(*args)
-            @_raw_attributes.merge!(*args)
-            changed!
-            self
-          end
-
-          def reject!(&block)
-            result = @_raw_attributes.reject!(&block)
-            return nil if result.nil?
-            changed!
-            self
-          end
-
-          def select!(&block)
-            result = @_raw_attributes.select!(&block)
-            return nil if result.nil?
-            changed!
-            self
-          end
-          alias filter! select!
-
-          def shift
-            result = @_raw_attributes.shift
-            changed!
-            result
-          end
-
-          def store(name, val)
-            _relaxed_validate_attribute(name, val) if @_validate_attributes
-            changed!
-            @_raw_attributes[name] = val
-          end
-
-          # If using def the method to_h gets not overwritten.
-          base.define_method :to_h do
-            @_raw_attributes.dup.transform_keys!(&:to_s)
-          end
-
-          def transform_keys!(&block)
-            @_raw_attributes.transform_keys!(&block)
-            changed!
-            self
-          end
-
-          def transform_values!(&block)
-            @_raw_attributes.transform_values!(&block)
-            changed!
-            self
-          end
-
-          def update(*args)
-            @_raw_attributes.update(*args)
-            changed!
-            self
-          end
-        end  # RUBY_ENGINE
-      end
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_data/link/base.rb

@@ -1,13 +0,0 @@
-module LucidData
-  module Link
-    class Base
-      include LucidData::Edge::Mixin
-
-      if RUBY_ENGINE != 'opal'
-        def self.inherited(base)
-          Isomorfeus.add_valid_data_class(base)
-        end
-      end
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_data/link/mixin.rb

@@ -1,9 +0,0 @@
-module LucidData
-  module Link
-    module Mixin
-      def self.included(base)
-        base.include(LucidData::Edge::Mixin)
-      end
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_data/link_collection/base.rb

@@ -1,13 +0,0 @@
-module LucidData
-  module LinkCollection
-    class Base
-      include LucidData::EdgeCollection::Mixin
-
-      if RUBY_ENGINE != 'opal'
-        def self.inherited(base)
-          Isomorfeus.add_valid_data_class(base)
-        end
-      end
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_data/link_collection/mixin.rb

@@ -1,9 +0,0 @@
-module LucidData
-  module LinkCollection
-    module Mixin
-      def self.included(base)
-        base.include(LucidData::EdgeCollection::Mixin)
-      end
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_data/node/base.rb

@@ -1,13 +0,0 @@
-module LucidData
-  module Node
-    class Base
-      include LucidData::Node::Mixin
-
-      if RUBY_ENGINE != 'opal'
-        def self.inherited(base)
-          Isomorfeus.add_valid_data_class(base)
-        end
-      end
-    end
-  end
-end