isomorfeus-data 1.0.0.zeta10 → 1.0.0.zeta11

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

@@ -18,53 +18,103 @@ module LucidData
             @node_collections ||= {}
           end
 
-          def nodes(access_name, collection_class = nil)
-            node_collections[access_name] = collection_class
+          def nodes(access_name, validate_hash = {})
+            node_collections[access_name] = validate_hash
 
             define_method(access_name) do
               node_collections[access_name]
             end
 
             define_method("#{access_name}=") do |collection|
+              _validate_node_collection(access_name, collection)
               @_changed = true
               node_collections[access_name] = collection
               node_collections[access_name].graph = self
               node_collections[access_name]
             end
 
-            if collection_class
-              singular_access_name = access_name.to_s.singularize
-              define_singleton_method("valid_#{singular_access_name}?") do |node|
-                collection_class.valid_node?(node)
-              end
+            define_singleton_method("valid_#{access_name}?") do |collection|
+              _validate_node_collection(access_name, collection)
+            rescue
+              false
             end
           end
           alias documents nodes
           alias vertices nodes
           alias vertexes nodes
 
-          def edges(access_name, collection_class = nil)
-            edge_collections[access_name] = collection_class
+          def _validate_nodes(nodes_hash_or_array)
+            if nodes_hash_or_array.class == ::Hash
+              nodes_hash_or_array.each do |access_name, collection|
+                _validate_node_collection(access_name, collection)
+              end
+            else
+              _validate_node_collection(:nodes, nodes_hash_or_array)
+            end
+          end
+
+          def _validate_node_collection(access_name, collection)
+            unless node_collections.key?(access_name) || access_name == :nodes
+              raise "#{self.name}: No such node collection declared: '#{access_name}'!"
+            end
+            Isomorfeus::Data::ElementValidator.new(self.name, collection, node_collections[access_name]).validate! if node_collections[access_name]
+          end
+
+          def edges(access_name, validate_hash = {})
+            edge_collections[access_name] = validate_hash
 
             define_method(access_name) do
               edge_collections[access_name]
             end
 
             define_method("#{access_name}=") do |collection|
+              _validate_edge_collection(access_name, collection)
               @_changed = true
               edge_collections[access_name] = collection
               edge_collections[access_name].graph = self
               edge_collections[access_name]
             end
 
-            if collection_class
-              singular_access_name = access_name.to_s.singularize
-              define_singleton_method("valid_#{singular_access_name}?") do |edge|
-                collection_class.valid_edge?(edge)
-              end
+            define_singleton_method("valid_#{access_name}?") do |collection|
+              _validate_edge_collection(access_name, collection)
+            rescue
+              false
             end
           end
           alias links edges
+
+          def _validate_edges(edges_hash_or_array)
+            if edges_hash_or_array.class == ::Hash
+              edges_hash_or_array.each do |access_name, collection|
+                _validate_edge_collection(access_name, collection)
+              end
+            else
+              _validate_edge_collection(:edges, edges_hash_or_array)
+            end
+          end
+
+          def _validate_edge_collection(access_name, collection)
+            unless edge_collections.key?(access_name) || access_name == :edges
+              raise "#{self.name}: No such edge collection declared: '#{access_name}'!"
+            end
+            Isomorfeus::Data::ElementValidator.new(self.name, collection, edge_collections[access_name]).validate! if edge_collections[access_name]
+          end
+        end
+
+        def _validate_edges(edges_hash_or_array)
+          self.class._validate_edges(edges_hash_or_array)
+        end
+
+        def _validate_edge_collection(access_name, collection)
+          self.class._validate_edge_collection(access_name, collection)
+        end
+
+        def _validate_nodes(nodes_hash_or_array)
+          self.class._validate_nodes(nodes_hash_or_array)
+        end
+
+        def _validate_node_collection(access_name, collection)
+          self.class._validate_node_collection(access_name, collection)
         end
 
         def method_missing(method_name, *args, &block)
@@ -200,7 +250,7 @@ module LucidData
             loaded = loaded?
 
             if attributes
-              attributes.each { |a,v| _validate_attribute(a, v) }
+              _validate_attributes(attributes)
               if loaded
                 raw_attributes = Redux.fetch_by_path(*@_store_path)
                 if `raw_attributes === null`
@@ -219,6 +269,7 @@ module LucidData
             @_node_collections = {}
             nodes = nodes || documents || vertices || vertexes
             if nodes && loaded
+              _validate_nodes(nodes)
               if nodes.class == ::Hash
                 self.class.node_collections.each_key do |access_name|
                   if nodes.key?(access_name)
@@ -249,6 +300,7 @@ module LucidData
             @_edge_collections = {}
             edges = edges || links
             if edges && loaded
