redgraph 0.1.4 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7866e9db857e11a68ddbcf8eef90b839ddc2e6fac110edfc87bfec3dd54edec7
-  data.tar.gz: 1c911439cd1f3f815db5a42f348e3a67449ef9aae128b4f48f9ee36934d2874d
+  metadata.gz: 8b51ea5b1c1c11aab62f08cfe08508130f65def1a3b527ddcaf9419140c4e12a
+  data.tar.gz: 6518c572f6a4c14c733653acf1282c9b8473a8737b028a5695f93f953766f0bd
 SHA512:
-  metadata.gz: 78a668833d8a16ba61fca88f0b58e4d6ebac5e33b68e6698c03649c5fb66bb13ff33437ac7bcb9265792059d745999148dfee47d85d5d1ae96265f650ef5f068
-  data.tar.gz: 85a15bfdb886959114ccb13eed27adc9b3e83e7a77783be1d5cf65d4c33c40a27501e34d5a5af82350a3c43e08178d159e7732da3b9ad86f4944930751a5e8f9
+  metadata.gz: 634966fdde2e4567654b9a2d3e77eb77b26b8d1c8def562deeef8015d0b798ef8c7a9dd993dd15eabeeac4e2cc32013b748649c3f599dcc524742edd67d0b252
+  data.tar.gz: 9dba064e18ded1c51b80eca7d17cf487e1748b31fcbc18be656d57dcbe70954c563f3e7ee7bcd6ed847e4d9e170b40c0a498007980642349f1a4aa1ba5f0c706

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.2.2] - 2022-05-15
+
+- Nodes allow multiple labels
+- Friendlier exception message when the RedisGraph module is missing
+
+## [0.2.1]
+
+- Add NodeModel#destroy method
+- Add NodeModel.create method
+
+## [0.2.0]
+
+- revamp the NodeModel mixin, the Node to model mapping is now handled by the `_type` property
+
 ## [0.1.4]
 
 - add NodeModel mixin for a basic ActiveRecord-like syntax

data/Gemfile.lock

@@ -1,23 +1,22 @@
 PATH
   remote: .
   specs:
-    redgraph (0.1.4)
+    redgraph (0.2.2)
       activesupport (>= 3.0.0)
       redis (~> 4)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.1.3.1)
