isomorfeus-data 1.0.0.zeta10 → 1.0.0.zeta11

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

@@ -10,7 +10,7 @@ module LucidData
         base.include(LucidData::Collection::Finders)
 
         base.instance_exec do
-          def nodes(validate_hash = {})
+          def nodes(validate_hash)
             @node_conditions = validate_hash
           end
           alias document nodes
@@ -21,25 +21,33 @@ module LucidData
           alias node nodes
 
           def node_conditions
-            @node_conditions
+            @node_conditions ||= {}
           end
 
           def valid_node?(node)
-            return true unless @node_conditions
-            Isomorfeus::Data::ElementValidator.new(self.name, node, @node_conditions).validate!
+            return true unless node_conditions.any?
+            _validate_node(node)
           rescue
             false
           end
           alias valid_vertex? valid_node?
           alias valid_document? valid_node?
+
+          def _validate_node(node)
+            Isomorfeus::Data::ElementValidator.new(self.to_s, node, node_conditions).validate!
+          end
+
+          def _validate_nodes(many_nodes)
+            many_nodes.each { |node| _validate_node(node) } if node_conditions.any?
+          end
         end
 
         def _validate_node(node)
-          Isomorfeus::Data::ElementValidator.new(@class_name, node, @_node_con).validate!
+          self.class._validate_node(node)
         end
 
         def _validate_nodes(many_nodes)
-          many_nodes.each { |node| Isomorfeus::Data::ElementValidator.new(@class_name, node, @_node_con).validate! }
+          self.class._validate_nodes(many_nodes)
         end
 
         def _collection_to_sids(collection)
@@ -111,13 +119,12 @@ module LucidData
             @_composition = composition
             @_changed = false
             @_changed_collection = nil
-            @_node_con = self.class.node_conditions
-            @_validate_nodes = @_node_con ? true : false
+            @_validate_nodes = self.class.node_conditions.any?
 
             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`
@@ -134,9 +141,7 @@ module LucidData
 
             nodes = documents || nodes || vertices || vertexes
             if nodes && loaded
-              if @_validate_nodes
-                nodes.each { |e| _validate_node(e) }
-              end
+              _validate_nodes(nodes)
               raw_nodes = _collection_to_sids(nodes)
               raw_collection = Redux.fetch_by_path(*@_nodes_path)
               if raw_collection != raw_nodes
@@ -453,12 +458,32 @@ 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)
+              attributes = data.delete(:attributes)
+              documents = data.delete(:documents)
+              vertexes = data.delete(:vertexes)
+              vertices = data.delete(:vertices)
+              nodes = data.delete(:nodes)
+              self.new(key: key, revision: revision, attributes: attributes, documents: documents, vertexes: vertexes, vertices: vertices,
+                       nodes: nodes)
+            end
+
+            def save(key:, revision: nil, attributes: nil, documents: nil, vertexes: nil, vertices: nil, nodes: nil,
+                     pub_sub_client: nil, current_user: nil)
+              val_nodes = documents || nodes || vertexes || vertices
+              _validate_attributes(attributes) if self.class.attribute_conditions.any?
+              _validate_nodes(val_nodes) if self.class.node_conditions.any?
+              data = instance_exec(key: key, revision: revision, attributes: attributes, documents: documents, vertexes: vertexes, vertices: vertices,
+                                   nodes: nodes, 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)
-              self.new(key: key, revision: revision, attributes: attributes, nodes: nodes)
+              self.new(key: key, revision: revision, attributes: attributes, documents: documents, vertexes: vertexes, vertices: vertices,
+                       nodes: nodes)
             end
           end
 
@@ -471,20 +496,15 @@ module LucidData
             @_composition = composition
             @_changed = false
             @_validate_attributes = self.class.attribute_conditions.any?
-            @_node_con = self.class.node_conditions
-            @_validate_nodes = @_node_con ? true : false
+            @_validate_nodes = self.class.node_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
 
             nodes = documents || nodes || vertices || vertexes
             nodes = [] unless nodes
-            if @_validate_nodes
-              nodes.each { |n| _validate_node(n) }
-            end
+            _validate_nodes(nodes) if @_validate_nodes
             nodes.each { |n| n.collection = self }
             @_raw_collection = nodes
             @_sid_to_node_cache = {}

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

@@ -15,20 +15,50 @@ module LucidData
             @parts ||= {}
           end
 
-          def compose_with(access_name, part_class = nil)
-            parts[access_name] = part_class
+          def compose_with(access_name, validate_hash = {})
+            parts[access_name] = validate_hash
 
             define_method(access_name) do
               parts[access_name]
             end
 
             define_method("#{access_name}=") do |part|
+              part_conditions = self.class.parts[access_name]
+              Isomorfeus::Data::ElementValidator.new(self.name, part, part_conditions).validate!
               @_changed = true
               parts[access_name] = part
               parts[access_name].composition = self
               parts[access_name]
             end
+
+            define_singleton_method("valid_#{access_name}?") do |part|
+              _validate(access_name, part)
+            rescue
+              false
+            end
           end
+
+          def _validate_part(access_name, part)
+            raise "#{self.name}: No such part declared: '#{access_name}'!" unless parts.key?(access_name)
+            Isomorfeus::Data::ElementValidator.new(self.name, part, parts[access_name]).validate!
+          end
+
+          def _validate_parts(many_parts)
+            parts.each_key do |access_name|
+              if parts[access_name].key?(:required) && parts[access_name][:required] && !many_parts.key?(attr)
+                raise "Required part #{access_name} not given!"
+              end
+            end
+            many_parts.each { |access_name, part| _validate_part(access_name, part) } if parts.any?
+          end
+        end
+
+        def _validate_part(access_name, part)
+          self.class._validate_part(access_name, part)
+        end
+
+        def _validate_parts(many_parts)
+          self.class._validate_parts(many_parts)
         end
 
         def changed?
@@ -70,7 +100,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`
@@ -87,6 +117,7 @@ module LucidData
 
             @_parts = {}
             if parts && loaded