+              _validate_edges(edges)
               if edges.class == ::Hash
                 self.class.edge_collections.each_key do |access_name|
                   if edges.key?(access_name)
@@ -329,34 +381,54 @@ module LucidData
 
           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)
+              data = instance_exec(key: key, pub_sub_client: pub_sub_client, current_user: current_user, &@_load_block)
+              revision = data.delete(:revision)
               nodes = data.delete(:nodes)
               edges = data.delete(:edges)
               attributes = data.delete(:attributes)
               self.new(key: key, revision: revision, edges: edges, nodes: nodes, attributes: attributes)
             end
+
+            def save(key:, revision: nil, attributes: nil, edges: nil, links: nil, nodes: nil, documents: nil, vertices: nil, vertexes: nil,
+                     pub_sub_client: nil, current_user: nil)
+              attributes = {} unless attributes
+              val_edges = edges || links
+              val_nodes = documents || nodes || vertexes || vertices
+              _validate_attributes(attributes) if attributes.any?
+              _validate_edges(val_edges)
+              _validate_nodes(val_nodes)
+              data = instance_exec(key: key, revision: revision, parts: parts, attributes: attributes,
+                                   pub_sub_client: pub_sub_client, current_user: current_user, &@_save_block)
+              revision = data.delete(:revision)
+              attributes = data.delete(:attributes)
+              documents = data.delete(:documents)
+              vertexes = data.delete(:vertexes)
+              vertices = data.delete(:vertices)
+              nodes = data.delete(:nodes)
+              edges = data.delete(:edges)
+              links = data.delete(:links)
+              self.new(key: key, revision: revision, attributes: attributes, edges: edges, links: links, nodes: nodes, documents: documents,
+                       vertices: vertices, vertexes: vertexes, pub_sub_client: nil, current_user: nil)
+            end
           end
 
-          def initialize(key:, revision: nil, attributes: nil, edges: nil, links: nil, nodes: nil, documents: nil, vertices: nil, vertexes: nil, composition: nil)
+          def initialize(key:, revision: nil, attributes: nil, edges: nil, links: nil, nodes: nil, documents: nil, vertices: nil, vertexes: 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
             @_changed = false
             @_composition = composition
-            @_validate_attributes = self.class.attribute_conditions.any?
             attributes = {} unless attributes
-            if @_validate_attributes
-              attributes.each { |a,v| _validate_attribute(a, v) }
-            end
+            _validate_attributes(attributes) if attributes.any?
             @_raw_attributes = attributes
 
             # nodes
             @_node_collections = {}
             nodes = nodes || documents || vertices || vertexes
             if nodes.class == ::Hash
+              _validate_nodes(nodes)
               self.class.node_collections.each_key do |access_name|
                 if nodes.key?(access_name)
                   @_node_collections[access_name] = nodes[access_name]
@@ -364,6 +436,7 @@ module LucidData
                 end
               end
             else
+              _validate_nodes(nodes) if nodes
               @_node_collections[:nodes] = nodes ? nodes : []
               @_node_collections[:nodes].graph = self if @_node_collections[:nodes].respond_to?(:graph=)
             end
@@ -372,6 +445,7 @@ module LucidData
             @_edge_collections = {}
             edges = edges || links
             if edges.class == ::Hash
+              _validate_edges(edges)
               self.class.edge_collections.each_key do |access_name|
                 if edges.key?(access_name)
                   @_edge_collections[access_name] = edges[access_name]
@@ -379,6 +453,7 @@ module LucidData
                 end
               end
             else
+              _validate_edges(edges) if edges
               @_edge_collections[:edges] = edges ? edges : []
               @_edge_collections[:edges].graph = self if @_edge_collections[:edges].respond_to?(:graph=)
             end

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

@@ -4,6 +4,7 @@ module LucidData
       def self.included(base)
         base.include(Enumerable)
         base.extend(LucidPropDeclaration::Mixin)
+        base.include(Isomorfeus::Data::AttributeSupport)
         base.extend(Isomorfeus::Data::GenericClassApi)
         base.include(Isomorfeus::Data::GenericInstanceApi)
 
@@ -11,16 +12,25 @@ module LucidData
         attr_accessor :default_proc
 
         base.instance_exec do
-          def attribute_conditions
-            @attribute_conditions ||= {}
-          end
-
           def valid_attribute?(attr_name, attr_value)
-            return true unless @attribute_conditions
+            return true unless attribute_conditions.any?
             Isomorfeus::Props::Validator.new(self.name, attr_name, attr_value, attribute_conditions[attr_name]).validate!
           rescue
             false
           end
+
+          def _relaxed_validate_attribute(attr_name, attr_val)
+            Isomorfeus::Props::Validator.new(@class_name, attr_name, attr_val, attribute_conditions[attr_name]).validate!
+          end
+
+          def _relaxed_validate_attributes(attrs)
+            attribute_conditions.each_key do |attr|
+              if attribute_conditions[attr].key?(:required) && attribute_conditions[attr][:required] && !attrs.key?(attr)
+                raise "Required attribute #{attr} not given!"
+              end
+            end
+            attrs.each { |attr, val| _relaxed_validate_attribute(attr, val) } if attribute_conditions.any?
+          end
         end
 
         def composition
@@ -42,8 +52,12 @@ module LucidData
           { @class_name => { @key => hash }}
         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!
+        def _relaxed_validate_attribute(attr_name, attr_val)
+          self.class._relaxed_validate_attribute(attr_name, attr_val)
+        end
+
+        def _relaxed_validate_attributes(attrs)
+          self.class._relaxed_validate_attributes(attrs)
         end
 
         if RUBY_ENGINE == 'opal'
@@ -63,7 +77,7 @@ module LucidData
               end
 
               define_method("#{name}=") do |val|
-                _validate_attribute(name, val) if @_validate_attributes
+                _relaxed_validate_attribute(name, val) if @_validate_attributes
                 @_changed_attributes[name] = val
               end
             end
@@ -82,9 +96,7 @@ module LucidData
             @_composition = composition
             @_validate_attributes = self.class.attribute_conditions.any?
             attributes = {} unless attributes
-            if @_validate_attributes
-              attributes.each { |a,v| _validate_attribute(a, v) }
-            end
+            _relaxed_validate_attributes(attributes) if @_validate_attributes
             raw_attributes = Redux.fetch_by_path(*@_store_path)
             if `raw_attributes === null`
               @_changed_attributes = !attributes ? {} : attributes
@@ -129,7 +141,7 @@ module LucidData
           end
 
           def []=(name, val)
-            _validate_attribute(name, val) if @_validate_attributes
+            _relaxed_validate_attribute(name, val) if @_validate_attributes
             changed!
             @_changed_attributes[name] = val
           end
@@ -161,7 +173,7 @@ module LucidData
           def method_missing(method_name, *args, &block)
             if method_name.end_with?('=')
               val = args[0]
-              _validate_attribute(method_name, val) if @_validate_attributes
+              _relaxed_validate_attribute(method_name, val) if @_validate_attributes
               changed!
               @_changed_attributes[method_name] = val
             elsif args.size == 0 && hash.key?(method_name)
@@ -222,7 +234,7 @@ module LucidData
           end
 
           def store(name, val)
-            _validate_attribute(name, val) if @_validate_attributes
+            _relaxed_validate_attribute(name, val) if @_validate_attributes
             @_changed_attributes[name] = val
             changed!
             val
@@ -265,16 +277,25 @@ module LucidData
               end
 
               define_method("#{name}=") do |val|
-                _validate_attribute(name, val) if @_validate_attributes
+                _relaxed_validate_attribute(name, val) if @_validate_attributes
                 changed!
                 @_raw_attributes[name] = val
               end
             end
 
             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)