+    activesupport (7.0.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
-      zeitwerk (~> 2.3)
     coderay (1.1.3)
-    concurrent-ruby (1.1.8)
+    concurrent-ruby (1.1.10)
     docile (1.3.5)
-    i18n (1.8.10)
+    i18n (1.10.0)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
     minitest (5.14.4)
@@ -25,7 +24,7 @@ GEM
       coderay (~> 1.1)
       method_source (~> 1.0)
     rake (13.0.3)
-    redis (4.2.5)
+    redis (4.6.0)
     simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
@@ -34,9 +33,9 @@ GEM
     simplecov_json_formatter (0.1.2)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
-    zeitwerk (2.4.2)
 
 PLATFORMS
+  arm64-darwin-21
   x86_64-darwin-20
 
 DEPENDENCIES
@@ -47,4 +46,4 @@ DEPENDENCIES
   simplecov (~> 0.21.2)
 
 BUNDLED WITH
-   2.2.15
+   2.2.22

data/README.md

@@ -1,5 +1,8 @@
 # Redgraph
 
+[![Gem Version](https://badge.fury.io/rb/redgraph.svg)](https://badge.fury.io/rb/redgraph)
+[![Code Climate](https://codeclimate.com/github/pzac/redgraph.svg)](https://codeclimate.com/github/pzac/redgraph)
+
 A simple RedisGraph library. This gem owes **a lot** to the existing [redisgraph-rb](https://github.com/RedisGraph/redisgraph-rb) gem, but tries to provide a friendlier interface, similar to the existing [Python](https://github.com/RedisGraph/redisgraph-py) and [Elixir](https://github.com/crflynn/redisgraph-ex) clients.
 
 ## Installation
@@ -24,85 +27,130 @@ The gem assumes you have a recent version of [RedisGraph](https://oss.redislabs.
 
 Basic usage:
 
-    graph = Redgraph::Graph.new('movies', url: "redis://localhost:6379/1")
-    => #<Redgraph::Graph:0x00007f8d5c2b7e38 @connection=#<Redis client v4.2.5 for redis://localhost:6379/1>, @graph_name="movies", @module_version=999999>
+```ruby
+graph = Redgraph::Graph.new('movies', url: "redis://localhost:6379/1")
+=> #<Redgraph::Graph:0x00007f8d5c2b7e38 @connection=#<Redis client v4.2.5 for redis://localhost:6379/1>, @graph_name="movies", @module_version=999999>
+```
 
 Create a couple nodes:
 
-    actor = Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"})
-    => #<Redgraph::Node:0x00007f8d5f95cf88 @label="actor", @properties={:name=>"Al Pacino"}>
-    graph.add_node(actor)
-    => #<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>
-    film = Redgraph::Node.new(label: 'film', properties: {name: "Scarface"})
-    => #<Redgraph::Node:0x00007f8d5f85ccc8 @label="film", @properties={:name=>"Scarface"}>
-    graph.add_node(film)
-    => #<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>
+```ruby
+actor = Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"})
+=> #<Redgraph::Node:0x00007fce3baa0580 @id=nil, @labels=["actor"], @properties={"name"=>"Al Pacino"}>
+graph.add_node(actor)
+=> #<Redgraph::Node:0x00007fce3baa0580 @id=0, @labels=["actor"], @properties={"name"=>"Al Pacino"}>
+film = Redgraph::Node.new(label: 'film', properties: {name: "Scarface"})
+=> #<Redgraph::Node:0x00007fce3e8c6c48 @id=nil, @labels=["film"], @properties={"name"=>"Scarface"}>
+graph.add_node(film)
+=> #<Redgraph::Node:0x00007fce3e8c6c48 @id=1, @labels=["film"], @properties={"name"=>"Scarface"}>
+```
+
+Nodes might have multiple labels, although they're not supported by RedisGraph yet (you can track the feature progress [here](https://github.com/RedisGraph/RedisGraph/pull/1561)):
+
+```ruby
+item = Redgraph::Node.new(labels: ['film', 'drama'], properties: {name: "Casino"})
+=> #<Redgraph::Node:0x00007fce3bc73308 @id=nil, @labels=["film", "drama"], @properties={"name"=>"Casino"}>
+```
 
 Create an edge between those nodes:
 
-    edge = Redgraph::Edge.new(src: actor, dest: film, type: 'ACTOR_IN', properties: {role: "Tony Montana"})
-    => #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
-    @graph.add_edge(edge)
-    => #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @id=0, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+```ruby
+edge = Redgraph::Edge.new(src: actor, dest: film, type: 'ACTOR_IN', properties: {role: "Tony Montana"})
+=> #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+graph.add_edge(edge)
+=> #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @id=0, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+```
 
 You can merge nodes - the node will be created only if there isn't another with the same label and properties:
 
-    graph.merge_node(film)
-    => #<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>
+```ruby
+graph.merge_node(film)
+=> #<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>
+```
 
 Same with edges:
 
-    @graph.merge_edge(edge)
-    => #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @id=0, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+```ruby
+graph.merge_edge(edge)
+=> #<Redgraph::Edge:0x00007f8d5f9ae3d8 @dest=#<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>, @dest_id=1, @id=0, @properties={:role=>"Tony Montana"}, @src=#<Redgraph::Node:0x00007f8d5f95cf88 @id=0, @label="actor", @properties={:name=>"Al Pacino"}>, @src_id=0, @type="ACTOR_IN">
+```
 
 Find a node by id:
 
-    @graph.find_node_by_id(1)
-    => #<Redgraph::Node:0x00007f8d5c2c6e88 @id=1, @label="film", @properties={"name"=>"Scarface"}>
+```ruby
+graph.find_node_by_id(1)
+=> #<Redgraph::Node:0x00007f8d5c2c6e88 @id=1, @label="film", @properties={"name"=>"Scarface"}>
+```
 
 To get all nodes:
 
-    @graph.nodes
-    => [#<Redgraph::Node:0x00007f8d5c2ee0a0 @id=0, @label="actor", @properties={"name"=>"Al Pacino"}>, #<Redgraph::Node:0x00007f8d5c2edfd8 @id=1, @label="film", @properties={"name"=>"Scarface"}>]
+```ruby
+graph.nodes
+=> [#<Redgraph::Node:0x00007f8d5c2ee0a0 @id=0, @label="actor", @properties={"name"=>"Al Pacino"}>, #<Redgraph::Node:0x00007f8d5c2edfd8 @id=1, @label="film", @properties={"name"=>"Scarface"}>]
+```
 
 Optional filters that can be combined:
 
-    @graph.nodes(label: 'actor')
-    @graph.nodes(properties: {name: "Al Pacino"})
-    @graph.nodes(limit: 10, skip: 20)
+```ruby
+graph.nodes(label: 'actor')
+graph.nodes(properties: {name: "Al Pacino"})
+graph.nodes(limit: 10, skip: 20)
+```
 
 Counting nodes
 
-    @graph.count_nodes(label: 'actor')
-    => 1
+```ruby
+graph.count_nodes(label: 'actor')
+=> 1
+```
 
 Getting edges:
 
-    @graph.edges
-    @graph.edges(src: actor, dest: film)
-    @graph.edges(kind: 'FRIEND_OF', limit: 10, skip: 20)
-    @graph.count_edges
+```ruby
+graph.edges
+graph.edges(src: actor, dest: film)
+graph.edges(kind: 'FRIEND_OF', limit: 10, skip: 20)
+graph.count_edges
+```
 
 Running custom queries
 
-    @graph.query("MATCH (src)-[edge:FRIEND_OF]->(dest) RETURN src, edge")
+```ruby
+graph.query("MATCH (src)-[edge:FRIEND_OF]->(dest) RETURN src, edge")
+```
 
 ### NodeModel
 
 You can use the `NodeModel` mixin for a limited ActiveRecord-like interface:
 
-    class Actor
-      include Redgraph::NodeModel
-      self.graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
-      attribute :name
-    end
+```ruby
+class Actor
+  include Redgraph::NodeModel
+  self.graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
+  attribute :name
+end
+```
 
 And this will give you stuff such as
 
-    Actor.count
-    john = Actor.new(name: "John Travolta")
-    john.add_to_graph # Will add the node to the graph
-    john.add_relation(type: "ACTED_IN", node: film, properties: {role: "Tony Manero"})
+```ruby
+Actor.count
+john = Actor.new(name: "John Travolta")
+john.add_to_graph
+john.add_relation(type: "ACTED_IN", node: film, properties: {role: "Tony Manero"})
+john.reload
+john.destroy
+Actor.create(name: "Al Pacino")
+```
+
+`NodeModel` models will automatically set a `_type` property to keep track of the object class.
+
+You will then be able to run custom queries such as:
+
+```ruby
+Actor.query("MATCH (node) RETURN node ORDER BY node.name")
+```
+And the result rows object will be instances of the classes defined by the `_type` attribute.
 
 ## Development
 
@@ -118,6 +166,15 @@ You can also run `bin/console` for an interactive prompt that will allow you to
 
 To install this gem onto your local machine, run `bundle exec rake install`.
 
+### Installing RedisGraph
+
+If you're using an Apple silicon mac you might want to use the docker image: I've had issues compiling the module (OpenMP problems). Just do a:
+
+    docker run -p 6380:6379 -it --rm redislabs/redisgraph
+    TEST_REDIS_URL=redis://localhost:6380/0 be rake test
+
+I'm using port 6380 to not interphere with the other redis instance.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/pzac/redgraph.

data/lib/redgraph/graph/node_methods.rb

@@ -68,7 +68,27 @@ module Redgraph
         node = Node.new(label: label, properties: properties)
 
         cmd = "MATCH #{node.to_query_string} RETURN COUNT(node)"
-        query(cmd).flatten[0]
+        # RedisGraph bug: if there are no matches COUNT returns zero rows
+        # https://github.com/RedisGraph/RedisGraph/issues/1455
+        query(cmd).flatten[0] || 0
+      end
+
+      def update_node(node)
+        return false unless node.persisted?
+        _set = node.properties.map do |(key, val)|
+          "node.#{key} = #{escape_value(val)}"
+        end.join(", ")
+
+        cmd = "MATCH (node) WHERE ID(node) = #{node.id} SET #{_set} RETURN node"
+        result = _query(cmd)
+        node_from_resultset_item(result.resultset.first["node"])
+      end
+
+      def destroy_node(node)
+        return false unless node.persisted?
+        cmd = "MATCH (node) WHERE ID(node) = #{node.id} DELETE node"
+        result = _query(cmd)
+        result.stats["nodes_deleted"] == 1
       end
 
       private
@@ -97,6 +117,7 @@ module Redgraph
         node
       end
 
+
     end
   end
 end

data/lib/redgraph/graph.rb

@@ -7,6 +7,7 @@ module Redgraph
   class Graph
     include NodeMethods
     include EdgeMethods
+    include Util
 
     attr_accessor :connection, :graph_name
 
@@ -18,7 +19,7 @@ module Redgraph
       @graph_name = graph_name
       @connection = Redis.new(redis_options)
       @module_version = module_version
-      raise ServerError unless @module_version
+      raise ServerError, "Can't find RedisGraph module" unless @module_version
     end
 
     # Returns the version of the RedisGraph module

data/lib/redgraph/node.rb

@@ -4,14 +4,19 @@ module Redgraph
   class Node
     include Util
 
-    attr_accessor :id, :label, :properties
+    attr_accessor :id, :labels, :properties
 
-    def initialize(label: nil, properties: nil, id: nil)
+    def initialize(label: nil, properties: nil, id: nil, labels: nil)
       @id = id
-      @label = label
+      raise(Error, "You can either define a single label or a label array") if label && labels
+      @labels = labels || (label ? [label] : [])
       @properties = (properties || {}).with_indifferent_access
     end
 
+    def label
+      labels.first
+    end
+
     def persisted?
       id.present?
     end
@@ -21,7 +26,7 @@ module Redgraph
     end
 
     def to_query_string(item_alias: 'node')
-      _label = ":#{label}" if label
+      _label = labels.map {|l| ":`#{l}`"}.join
       "(#{item_alias}#{_label} #{properties_to_string(properties)})"
     end
   end

data/lib/redgraph/node_model/class_methods.rb

@@ -0,0 +1,83 @@
+module Redgraph
+  module NodeModel
+    module ClassMethods
+      # Returns an array of nodes. Options:
+      #
+      # - label: filter by label
+      # - properties: filter by properties
+      # - order: node.name ASC, node.year DESC
+      # - limit: number of items
+      # - skip: items offset (useful for pagination)
+      #
+      def all(label: nil, properties: {}, limit: nil, skip: nil, order: nil)
+        graph.nodes(label: label, properties: properties_plus_type(properties),
+                    limit: limit, skip: skip, order: nil).map do |node|
+          reify_from_node(node)
+        end
+      end
+
+      # Returns the number of nodes with the current label. Options:
+      #
+      # - properties: filter by properties
+      #
+      def count(label: nil, properties: nil)
+        graph.count_nodes(label: label, properties: properties_plus_type(properties))
+      end
+
+      # Finds a node by id. Returns nil if not found
+      #
+      def find(id)
+        node = graph.find_node_by_id(id)
+        return unless node
+        reify_from_node(node)
+      end
+
+      # Sets the label for this class of nodes. If missing it will be computed from the class name
+      def label=(x)
+        @label = x
+      end
+
+      # Current label
+      #
+      def label
+        @label ||= default_label
+      end
+
+      # Converts a Node object into NodeModel
+      #
+      def reify_from_node(node)
+        klass = node.properties[:_type].to_s.safe_constantize || self
+        klass.new(id: node.id, **node.properties)
+      end
+
+      # Runs a query on the graph, but converts the nodes to the corresponding ActiveModel class
+      # if available - otherwise they stay NodeObjects.
+      #
+      # Returns an array of rows.
+      #
+      def query(cmd)
+        raise MissingGraphError unless graph
+
+        graph.query(cmd).map do |row|
+          row.map do |item|
+            item.is_a?(Node) ? reify_from_node(item) : item
+          end
+        end
+      end
+
+      def create(properties)
+        new(**properties).add_to_graph
+      end
+
+      private
+
+      def default_label
+        name.demodulize.underscore
+      end
+
+      def properties_plus_type(properties = {})
+        {_type: name}.merge(properties || {})
+      end
+    end
+  end
+end

data/lib/redgraph/node_model/graph_manipulation.rb

@@ -0,0 +1,24 @@
+module Redgraph
+  module NodeModel
+    module GraphManipulation
+      # Adds a relation between the node and another node.
+      #
+      # - type: type of relation
+      # - node: the destination node
+      # - properties: optional properties hash
+      # - allow_duplicates: if false it will create a relation between two nodes with the same type
+      #     and properties only if not present
+      #
+      def add_relation(type:, node:, properties: nil, allow_duplicates: true)
+        edge = Edge.new(type: type, src: to_node, dest: node.to_node, properties: properties)
+        allow_duplicates ? graph.add_edge(edge) : graph.merge_edge(edge)
+      end
+
+      # Runs a custom query on the graph
+      #
+      def query(cmd)
+        self.class.query(cmd)
+      end
+    end
+  end
+end

data/lib/redgraph/node_model/persistence.rb

@@ -0,0 +1,56 @@
+module Redgraph
+  module NodeModel
+    module Persistence
+      # Adds the node to the graph
+      #
+      # - allow_duplicates: if false it will create a node with the same type and properties only if
+      #     not present
+      #
+      def add_to_graph(allow_duplicates: true)
+        raise MissingGraphError unless graph
+        item = allow_duplicates ? graph.add_node(to_node) : graph.merge_node(to_node)
+        self.id = item.id
+        self
+      end
+
+      # Creates a new record or updates the existing
+      #
+      def save
+        if persisted?
+          item = graph.update_node(to_node)
+          self.class.reify_from_node(item)
+        else
+          add_to_graph
+        end
+      end
+
+      def persisted?
+        id.present?
+      end
+
+      def reload
+        item = self.class.find(id)
+        @label = item.label
+        assign_attributes(item.attributes)
+        self
+      end
+
+      # Deletes the record from the graph
+      #
+      def destroy
+        @destroyed = true
+        if graph.destroy_node(self)
+          self
+        else
+          false
+        end
+      end
+
+      # Returns true if this object has been destroyed, otherwise returns false.
+      #
+      def destroyed?
+        !!@destroyed
+      end
+    end
+  end
+end

data/lib/redgraph/node_model.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+require_relative 'node_model/class_methods'
+require_relative 'node_model/graph_manipulation'
+require_relative 'node_model/persistence'
 
 module Redgraph
   # This mixin allows you to use an interface similar to ActiveRecord
@@ -16,13 +19,19 @@ module Redgraph
   # john = Actor.find(123)
   # total = Actor.count
   #
+  # When you create a record it will automatically set the _type property with the class name.
+  # This allows reifying the node into the corresponding NodeModel class.
+  #
   module NodeModel
     extend ActiveSupport::Concern
 
-    included do
+    included do |base|
+      include Persistence
+      include GraphManipulation
+
       @attribute_names = [:id]
 
-      attr_accessor :id
+      attr_accessor :id, :_type
 
       class << self
         attr_reader :attribute_names
@@ -30,7 +39,7 @@ module Redgraph
 
         def attribute(name)
           @attribute_names << name
-          attr_reader(name)
+          attr_accessor(name)
         end
 
         private
@@ -43,57 +52,8 @@ module Redgraph
       end
     end
 
-    class_methods do
-      # Returns an array of nodes. Options:
-      #
-      # - properties: filter by properties
-      # - order: node.name ASC, node.year DESC
-      # - limit: number of items
-      # - skip: items offset (useful for pagination)
-      #
-      def all(properties: nil, limit: nil, skip: nil, order: nil)
-        graph.nodes(label: label, properties: properties,
-                    limit: limit, skip: skip, order: nil).map do |node|
-          new(id: node.id, **node.properties)
-        end
-      end
-
-      # Returns the number of nodes with the current label. Options:
-      #
-      # - properties: filter by properties
-      #
-      def count(properties: nil)
-        graph.count_nodes(label: label, properties: properties)
-      end
-
-      # Finds a node by id. Returns nil if not found
-      #
-      def find(id)
-        node = graph.find_node_by_id(id)
-        return unless node
-        new(id: node.id, **node.properties)
-      end
-
-      # Sets the label for this class of nodes. If missing it will be computed from the class name
-      def label=(x)
-        @label = x
-      end
-
-      # Current label
-      #
-      def label
-        @label ||= default_label
-      end
-
-      private
-
-      def default_label
-        name.demodulize.underscore
-      end
-    end
-
     def initialize(**args)
-      absent_attributes = args.keys.map(&:to_sym) - self.class.attribute_names
+      absent_attributes = args.keys.map(&:to_sym) - self.class.attribute_names - [:_type]
 
       if absent_attributes.any?
         raise ArgumentError, "Unknown attribute #{absent_attributes}"
@@ -120,36 +80,15 @@ module Redgraph
       self.class.attribute_names.to_h { |name| [name, public_send(name)] }
     end
 
-    def persisted?
-      id.present?
-    end
-
-    # Adds the node to the graph
-    #
-    # - allow_duplicates: if false it will create a node with the same type and properties only if
-    #     not present
-    #
-    def add_to_graph(allow_duplicates: true)
-      item = allow_duplicates ? graph.add_node(to_node) : graph.merge_node(to_node)
-      self.id = item.id
-      self
-    end
-
-    # Adds a relation between the node and another node.
-    #
-    # - type: type of relation
-    # - node: the destination node
-    # - properties: optional properties hash
-    # - allow_duplicates: if false it will create a relation between two nodes with the same type
-    #     and properties only if not present
-    #
-    def add_relation(type:, node:, properties: nil, allow_duplicates: true)
-      edge = Edge.new(type: type, src: to_node, dest: node.to_node, properties: properties)
-      allow_duplicates ? graph.add_edge(edge) : graph.merge_edge(edge)
+    def assign_attributes(attrs = {})
+      attrs.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
     end
 
     def to_node
-      Redgraph::Node.new(id: id, label: label, properties: attributes.except(:id))
+      props = attributes.except(:id).merge(_type: self.class.name)
+      Redgraph::Node.new(id: id, label: label, properties: props)
     end
 
     def ==(other)

data/lib/redgraph/query_response.rb

@@ -29,9 +29,16 @@ module Redgraph
       @response = response
       @graph = graph
 
-      @header_row = @response[0]
-      @result_rows = @response[1]
-      @query_statistics = @response[2]
+      case @response.size
+      when 3
+        @header_row = @response[0]
+        @result_rows = @response[1]
+        @query_statistics = @response[2]
+      when 1 # queries with no RETURN clause
+        @header_row = []
+        @result_rows = []
+        @query_statistics = @response[0]
+      end
     end
 
     def stats
@@ -121,6 +128,8 @@ module Redgraph
         case label
         when /^Nodes created/
           stats[:nodes_created] = value.to_i
+        when /^Nodes deleted/
+          stats[:nodes_deleted] = value.to_i
         when /^Relationships created/
           stats[:relationships_created] = value.to_i
         when /^Properties set/

data/lib/redgraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Redgraph
-  VERSION = "0.1.4"
+  VERSION = "0.2.2"
 end

data/lib/redgraph.rb

@@ -21,4 +21,9 @@ module Redgraph
       "The order clause requires the node/edge alias prefix, ie order('node.foo') instead order('foo')"
     end
   end
+  class MissingGraphError < Error
+    def message
+      "A graph to use is not defined"
+    end
+  end
 end

data/test/node_model_class_methods_test.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeModelClassMethodsTest < Minitest::Test
+  include TestHelpers
+
+  GRAPH = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+  def setup
+    @graph = GRAPH
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  # test classes
+  #
+
+  class Actor
+    include Redgraph::NodeModel
+    self.graph = GRAPH
+    attribute :name
+  end
+
+  class MissingGraphActor
+    include Redgraph::NodeModel
+    attribute :name
+  end
+
+  # tests
+  #
+
+  def test_count
+    quick_add_node(label: 'actor', properties: {_type: Actor.name, name: "Al Pacino"})
+    quick_add_node(label: 'actor', properties: {_type: Actor.name, name: "John Travolta"})
+    assert_equal(2, Actor.count)
+    assert_equal(1, Actor.count(properties: {name: "Al Pacino"}))
+  end
+
+  def test_all
+    al = Actor.new(name: "Al Pacino").add_to_graph
+    john = Actor.new(name: "John Travolta").add_to_graph
+
+    items = Actor.all
+    assert_equal(2, items.size)
+    assert_includes(items, al)
+    assert_includes(items, john)
+
+    items = Actor.all(properties: {name: "Al Pacino"})
+    assert_equal(1, items.size)
+    assert_includes(items, al)
+  end
+
+  def test_find
+    al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    item = Actor.find(al.id)
+
+    assert_equal(Actor, item.class)
+    assert_predicate(item, :persisted?)
+    assert_equal(al.id, item.id)
+    assert_equal("Al Pacino", item.name)
+  end
+
+  def test_find_bad_id
+    quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    item = Actor.find("-1")
+    assert_nil(item)
+  end
+
+  def test_create
+    assert_equal(0, Actor.count)
+
+    actor = Actor.create(name: "Harrison Ford")
+
+    assert_equal(1, Actor.count)
+    assert_predicate(actor, :persisted?)
+    assert_equal("Harrison Ford", actor.name)
+    assert_equal("actor", actor.label)
+
+    found = Actor.find(actor.id)
+    assert_equal("Harrison Ford", found.name)
+    assert_equal("actor", found.label)
+    assert_equal(Actor.name, found._type)
+  end
+
+  def test_create_with_missing_graph
+    assert_raises(Redgraph::MissingGraphError) do
+      MissingGraphActor.create(name: "Harrison Ford")
+    end
+  end
+end

data/test/node_model_labels_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeModelLabelsTest < Minitest::Test
+  include TestHelpers
+
+  GRAPH = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+  def setup
+    @graph = GRAPH
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  # test classes
+  #
+
+  class Actor
+    include Redgraph::NodeModel
+    self.graph = GRAPH
+    attribute :name
+  end
+
+  class Artist
+    include Redgraph::NodeModel
+    self.label = "_artist"
+  end
+
+  class Painter < Artist
+  end
+
+  class Pianist < Artist
+    self.label = "pianist"
+  end
+
+  # tests
+  #
+
+  def test_label
+    assert_equal("actor", Actor.label)
+  end
+
+  def test_custom_label
+    assert_equal("_artist", Artist.label)
+  end
+
+  def test_default_label_when_inherited
+    assert_equal("painter", Painter.label)
+  end
+
+  def test_custom_label_when_inherited
+    assert_equal("pianist", Pianist.label)
+  end
+end

data/test/node_model_persistence_test.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeModelPersistenceTest < Minitest::Test
+  include TestHelpers
+
+  GRAPH = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+  def setup
+    @graph = GRAPH
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  # test classes
+  #
+
+  class Film
+    include Redgraph::NodeModel
+    self.graph = GRAPH
+    attribute :name
+  end
+
+  # tests
+  #
+
+  def test_save_new
+    assert_equal(0, Film.count)
+
+    film = Film.new(name: "Star Wars")
+    film.save
+
+    assert_predicate(film, :persisted?)
+    assert_equal(1, Film.count)
+  end
+
+  def test_save_existing
+    film = Film.create(name: "Star Wars")
+    film.name = "Commando"
+    film.save
+
+    assert_equal(1, Film.count)
+    item = Film.find(film.id)
+    assert_equal("Commando", item.name)
+  end
+
+  def test_reload
+    film = Film.create(name: "Star Wars")
+    copy = Film.find(film.id)
+
+    assert_equal("Star Wars", copy.name)
+
+    film.name = "Commando"
+    film.save
+
+    assert_equal("Star Wars", copy.name)
+    assert_equal("Commando", copy.reload.name)
+  end
+
+  def test_destroy
+    film = Film.create(name: "Star Wars")
+    assert_equal(1, Film.count)
+    film.destroy
+    assert_predicate(film, :destroyed?)
+    assert_equal(0, Film.count)
+  end
+end

data/test/node_model_test.rb

@@ -15,6 +15,9 @@ class NodeModelTest < Minitest::Test
     @graph.delete
   end
 
+  # test classes
+  #
+
   class Animal
     include Redgraph::NodeModel
     attribute :name
@@ -24,73 +27,12 @@ class NodeModelTest < Minitest::Test
   class Dog < Animal
   end
 
-  def test_graph_accessor
-    assert_equal("pippo", Animal.graph)
-    assert_equal("pippo", Animal.new.graph)
-  end
-
-  def test_class_inheritance
-    assert_equal("pippo", Dog.graph)
-    assert_equal("dog", Dog.label)
-    assert_equal([:id, :name], Dog.attribute_names)
-  end
-
   class Actor
     include Redgraph::NodeModel
     self.graph = GRAPH
     attribute :name
   end
 
-  def test_count
-    quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
-    quick_add_node(label: 'actor', properties: {name: "John Travolta"})
-    assert_equal(2, Actor.count)
-    assert_equal(1, Actor.count(properties: {name: "Al Pacino"}))
-  end
-
-  def test_all
-    al = Actor.new(name: "Al Pacino").add_to_graph
-    john = Actor.new(name: "John Travolta").add_to_graph
-
-    items = Actor.all
-    assert_equal(2, items.size)
-    assert_includes(items, al)
-    assert_includes(items, john)
-
-    items = Actor.all(properties: {name: "Al Pacino"})
-    assert_equal(1, items.size)
-    assert_includes(items, al)
-  end
-
-  def test_find
-    al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
-    item = Actor.find(al.id)
-
-    assert_equal(Actor, item.class)
-    assert_predicate(item, :persisted?)
-    assert_equal(al.id, item.id)
-    assert_equal("Al Pacino", item.name)
-  end
-
-  def test_find_bad_id
-    quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
-    item = Actor.find("-1")
-    assert_nil(item)
-  end
-
-  def test_label
-    assert_equal("actor", Actor.label)
-  end
-
-  class Artist
-    include Redgraph::NodeModel
-    self.label = "person"
-  end
-
-  def test_custom_label
-    assert_equal("person", Artist.label)
-  end
-
   class Film
     include Redgraph::NodeModel
     self.graph = GRAPH
@@ -98,6 +40,20 @@ class NodeModelTest < Minitest::Test
     attribute :year
   end
 
+  # tests
+  #
+
+  def test_graph_accessor
+    assert_equal("pippo", Animal.graph)
+    assert_equal("pippo", Animal.new.graph)
+  end
+
+  def test_class_inheritance
+    assert_equal("pippo", Dog.graph)
+    assert_equal("dog", Dog.label)
+    assert_equal([:id, :name], Dog.attribute_names)
+  end
+
   def test_attribute_names
     assert_equal([:id, :name, :year], Film.attribute_names)
 
@@ -157,4 +113,24 @@ class NodeModelTest < Minitest::Test
     assert_equal(2, @graph.count_edges)
   end
 
+  def test_casting_query
+    Film.new(name: "Star Wars", year: 1977).add_to_graph
+    Actor.new(name: "Harrison Ford").add_to_graph
+
+    items = Film.query("MATCH (node) RETURN node ORDER BY node.name")
+    assert_equal(2, items.size)
+    assert_kind_of(Actor, items[0][0])
+    assert_kind_of(Film, items[1][0])
+  end
+
+  def test_casting_query_from_model
+    film = Film.create(name: "Star Wars", year: 1977)
+    Actor.create(name: "Harrison Ford")
+
+    items = film.query("MATCH (node) RETURN node ORDER BY node.name")
+    assert_equal(2, items.size)
+    assert_kind_of(Actor, items[0][0])
+    assert_kind_of(Film, items[1][0])
+  end
+
 end

data/test/node_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeTest < Minitest::Test
+  def test_single_labels
+    node = Redgraph::Node.new(label: "film")
+    assert_equal(["film"], node.labels)
+    assert_equal("film", node.label)
+  end
+
+  def test_multiple_labels
+    node = Redgraph::Node.new(labels: ["film", "drama"])
+    assert_equal(["film", "drama"], node.labels)
+    assert_equal("film", node.label)
+  end
+
+  def test_conflicting_labels
+    assert_raises(Redgraph::Error) do
+      node = Redgraph::Node.new(labels: ["film", "drama"], label: "film")
+    end
+  end
+end

data/test/test_helper.rb

@@ -16,7 +16,8 @@ require "minitest/autorun"
 require "pry"
 
 unless $REDIS_URL = ENV['TEST_REDIS_URL']
-  puts "To run the tests you need to define the TEST_REDIS_URL environment variable"
+  puts "To run the tests you need to define the TEST_REDIS_URL environment variable. Ex:"
+  puts "  TEST_REDIS_URL=redis://localhost:6379/0"
   exit(1)
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redgraph
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.2
 platform: ruby
 authors:
 - Paolo Zaccagnini
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-15 00:00:00.000000000 Z
+date: 2022-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -62,6 +62,9 @@ files:
 - lib/redgraph/graph/node_methods.rb
 - lib/redgraph/node.rb
 - lib/redgraph/node_model.rb
+- lib/redgraph/node_model/class_methods.rb
+- lib/redgraph/node_model/graph_manipulation.rb
+- lib/redgraph/node_model/persistence.rb
 - lib/redgraph/query_response.rb
 - lib/redgraph/util.rb
 - lib/redgraph/version.rb
@@ -72,7 +75,11 @@ files:
 - test/graph_node_methods_test.rb
 - test/graph_queries_test.rb
 - test/graph_test.rb
+- test/node_model_class_methods_test.rb
+- test/node_model_labels_test.rb
+- test/node_model_persistence_test.rb
 - test/node_model_test.rb
+- test/node_test.rb
 - test/redgraph_test.rb
 - test/test_helper.rb
 homepage: https://github.com/pzac/redgraph
@@ -97,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: A simple RedisGraph client