redgraph 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0171849182c559f603bf4e09d1cb17eb5a3a4e3d95ddf8e6f1853434c0fc9380'
-  data.tar.gz: 7bdff0a775ebeffffe6b842b07a990292d351ee477c4aa2ef8ec492806a0b048
+  metadata.gz: 2fd53776ff217146cd6ca4924da40a43f5bf929fad03b73b79f32d371ea955e8
+  data.tar.gz: 551afc973f8e732ad532e74395e6c73251f14d68db73f667a207b234bd64163b
 SHA512:
-  metadata.gz: 53de618a85999bd837e1fabb458c204ac7e0f783425cef8f1d0c07e810c33f580c41d9fd8bf124015970618d6c905c8945020c06a382ae2f692384d0df856482
-  data.tar.gz: 66866ac946e4b7456684e26587bfcec17eec93de0e4c84bc6827ee77f1f712adce2b895fc38138522c0635fe2ade930a5606e3f638eaec8ab10afc71879e612e
+  metadata.gz: dd7f88ae09acb7f09b6c8de949d4f31bbc52b12e4b914f035de99c7cd9b409c14eac3e592f834cc968517b796fed0cf3a085f7eba4915e630b2e66c424ae9870
+  data.tar.gz: 979aac39193d3150441ddf5baca14772a35c6cfd00f09df42752277aed3d955869822b2d97150209f1e71ad5ab95e566dc645d15d3e8262675dd858bd6fbb1dd

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,3 +1,29 @@
+## [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
+- 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:

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.1)
+    redgraph (0.2.1)
+      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

@@ -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
@@ -20,34 +23,127 @@ 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")
+```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', attributes: {name: "Al Pacino"})
-    graph.add_node(actor)
-    film = Redgraph::Node.new(label: 'film', attributes: {name: "Scarface"})
-    graph.add_node(film)
+```ruby
+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"}>
+```
 
 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)
+```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:
+
+```ruby
+graph.merge_node(film)
+=> #<Redgraph::Node:0x00007f8d5f85ccc8 @id=1, @label="film", @properties={:name=>"Scarface"}>
+```
+
+Same with edges:
+
+```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(123)
+```ruby
+@graph.find_node_by_id(1)
+=> #<Redgraph::Node:0x00007f8d5c2c6e88 @id=1, @label="film", @properties={"name"=>"Scarface"}>
+```
 
 To get all nodes:
 
-    @graph.nodes
+```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:
 
-Optional filters:
+```ruby
+@graph.nodes(label: 'actor')
+@graph.nodes(properties: {name: "Al Pacino"})
+@graph.nodes(limit: 10, skip: 20)
+```
 
-    @graph.nodes(label: 'actor')
-    @graph.nodes(properties: {name: "Al Pacino"})
+Counting nodes
+
+```ruby
+@graph.count_nodes(label: 'actor')
+=> 1
+```
+
+Getting 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
+
+```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:
+
+```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
+
+```ruby
+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"})
+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
 
@@ -55,7 +151,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.
 
@@ -63,8 +159,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,29 @@
 # 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
+  class MissingGraphError < Error
+    def message
+      "A graph to use is not defined"
+    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,22 @@
 # frozen_string_literal: true
 
+require_relative "graph/node_methods"
+require_relative "graph/edge_methods"
+
 module Redgraph
   class Graph
+    include NodeMethods
+    include EdgeMethods
+    include Util
+
     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,120 +40,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
+    # @return [Array] Existing relationship types
     #
-    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
+    def relationship_types
+      result = _query("CALL db.relationshipTypes()")
+      result.resultset.map(&:values).flatten
     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
+    # You can run custom cypher queries
+    def query(cmd)
+      _query(cmd).rows
     end
 
-    # Returns nodes. Options:
+    # @param id [Integer] label id
+    # @return [String, nil] label
     #
-    # - label: filter by label
-    # - properties: filter by properties
-    # - limit: number of items
-    # - skip: items offset (useful for pagination)
+    def get_label(id)
+      @labels ||= labels
+      @labels[id] || (@labels = labels)[id]
+    end
+
+    # @param id [Integer] property id
+    # @return [String, nil] property
     #
-    def nodes(label: nil, properties: nil, limit: nil, skip: nil)
-      _label = ":`#{label}`" if label
-      _props = quote_hash(properties) if properties
-      _limit = "LIMIT #{limit}" if limit
-      _skip = "SKIP #{skip}" if skip
-
-      cmd = "MATCH (node#{_label} #{_props}) RETURN node #{_skip} #{_limit}"
-      result = query(cmd)
-
-      result.resultset.map do |item|
-        (node_id, labels, props) = item["node"]
-        attrs = {}
-
-        props.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 get_property(id)
+      @properties ||= properties
+      @properties[id] || (@properties = properties)[id]
     end
 
-    # Adds an edge. If successul it returns the created object, otherwise false
+    # @param id [Integer] relationship type id
+    # @return [String, nil] relationship type
     #
-    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 get_relationship_type(id)
+      @relationship_types ||= relationship_types
+      @relationship_types[id] || (@relationship_types = relationship_types)[id]
     end
 
     private
 
-    def query(cmd)
+    def _query(cmd)
       data = @connection.call("GRAPH.QUERY", graph_name, cmd, "--compact")
-      QueryResponse.new(data)
-    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
-      else
-        "'#{x}'"
-      end
-    end
-
-    def get_label(id)
-      @labels ||= labels
-      @labels[id] || (@labels = labels)[id]
-    end
-
-    def get_property(id)
-      @properties ||= properties
-      @properties[id] || (@properties = properties)[id]
+      QueryResponse.new(data, self)
     end
   end
 end