redgraph 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80c7cce1d1d19897882873e07e7a5a1fadabbb52d14717e16ff113f83511b32a
-  data.tar.gz: 72be15f7b95a7b45ec9ec21adb54f54676e0f960938c602fbb8381ae3ca1c682
+  metadata.gz: a5a64b5cffa36368ac0664e813ab61f0329a055237b7e4acd473820d9c73409d
+  data.tar.gz: 371cde906c0a80370e39763a9b3ba9f3fcb83cdd2c19e97f635bfea6e35c5540
 SHA512:
-  metadata.gz: cce480b50ada0fb75bb1491d730668a8ac7f92be766dd161b1b3c3fa8082d579d7276383adb2966894388f6c95fb7e444abd9eb2935e50f6659d35be938df450
-  data.tar.gz: 806e2105e78b9c6a188dd271ed7b6315ec9afbe0bbd6d1008eb2c4f991e756512e7b4a83dbb7808b944ab2c8b66671f270cb1a4008a476945c9f20818209dad9
+  metadata.gz: ac0481573ed2d41bb20de03ab1dc36d6781f5a121a865358e296654dc09abe168868104df92deeb623594b6d68363a0c9333268a059c7b8caf362504039e1431
+  data.tar.gz: dcb4c293c0a1003926d8776930123c81a5d35981a0896d447a03cc8ee1082f837ce1d73a1f7ca664478980fb485eefb39dad120f703b4584d40ffd6a3ff509c2

data/.github/workflows/main.yml

@@ -5,6 +5,12 @@ on: [push,pull_request]
 jobs:
   build:
     runs-on: ubuntu-latest
+
+    services:
+      redis:
+        image: redislabs/redisgraph
+        ports: ["6379:6379"]
+
     steps:
     - uses: actions/checkout@v2
     - name: Set up Ruby
@@ -12,6 +18,8 @@ jobs:
       with:
         ruby-version: 3.0.0
     - name: Run the default task
+      env:
+        TEST_REDIS_URL: redis://localhost:6379/0
       run: |
         gem install bundler -v 2.2.15
         bundle install

data/CHANGELOG.md

@@ -1,4 +1,29 @@
-## [Unreleased]
+## [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
+- 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
+- nodes and edges query now allow the `order` option
+
+## [0.1.2] - 2021-04-12
+
+- Add Graph#relationship_types
+- Add Graph#count_nodes
+- Add Graph#edges
+
+## [0.1.1] - 2021-04-11
+
+- Graph#nodes:
+    - filter by properties
+    - skip and limit options
 
 ## [0.1.0] - 2021-04-08
 

data/Gemfile

@@ -9,3 +9,5 @@ gem "rake", "~> 13.0"
 
 gem "minitest", "~> 5.0"
 gem "pry", "~> 0.14.0"
+gem "simplecov", "~> 0.21.2"
+

data/Gemfile.lock

@@ -1,13 +1,24 @@
 PATH
   remote: .
   specs:
-    redgraph (0.1.0)
+    redgraph (0.2.0)
+      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)
@@ -15,6 +26,15 @@ GEM
       method_source (~> 1.0)
     rake (13.0.3)
     redis (4.2.5)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      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
@@ -24,6 +44,7 @@ DEPENDENCIES
   pry (~> 0.14.0)
   rake (~> 13.0)
   redgraph!
+  simplecov (~> 0.21.2)
 
 BUNDLED WITH
    2.2.15

data/README.md

@@ -20,33 +20,97 @@ Or install it yourself as:
 
 ## Usage
 
