isomorfeus-data 1.0.0.zeta5 → 1.0.0.zeta6

data/lib/lucid_collection/mixin.rb

@@ -1,241 +0,0 @@
-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(LucidPropDeclaration::Mixin)
-
-      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)
-          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
-          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)
-
-            Isomorfeus::Transport.promise_send_path('Isomorfeus::Data::Handler::CollectionLoadHandler', self.name, props_json).then do |agent|
-              if agent.processed
-                agent.result
-              else
-                agent.processed = true
-                if agent.response.key?(:error)
-                  `console.error(#{agent.response[:error].to_n})`
-                  raise agent.response[:error]
-                end
-                Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
-                agent.result = instance
-              end
-            end
-          end
-
-          def query
-            nil
-          end
-        end
-      else # RUBY_ENGINE
-        unless base == LucidCollection::Base
-          base.prop :pub_sub_client, 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

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

data/lib/lucid_edge/mixin.rb

@@ -1,238 +0,0 @@
-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
-          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
-          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)
-          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
-              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)
-              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

@@ -1,14 +0,0 @@
-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 :current_user, default: nil
-      end
-    end
-  end
-end