+              data = instance_exec(key: key, pub_sub_client: pub_sub_client, current_user: current_user, &@_load_block)
+              revision = data.delete(:revision)
+              attributes = data.delete(:attributes)
+              self.new(key: key, revision: revision, attributes: attributes)
+            end
+
+            def save(key:, revision: nil, attributes: nil, pub_sub_client: nil, current_user: nil)
+              attributes = {} unless attributes
+              _relaxed_validate_attributes(attributes)
+              data = instance_exec(key: key, revision: revision, attributes: attributes,
+                                   pub_sub_client: pub_sub_client, current_user: current_user, &@_save_block)
+              revision = data.delete(:revision)
               attributes = data.delete(:attributes)
               self.new(key: key, revision: revision, attributes: attributes)
             end
@@ -289,9 +310,7 @@ module LucidData
             @_changed = false
             @_validate_attributes = self.class.attribute_conditions.any?
             attributes = {} unless attributes
-            if @_validate_attributes
-              attributes.each { |a,v| _validate_attribute(a, v) }
-            end
+            _relaxed_validate_attributes(attributes) if @_validate_attributes
             @_raw_attributes = attributes
           end
 
@@ -308,7 +327,7 @@ module LucidData
           end
 
           def []=(name, val)
-            _validate_attribute(name, val) if @_validate_attributes
+            _relaxed_validate_attribute(name, val) if @_validate_attributes
             changed!
             @_raw_attributes[name] = val
           end
@@ -341,7 +360,7 @@ module LucidData
           def method_missing(method_name, *args, &block)
             if method_name.end_with?('=')
               val = args[0]
-              _validate_attribute(name, val) if @_validate_attributes
+              _relaxed_validate_attribute(name, val) if @_validate_attributes
               changed!
               @_raw_attributes[name] = val
             elsif args.size == 0 && @_raw_attributes.key?(method_name)
