redgraph 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a432a1b2f9b30601701af0c1464c3c93c14c94da044bad69e531bd3a9f6b26d
-  data.tar.gz: 42f9ce782a67034c5d64c28c02e44d31272945073a1a868c521d7f4213346fc1
+  metadata.gz: 7866e9db857e11a68ddbcf8eef90b839ddc2e6fac110edfc87bfec3dd54edec7
+  data.tar.gz: 1c911439cd1f3f815db5a42f348e3a67449ef9aae128b4f48f9ee36934d2874d
 SHA512:
-  metadata.gz: fc2c9b7a5d6653fcc997807c994ec55f9be3f514f510c20d9b4569e9d14faedf112462c68e7127e5c7310b7b444d84dfe14b2b8d0332f5a884d3d7c096d5e85e
-  data.tar.gz: 7e031759d2edc7d7577b8df4db41ae055a35f5f46fdb434cf11b36aa7874e3f297c5512164c5e739a56f3ce5eba5200f0a18af9b9eeb0a8feeda09f61e8e73f3
+  metadata.gz: 78a668833d8a16ba61fca88f0b58e4d6ebac5e33b68e6698c03649c5fb66bb13ff33437ac7bcb9265792059d745999148dfee47d85d5d1ae96265f650ef5f068
+  data.tar.gz: 85a15bfdb886959114ccb13eed27adc9b3e83e7a77783be1d5cf65d4c33c40a27501e34d5a5af82350a3c43e08178d159e7732da3b9ad86f4944930751a5e8f9

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.1.4]
+
+- add NodeModel mixin for a basic ActiveRecord-like syntax
+- add Graph#merge_node and Graph#merge_edge 
+- edge and node properties are now a HashWithIndifferentAccess
+
 ## [0.1.3] - 2021-04-13
 
 - allow custom queries

data/Gemfile.lock

@@ -1,14 +1,24 @@
 PATH
   remote: .
   specs:
-    redgraph (0.1.3)
+    redgraph (0.1.4)
+      activesupport (>= 3.0.0)
       redis (~> 4)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (6.1.3.1)
+      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)
     docile (1.3.5)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
     method_source (1.0.0)
     minitest (5.14.4)
     pry (0.14.0)
@@ -22,6 +32,9 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   x86_64-darwin-20

data/README.md

@@ -45,6 +45,16 @@ Create an edge between those nodes:
     @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"}>
+
+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">
+
 Find a node by id:
 
     @graph.find_node_by_id(1)
@@ -71,11 +81,28 @@ Getting edges:
     @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")
 
+### 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
+
+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"})
 
 ## Development
 

data/lib/redgraph.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 require "redis"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+require "active_support/concern"
 
 require_relative "redgraph/version"
+require_relative "redgraph/util"
 require_relative "redgraph/graph"
 require_relative "redgraph/node"
 require_relative "redgraph/edge"
 require_relative "redgraph/query_response"
+require_relative "redgraph/node_model"
 
 module Redgraph
   class Error < StandardError; end

data/lib/redgraph/edge.rb

@@ -2,6 +2,8 @@
 
 module Redgraph
   class Edge
+    include Util
+
     attr_accessor :id, :src, :dest, :src_id, :dest_id, :type, :properties
 
     def initialize(src: nil, dest: nil, type: nil, properties: {})
@@ -10,15 +12,20 @@ module Redgraph
       @dest = dest
       @dest_id = @dest.id if @dest
       @type = type
-      @properties = properties
+      @properties = (properties || {}).with_indifferent_access
     end
 
     def persisted?
-      !id.nil?
+      id.present?
     end
 
     def ==(other)
       super || other.instance_of?(self.class) && !id.nil? && other.id == id
     end
+
+    def to_query_string(item_alias: 'edge', src_alias: 'src', dest_alias: 'dest')
+      _type = ":#{type}" if type
+      "(#{src_alias})-[#{item_alias}#{_type} #{properties_to_string(properties)}]->(#{dest_alias})"
+    end
   end
 end

data/lib/redgraph/graph.rb

@@ -10,8 +10,12 @@ module Redgraph
 
     attr_accessor :connection, :graph_name
 
