isomorfeus-data 1.0.0.zeta25 → 2.0.0.rc1

data/lib/lucid_arango/node/mixin.rb

@@ -1,79 +0,0 @@
-module LucidArango
-  module Document
-    module Mixin
-      def self.included(base)
-        base.include(Enumerable)
-        base.extend(LucidPropDeclaration::Mixin)
-        base.extend(Isomorfeus::Data::GenericClassApi)
-        base.include(Isomorfeus::Data::GenericInstanceApi)
-        # TODO implement, depends on arango-driver
-
-        base.instance_exec do
-          def attribute_conditions
-            @attribute_conditions ||= {}
-          end
-
-          def valid_attribute?(attr_name, attr_value)
-            return true unless @attribute_conditions
-            Isomorfeus::Props::Validator.new(self.name, attr_name, attr_value, attribute_conditions[attr_name]).validate!
-          rescue
-            false
-          end
-        end
-
-        def to_transport
-          { @class_name => { @key => to_h }}
-        end
-
-        def _validate_attribute(attr_name, attr_val)
-          Isomorfeus::Props::Validator.new(@class_name, attr_name, attr_val, self.class.attribute_conditions[attr_name]).validate!
-        end
-
-        if RUBY_ENGINE == 'opal'
-          base.instance_exec do
-            def attribute(name, options = {})
-              attribute_conditions[name] = options
-
-              define_method(name) do
-                path = @_store_path + [name]
-                result = Redux.fetch_by_path(*path)
-                if result
-                  result
-                elsif !@_default_proc
-                  @_default
-                else
-                  @_default_proc.call(self, name)
-                end
-              end
-
-              define_method("#{name}=") do |val|
-                _validate_attribute(name, val) if @_validate_attributes
-                _update_attribute(name, val)
-                val
-              end
-            end
-          end
-
-          def initialize(key:, revision: nil,  attributes: nil)
-            @key = key.to_s
-            @class_name = self.class.name
-            @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-            @_store_path = [:data_state, @class_name, @key]
-            @_changed_store_path = [:data_state, :changed, @class_name, @key]
-            @_revision_store_path = [:data_state, :revision, @class_name, @key]
-            attributes = {} unless attributes
-            attributes.each { |a,v| _validate_attribute(a, v) }
-            Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: { @class_name => { @key => attributes },
-                                                                 changed: { @class_name => { @key => false }},
-                                                                 revision: { @class_name => { @key => revision }}})
-          end
-
-        else # RUBY_ENGINE
-          unless base == LucidArango::Document::Base
-            Isomorfeus.add_valid_data_class(base)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lucid_arango/object/base.rb

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

data/lib/lucid_arango/object/mixin.rb