@@ -379,7 +398,7 @@ module LucidData
           end
 
           def store(name, val)
-            _validate_attribute(name, val) if @_validate_attributes
+            _relaxed_validate_attribute(name, val) if @_validate_attributes
             changed!
             @_raw_attributes[name] = val
           end

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

@@ -63,7 +63,7 @@ module LucidData
             @_changed = false
             loaded = loaded?
             if attributes
-              attributes.each { |a,v| _validate_attribute(a, v) }
+              _validate_attributes(attributes)
               if loaded
                 raw_attributes = Redux.fetch_by_path(*@_store_path)
                 if `raw_attributes === null`
@@ -146,11 +146,19 @@ module LucidData
 
           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)
-              data.delete(:_key)
-              attributes = data.key?(:attributes) ? data.delete(:attributes) : data
+              data = instance_exec(key: key, pub_sub_client: pub_sub_client, current_user: current_user, &@_load_block)
+              revision = data.delete(:revision)
+              attributes = data.delete(:attributes)
+              self.new(key: key, revision: revision, attributes: attributes)
+            end
+
+            def save(key:, revision: nil, attributes: nil, pub_sub_client: nil, current_user: nil)
+              attributes = {} unless attributes
+              _validate_attributes(attributes)
+              data = instance_exec(key: key, revision: revision, attributes: attributes,
+                                   pub_sub_client: pub_sub_client, current_user: current_user, &@_save_block)
+              revision = data.delete(:revision)
+              attributes = data.delete(:attributes)
               self.new(key: key, revision: revision, attributes: attributes)
             end
           end
@@ -163,11 +171,8 @@ module LucidData
             @_collection = collection
             @_composition = composition
             @_changed = false
-            @_validate_attributes = self.class.attribute_conditions.any?
             attributes = {} unless attributes
-            if @_validate_attributes
-              attributes.each { |a,v| _validate_attribute(a, v) }
-            end
+            _validate_attributes(attributes) if attributes
             @_raw_attributes = attributes
           end
 

data/lib/isomorfeus_data/lucid_data/query_result.rb

@@ -0,0 +1,93 @@
+module LucidData
+  class QueryResult
+    attr_reader :key
+
+    def to_sid
+      [@class_name, @key]
+    end
+
+    if RUBY_ENGINE == 'opal'
+      def initialize(key: nil, result_set: {})
+        @class_name = 'LucidData::QueryResult'
+        @key = key ? key.to_s : self.object_id.to_s
+        @result_set = result_set
+      end
+
+      def _load_from_store!
+        @result_set = nil
+      end
+
+      def loaded?
+        Redux.fetch_by_path([:data_state, @class_name, @key]) ? true : false
+      end
+
+      def key?(k)
+        if @result_set.any?
+          @result_set.key?(k)
+        else
+          stored_results = Redux.fetch_by_path([:data_state, @class_name, @key])
+          `Object.hasOwnProperty(stored_results, k)`
+        end
+      end
+      alias has_key? key?
+
+      def result_set=(r)
+        @result_set = r
+      end
+
+      def method_missing(accessor_name, *args, &block)
+        raise "#{@class_name}: no such thing '#{accessor_name}‘in the results!" unless @result_set.key?(accessor_name)
+        sid = if @result_set.any?
+                @result_set[accessor_name]
+              else
+                stored_results = Redux.fetch_by_path([:data_state, @class_name, @key])
+                stored_results.JS[accessor_name]
+              end
+        Isomorfeus.instance_from_sid(sid)
+      end
+    else
+      def initialize(key: nil, result_set: {})
+        @class_name = 'LucidData::QueryResult'
+        @key = key ? key.to_s : self.object_id.to_s
+        @result_set = result_set
+      end
+
+      def loaded?
+        @result_set.any?
+      end
+
+      def key?(k)
+        @result_set.key?(k)
+      end
+      alias has_key? key?
+
+      def result_set=(r)
+        @result_set = r
+      end
+
+      def method_missing(accessor_name, *args, &block)
+        raise "#{@class_name}: no such thing '#{accessor_name}‘in the results!" unless @result_set.key?(accessor_name)
+        @result_set[accessor_name]
+      end
+
+      def to_transport
+        sids_hash = {}
+        @result_set.each do |key, value|
+          sids_hash[key] = value.to_sid
+        end
+        { @class_name => { @key => sids_hash }}
+      end
+
+      def included_items_to_transport
+        data_hash = {}
+        @result_set.each_value do |value|
+          data_hash.deep_merge!(value.to_transport)
+          if value.respond_to?(:included_items_to_transport)
+            data_hash.deep_merge!(value.included_items_to_transport)
+          end
+        end
+        data_hash
+      end
+    end
+  end
+end