redgraph 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7866e9db857e11a68ddbcf8eef90b839ddc2e6fac110edfc87bfec3dd54edec7
-  data.tar.gz: 1c911439cd1f3f815db5a42f348e3a67449ef9aae128b4f48f9ee36934d2874d
+  metadata.gz: a5a64b5cffa36368ac0664e813ab61f0329a055237b7e4acd473820d9c73409d
+  data.tar.gz: 371cde906c0a80370e39763a9b3ba9f3fcb83cdd2c19e97f635bfea6e35c5540
 SHA512:
-  metadata.gz: 78a668833d8a16ba61fca88f0b58e4d6ebac5e33b68e6698c03649c5fb66bb13ff33437ac7bcb9265792059d745999148dfee47d85d5d1ae96265f650ef5f068
-  data.tar.gz: 85a15bfdb886959114ccb13eed27adc9b3e83e7a77783be1d5cf65d4c33c40a27501e34d5a5af82350a3c43e08178d159e7732da3b9ad86f4944930751a5e8f9
+  metadata.gz: ac0481573ed2d41bb20de03ab1dc36d6781f5a121a865358e296654dc09abe168868104df92deeb623594b6d68363a0c9333268a059c7b8caf362504039e1431
+  data.tar.gz: dcb4c293c0a1003926d8776930123c81a5d35981a0896d447a03cc8ee1082f837ce1d73a1f7ca664478980fb485eefb39dad120f703b4584d40ffd6a3ff509c2

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [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,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redgraph (0.1.4)
+    redgraph (0.2.0)
       activesupport (>= 3.0.0)
       redis (~> 4)
 

data/README.md

@@ -104,6 +104,14 @@ And this will give you stuff such as
     john.add_to_graph # Will add the node to the graph
     john.add_relation(type: "ACTED_IN", node: film, properties: {role: "Tony Manero"})
 
+`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:
+
+    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
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run 

data/lib/redgraph/graph/node_methods.rb

@@ -68,7 +68,9 @@ 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
 
       private

data/lib/redgraph/node_model.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require_relative 'node_model/class_methods'
 
 module Redgraph
   # This mixin allows you to use an interface similar to ActiveRecord
@@ -16,13 +17,17 @@ 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|
       @attribute_names = [:id]
 
       attr_accessor :id
+      attr_accessor :_type
 
       class << self
         attr_reader :attribute_names
@@ -43,57 +48,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}"
@@ -149,7 +105,14 @@ module Redgraph
     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
+
+    # Converts a Node object into NodeModel
+    #
+    def reify_from_node(node)
+      self.class.reify_from_node(node)
     end
 
     def ==(other)

data/lib/redgraph/node_model/class_methods.rb

@@ -0,0 +1,76 @@
+module Redgraph
+  module NodeModel
+    module ClassMethods
+      # 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: {}, 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(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)
+        graph.query(cmd).map do |row|
+          row.map do |item|
+            item.is_a?(Node) ? reify_from_node(item) : item
+          end
+        end
+      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/version.rb

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

data/test/node_model_class_methods_test.rb

@@ -0,0 +1,66 @@
+# 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
+
+  # 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
+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_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,14 @@ 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
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redgraph
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Paolo Zaccagnini
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-15 00:00:00.000000000 Z
+date: 2021-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -62,6 +62,7 @@ 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/query_response.rb
 - lib/redgraph/util.rb
 - lib/redgraph/version.rb
@@ -72,6 +73,8 @@ 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_test.rb
 - test/redgraph_test.rb
 - test/test_helper.rb