-    def initialize(graph, redis_options = {})
-      @graph_name = graph
+    # @example Graph.new("foobar", url: "redis://localhost:6379/0", logger: Logger.new(STDOUT))
+    # @param graph_name [String] Name of the graph
+    # @param redis_options [Hash] Redis client options
+    #
+    def initialize(graph_name, redis_options = {})
+      @graph_name = graph_name
       @connection = Redis.new(redis_options)
       @module_version = module_version
       raise ServerError unless @module_version
@@ -35,27 +39,27 @@ module Redgraph
       raise e
     end
 
-    # Returns an array of existing graphs
+    # @return [Array] Existing graph names
     #
     def list
       @connection.call("GRAPH.LIST")
     end
 
-    # Returns an array of existing labels
+    # @return [Array] Existing labels
     #
     def labels
       result = _query("CALL db.labels()")
       result.resultset.map(&:values).flatten
     end
 
-    # Returns an array of existing properties
+    # @return [Array] Existing properties
     #
     def properties
       result = _query("CALL db.propertyKeys()")
       result.resultset.map(&:values).flatten
     end
 
-    # Returns an array of existing relationship types
+    # @return [Array] Existing relationship types
     #
     def relationship_types
       result = _query("CALL db.relationshipTypes()")
@@ -67,16 +71,25 @@ module Redgraph
       _query(cmd).rows
     end
 
+    # @param id [Integer] label id
+    # @return [String, nil] label
+    #
     def get_label(id)
       @labels ||= labels
       @labels[id] || (@labels = labels)[id]
     end
 
+    # @param id [Integer] property id
+    # @return [String, nil] property
+    #
     def get_property(id)
       @properties ||= properties
       @properties[id] || (@properties = properties)[id]
     end
 
+    # @param id [Integer] relationship type id
+    # @return [String, nil] relationship type
+    #
     def get_relationship_type(id)
       @relationship_types ||= relationship_types
       @relationship_types[id] || (@relationship_types = relationship_types)[id]
@@ -88,21 +101,5 @@ module Redgraph
       data = @connection.call("GRAPH.QUERY", graph_name, cmd, "--compact")
       QueryResponse.new(data, self)
     end
-
-    def quote_hash(hash)
-      "{" +
-      hash.map {|k,v| "#{k}:#{escape_value(v)}" }.join(", ") +
-      "}"
-    end
-
-    def escape_value(x)
-      case x
-      when Integer then x
-      when NilClass then "''"
-      else
-        '"' + x.gsub('"', '\"') + '"'
-      end
-    end
-
   end
 end

data/lib/redgraph/graph/edge_methods.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
 module Redgraph
   class Graph
     module EdgeMethods
       # Adds an edge. If successul it returns the created object, otherwise false
       #
       def add_edge(edge)