+              _validate_parts(parts)
               self.class.parts.each_key do |access_name|
                 if parts.key?(access_name)
                   part = parts[access_name]
@@ -140,9 +171,20 @@ 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)
+              attributes = data.delete(:attributes)
+              parts = data.delete(:parts)
+              self.new(key: key, revision: revision, parts: parts, attributes: attributes)
+            end
+
+            def save(key:, revision: nil, parts: nil, attributes: nil, pub_sub_client: nil, current_user: nil)
+              attributes = {} unless attributes
+              _validate_attributes(attributes)
+              _validate_parts(parts)
+              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)
               parts = data.delete(:parts)
               self.new(key: key, revision: revision, parts: parts, attributes: attributes)
@@ -157,12 +199,11 @@ 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
+            _validate_attributes(attributes) if attributes.any?
             @_raw_attributes = attributes
 
             @_parts = {}
+            _validate_parts(parts)
             self.class.parts.each_key do |access_name|
               if parts.key?(access_name)
                 @_parts[access_name] = parts[access_name]

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

@@ -74,7 +74,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`
@@ -170,15 +170,22 @@ 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)
-              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)
+              data = instance_exec(key: key, pub_sub_client: pub_sub_client, current_user: current_user, &@_load_block)
+              revision = data.delete(:revision)
+              from = data.delete(:from)
+              to = data.delete(:to)
+              attributes = data.delete(:attributes)
+              self.new(key: key, revision: revision, from: from, to: to, attributes: attributes)
+            end
+
+            def save(key:, revision: nil, from:, to:, attributes: nil, pub_sub_client: nil, current_user: nil)
+              attributes = {} unless attributes
+              _validate_attributes(attributes)
+              data = instance_exec(key: key, revision: revision, from: from, to: to, attributes: attributes,
+                                   pub_sub_client: pub_sub_client, current_user: current_user, &@_save_block)
+              revision = data.delete(:revision)
+              from = data.delete(:from)
+              to = data.delete(:to)
               attributes = data.delete(:attributes)
               self.new(key: key, revision: revision, from: from, to: to, attributes: attributes)
             end
@@ -192,11 +199,8 @@ module LucidData
             @_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
+            _validate_attributes(attributes) if attributes
             @_raw_attributes = attributes
             @_changed_from = nil
             @_changed_to = nil

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

@@ -10,30 +10,38 @@ module LucidData
         base.include(LucidData::EdgeCollection::Finders)
 
         base.instance_exec do
-          def edges(validate_hash = {})
+          def edges(validate_hash)
             @edge_conditions = validate_hash
           end
           alias links edges
 
           def edge_conditions
-            @edge_conditions
+            @edge_conditions ||= {}
           end
 
           def valid_edge?(edge)
-            return true unless @edge_conditions
-            Isomorfeus::Data::ElementValidator.new(self.name, edge, @edge_conditions).validate!
+            return true unless edge_conditions.any?
+            _validate_edge(edge)
           rescue
             false
           end
           alias valid_link? valid_edge?
+
+          def _validate_edge(edge)
+            Isomorfeus::Data::ElementValidator.new(self.to_s, edge, edge_conditions).validate!
+          end
+
+          def _validate_edges(many_edges)
+            many_edges.each { |edge| _validate_edge(edge) } if edge_conditions.any?
+          end
         end
 
         def _validate_edge(edge)
-          Isomorfeus::Data::ElementValidator.new(@class_name, edge, @_edge_con).validate!
+          self.class._validate_edge(edge)
         end
 
         def _validate_edges(many_edges)
-          many_edges.each { |edge| Isomorfeus::Data::ElementValidator.new(@class_name, edge, @_edge_con).validate! }
+          self.class._validate_edges(many_edges)
         end
 
         def _collection_to_sids(collection)
@@ -116,13 +124,12 @@ module LucidData
             @_composition = composition
             @_node_to_edge_cache = {}
             @_changed_collection = nil
-            @_edge_con = self.class.edge_conditions
-            @_validate_edges = @_edge_con ? true : false
+            @_validate_edges = self.class.edge_conditions.any?
 
             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`
