isomorfeus-data 1.0.0.delta11

data/lib/lucid_array/mixin.rb

@@ -0,0 +1,163 @@
+module LucidArray
+  module Mixin
+    def self.included(base)
+      if RUBY_ENGINE != 'opal'
+        Isomorfeus.add_valid_array_class(base) unless base == LucidArray::Base
+      end
+
+      base.extend(Isomorfeus::Data::PropDeclaration)
+
+      def to_gid
+        [@class_name, @props_json]
+      end
+
+      base.instance_exec do
+        def on_load_block
+          @on_load_block
+        end
+
+        def query_block
+          @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
+          Redux.register_used_store_path(*@store_path)
+          raw_array = Redux.fetch_by_path(*@store_path)
+          raw_array ? raw_array : []
+        end
+
+        def method_missing(method_name, *args, &block)
+          Redux.register_used_store_path(*@store_path)
+          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)
+          Redux.register_used_store_path(*@store_path)
+          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)
+
+            Redux.register_used_store_path(:data_state, :arrays, self.name, props_json)
+
+            Isomorfeus::Transport.promise_send_path('Isomorfeus::Data::Handler::ArrayLoadHandler', self.name, props_json).then do |response|
+              if response[:agent_response].key?(:error)
+                `console.error(#{response[:agent_response][:error].to_n})`
+                raise response[:agent_response][:error]
+              end
+              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: response[:full_response][:data])
+              instance
+            end
+          end
+
+          def query
+            nil
+          end
+        end
+      else # RUBY_ENGINE
+        unless base == LucidArray::Base
+          base.prop :pub_sub_client, default: nil
+          base.prop :session_id, default: nil
+          base.prop :current_user, default: nil
+        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.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 query(&block)
+            @query_block = block
+          end
+        end
+      end  # RUBY_ENGINE
+    end
+  end
+end

data/lib/lucid_collection/base.rb

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

data/lib/lucid_collection/mixin.rb

@@ -0,0 +1,241 @@
+module LucidCollection
+  module Mixin
+    def self.included(base)
+      if RUBY_ENGINE != 'opal'
+        Isomorfeus.add_valid_collection_class(base) unless base == LucidCollection::Base
+      end
+
+      base.extend(Isomorfeus::Data::PropDeclaration)
+
+      def find_node(attribute_hash = nil, &block)
+        if block_given?
+          nodes.each do |node|
+            return node if block.call(node)
+          end
+        else
+          node_class = attribute_hash.delete(:class)
+          is_a_module = attribute_hash.delete(:is_a)
+          nodes.each do |node|
+            if node_class
+              next unless node.class == node_class
+            end
+            if is_a_module
+              next unless node.is_a?(is_a_module)
+            end
+            found = true
+            attribute_hash.each do |k,v|
+              found &&= (node[k] == v)
+              break unless found
+            end
+            return node if found
+          end
+        end
+        nil
+      end
+
+      def find_nodes(attribute_hash = nil, &block)
+        found_nodes = Set.new
+        if block_given?
+          nodes.each do |node|
+            found_nodes << node if block.call(node)
+          end
+        else
+          node_class = attribute_hash.delete(:class)
+          is_a_module = attribute_hash.delete(:is_a)
+          nodes.each do |node|
+            if node_class
+              next unless node.class == node_class
+            end
+            if is_a_module
+              next unless node.is_a?(is_a_module)
+            end
+            found = true
+            attribute_hash.each do |k,v|
+              found &&= (node[k] == v)
+              break unless found
+            end
+            found_nodes << node if found
+          end
+        end
+        found_nodes
+      end
+
+      def to_gid
+        [@class_name, @props_json]
+      end
+
+      def to_transport(inline: false)
+        if inline
+          { '_inline' => { @props_json => nodes_as_cids }}
+        else
+          { 'collections' => { @class_name => { @props_json => nodes_as_cids }}}
+        end
+      end
+
+      def included_items_to_transport
+        nodes_hash = {}
+        nodes.each do |node|
+          nodes_hash.deep_merge!(node.to_transport)
+        end
+        nodes_hash
+      end
+
+      base.instance_exec do
+        def on_load_block
+          @on_load_block
+        end
+
+        def query_block
+          @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
+          @store_path = store_path
+          @class_name = self.class.name
+          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+          @store_path = store_path ? store_path : [:data_state, :collections, @class_name, @props_json]
+        end
+
+        def loaded?
+          Redux.fetch_by_path(*@store_path) ? true : false
+        end
+
+        def find_node_by_id(node_id)
+          Redux.register_used_store_path(*@store_path)
+          nodes_as_cids.each do |node_cid|
+            return  LucidNode::Base.node_from_cid(node_cid) if node_cid[1] == node_id
+          end
+          nil
+        end
+
+        def nodes
+          # maybe use a node cache, maybe not:
+          # - pro node cache: maybe faster
+          # - contra node cache: js garbage collection fails because references are kept forever, memory usage just grows and grows
+          nodes_as_cids.map { |node_cid| LucidNode::Base.node_from_cid(node_cid) }
+        end
+
+        def nodes_as_cids
+          Redux.register_used_store_path(*@store_path)
+          node_cids = Redux.fetch_by_path(*@store_path)
+          node_cids ? node_cids : []
+        end
+
+        def method_missing(method_name, *args, &block)
+          if method_name.JS.startsWith('find_node_by_')
+            attribute = method_name[13..-1] # remove 'find_node_by_'
+            value = args[0]
+            attribute_hash = { attribute => value }
+            attribute_hash.merge!(args[1]) if args[1]
+            find_node(attribute_hash)
+          else
+            super
+          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)
+
+            Redux.register_used_store_path(:data_state, :collections, self.name, props_json)
+
+            Isomorfeus::Transport.promise_send_path('Isomorfeus::Data::Handler::CollectionLoadHandler', self.name, props_json).then do |response|
+              if response[:agent_response].key?(:error)
+                `console.error(#{response[:agent_response][:error].to_n})`
+                raise response[:agent_response][:error]
+              end
+              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: response[:full_response][:data])
+              instance
+            end
+          end
+
+          def query
+            nil
+          end
+        end
+      else # RUBY_ENGINE
+        unless base == LucidCollection::Base
+          base.prop :pub_sub_client, default: nil
+          base.prop :session_id, default: nil
+          base.prop :current_user, default: nil
+        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 method_missing(method_name, *args, &block)
+          if method_name.start_with?('find_node_by_')
+            attribute = method_name[13..-1] # remove 'find_node_by_'
+            value = args[0]
+            attribute_hash = { attribute => value }
+            attribute_hash.merge!(args[1]) if args[1]
+            find_node(attribute_hash)
+          else
+            super
+          end
+        end
+
+        def nodes_as_cids
+          nodes.map { |node| node.to_cid }
+        end
+
+        base.instance_exec do
+          attr_reader :nodes
+
+          def load(props_hash = {})
+            validate_props(props_hash)
+            instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
+            instance.instance_exec do
+              @nodes = self.class.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 query(&block)
+            @query_block = block
+          end
+        end
+      end  # RUBY_ENGINE
+    end
+  end
+end