+The gem assumes you have a recent version of [RedisGraph](https://oss.redislabs.com/redisgraph/) up and running.
+
 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>
 
 Create a couple nodes:
 
-    actor = Redgraph::Node.new(label: 'actor', attributes: {name: "Al Pacino"})
+    actor = Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"})
+    => #<Redgraph::Node:0x00007f8d5f95cf88 @label="actor", @properties={:name=>"Al Pacino"}>
     graph.add_node(actor)
-    film = Redgraph::Node.new(label: 'film', attributes: {name: "Scarface"})
+    => #<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"}>
 
 Create an edge between those nodes:
 
     edge = Redgraph::Edge.new(src: actor, dest: film, type: 'ACTOR_IN', properties: {role: "Tony Montana"})
-    result = @graph.add_edge(edge)
+    => #<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"}>
+
+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(123)
+    @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"}>]
 
-Optional filters:
+Optional filters that can be combined:
 
     @graph.nodes(label: 'actor')
+    @graph.nodes(properties: {name: "Al Pacino"})
+    @graph.nodes(limit: 10, skip: 20)
+
+Counting nodes
+
+    @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
+
+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"})
+
+`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
 
@@ -54,7 +118,7 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
     TEST_REDIS_URL=YOUR-REDIS-URL rake test
 
-to run the tests.
+to run the tests. Test coverage will be enabled if you set the `COVERAGE` environment variable to any value.
 
 You can use a `TEST_REDIS_URL` such as `redis://localhost:6379/1`. Make sure you're not overwriting important databases.
 
@@ -62,8 +126,6 @@ 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`.
 
-Run `bin/console` for an interactive prompt.
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/pzac/redgraph.

data/lib/redgraph.rb

@@ -1,13 +1,24 @@
 # 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
   class ServerError < Error; end
+  class MissingAliasPrefixError < Error
+    def message
+      "The order clause requires the node/edge alias prefix, ie order('node.foo') instead order('foo')"
+    end
+  end
 end

data/lib/redgraph/edge.rb

@@ -2,17 +2,30 @@
 
 module Redgraph
   class Edge
-    attr_accessor :id, :src, :dest, :type, :properties
+    include Util
 
-    def initialize(src:, dest:, type:, properties: {})
+    attr_accessor :id, :src, :dest, :src_id, :dest_id, :type, :properties
+
+    def initialize(src: nil, dest: nil, type: nil, properties: {})
       @src = src
+      @src_id = @src.id if @src
       @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

@@ -1,11 +1,21 @@
 # frozen_string_literal: true
 
+require_relative "graph/node_methods"
+require_relative "graph/edge_methods"
+
 module Redgraph
   class Graph
+    include NodeMethods
+    include EdgeMethods
+
     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
@@ -29,112 +39,67 @@ 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 = _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 = _query("CALL db.propertyKeys()")
       result.resultset.map(&:values).flatten
     end
 
-    # 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
-    end
-
-    def find_node_by_id(id)
-      result = query("MATCH (node) WHERE ID(node) = #{id} RETURN node")
-      return nil if result.resultset.empty?
-      (node_id, labels, properties) = result.resultset.first["node"]
-      attrs = {}
-
-      properties.each do |(index, type, value)|
-        attrs[get_property(index)] = value
-      end
-      Node.new(label: get_label(labels.first), properties: attrs).tap do |node|
-        node.id = node_id
-      end
-    end
-
-    def nodes(label: nil)
-      node_or_node_with_label = label ? "node:`#{label}`" : "node"
-
-      cmd = "MATCH (#{node_or_node_with_label}) RETURN node"
-      result = query(cmd)
-
-      result.resultset.map do |item|
-        (node_id, labels, properties) = item["node"]
-        attrs = {}
-
-        properties.each do |(index, type, value)|
-          attrs[get_property(index)] = value
-        end
-        Node.new(label: get_label(labels.first), properties: attrs).tap do |node|
-          node.id = node_id
-        end
-      end
-    end
-
-    # Adds an edge. If successul it returns the created object, otherwise false
+    # @return [Array] Existing relationship types
     #
-    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
+    def relationship_types
+      result = _query("CALL db.relationshipTypes()")
+      result.resultset.map(&:values).flatten
     end
 
-    private
-
+    # You can run custom cypher queries
     def query(cmd)
-      data = @connection.call("GRAPH.QUERY", graph_name, cmd, "--compact")
-      QueryResponse.new(data)
-    end
-
-    def quote_hash(hash)
-      out = "{"
-      hash.each do |k,v|
-        out += "#{k}:#{escape_value(v)}"
-      end
-      out + "}"
-    end
-
-    def escape_value(x)
-      case x
-      when Integer then x
-      else
-        "'#{x}'"
-      end
+      _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]
+    end
+
+    private
+
+    def _query(cmd)
+      data = @connection.call("GRAPH.QUERY", graph_name, cmd, "--compact")
+      QueryResponse.new(data, self)
+    end
   end
 end