@@ -139,9 +146,7 @@ module LucidData
 
             edges = edges || links
             if edges && loaded
-              if @_validate_edges
-                edges.each { |e| _validate_edges(e) }
-              end
+              _validate_edges(edges)
               raw_edges = _collection_to_sids(edges)
               raw_collection = Redux.fetch_by_path(*@_edges_path)
               if raw_collection != raw_edges
@@ -462,12 +467,25 @@ 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)
+              attributes = data.delete(:attributes)
+              edges = data.delete(:edges)
+              links = data.delete(:links)
+              self.new(key: key, revision: revision, attributes: attributes, edges: edges, links: links)
+            end
+
+            def save(key:, revision: nil, attributes: nil, edges: nil, links: nil, pub_sub_client: nil, current_user: nil)
+              val_edges = edges || links
+              _validate_attributes(attributes) if attributes
+              _validate_edges(val_edges)
+              data = instance_exec(key: key, revision: revision, attributes: attributes, edges: edges, links: links,
+                                   pub_sub_client: pub_sub_client, current_user: current_user, &@_save_block)
+              revision = data.delete(:revision)
               attributes = data.delete(:attributes)
               edges = data.delete(:edges)
-              self.new(key: key, revision: revision, attributes: attributes, edges: edges)
+              links = data.delete(:links)
+              self.new(key: key, revision: revision, attributes: attributes, edges: edges, links: links)
             end
           end
 
@@ -481,20 +499,15 @@ module LucidData
             @_node_to_edge_cache = {}
             @_changed = false
             @_validate_attributes = self.class.attribute_conditions.any?
-            @_edge_con = self.class.edge_conditions
-            @_validate_edges = @_edge_con ? true : false
+            @_validate_edges = self.class.edge_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
 
             edges = edges || links
             edges = [] unless edges
-            if @_validate_edges
-              edges.each { |e| _validate_edge(e) }
-            end
+            _validate_edges(edges) if @_validate_edges
             edges.each { |e| e.collection = self }
             @_raw_collection = edges
           end

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

@@ -2,7 +2,7 @@ module LucidData
   module Graph
     module Finders
       def find_node(attribute_hash = nil, &block)
-        @_node_collections.each_value do |collection|
+        node_collections.each_value do |collection|
           node = collection.find(attribute_hash, &block)
           return node if node
         end
