isomorfeus-data 1.0.0.zeta5 → 1.0.0.zeta6

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

@@ -0,0 +1,185 @@
+module LucidData
+  module Composition
+    module Mixin
+      # TODO nodes -> documents
+      # TODO include -> compose dsl
+      # TODO inline store path
+      def self.included(base)
+        base.extend(LucidPropDeclaration::Mixin)
+        base.include(Isomorfeus::Data::AttributeSupport)
+        base.extend(Isomorfeus::Data::GenericClassApi)
+        base.include(Isomorfeus::Data::GenericInstanceApi)
+
+        base.instance_exec do
+          def parts
+            @parts ||= {}
+          end
+
+          def compose_with(access_name, part_class = nil)
+            parts[access_name] = part_class
+
+            define_method(access_name) do
+              parts[access_name]
+            end
+
+            define_method("#{access_name}=") do |part|
+              @_changed = true
+              parts[access_name] = part
+              parts[access_name].composition = self
+              parts[access_name]
+            end
+          end
+        end
+
+        def changed?
+          @_changed
+        end
+
+        def changed!
+          @_changed = true
+        end
+
+        def to_transport
+          hash = { 'attributes' => _get_selected_attributes, 'parts' => {} }
+          hash.merge!('revision' => revision) if revision
+          parts.each do |name, instance|
+            hash['parts'][name.to_s] = instance.to_sid
+          end
+          { @class_name => { @key => hash }}
+        end
+
+        def included_items_to_transport
+          hash = {}
+          parts.each_value do |instance|
+            hash.deep_merge!(instance.to_transport)
+            hash.deep_merge!(instance.included_items_to_transport) if instance.respond_to?(:included_items_to_transport)
+          end
+          hash
+        end
+
+        if RUBY_ENGINE == 'opal'
+          def initialize(key:, revision: nil, attributes: nil, parts: 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, :attributes]
+            @_parts_path = [:data_state, @class_name, @key, :parts]
+            @_revision = revision ? revision : Redux.fetch_by_path(:data_state, @class_name, @key, :revision)
+            @_changed = false
+
+            loaded = loaded?
+
+            if attributes
+              attributes.each { |a,v| _validate_attribute(a, v) }
+              if loaded
+                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
+              else
+                @_changed_attributes = attributes
+              end
+            else
+              @_changed_attributes = {}
+            end
+
+            @_parts = {}
+            if parts && loaded
+              self.class.parts.each_key do |access_name|
+                if parts.key?(access_name)
+                  part = parts[access_name]
+                  @_parts[access_name] = if part.respond_to?(:to_sid)
+                                           part
+                                         else
+                                           Isomorfeus.instance_from_sid(part)
+                                         end
+                end
+              end
+            elsif loaded
+              self.class.parts.each_key do |access_name|
+                sid = Redux.fetch_by_path(*(@_parts_path + [access_name]))
+                @_parts[access_name] = Isomorfeus.instance_from_sid(sid) if sid
+              end
+            end
+            @_parts.each_value { |part| part.composition = self }
+          end
+
+          def _load_from_store!
+            @_changed = false
+            @_changed_attributes = {}
+            @_parts = {}
+            nil
+          end
+
+          def _init_parts
+            self.class.parts.each_key do |access_name|
+              sid = Redux.fetch_by_path(*(@_parts_path + [access_name]))
+              if sid
+                @_parts[access_name] = Isomorfeus.instance_from_sid(sid)
+                @_parts[access_name].composition = self
+              end
+            end
+          end
+
+          def parts
+            _init_parts if @_parts.empty?
+            @_parts
+          end
+
+          def parts_as_sids
+            Redux.fetch_by_path(*@_composition_path)
+          end
+        else # RUBY_ENGINE
+          unless base == LucidData::Composition::Base
+            Isomorfeus.add_valid_data_class(base)
+            base.prop :pub_sub_client, default: nil
+            base.prop :current_user, default: Anonymous.new
+          end
+
+          base.instance_exec do
+            def load(key:, pub_sub_client: nil, current_user: nil)
+              data = instance_exec(key: key, &@_load_block)
+              revision = nil
+              revision = data.delete(:revision) if data.key?(:revision)
+              attributes = data.delete(:attributes)
+              parts = data.delete(:parts)
+              self.new(key: key, revision: revision, parts: parts, attributes: attributes)
+            end
+          end
+
+          def initialize(key:, revision: nil, attributes: nil, parts: nil)
+            @key = key.to_s
+            @class_name = self.class.name
+            @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+            @_revision = revision
+            @_changed = false
+            @_validate_attributes = self.class.attribute_conditions.any?
+            attributes = {} unless attributes
+            if @_validate_attributes
+              attributes.each { |a,v| _validate_attribute(a, v) }
+            end
+            @_raw_attributes = attributes
+
+            @_parts = {}
+            self.class.parts.each_key do |access_name|
+              if parts.key?(access_name)
+                @_parts[access_name] = parts[access_name]
+                @_parts[access_name].composition = self
+              end
+            end
+          end
+
+          def parts
+            @_parts
+          end
+
+          def parts_as_sids
+            parts.map { |part| part.to_sid }
+          end
+        end # RUBY_ENGINE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module LucidData
+  module Document
+    class Base
+      include LucidData::Node::Mixin
+
+      if RUBY_ENGINE != 'opal'
+        def self.inherited(base)
+          Isomorfeus.add_valid_data_class(base)
+          base.prop :pub_sub_client, default: nil
+          base.prop :current_user, default: Anonymous.new
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,15 @@
+module LucidData
+  module Edge
+    class Base
+      include LucidData::Edge::Mixin
+
+      if RUBY_ENGINE != 'opal'
+        def self.inherited(base)
+          Isomorfeus.add_valid_data_class(base)
+          base.prop :pub_sub_client, default: nil
+          base.prop :current_user, default: Anonymous.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,281 @@
+module LucidData
+  module Edge
+    module Mixin
+      def self.included(base)
+        base.extend(LucidPropDeclaration::Mixin)
+        base.include(Isomorfeus::Data::AttributeSupport)
+        base.extend(Isomorfeus::Data::GenericClassApi)
+        base.include(Isomorfeus::Data::GenericInstanceApi)
+
+        def changed?
+          @_changed
+        end
+
+        def changed!
+          @_collection.changed! if @_collection
+          @_composition.changed! if @_composition
+          @_changed = true
+        end
+
+        def collection
+          @_collection
+        end
+
+        def collection=(c)
+          @_collection = c
+        end
+
+        def graph
+          @_collection&.graph
+        end
+
+        def composition
+          @_composition
+        end
+
+        def composition=(c)
+          @_composition = c
+        end
+
+        def other(node)
+          other_from = from
+          other_to = to
+          return other_to if other_from == node
+          other_from if other_to == node
+        end
+
+        def to_transport
+          hash = { "attributes" => _get_selected_attributes,
+                   "from" => from_as_sid,
+                   "to" => to_as_sid }
+          hash.merge!("revision" => revision) if revision
+          { @class_name => { @key => hash }}
+        end
+
+        if RUBY_ENGINE == 'opal'
+          def initialize(key:, revision: nil, from: nil, to: nil, attributes: nil, collection: nil, composition: 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, :attributes]
+            @_from_path = [:data_state, @class_name, @key, :from]
+            @_to_path = [:data_state, @class_name, @key, :to]
+            @_revision = revision ? revision : Redux.fetch_by_path(:data_state, @class_name, @key, :revision)
+            @_collection = collection
+            @_composition = composition
+            @_changed = false
+            loaded = loaded?
+            if attributes
+              attributes.each { |a,v| _validate_attribute(a, v) }
+              if loaded
+                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
+              else
+                @_changed_attributes = attributes
+              end
+            else
+              @_changed_attributes = {}
+            end
+            from = from.to_sid if from.respond_to?(:to_sid)
+            if loaded && from
+              @_changed_from = nil
+              store_from = Redux.fetch_by_path(*@_from_path)
+              @_changed_from = from unless `from == store_from`
+            else
+              @_changed_from = from
+            end
+            to = to.to_sid if to.respond_to?(:to_sid)
+            if loaded && to
+              @_changes_to = nil
+              store_to = Redux.fetch_by_path(*@_to_path)
+              @_changed_to = to unless `to == store_to`
+            else
+              @_changed_to = to
+            end
+          end
+
+          def _load_from_store!
+            @_changed_attributes = {}
+            @_changed_from = nil
+            @_changed_to = nil
+            @_changed = false
+          end
+
+          def each(&block)
+            _get_attributes.each(&block)
+          end
+
+          def [](name)
+            _get_attribute(name)
+          end
+
+          def []=(name, val)
+            _validate_attribute(name, val)
+            changed!
+            @_changed_attributes[name] = val
+          end
+
+          def from
+            sid = from_as_sid
+            Isomorfeus.instance_from_sid(sid) if sid
+          end
+
+          def from_as_sid
+            @_changed_from ? @_changed_from : Redux.fetch_by_path(*@_from_path)
+          end
+
+          def from=(document)
+            changed!
+            if document.respond_to?(:to_sid)
+              @_changed_from = document.to_sid
+              document
+            else
+              @_changed_from = document
+              Isomorfeus.instance_from_sid(document)
+            end
+          end
+
+          def to
+            sid = to_as_sid
+            Isomorfeus.instance_from_sid(sid) if sid
+          end
+
+          def to_as_sid
+            @_changed_to ? @_changed_to : Redux.fetch_by_path(*@_to_path)
+          end
+
+          def to=(document)
+            changed!
+            if document.respond_to?(:to_sid)
+              @_changed_to = document.to_sid
+              document
+            else
+              @_changed_to = document
+              Isomorfeus.instance_from_sid(document)
+            end
+          end
+        else # RUBY_ENGINE
+          unless base == LucidData::Edge::Base || base == LucidData::Link::Base
+            Isomorfeus.add_valid_data_class(base)
+            base.prop :pub_sub_client, default: nil
+            base.prop :current_user, default: Anonymous.new
+          end
+
+          base.instance_exec do
+            def load(key:, pub_sub_client: nil, current_user: nil)
+              data = instance_exec(key: key, &@_load_block)
+              revision = nil
+              revision = data.delete(:revision) if data.key?(:revision)
+              from = nil
+              from = data.delete(:_from) if data.key?(:_from)
+              from = data.delete(:from) if !from && data.key?(:from)
+              to = nil
+              to = data.delete(:_to) if data.key?(:_to)
+              to = data.delete(:to) if !to&& data.key?(:to)
+              attributes = data.delete(:attributes)
+              self.new(key: key, revision: revision, from: from, to: to, attributes: attributes)
+            end
+          end
+
+          def initialize(key:, revision: nil, from:, to:, attributes: nil, collection: 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
+            @_collection = collection
+            @_validate_attributes = self.class.attribute_conditions.any?
+            attributes = {} unless attributes
+            if @_validate_attributes
+              attributes.each { |a,v| _validate_attribute(a, v) }
+            end
+            @_raw_attributes = attributes
+            @_changed_from = nil
+            @_changed_to = nil
+            @_raw_from = if from.respond_to?(:to_sid)
+                           from.to_sid
+                         else
+                           from[1] = from[1].to_s
+                           from
+                         end
+            @_raw_to = if to.respond_to?(:to_sid)
+                         to.to_sid
+                       else
+                         to[1] = to[1].to_s
+                         to
+                       end
+          end
+
+          def each(&block)
+            @_raw_attributes.each(&block)
+          end
+
+          def [](name)
+            @_raw_attributes[name]
+          end
+
+          def []=(name, val)
+            _validate_attribute(name, val)
+            changed!
+            @_raw_attributes[name] = val
+          end
+
+          def from
+            sid = @_changed_from ? @_changed_from : @_raw_from
+            graph&.node_from_sid(sid)
+          end
+
+          def from_as_sid
+            @_changed_from ? @_changed_from : @_raw_from
+          end
+
+          def from=(node)
+            raise "A invalid 'from' was given" unless node
+            changed!
+            old_from = from
+            if node.respond_to?(:to_sid)
+              node_sid = node.to_sid
+            else
+              node_sid = node
+              node_sid[1] = node_sid[1].to_s
+              node = graph.node_from_sid(node_sid)
+            end
+            @_changed_from = node_sid
+            @_collection.update_node_to_edge_cache(self, old_from, node) if @_collection
+            node
+          end
+
+          def to
+            sid = @_changed_to ? @_changed_to : @_raw_to
+            graph&.node_from_sid(sid)
+          end
+
+          def to_as_sid
+            @_changed_to ? @_changed_to : @_raw_to
+          end
+
+          def to=(node)
+            raise "A invalid 'to' was given" unless node
+            old_to = to
+            changed!
+            if node.respond_to?(:to_sid)
+              node_sid = node.to_sid
+            else
+              node_sid = node
+              node_sid[1] = node_sid[1].to_s
+              node = graph.node_from_sid(node_sid)
+            end
+            @_changed_to = node_sid
+            @_collection.update_node_to_edge_cache(self, old_to, node) if @_collection
+            node
+          end
+        end # RUBY_ENGINE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module LucidData
+  module EdgeCollection
+    class Base
+      include LucidData::EdgeCollection::Mixin
+
+      if RUBY_ENGINE != 'opal'
+        def self.inherited(base)
+          Isomorfeus.add_valid_data_class(base)
+          base.prop :pub_sub_client, default: nil
+          base.prop :current_user, default: Anonymous.new
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus_data/lucid_data/edge_collection/finders.rb

@@ -0,0 +1,134 @@
+module LucidData
+  module EdgeCollection
+    module Finders
+      def find(attribute_hash = nil, &block)
+        if block_given?
+          edges.each do |edge|
+            return edge if block.call(edge)
+          end
+        else
+          edge_class = attribute_hash.delete(:class)
+          is_a_module = attribute_hash.delete(:is_a)
+          edges.each do |edge|
+            if edge_class
+              next unless edge.class == edge_class
+            end
+            if is_a_module
+              next unless edge.is_a?(is_a_module)
+            end
+            found = true
+            attribute_hash.each do |k,v|
+              found &&= (edge[k] == v)
+              break unless found
+            end
+            return edge if found
+          end
+        end
+        nil
+      end
+
+      def find_all(attribute_hash = nil, &block)
+        found_edges = Set.new
+        if block_given?
+          edges.each do |edge|
+            found_edges << edge if block.call(edge)
+          end
+        else
+          edge_class = attribute_hash.delete(:class)
+          is_a_module = attribute_hash.delete(:is_a)
+          edges.each do |edge|
+            if edge_class
+              next unless edge.class == edge_class
+            end
+            if is_a_module
+              next unless edge.is_a?(is_a_module)
+            end
+            found = true
+            attribute_hash.each do |k,v|
+              found &&= (edge[k] == v)
+              break unless found
+            end
+            found_edges << edge if found
+          end
+        end
+        found_edges
+      end
+
+      def find_by_key(edge_key)
+        edges.each do |edge|
+          return edge if edge.key == edge_key
+        end
+        nil
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def find_by_sid(edge)
+          edge_sid = edge.respond_to?(:to_sid) ? edge.to_sid : edge
+          edges_as_sids.each do |sid|
+            return Isomorfeus.instance_from_sid(edge_sid) if sid == edge_sid
+          end
+          nil
+        end
+      else
+        def find_by_sid(edge)
+          edge_sid = edge.respond_to?(:to_sid) ? edge.to_sid : edge
+          edges.each do |edge|
+            return edge if edge.to_sid == edge_sid
+          end
+          nil
+        end
+      end
+
+      def find_by_from(node)
+        node_sid = node.respond_to?(:to_sid) ? node.to_sid : node
+        edges.each do |edge|
+          return edge if edge.from_as_sid == node_sid
+        end
+        nil
+      end
+
+      def find_all_by_from(node)
+        node_sid = node.respond_to?(:to_sid) ? node.to_sid : node
+        found_edges = []
+        edges.each do |edge|
+          found_edges << edge if edge.from_as_sid == node_sid
+        end
+        found_edges
+      end
+
+      def find_by_to(node)
+        node_sid = node.respond_to?(:to_sid) ? node.to_sid : node
+        edges.each do |edge|
+          return edge if edge.to_as_sid == node_sid
+        end
+        nil
+      end
+
+      def find_all_by_to(node)
+        node_sid = node.respond_to?(:to_sid) ? node.to_sid : node
+        found_edges = []
+        edges.each do |edge|
+          found_edges << edge if edge.to_as_sid == node_sid
+        end
+        found_edges
+      end
+
+      def find_by_target(node)
+        node_sid = node.respond_to?(:to_sid) ? node.to_sid : node
+        edges.each do |edge|
+          return edge if edge.from_as_sid == node_sid || edge.to_as_sid == node_sid
+        end
+        nil
+      end
+
+      def find_all_by_target(node)
+        node_sid = node.respond_to?(:to_sid) ? node.to_sid : node
+        found_edges = []
+        edges.each do |edge|
+          found_edges << edge if edge.from_as_sid == node_sid || edge.to_as_sid == node_sid
+        end
+        found_edges
+      end
+    end
+  end
+end