@@ -1,158 +0,0 @@
-module LucidStorableObject
-  module Mixin
-    # TODO on revision conflict
-    def self.included(base)
-      base.include(Enumerable)
-      base.extend(LucidPropDeclaration::Mixin)
-      base.extend(Isomorfeus::Data::GenericClassApi)
-      base.include(Isomorfeus::Data::GenericInstanceApi)
-
-      def to_gid
-        [@class_name, @props_json]
-      end
-
-      base.instance_exec do
-        def on_load_block
-          @on_load_block
-        end
-
-        def load_query_block
-          @load_query_block
-        end
-      end
-
-      if RUBY_ENGINE == 'opal'
-        def initialize(store_path: nil, validated_props: nil)
-          @props = validated_props
-          @props_json = @props.to_json if @props
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-          @store_path = store_path ? store_path : [:data_state, :arrays, @class_name, @props_json]
-        end
-
-        def loaded?
-          Redux.fetch_by_path(*@store_path) ? true : false
-        end
-
-        def items
-          raw_array = Redux.fetch_by_path(*@store_path)
-          raw_array ? raw_array : []
-        end
-
-        def method_missing(method_name, *args, &block)
-          raw_array = Redux.fetch_by_path(*@store_path)
-          data_array = raw_array ? raw_array : []
-          data_array.send(method_name, *args, &block)
-        end
-
-        def to_transport(inline: false)
-          raw_array = Redux.fetch_by_path(*@store_path)
-          if inline
-            { '_inline' => { @props_json => (raw_array ? raw_array : []) }}
-          else
-            { 'arrays' => { @class_name => { @props_json => (raw_array ? raw_array : []) }}}
-          end
-        end
-
-        base.instance_exec do
-          def load(props_hash = {})
-            validate_props(props_hash)
-            # instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
-            self.promise_load(props_hash, instance) unless instance.loaded?
-            instance
-          end
-
-          def on_load(&block)
-          end
-
-          def promise_load(props_hash = {}, instance = nil)
-            unless instance
-              validate_props(props_hash)
-              # instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
-            end
-
-            props_json = instance.instance_variable_get(:@props_json)
-
-            Isomorfeus::Transport.promise_send_path('Isomorfeus::Data::Handler::Generic', self.name, props_json).then do |agent|
-              if agent.processed
-                agent.result
-              else
-                agent.processed = true
-                if agent.response.key?(:error)
-                  Isomorfeus.raise_error(message: agent.response[:error])
-                end
-                Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
-                agent.result = instance
-              end
-            end
-          end
-
-          def load_query; end
-        end
-      else # RUBY_ENGINE
-        unless base == LucidStorableObject::Base
-          Isomorfeus.add_valid_data_class(base)
-        end
-
-        def initialize(store_path: nil, validated_props: nil)
-          @props = validated_props
-          @props_json = @props.to_json if @props
-          @loaded = false
-          @class_name = self.class.name
-          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
-        end
-
-        def loaded?
-          @loaded
-        end
-
-        def [](name)
-          @data_array[name]
-        end
-
-        def items
-          @data_array
-        end
-
-        def method_missing(method_name, *args, &block)
-          @data_array.send(method_name, *args, &block)
-        end
-
-        def to_transport(inline: false)
-          if inline
-            { '_inline' => { @props_json => @data_array }}
-          else
-            { 'arrays' => { @class_name => { @props_json => @data_array }}}
-          end
-        end
-
-        base.instance_exec do
-          def load(props_hash = {})
-            validate_props(props_hash)
-            # instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
-            instance.instance_exec do
-              @data_array = self.class.load_query_block.call(props_hash)
-              @loaded = true
-            end
-            instance
-          end
-
-          def on_load(&block)
-            @on_load_block = block
-          end
-
-          def promise_load(props_hash = {}, instance = nil)
-            instance = self.load(props_hash)
-            result_promise = Promise.new
-            result_promise.resolve(instance)
-            result_promise
-          end
-
-          def load_query(&block)
-            @load_query_block = block
-          end
-        end
-      end  # RUBY_ENGINE
-    end
-  end
-end

data/lib/lucid_arango/remote_object/base.rb

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

data/lib/lucid_arango/remote_object/mixin.rb

@@ -1,17 +0,0 @@
-module LucidRemoteObject
-  module Mixin
-    # TODO on revision conflict
-    def self.included(base)
-      if RUBY_ENGINE != 'opal'
-        unless base == LucidRemoteObject::Base
-          Isomorfeus.add_valid_data_class(base)
-        end
-      end
-
-      base.include(Enumerable)
-      base.extend(LucidPropDeclaration::Mixin)
-      base.extend(Isomorfeus::Data::GenericClassApi)
-      base.include(Isomorfeus::Data::GenericInstanceApi)
-    end
-  end
-end

data/lib/lucid_arango/vertex/base.rb

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

data/lib/lucid_arango/vertex/mixin.rb

@@ -1,9 +0,0 @@
-module LucidArango
-  module Vertex
-    module Mixin
-      def self.included(base)
-        base.include(LucidArango::Node::Mixin)
-      end
-    end
-  end
-end