@@ -13,9 +13,9 @@ module LucidData
 
       def find_nodes(attribute_hash = nil, &block)
         found_nodes = []
-        @_node_collections.each_value do |collection|
-          nodes = collection.find_all(attribute_hash, &block)
-          found_nodes.push(*nodes)
+        node_collections.each_value do |collection|
+          coll_nodes = collection.find_all(attribute_hash, &block)
+          found_nodes.push(*coll_nodes)
         end
         found_nodes
       end
@@ -24,7 +24,7 @@ module LucidData
       alias find_vertices find_nodes
 
       def find_node_by_key(node_key)
-        @_node_collections.each_value do |collection|
+        node_collections.each_value do |collection|
           node = collection.find_by_key(node_key)
           return node if node
         end
@@ -34,7 +34,7 @@ module LucidData
       alias find_vertex_by_key find_node_by_key
 
       def find_node_by_sid(node)
-        @_node_collections.each_value do |collection|
+        node_collections.each_value do |collection|
           node = collection.find_by_sid(node)
           return node if node
         end
@@ -44,7 +44,7 @@ module LucidData
       alias find_vertex_by_sid find_node_by_sid
 
       def find_edge(attribute_hash = nil, &block)
-        @_edge_collections.each_value do |collection|
+        edge_collections.each_value do |collection|
           edge = collection.find(attribute_hash, &block)
           return edge if edge
         end
@@ -54,16 +54,16 @@ module LucidData
 
       def find_edges(attribute_hash = nil, &block)
         found_edges = []
-        @_edge_collections.each_value do |collection|
-          edges = collection.find_all(attribute_hash, &block)
-          found_edges.push(*edges)
+        edge_collections.each_value do |collection|
+          coll_edges = collection.find_all(attribute_hash, &block)
+          found_edges.push(*coll_edges)
         end
         found_edges
       end
       alias find_links find_edges
 
       def find_edge_by_key(edge_key)
-        @_edge_collections.each_value do |collection|
+        edge_collections.each_value do |collection|
           edge = collection.find_by_key(edge_key)
           return edge if edge
         end
@@ -72,7 +72,7 @@ module LucidData
       alias find_link_by_key find_edge_by_key
 
       def find_edge_by_sid(edge)
-        @_edge_collections.each_value do |collection|
+        edge_collections.each_value do |collection|
           edge = collection.find_by_sid(edge)
           return edge if edge
         end
@@ -81,7 +81,7 @@ module LucidData
       alias find_link_by_key find_edge_by_key
 
       def find_edge_by_from(node)
-        @_edge_collections.each_value do |collection|
+        edge_collections.each_value do |collection|
           edge = collection.find_by_from(node)
           return edge if edge
         end
@@ -90,7 +90,7 @@ module LucidData
       alias find_link_by_from find_edge_by_from
 
       def find_edge_by_to(node)
-        @_edge_collections.each_value do |collection|
+        edge_collections.each_value do |collection|
           edge = collection.find_by_to(node)
           return edge if edge
         end
@@ -99,7 +99,7 @@ module LucidData
       alias find_link_by_to find_edge_by_to
 
       def find_edge_by_target(node)
-        @_edge_collections.each_value do |collection|
+        edge_collections.each_value do |collection|
           edge = collection.find_by_target(node)
           return edge if edge
         end
@@ -109,7 +109,7 @@ module LucidData
 
       def find_edges_by_from(node)
         found_edges = []
-        @_edge_collections.each_value do |collection|
+        edge_collections.each_value do |collection|
           coll_edges = collection.find_all_by_from(node)
           found_edges.push(*coll_edges)
         end
@@ -119,7 +119,7 @@ module LucidData
 
       def find_edges_by_to(node)
         found_edges = []
-        @_edge_collections.each_value do |collection|
+        edge_collections.each_value do |collection|
           coll_edges = collection.find_all_by_to(node)
           found_edges.push(*coll_edges)
         end
@@ -129,7 +129,7 @@ module LucidData
 
       def find_edges_by_target(node)
         found_edges = []
-        @_edge_collections.each_value do |collection|
+        edge_collections.each_value do |collection|
           coll_edges = collection.find_all_by_target(node)
           found_edges.push(*coll_edges)
         end