isomorfeus-data 1.0.0.delta11

data/lib/lucid_graph/mixin.rb

@@ -0,0 +1,672 @@
+module LucidGraph
+  module Mixin
+    def self.included(base)
+      if RUBY_ENGINE != 'opal'
+        Isomorfeus.add_valid_graph_class(base) unless base == LucidGraph::Base
+      end
+
+      base.extend(Isomorfeus::Data::PropDeclaration)
+
+      def find_edge(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 &&= (node[k] == v)
+              break unless found
+            end
+            return edge if found
+          end
+        end
+        nil
+      end
+
+      def find_edges(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 &&= (node[k] == v)
+              break unless found
+            end
+            found_edges << edge if found
+          end
+        end
+        found_edges
+      end
+
+      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)
+        items_hash = {}
+        own_edge_cids = own_edges_as_cids
+        own_node_cids = own_nodes_as_cids
+        items_hash['edges'] = own_edge_cids.to_a if own_edge_cids.size > 0
+        items_hash['nodes'] = own_node_cids.to_a if own_node_cids.size > 0
+
+        if @included_arrays.size > 0
+          items_hash['included_arrays'] = {}
+          @included_arrays.each do |name, instance|
+            items_hash['included_arrays'][name.to_s] = if self.class.included_arrays[name].key?(:anonymous)
+                                                    instance.to_transport(inline: true)
+                                                  else
+                                                    instance.to_gid
+                                                  end
+          end
+        end
+
+        if @included_collections.size > 0
+          items_hash['included_collections'] = {}
+          @included_collections.each do |name, instance|
+            items_hash['included_collections'][name.to_s] = if self.class.included_collections[name].key?(:anonymous)
+                                                         instance.to_transport(inline: true)
+                                                       else
+                                                         instance.to_gid
+                                                       end
+          end
+        end
+
+        if @included_graphs.size > 0
+          items_hash['included_graphs'] = {}
+          @included_graphs.each do |name, instance|
+            items_hash['included_graphs'][name.to_s] = if self.class.included_graphs[name].key?(:anonymous)
+                                                    instance.to_transport(inline: true)
+                                                  else
+                                                    instance.to_gid
+                                                  end
+          end
+        end
+
+        if @included_hashes.size > 0
+          items_hash['included_hashes'] = {}
+          @included_hashes.each do |name, instance|
+            items_hash['included_hashes'][name.to_s] = if self.class.included_hashes[name].key?(:anonymous)
+                                                    instance.to_transport(inline: true)
+                                                  else
+                                                    instance.to_gid
+                                                  end
+          end
+        end
+
+        incl_nodes = included_nodes
+        if incl_nodes.size > 0
+          items_hash['included_nodes'] = {}
+          incl_nodes.each do |name, instance|
+            items_hash['included_nodes'][name.to_s] = instance.to_cid
+          end
+        end
+
+        if inline
+          { '_inline' => { @props_json => items_hash }}
+        else
+          { 'graphs' => { @class_name => { @props_json => items_hash }}}
+        end
+      end
+
+      def included_items_to_transport
+        result_hash = {}
+
+        self.class.included_arrays.each do |name, options|
+          unless options.key?(:anonymous)
+            result_hash.deep_merge!(@included_arrays[name].to_transport)
+          end
+        end
+
+        self.class.included_collections.each do |name, options|
+          unless options.key?(:anonymous)
+            result_hash.deep_merge!(@included_collections[name].to_transport)
+          end
+          result_hash.deep_merge!(@included_collections[name].included_items_to_transport)
+        end
+
+        self.class.included_graphs.each do |name, options|
+          unless options.key?(:anonymous)
+            result_hash.deep_merge!(@included_graphs[name].to_transport)
+          end
+          result_hash.deep_merge!(@included_graphs[name].included_items_to_transport)
+        end
+
+        self.class.included_hashes.each do |name, options|
+          unless options.key?(:anonymous)
+            result_hash.deep_merge!(@included_hashes[name].to_transport)
+          end
+        end
+
+        included_nodes.each_value do |instance|
+          result_hash.deep_merge!(instance.to_transport)
+        end
+
+        edges.each do |edge|
+          result_hash.deep_merge!(edge.to_transport)
+        end
+
+        nodes.each do |node|
+          result_hash.deep_merge!(node.to_transport)
+        end
+
+        result_hash
+      end
+
+      base.instance_exec do
+        def included_arrays
+          @included_arrays ||= {}
+        end
+
+        def included_collections
+          @included_collections ||= {}
+        end
+
+        def included_graphs
+          @included_graphs ||= {}
+        end
+
+        def included_hashes
+          @included_hashes ||= {}
+        end
+
+        def included_nodes
+          @included_nodes ||= {}
+        end
+
+        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, :graphs, @class_name, @props_json]
+
+          @included_arrays = {}
+          self.class.included_arrays.each do |name, options|
+            @included_arrays[name] = if options.key?(:anonymous)
+                                       options[:class].new(store_path: @store_path + [:included_arrays, name, :_inline],
+                                                           validated_props: @props)
+                                     else
+                                       options[:class].new(validated_props: @props)
+                                     end
+          end
+          @included_collections = {}
+          self.class.included_collections.each do |name, options|
+            @included_collections[name] = if options.key?(:anonymous)
+                                            options[:class].new(store_path: @store_path + [:included_arrays, name, :_inline],
+                                                                validated_props: @props)
+                                          else
+                                            options[:class].new(validated_props: @props)
+                                          end
+          end
+          @included_graphs = {}
+          self.class.included_graphs.each do |name, options|
+            @included_graphs[name] = if options.key?(:anonymous)
+                                       options[:class].new(store_path: @store_path + [:included_arrays, name, :_inline],
+                                                           validated_props: @props)
+                                     else
+                                       options[:class].new(validated_props: @props)
+                                     end
+          end
+          @included_hashes = {}
+          self.class.included_hashes.each do |name, options|
+            @included_hashes[name] = if options.key?(:anonymous)
+                                       options[:class].new(store_path: @store_path + [:included_arrays, name, :_inline],
+                                                           validated_props: @props)
+                                     else
+                                       options[:class].new(validated_props: @props)
+                                     end
+          end
+        end
+
+        def loaded?
+          Redux.fetch_by_path(*@store_path) ? true : false
+        end
+
+        def edges
+          edges_as_cids.map { |edge_cid| LucidEdge::Base.edge_from_cid(edge_cid) }
+        end
+
+        def edges_as_cids
+          edge_cids = own_edges_as_cids
+          @included_graphs.each_value { |graph| edge_cids += graph.edges_as_cids }
+          edge_cids
+        end
+
+        def own_edges_as_cids
+          path = @store_path + [:edges]
+          Redux.register_used_store_path(*path)
+          edge_cids = Redux.fetch_by_path(*path)
+          edge_cids ? Set.new(edge_cids) : Set.new
+        end
+
+        def find_edge_by_id(edge_id)
+          edges_as_cids.each do |edge_cid|
+            return  LucidNode::Base.edge_from_cid(edge_cid) if edge_cid[1] == edge_id
+          end
+          nil
+        end
+
+        def find_node_by_id(node_id)
+          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 included_nodes
+          incl_nodes = {}
+          path = @store_path + [:included_nodes]
+          Redux.register_used_store_path(*path)
+          self.class.included_nodes.each_key do |name|
+            node_cid = Redux.fetch_by_path(*(path + [name]))
+            incl_nodes[name] = LucidNode::Base.node_from_cid(node_cid) if node_cid
+          end
+          incl_nodes
+        end
+
+        def nodes
+          nodes_as_cids.map { |node_cid| LucidNode::Base.node_from_cid(node_cid) }
+        end
+
+        def nodes_as_cids
+          node_cids = own_nodes_as_cids
+          @included_graphs.each_value { |graph| node_cids += graph.nodes_as_cids }
+          @included_collections.each_value { |collection| node_cids += collection.nodes_as_cids }
+          included_nodes.each_value { |node| node_cids << node.to_cid }
+          node_cids
+        end
+
+        def own_nodes_as_cids
+          path = @store_path + [:nodes]
+          Redux.register_used_store_path(*path)
+          node_cids = Redux.fetch_by_path(*path)
+          node_cids ? Set.new(node_cids) : Set.new
+        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)
+          elsif method_name.JS.startsWith('find_edge_by_')
+            attribute = method_name[13..-1] # remove 'find_edge_by_'
+            value = args[0]
+            attribute_hash = { attribute => value }
+            attribute_hash.merge!(args[1]) if args[1]
+            find_edge(attribute_hash)
+          else
+            super
+          end
+        end
+
+        base.instance_exec do
+          def include_array(name, array_class = nil, &block)
+            included_arrays[name] = if array_class
+                                      { class: array_class }
+                                    else
+                                      new_class = Class.new(LucidArray::Base)
+                                      new_class.instance_exec(&block)
+                                      { anonymous: true, class: new_class }
+                                    end
+            define_method(name) do
+              @included_arrays[name]
+            end
+          end
+
+          def include_collection(name, collection_class = nil, &block)
+            included_collections[name] = if collection_class
+                                           { class: collection_class }
+                                         else
+                                           new_class = Class.new(LucidCollection::Base)
+                                           new_class.instance_exec(&block)
+                                           { anonymous: true, class: new_class }
+                                         end
+            define_method(name) do
+              @included_collections[name]
+            end
+          end
+
+          def include_graph(name, graph_class = nil, &block)
+            included_graphs[name] = if graph_class
+                                      { class: graph_class }
+                                    else
+                                      new_class = Class.new(LucidGraph::Base)
+                                      new_class.instance_exec(&block)
+                                      { anonymous: true, class: new_class }
+                                    end
+            define_method(name) do
+              @included_graphs[name]
+            end
+          end
+
+          def include_hash(name, hash_class = nil, &block)
+            included_hashes[name] = if hash_class
+                                      { class: hash_class }
+                                    else
+                                      new_class = Class.new(LucidHash::Base)
+                                      new_class.instance_exec(&block)
+                                      { anonymous: true, class: new_class }
+                                    end
+            define_method(name) do
+              @included_hashes[name]
+            end
+          end
+
+          def include_node(name, node_class, &block)
+            included_nodes[name] = { class: node_class, anonymous: true, block: block }
+            define_method(name) do
+              path = @store_path + [:included_nodes, name]
+              Redux.register_used_store_path(*path)
+              node_cid = Redux.fetch_by_path(*path)
+              node_cid ? self.class.included_nodes[name][:class].node_from_cid(node_cid) : nil
+            end
+          end
+
+          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, :graphs, self.name, props_json)
+
+            Isomorfeus::Transport.promise_send_path('Isomorfeus::Data::Handler::GraphLoadHandler', 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 == LucidGraph::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
+          @included_arrays = {}
+          @included_collections = {}
+          @included_hashes = {}
+          @included_graphs = {}
+          @included_nodes = {}
+          @class_name = self.class.name
+          @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def edges
+          all_edges = @edges.to_a
+          @included_graphs.each_value { |graph| all_edges += graph.edges }
+          all_edges.uniq!(&:to_cid)
+          all_edges
+        end
+
+        def edges_as_cids
+          edges.map { |edge| [edge.class.name, edge.id] }
+        end
+
+        def own_edges_as_cids
+          @edges.map(&:to_cid).uniq
+        end
+
+        def nodes
+          all_nodes = @nodes.to_a
+          @included_graphs.each_value { |graph| all_nodes += graph.nodes }
+          @included_collections.each_value { |collection| all_nodes += collection.nodes }
+          included_nodes.each_value { |node| all_nodes << node }
+          all_nodes.uniq!(&:to_cid)
+          all_nodes
+        end
+
+        def nodes_as_cids
+          nodes.map { |node| [node.class.name, node.id] }
+        end
+
+        def own_nodes_as_cids
+          @nodes.map(&:to_cid).uniq
+        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)
+          elsif method_name.start_with?('find_edge_by_')
+            attribute = method_name[13..-1] # remove 'find_edge_by_'
+            value = args[0]
+            attribute_hash = { attribute => value }
+            attribute_hash.merge!(args[1]) if args[1]
+            find_edge(attribute_hash)
+          else
+            super
+          end
+        end
+
+        base.instance_exec do
+          attr_accessor :included_nodes
+
+          def include_array(name, array_class = nil, &block)
+            included_arrays[name] = if array_class
+                                           { class: array_class }
+                                         else
+                                           new_class = Class.new(LucidArray::Base)
+                                           new_class.instance_exec(&block)
+                                           { anonymous: true, class: new_class }
+                                         end
+            define_method(name) do
+              @included_arrays[name]
+            end
+          end
+
+          def include_collection(name, collection_class = nil, &block)
+            included_collections[name] = if collection_class
+                                           { class: collection_class }
+                                         else
+                                           new_class = Class.new(LucidCollection::Base)
+                                           new_class.instance_exec(&block)
+                                           { anonymous: true, class: new_class }
+                                         end
+            define_method(name) do
+              @included_collections[name]
+            end
+          end
+
+          def include_graph(name, graph_class = nil, &block)
+            included_graphs[name] = if graph_class
+                                      { class: graph_class }
+                                    else
+                                      new_class = Class.new(LucidGraph::Base)
+                                      new_class.instance_exec(&block)
+                                      { anonymous: true, class: new_class }
+                                    end
+            define_method(name) do
+              @included_graphs[name]
+            end
+          end
+
+          def include_hash(name, hash_class = nil, &block)
+            included_hashes[name] = if hash_class
+                                      { class: hash_class }
+                                    else
+                                      new_class = Class.new(LucidHash::Base)
+                                      new_class.instance_exec(&block)
+                                      { anonymous: true, class: new_class }
+                                    end
+            define_method(name) do
+              @included_hashes[name]
+            end
+          end
+
+          def include_node(name, node_class, &block)
+            included_nodes[name] = { class: node_class, anonymous: true, block: block }
+            define_method(name) do
+              included_nodes[name]
+            end
+          end
+
+          def load(props_hash = {})
+            validate_props(props_hash)
+            instance = self.new(validated_props: Isomorfeus::Data::Props.new(props_hash))
+            instance.instance_exec do
+              nodes, edges = self.class.query_block.call(props_hash)
+              @nodes = Set.new(nodes)
+              @edges = Set.new(edges)
+              self.class.included_arrays.each do |name, options|
+                @included_arrays[name] = options[:class].load(props_hash)
+              end
+              self.class.included_collections.each do |name, options|
+                @included_collections[name] = options[:class].load(props_hash)
+              end
+              self.class.included_graphs.each do |name, options|
+                @included_graphs[name] = options[:class].load(props_hash)
+              end
+              self.class.included_hashes.each do |name, options|
+                @included_hashes[name] = options[:class].load(props_hash)
+              end
+              self.class.included_nodes.each do |name, options|
+                result = options[:block].call(props_hash)
+                @included_nodes[name] = if result.class == options[:class]
+                                          result
+                                        elsif result.class == Hash
+                                          options[:class].new(result)
+                                        end
+              end
+              @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_hash/base.rb

@@ -0,0 +1,15 @@
+module LucidHash
+  class Base
+    include LucidHash::Mixin
+
+    if RUBY_ENGINE != 'opal'
+      def self.inherited(base)
+        Isomorfeus.add_valid_hash_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