-        result = _query("MATCH (src), (dest)
-                        WHERE ID(src) = #{edge.src.id} AND ID(dest) = #{edge.dest.id}
-                        CREATE (src)-[e:`#{edge.type}` #{quote_hash(edge.properties)}]->(dest) RETURN ID(e)")
-        return false if result.stats[:relationships_created] != 1
-        id = result.resultset.first["ID(e)"]
-        edge.id = id
-        edge
+        merge_or_add_edge(edge, :create)
+      end
+
+      # Merges (creates an edge unless one with the same type and properties exists) an edge.
+      # If successul it returns the object, otherwise false
+      #
+      def merge_edge(edge)
+        merge_or_add_edge(edge, :merge)
       end
 
       # Finds edges. Options:
@@ -24,8 +27,6 @@ module Redgraph
       # - skip
       #
       def edges(type: nil, src: nil, dest: nil, properties: nil, order: nil, limit: nil, skip: nil)
-        _type = ":`#{type}`" if type
-        _props = quote_hash(properties) if properties
         _order = if order
           raise MissingAliasPrefixError unless order.include?("edge.")
           "ORDER BY #{order}"
@@ -41,7 +42,9 @@ module Redgraph
           "WHERE #{clauses}"
         end
 
-        cmd = "MATCH (src)-[edge#{_type} #{_props}]->(dest) #{_where}
+        edge = Edge.new(type: type, src: src, dest: dest, properties: properties)
+
+        cmd = "MATCH #{edge.to_query_string} #{_where}
                RETURN src, edge, dest #{_order} #{_skip} #{_limit}"
         result = _query(cmd)
 
@@ -57,11 +60,24 @@ module Redgraph
         end
       end
 
+      # Counts edges. Options:
+      #
+      # - type: filter by type
+      # - properties: filter by properties
+      #
+      def count_edges(type: nil, properties: nil)
+        edge = Edge.new(type: type, properties: properties)
+
+        cmd = "MATCH #{edge.to_query_string} RETURN COUNT(edge)"
+        query(cmd).flatten[0]
+      end
+
+
       private
 
       def edge_from_resultset_item(item)
         (edge_id, type_id, _src_id, _dest_id, props) = item
-        attrs = {}
+        attrs = HashWithIndifferentAccess.new
 
         props.each do |(index, type, value)|
           attrs[get_property(index)] = value
@@ -73,6 +89,17 @@ module Redgraph
           edge.properties = attrs
         end
       end
+
+      def merge_or_add_edge(edge, verb = :create)
+        verb = verb == :create ? "CREATE" : "MERGE"
+        result = _query("MATCH (src), (dest)
+                        WHERE ID(src) = #{edge.src.id} AND ID(dest) = #{edge.dest.id}
+                        #{verb} #{edge.to_query_string} RETURN ID(edge)")
+        return false if result.stats[:relationships_created] != 1
+        id = result.resultset.first["ID(edge)"]
+        edge.id = id
+        edge
+      end
     end
   end
 end

data/lib/redgraph/graph/node_methods.rb

@@ -1,14 +1,19 @@
+# frozen_string_literal: true
+
 module Redgraph
   class Graph
     module NodeMethods
       # Adds a node. If successul it returns the created object, otherwise false
       #
       def add_node(node)
-        result = _query("CREATE (n:`#{node.label}` #{quote_hash(node.properties)}) RETURN ID(n)")
-        return false if result.stats[:nodes_created] != 1
-        id = result.resultset.first["ID(n)"]
-        node.id = id
-        node
+        merge_or_add_node(node, :create)
+      end
+
+      # Merges (creates a node unless one with the same label and properties exists). If successul
+      # it returns the object, otherwise false
+      #
+      def merge_node(node)
+        merge_or_add_node(node, :merge)
       end
 
       def find_node_by_id(id)
@@ -36,7 +41,6 @@ module Redgraph
       #
       def nodes(label: nil, properties: nil, order: nil, limit: nil, skip: nil)
         _label = ":`#{label}`" if label
-        _props = quote_hash(properties) if properties
         _order = if order
           raise MissingAliasPrefixError unless order.include?("node.")
           "ORDER BY #{order}"
@@ -44,7 +48,9 @@ module Redgraph
         _limit = "LIMIT #{limit}" if limit
         _skip = "SKIP #{skip}" if skip
 
-        cmd = "MATCH (node#{_label} #{_props}) RETURN node #{_order} #{_skip} #{_limit}"
+        node = Node.new(label: label, properties: properties)
+
+        cmd = "MATCH #{node.to_query_string} RETURN node #{_order} #{_skip} #{_limit}"
 
         result = _query(cmd)
 
@@ -59,10 +65,9 @@ module Redgraph
       # - properties: filter by properties
       #
       def count_nodes(label: nil, properties: nil)
-        _label = ":`#{label}`" if label
-        _props = quote_hash(properties) if properties
+        node = Node.new(label: label, properties: properties)
 
-        cmd = "MATCH (node#{_label} #{_props}) RETURN COUNT(node)"
+        cmd = "MATCH #{node.to_query_string} RETURN COUNT(node)"
         query(cmd).flatten[0]
       end
 
@@ -72,7 +77,7 @@ module Redgraph
       #
       def node_from_resultset_item(item)
         (node_id, labels, props) = item
-        attrs = {}
+        attrs = HashWithIndifferentAccess.new
 
         props.each do |(index, type, value)|
           attrs[get_property(index)] = value
@@ -81,6 +86,17 @@ module Redgraph
           node.id = node_id
         end
       end
+
+      def merge_or_add_node(node, verb = :create)
+        verb = verb == :create ? "CREATE" : "MERGE"
+        result = _query("#{verb} #{node.to_query_string} RETURN ID(node)")
+        # Should we treat this case differently?
+        # return false if result.stats[:nodes_created] != 1
+        id = result.resultset.first["ID(node)"]
+        node.id = id
+        node
+      end
+
     end
   end
 end

data/lib/redgraph/node.rb

@@ -2,19 +2,27 @@
 
 module Redgraph
   class Node
+    include Util
+
     attr_accessor :id, :label, :properties
 
-    def initialize(label:, properties: {})
+    def initialize(label: nil, properties: nil, id: nil)
+      @id = id
       @label = label
-      @properties = properties
+      @properties = (properties || {}).with_indifferent_access
     end
 
     def persisted?
-      !id.nil?
+      id.present?
     end
 
     def ==(other)
       super || other.instance_of?(self.class) && !id.nil? && other.id == id
     end
+
+    def to_query_string(item_alias: 'node')
+      _label = ":#{label}" if label
+      "(#{item_alias}#{_label} #{properties_to_string(properties)})"
+    end
   end
 end

data/lib/redgraph/node_model.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Redgraph
+  # This mixin allows you to use an interface similar to ActiveRecord
+  #
+  # class Actor
+  #   include Redgraph::NodeModel
+  #
+  #   self.graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
+  #   self.label = "actor" # optional, if missing it will be extracted from the class name
+  #   attribute :name
+  # end
+  #
+  # You will then be able to
+  #
+  # john = Actor.find(123)
+  # total = Actor.count
+  #
+  module NodeModel
+    extend ActiveSupport::Concern
+
+    included do
+      @attribute_names = [:id]
+
+      attr_accessor :id
+
+      class << self
+        attr_reader :attribute_names
+        attr_accessor :graph
+
+        def attribute(name)
+          @attribute_names << name
+          attr_reader(name)
+        end
+
+        private
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@attribute_names, @attribute_names.dup)
+          subclass.instance_variable_set(:@graph, @graph.dup)
+        end
+      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
+
+      if absent_attributes.any?
+        raise ArgumentError, "Unknown attribute #{absent_attributes}"
+      end
+
+      args.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+    # The current graph
+    #
+    def graph
+      self.class.graph
+    end
+
+    def label
+      self.class.label
+    end
+
+    # Object attributes as a hash
+    #
+    def attributes
+      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)
+    end
+
+    def to_node
+      Redgraph::Node.new(id: id, label: label, properties: attributes.except(:id))
+    end
+
+    def ==(other)
+      attributes == other.attributes && id == other.id
+    end
+
+  end
+end

data/lib/redgraph/query_response.rb

@@ -136,7 +136,7 @@ module Redgraph
     # The resultset has one element per entity (as described by the header)
     def parse_resultset
       @result_rows.map do |item|
-        out = {}
+        out = HashWithIndifferentAccess.new
 
         item.each.with_index do |(type, value), i|
           out[entities[i]] = value

data/lib/redgraph/util.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Redgraph
+  module Util
+    def properties_to_string(hash)
+      return if hash.empty?
+      "{" +
+      hash.map {|k,v| "#{k}:#{escape_value(v)}" }.join(", ") +
+      "}"
+    end
+
+    def escape_value(x)
+      case x
+      when Integer then x
+      when NilClass then "''"
+      else
+        '"' + x.gsub('"', '\"') + '"'
+      end
+    end
+  end
+end

data/lib/redgraph/version.rb

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

data/redgraph.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "redis", "~> 4"
+  spec.add_dependency "activesupport", ">= 3.0.0"
 end

data/test/graph_edge_methods_test.rb

@@ -3,6 +3,8 @@
 require "test_helper"
 
 class GraphEdgeMethodsTest < Minitest::Test
+  include TestHelpers
+
   def setup
     @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
 
@@ -22,7 +24,6 @@ class GraphEdgeMethodsTest < Minitest::Test
     assert_equal(1980, edge.properties["since"])
     assert_equal(@al, edge.src)
     assert_equal(@john, edge.dest)
-
   end
 
   def test_find_all_edges
@@ -35,6 +36,15 @@ class GraphEdgeMethodsTest < Minitest::Test
     assert_equal(2, edges.size)
   end
 
+  def test_count_edges
+    marlon = quick_add_node(label: 'actor', properties: {name: "Marlon Brando"})
+    film = quick_add_node(label: 'film', properties: {name: "The Godfather"})
+    quick_add_edge(type: 'ACTOR_IN', src: marlon, dest: film, properties: {role: 'Don Vito'})
+    quick_add_edge(type: 'ACTOR_IN', src: @al,    dest: film, properties: {role: 'Michael'})
+
+    assert_equal(2, @graph.count_edges)
+  end
+
   def test_filter_edges
     marlon = quick_add_node(label: 'actor', properties: {name: "Marlon Brando"})
     film = quick_add_node(label: 'film', properties: {name: "The Godfather"})
@@ -87,14 +97,4 @@ class GraphEdgeMethodsTest < Minitest::Test
     edges = @graph.edges(type: 'FRIEND_OF', order: "edge.since DESC")
     assert_equal([e2, e3, e1], edges)
   end
-
-  private
-
-  def quick_add_node(label:, properties:)
-    @graph.add_node(Redgraph::Node.new(label: label, properties: properties))
-  end
-
-  def quick_add_edge(type:, src:, dest:, properties:)
-    @graph.add_edge(Redgraph::Edge.new(type: type, src: src, dest: dest, properties: properties))
-  end
 end

data/test/graph_manipulation_test.rb

@@ -3,6 +3,8 @@
 require "test_helper"
 
 class GraphManipulationTest < Minitest::Test
+  include TestHelpers
+
   def setup
     @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
   end
@@ -58,4 +60,32 @@ class GraphManipulationTest < Minitest::Test
 
     assert_predicate result, :persisted?
   end
+
+  def test_merge_node
+    quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    quick_add_node(label: 'actor', properties: {name: "John Travolta"})
+
+    nodes = @graph.nodes(label: 'actor')
+    assert_equal(2, nodes.size)
+
+    @graph.merge_node(Redgraph::Node.new(label: 'actor', properties: {name: "Joe Pesci"}))
+    assert_equal(3, @graph.nodes(label: 'actor').size)
+
+    @graph.merge_node(Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"}))
+    assert_equal(3, @graph.nodes(label: 'actor').size)
+  end
+
+  def test_merge_edge
+    al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    john = quick_add_node(label: 'actor', properties: {name: "John Travolta"})
+
+    assert_equal(0, @graph.edges.size)
+
+    edge = Redgraph::Edge.new(type: 'FRIEND_OF', src: al, dest: john, properties: {since: 1990})
+    @graph.merge_edge(edge)
+    assert_equal(1, @graph.edges.size)
+
+    @graph.merge_edge(edge)
+    assert_equal(1, @graph.edges.size)
+  end
 end

data/test/graph_node_methods_test.rb

@@ -3,6 +3,8 @@
 require "test_helper"
 
 class GraphNodeMethodsTest < Minitest::Test
+  include TestHelpers
+
   def setup
     @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
 
@@ -107,10 +109,4 @@ class GraphNodeMethodsTest < Minitest::Test
     assert_equal(3, items.size)
     assert_equal([3,4,5], items.map{|item| item.properties["number"]})
   end
-
-  private
-
-  def quick_add_node(label:, properties:)
-    @graph.add_node(Redgraph::Node.new(label: label, properties: properties))
-  end
 end

data/test/graph_queries_test.rb

@@ -3,6 +3,8 @@
 require "test_helper"
 
 class GraphQueriesTest < Minitest::Test
+  include TestHelpers
+
   def setup
     @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
 
@@ -40,14 +42,4 @@ class GraphQueriesTest < Minitest::Test
     result = @graph.query("MATCH (src)-[edge:FRIEND_OF]->(dest) RETURN src, edge")
     assert_equal([[@al, edge]], result)
   end
-
-  private
-
-  def quick_add_node(label:, properties:)
-    @graph.add_node(Redgraph::Node.new(label: label, properties: properties))
-  end
-
-  def quick_add_edge(type:, src:, dest:, properties:)
-    @graph.add_edge(Redgraph::Edge.new(type: type, src: src, dest: dest, properties: properties))
-  end
 end

data/test/node_model_test.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeModelTest < Minitest::Test
+  include TestHelpers
+
+  GRAPH = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+  def setup
+    @graph = GRAPH
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  class Animal
+    include Redgraph::NodeModel
+    attribute :name
+    self.graph = "pippo"
+  end
+
+  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
+    attribute :name
+    attribute :year
+  end
+
+  def test_attribute_names
+    assert_equal([:id, :name, :year], Film.attribute_names)
+
+    film = Film.new(name: "Star Wars", year: 1977)
+    assert_equal("Star Wars", film.name)
+    assert_equal(1977, film.year)
+  end
+
+  def test_attributes
+    film = Film.new(name: "Star Wars", year: 1977)
+    assert_equal({id: nil, name: "Star Wars", year: 1977}, film.attributes)
+  end
+
+  def test_add_to_graph
+    assert_equal(0, Film.count)
+    film = Film.new(name: "Star Wars", year: 1977)
+    item = film.add_to_graph
+    assert_predicate(item, :persisted?)
+
+    assert_equal(1, Film.count)
+  end
+
+  def test_merge_into_graph
+    film = Film.new(name: "Star Wars", year: 1977)
+    item = film.add_to_graph(allow_duplicates: false)
+    assert_predicate(item, :persisted?)
+
+    assert_equal(1, Film.count)
+
+    film = Film.new(name: "Star Wars", year: 1977)
+    item = film.add_to_graph(allow_duplicates: false)
+    assert_predicate(item, :persisted?)
+
+    assert_equal(1, Film.count)
+  end
+
+  def test_add_relation
+    film = Film.new(name: "Star Wars", year: 1977).add_to_graph
+    actor = Actor.new(name: "Harrison Ford").add_to_graph
+    edge = actor.add_relation(type: "ACTED_IN", node: film, properties: {role: "Han Solo"})
+
+    assert_predicate(edge, :persisted?)
+    assert_equal("ACTED_IN", edge.type)
+  end
+
+  def test_add_relation_with_duplicate_control
+    film = Film.new(name: "Star Wars", year: 1977).add_to_graph
+    actor = Actor.new(name: "Harrison Ford").add_to_graph
+
+    actor.add_relation(type: "ACTED_IN", node: film, properties: {role: "Han Solo"}, allow_duplicates: true)
+    assert_equal(1, @graph.count_edges)
+
+    actor.add_relation(type: "ACTED_IN", node: film, properties: {role: "Han Solo"}, allow_duplicates: true)
+    assert_equal(2, @graph.count_edges)
+
+    actor.add_relation(type: "ACTED_IN", node: film, properties: {role: "Han Solo"}, allow_duplicates: false)
+    assert_equal(2, @graph.count_edges)
+  end
+
+end

data/test/test_helper.rb

@@ -19,3 +19,15 @@ unless $REDIS_URL = ENV['TEST_REDIS_URL']
   puts "To run the tests you need to define the TEST_REDIS_URL environment variable"
   exit(1)
 end
+
+module TestHelpers
+  private
+
+  def quick_add_node(label:, properties:)
+    @graph.add_node(Redgraph::Node.new(label: label, properties: properties))
+  end
+
+  def quick_add_edge(type:, src:, dest:, properties:)
+    @graph.add_edge(Redgraph::Edge.new(type: type, src: src, dest: dest, properties: properties))
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redgraph
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Paolo Zaccagnini
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-13 00:00:00.000000000 Z
+date: 2021-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 description:
 email:
 - hi@pzac.net
@@ -47,7 +61,9 @@ files:
 - lib/redgraph/graph/edge_methods.rb
 - lib/redgraph/graph/node_methods.rb
 - lib/redgraph/node.rb
+- lib/redgraph/node_model.rb
 - lib/redgraph/query_response.rb
+- lib/redgraph/util.rb
 - lib/redgraph/version.rb
 - redgraph.gemspec
 - test/graph_connection_test.rb
@@ -56,6 +72,7 @@ files:
 - test/graph_node_methods_test.rb
 - test/graph_queries_test.rb
 - test/graph_test.rb
+- test/node_model_test.rb
 - test/redgraph_test.rb
 - test/test_helper.rb
 homepage: https://github.com/pzac/redgraph