data/lib/lucid_edge/base.rb

@@ -0,0 +1,5 @@
+module LucidEdge
+  class Base
+    include LucidEdge::Mixin
+  end
+end

data/lib/lucid_edge/mixin.rb

@@ -0,0 +1,243 @@
+module LucidEdge
+  module Mixin
+    def self.included(base)
+      attr_reader :id
+
+      def ==(other_node)
+        eql?(other_node)
+      end
+
+      def eql?(other_node)
+        @id == other_node.id && @class_name == other_node.instance_variable_get(:@class_name)
+      end
+
+      def id=(new_id)
+        new_id = new_id.to_s
+        changed_attributes[:id] = new_id
+        @id = new_id
+      end
+
+      def changed_attributes
+        @changed_attributes ||= Isomorfeus::Data::Props.new({})
+      end
+
+      def changed?
+        changed_attributes.any?
+      end
+
+      def to=(node)
+        @changed_to_cid = node.to_cid
+        node
+      end
+
+      def to_cid
+        [@class_name, @id]
+      end
+
+      def valid_attribute?(attr, value)
+        begin
+          validate_attribute!(attr, value)
+          true
+        rescue
+          false
+        end
+      end
+
+      def validate_attribute!(attr, value)
+        attr_options = self.class.attribute_options[attr]
+
+        if attr_options.key?(:class)
+          raise "#{attr}: value class is not #{attr_options[:class]}!" unless value.class == attr_options[:class]
+        end
+
+        if attr_options.key?(:is_a)
+          raise "#{attr}: value is not a #{attr_options[:class]}!" unless value.is_a?(attr_options[:is_a])
+        end
+
+        if attr_options.key?(:validate)
+          raise "#{attr}: value failed validation!" unless attr_options[:validate].call(value)
+        end
+      end
+
+      base.instance_exec do
+        def attributes
+          attribute_options.keys
+        end
+
+        def attribute_options
+          @attribute_options ||= { id: {} }
+        end
+
+        def edge_from_cid(cid)
+          Isomorfeus.cached_edge_class(cid[0]).new({id: cid[1]})
+        end
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def initialize(attributes_hash = nil)
+          attributes_hash = {} unless attributes_hash
+          self.class.attributes.each do |attr|
+            next if attr == :to || attr == :from
+            if attributes_hash.key?(attr)
+              validate_attribute!(attr, attributes_hash[attr])
+              changed_attributes[attr] = attributes_hash[attr]
+            elsif self.class.attribute_options[attr].key?(:default)
+              changed_attributes[attr] = self.class.attribute_options[attr][:default]
+            end
+          end
+          @id = attributes_hash[:id].to_s
+          @id = "new_#{object_id}" if @id.empty?
+          @changed_from_cid = attributes_hash[:from]&.to_cid
+          @changed_to_cid = attributes_hash[:to]&.to_cid
+          @class_name = self.class.name
+          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+        end
+
+        def loaded?
+          Redux.fetch_by_path(:data_state, :edges, @class_name, @id) ? true : false
+        end
+
+        def from
+          cid = from_as_cid
+          cid ? LucidNode::Base.node_from_cid(cid) : nil
+        end
+
+        def from_as_cid
+          Redux.register_used_store_path(:data_state, :edges, @class_name, @id, :from)
+          return @changed_from_cid if @changed_from_cid
+          cid = Redux.fetch_by_path(:data_state, :edges, @class_name, @id, :from)
+          cid ? cid : nil
+        end
+
+        def from=(node)
+          @changed_from_cid = node.to_cid
+          node
+        end
+
+        def to
+          cid = to_as_cid
+          cid ? LucidNode::Base.node_from_cid(cid) : nil
+        end
+
+        def to_as_cid
+          Redux.register_used_store_path(:data_state, :edges, @class_name, @id, :to)
+          return @changed_to_cid if @changed_to_cid
+          cid = Redux.fetch_by_path(:data_state, :edges, @class_name, @id, :to)
+          cid ? cid : nil
+        end
+
+        def to_transport(*args)
+          Redux.register_used_store_path(:data_state, :edges, @class_name, @id)
+          final_attributes = {}
+          self.class.attributes.each do |attr|
+            next if attr == :id
+            final_attributes[attr] = send(attr)
+          end
+          { 'edges' => { @class_name => { @id => { from: from_as_cid, to: to_as_cid, attributes: final_attributes }}}}
+        end
+
+        base.instance_exec do
+          def attribute(name, options = {})
+            attribute_options[name] = options
+
+            define_method(name) do
+              Redux.register_used_store_path(:data_state, :edges, @class_name, @id, :attributes, name)
+              if changed_attributes.key?(name)
+                changed_attributes[name]
+              else
+                Redux.fetch_by_path(:data_state, :edges, @class_name, @id, :attributes, name)
+              end
+            end
+
+            define_method("#{name}=") do |arg|
+              validate_attribute!(name, arg)
+              Redux.register_used_store_path(:data_state, :edges, @class_name, @id, :attributes, name)
+              changed_attributes.set(name, arg)
+            end
+          end
+        end
+      else # RUBY_ENGINE
+        def initialize(attributes_hash = nil)
+          attributes_hash = {} unless attributes_hash
+          given_attributes = Isomorfeus::Data::Props.new(attributes_hash)
+          valid_attributes_hash = {}
+          self.class.attributes.each do |attr|
+            next if attr == :to || attr == :from
+            if given_attributes.key?(attr)
+              validate_attribute!(attr, given_attributes[attr])
+              valid_attributes_hash[attr] = given_attributes[attr]
+            elsif self.class.attribute_options[attr].key?(:default)
+              valid_attributes_hash[attr] = self.class.attribute_options[attr][:default]
+            end
+          end
+          @attributes = Isomorfeus::Data::Props.new(valid_attributes_hash)
+          @id = @attributes[:id].to_s
+          @id = "new_#{object_id}" if @id.empty?
+          @from_cid = given_attributes[:from]&.to_cid
+          @changed_from_cid = nil
+          @to_cid = given_attributes[:to]&.to_cid
+          @changed_to_cid = nil
+          @class_name = self.class.name
+          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+        end
+
+        def loaded?
+          true
+        end
+
+        def from
+          from_cid = from_as_cid
+          from_cid ? LucidNode::Base.node_from_cid(from_cid) : nil
+        end
+
+        def from_as_cid
+          @changed_from_cid ? @changed_from_cid : @from_cid
+        end
+
+        def from=(node)
+          @changed_from_cid = node.to_cid
+          node
+        end
+
+        def to
+          to_cid = to_as_cid
+          to_cid ? LucidNode::Base.node_from_cid(to_cid) : nil
+        end
+
+        def to_as_cid
+          @changed_to_cid ? @changed_to_cid : @to_cid
+        end
+
+        def to_transport(*args)
+          final_attributes = {}
+          self.class.attributes.each do |attr|
+            next if attr == :id
+            include_attribute = @attributes.key?(attr)
+            include_attribute = !self.class.attribute_options[attr][:server_only] if self.class.attribute_options[attr].key?(:server_only)
+            final_attributes[attr.to_s] = @attributes[attr] if include_attribute
+          end
+          { 'edges' => { @class_name => { @id => { 'from' => from_as_cid, 'to' => to_as_cid, 'attributes' => final_attributes }}}}
+        end
+
+        base.instance_exec do
+          def attribute(name, options = {})
+            attribute_options[name] = options
+
+            define_method(name) do
+              if changed_attributes.key?(name)
+                changed_attributes[name]
+              else
+                @attributes[name]
+              end
+            end
+
+            define_method("#{name}=") do |arg|
+              validate_attribute!(name, arg)
+              changed_attributes.set(name, arg)
+            end
+          end
+        end
+      end # RUBY_ENGINE
+    end
+  end
+end

data/lib/lucid_graph/base.rb

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