redgraph 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba5feef26cde1b47f2da53277c18c3c234ce12f85f315e761c865135b60857b4
-  data.tar.gz: 1cb82a481b616ee4347a52347405155da600c176696de4ccb3efea97076b196d
+  metadata.gz: 1a432a1b2f9b30601701af0c1464c3c93c14c94da044bad69e531bd3a9f6b26d
+  data.tar.gz: 42f9ce782a67034c5d64c28c02e44d31272945073a1a868c521d7f4213346fc1
 SHA512:
-  metadata.gz: 60ee0fdcb153873a42acfd40534c76db63dae469e680ed949544f15301f51ed3027a87d2fa7c1583a781c7d8077ec3fec4baf62746e86f5937f56bb9355f6941
-  data.tar.gz: cfa1a6bdc454adb49bb6537d7e1b4662de0e5e68f71611045f9d11b3719531f37c883df6f7fd4aa41061bea464d1d78e4f7b559bc19bfa7aa14031d97d8f0bb2
+  metadata.gz: fc2c9b7a5d6653fcc997807c994ec55f9be3f514f510c20d9b4569e9d14faedf112462c68e7127e5c7310b7b444d84dfe14b2b8d0332f5a884d3d7c096d5e85e
+  data.tar.gz: 7e031759d2edc7d7577b8df4db41ae055a35f5f46fdb434cf11b36aa7874e3f297c5512164c5e739a56f3ce5eba5200f0a18af9b9eeb0a8feeda09f61e8e73f3

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,8 @@
+## [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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redgraph (0.1.2)
+    redgraph (0.1.3)
       redis (~> 4)
 
 GEM

data/README.md

@@ -25,26 +25,35 @@ 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>
 
 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">
 
 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 that can be combined:
 
@@ -55,6 +64,7 @@ Optional filters that can be combined:
 Counting nodes
 
     @graph.count_nodes(label: 'actor')
+    => 1
 
 Getting edges:
 
@@ -62,6 +72,11 @@ Getting edges:
     @graph.edges(src: actor, dest: film)
     @graph.edges(kind: 'FRIEND_OF', limit: 10, skip: 20)
 
+Running custom queries
+
+    @graph.query("MATCH (src)-[edge:FRIEND_OF]->(dest) RETURN src, edge")
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run 

data/lib/redgraph.rb

@@ -10,4 +10,9 @@ require_relative "redgraph/query_response"
 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,11 +2,13 @@
 
 module Redgraph
   class Edge
-    attr_accessor :id, :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
     end

data/lib/redgraph/graph.rb

@@ -1,7 +1,13 @@
 # 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 = {})
@@ -38,140 +44,49 @@ module Redgraph
     # Returns an array of 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
     #
     def properties
-      result = query("CALL db.propertyKeys()")
+      result = _query("CALL db.propertyKeys()")
       result.resultset.map(&:values).flatten
     end
 
     # Returns an array of existing relationship types
     #
     def relationship_types
-      result = query("CALL db.relationshipTypes()")
+      result = _query("CALL db.relationshipTypes()")
       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
-
-    # Returns nodes. Options:
-    #
-    # - label: filter by label
-    # - properties: filter by properties
-    # - limit: number of items
-    # - skip: items offset (useful for pagination)
-    #
-    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_from_resultset_item(item["node"])
-      end
+    # You can run custom cypher queries
+    def query(cmd)
+      _query(cmd).rows
     end
 
-    # Counts nodes. Options:
-    #
-    # - label: filter by label
-    # - properties: filter by properties
-    #
-    def count_nodes(label: nil, properties: nil)
-      _label = ":`#{label}`" if label
-      _props = quote_hash(properties) if properties
-
-      cmd = "MATCH (node#{_label} #{_props}) RETURN COUNT(node)"
-      result = query(cmd)
-
-      result.resultset.first["COUNT(node)"]
+    def get_label(id)
+      @labels ||= labels
+      @labels[id] || (@labels = labels)[id]
     end
 
-    # 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
+    def get_property(id)
+      @properties ||= properties
+      @properties[id] || (@properties = properties)[id]
     end
 
-    # Finds edges. Options:
-    #
-    # - type
-    # - src
-    # - dest
-    # - properties
-    # - limit
-    # - skip
-    #
-    def edges(type: nil, src: nil, dest: nil, properties: nil, limit: nil, skip: nil)
-      _type = ":`#{type}`" if type
-      _props = quote_hash(properties) if properties
-      _limit = "LIMIT #{limit}" if limit
-      _skip = "SKIP #{skip}" if skip
-
-      _where = if src || dest
-        clauses = [
-          ("ID(src) = #{src.id}" if src),
-          ("ID(dest) = #{dest.id}" if dest)
-        ].compact.join(" AND ")
-        "WHERE #{clauses}"
-      end
-
-      cmd = "MATCH (src)-[edge#{_type} #{_props}]->(dest) #{_where}
-             RETURN src, edge, dest #{_skip} #{_limit}"
-      result = query(cmd)
-
-      result.resultset.map do |item|
-        src = node_from_resultset_item(item["src"])
-        dest = node_from_resultset_item(item["dest"])
-        edge = edge_from_resultset_item(item["edge"])
-
-        edge.src = src
-        edge.dest = dest
-
-        edge
-      end
+    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)
+      QueryResponse.new(data, self)
     end
 
     def quote_hash(hash)
@@ -189,48 +104,5 @@ module Redgraph
       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]
-    end
-
-    def get_relationship_type(id)
-      @relationship_types ||= relationship_types
-      @relationship_types[id] || (@relationship_types = relationship_types)[id]
-    end
-
-    # Builds a Node object from the raw data
-    #
-    def node_from_resultset_item(item)
-      (node_id, labels, props) = item
-      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 edge_from_resultset_item(item)
-      (edge_id, type_id, _src_id, _dest_id, props) = item
-      attrs = {}
-
-      props.each do |(index, type, value)|
-        attrs[get_property(index)] = value
-      end
-
-      Edge.new.tap do |edge|
-        edge.id = edge_id
-        edge.type = get_relationship_type(type_id)
-        edge.properties = attrs
-      end
-    end
   end
 end

data/lib/redgraph/graph/edge_methods.rb

@@ -0,0 +1,78 @@
+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
+      end
+
+      # Finds edges. Options:
+      #
+      # - type
+      # - src
+      # - dest
+      # - properties
+      # - order
+      # - limit
+      # - 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}"
+        end
+        _limit = "LIMIT #{limit}" if limit
+        _skip = "SKIP #{skip}" if skip
+
+        _where = if src || dest
+          clauses = [
+            ("ID(src) = #{src.id}" if src),
+            ("ID(dest) = #{dest.id}" if dest)
+          ].compact.join(" AND ")
+          "WHERE #{clauses}"
+        end
+
+        cmd = "MATCH (src)-[edge#{_type} #{_props}]->(dest) #{_where}
+               RETURN src, edge, dest #{_order} #{_skip} #{_limit}"
+        result = _query(cmd)
+
+        result.resultset.map do |item|
+          src = node_from_resultset_item(item["src"])
+          dest = node_from_resultset_item(item["dest"])
+          edge = edge_from_resultset_item(item["edge"])
+
+          edge.src = src
+          edge.dest = dest
+
+          edge
+        end
+      end
+
+      private
+
+      def edge_from_resultset_item(item)
+        (edge_id, type_id, _src_id, _dest_id, props) = item
+        attrs = {}
+
+        props.each do |(index, type, value)|
+          attrs[get_property(index)] = value
+        end
+
+        Edge.new.tap do |edge|
+          edge.id = edge_id
+          edge.type = get_relationship_type(type_id)
+          edge.properties = attrs
+        end
+      end
+    end
+  end
+end

data/lib/redgraph/graph/node_methods.rb

@@ -0,0 +1,86 @@
+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
+      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
+
+
+      # Returns 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 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}"
+        end
+        _limit = "LIMIT #{limit}" if limit
+        _skip = "SKIP #{skip}" if skip
+
+        cmd = "MATCH (node#{_label} #{_props}) RETURN node #{_order} #{_skip} #{_limit}"
+
+        result = _query(cmd)
+
+        result.resultset.map do |item|
+          node_from_resultset_item(item["node"])
+        end
+      end
+
+      # Counts nodes. Options:
+      #
+      # - label: filter by label
+      # - properties: filter by properties
+      #
+      def count_nodes(label: nil, properties: nil)
+        _label = ":`#{label}`" if label
+        _props = quote_hash(properties) if properties
+
+        cmd = "MATCH (node#{_label} #{_props}) RETURN COUNT(node)"
+        query(cmd).flatten[0]
+      end
+
+      private
+
+      # Builds a Node object from the raw data
+      #
+      def node_from_resultset_item(item)
+        (node_id, labels, props) = item
+        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
+    end
+  end
+end

data/lib/redgraph/query_response.rb

@@ -10,8 +10,28 @@ module Redgraph
   # - query stats
   #
   class QueryResponse
-    def initialize(response)
+    TYPES = [
+      UNKNOWN = 0,
+      NULL    = 1,
+      STRING  = 2,
+      INTEGER = 3,
+      BOOLEAN = 4,
+      DOUBLE  = 5,
+      ARRAY   = 6,
+      EDGE    = 7,
+      NODE    = 8,
+      PATH    = 9,
+      MAP     = 10,
+      POINT   = 11
+    ].freeze
+
+    def initialize(response, graph)
       @response = response
+      @graph = graph
+
+      @header_row = @response[0]
+      @result_rows = @response[1]
+      @query_statistics = @response[2]
     end
 
     def stats
@@ -26,19 +46,76 @@ module Redgraph
       @resultset ||= parse_resultset
     end
 
+    # Wraps in custom datatypes if needed
+    #
+    def rows
+      @result_rows.map do |column|
+        column.map do |data|
+          reify_column_item(data)
+        end
+
+      end
+    end
+
     private
 
+    def reify_column_item(data)
+      value_type, value = data
+
+      case value_type
+      when STRING, INTEGER, BOOLEAN, DOUBLE then value
+      when NODE then reify_node_item(value)
+      when EDGE then reify_edge_item(value)
+      else
+        "other"
+      end
+    end
+
+    def reify_node_item(data)
+      (node_id, labels, props) = data
+
+      label = @graph.get_label(labels[0]) # Only one label is currently supported
+
+      node = Node.new(label: label)
+      node.id = node_id
+
+      props.each do |(prop_id, prop_type, prop_value)|
+        prop_name = @graph.get_property(prop_id)
+        node.properties[prop_name] = prop_value
+      end
+
+      node
+    end
+
+    def reify_edge_item(data)
+      (edge_id, type_id, src_id, dest_id, props) = data
+
+      type = @graph.get_relationship_type(type_id)
+
+      edge = Edge.new(type: type)
+      edge.id = edge_id
+      edge.src_id = src_id
+      edge.dest_id = dest_id
+
+      props.each do |(prop_id, prop_type, prop_value)|
+        prop_name = @graph.get_property(prop_id)
+        edge.properties[prop_name] = prop_value
+      end
+
+      edge
+    end
+
     # The header lists the entities described in the RETURN clause. It is an
     # array of [ColumnType (enum), name (string)] elements. We can ignore the
     # enum, it is always 1 (COLUMN_SCALAR).
     def parse_header
-      @response[0].map{|item| item[1]}
+      @header_row.map{|item| item[1]}
     end
 
     def parse_stats
       stats = {}
 
-      @response[2].each do |item|
+      @query_statistics.each do |item|
         label, value = item.split(":")
 
         case label
@@ -58,7 +135,7 @@ module Redgraph
 
     # The resultset has one element per entity (as described by the header)
     def parse_resultset
-      @response[1].map do |item|
+      @result_rows.map do |item|
         out = {}
 
         item.each.with_index do |(type, value), i|

data/lib/redgraph/version.rb

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

data/test/graph_edge_methods_test.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class GraphEdgeMethodsTest < Minitest::Test
+  def setup
+    @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+    @al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    @john = quick_add_node(label: 'actor', properties: {name: "John Travolta"})
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  def test_find_edge
+    quick_add_edge(type: 'FRIEND_OF', src: @al, dest: @john, properties: {since: 1980})
+    edge = @graph.edges.first
+
+    assert_equal('FRIEND_OF', edge.type)
+    assert_equal(1980, edge.properties["since"])
+    assert_equal(@al, edge.src)
+    assert_equal(@john, edge.dest)
+
+  end
+
+  def test_find_all_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'})
+
+    edges = @graph.edges
+    assert_equal(2, edges.size)
+  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"})
+    other_film = quick_add_node(label: 'film', properties: {name: "Carlito's Way"})
+    e_donvito = quick_add_edge(type: 'ACTOR_IN', src: marlon, dest: film, properties: {role: 'Don Vito'})
+    e_michael = quick_add_edge(type: 'ACTOR_IN', src: @al, dest: film, properties: {role: 'Michael'})
+    e_carlito = quick_add_edge(type: 'ACTOR_IN', src: @al, dest: other_film, properties: {role: 'Carlito'})
+    quick_add_edge(type: 'FRIEND_OF', src: @al, dest: marlon, properties: {since: 1980})
+
+    edges = @graph.edges(type: "FRIEND_OF")
+    assert_equal(1, edges.size)
+
+    edges = @graph.edges(type: "ACTOR_IN")
+    assert_equal(3, edges.size)
+
+    edges = @graph.edges(type: "ACTOR_IN", limit: 2)
+    assert_equal(2, edges.size)
+
+    edges = @graph.edges(type: "ACTOR_IN", skip: 2, limit: 10)
+    assert_equal(1, edges.size)
+
+    edges = @graph.edges(properties: {role: "Carlito"})
+    assert_equal([e_carlito], edges)
+
+    edges = @graph.edges(src: marlon)
+    assert_equal([e_donvito], edges)
+
+    edges = @graph.edges(type: 'ACTOR_IN', dest: film)
+    assert_equal(2, edges.size)
+    assert_includes(edges, e_donvito)
+    assert_includes(edges, e_michael)
+
+    edges = @graph.edges(src: @al, dest: marlon)
+    assert_equal(1, edges.size)
+    edge = edges[0]
+    assert_equal('FRIEND_OF', edge.type)
+    assert_equal(1980, edge.properties["since"])
+  end
+
+  def test_order_edges
+    marlon = quick_add_node(label: 'actor', properties: {name: "Marlon Brando"})
+
+    e1 = quick_add_edge(type: 'FRIEND_OF', src: @al, dest: marlon, properties: {since: 1980})
+    e2 = quick_add_edge(type: 'FRIEND_OF', src: @al, dest: @john, properties: {since: 2000})
+    e3 = quick_add_edge(type: 'FRIEND_OF', src: marlon, dest: @john, properties: {since: 1990})
+
+    edges = @graph.edges(type: 'FRIEND_OF', order: "edge.since ASC")
+    assert_equal([e1, e3, e2], edges)
+
+    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_node_methods_test.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class GraphNodeMethodsTest < Minitest::Test
+  def setup
+    @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+    @al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    @john = quick_add_node(label: 'actor', properties: {name: "John Travolta"})
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  def test_find_node_by_id
+    node = @graph.find_node_by_id(@al.id)
+
+    refute_nil(node)
+    assert_equal("actor", node.label)
+    assert_equal("Al Pacino", node.properties["name"])
+    assert_equal(@al.id, node.id)
+  end
+
+  def test_find_node_by_wrong_id
+    node = @graph.find_node_by_id("-1")
+
+    assert_nil(node)
+  end
+
+  def test_find_all_nodes
+    actors = @graph.nodes
+
+    assert_equal(2, actors.size)
+    assert_includes(actors, @al)
+    assert_includes(actors, @john)
+  end
+
+  def test_find_all_nodes_by_label
+    film = quick_add_node(label: 'film', properties: {name: "Scarface"})
+
+    actors = @graph.nodes(label: 'actor')
+    assert_equal(2, actors.size)
+    assert_includes(actors, @al)
+    assert_includes(actors, @john)
+
+    films = @graph.nodes(label: 'film')
+    assert_equal(1, films.size)
+    assert_includes(films, film)
+  end
+
+  def test_find_all_nodes_by_property
+    scarface = quick_add_node(label: 'film', properties: {name: "Scarface", genre: "drama"})
+    casino = quick_add_node(label: 'film', properties: {name: "Casino", genre: "drama"})
+    _mamma_mia = quick_add_node(label: 'film', properties: {name: "Mamma Mia", genre: "musical"})
+
+    dramas = @graph.nodes(properties: {genre: "drama"})
+
+    assert_equal(2, dramas.size)
+    assert_includes(dramas, scarface)
+    assert_includes(dramas, casino)
+  end
+
+  def test_order_nodes_by_property
+    scarface = quick_add_node(label: 'film', properties: {name: "Scarface", genre: "drama"})
+    casino = quick_add_node(label: 'film', properties: {name: "Casino", genre: "drama"})
+    mamma_mia = quick_add_node(label: 'film', properties: {name: "Mamma Mia", genre: "musical"})
+
+    items = @graph.nodes(label: 'film', order: "node.name")
+    assert_equal([casino, mamma_mia, scarface], items)
+
+    items = @graph.nodes(label: 'film', order: "node.name ASC")
+    assert_equal([casino, mamma_mia, scarface], items)
+
+    items = @graph.nodes(label: 'film', order: "node.name DESC")
+    assert_equal([scarface, mamma_mia, casino], items)
+  end
+
+  def test_count_nodes
+    quick_add_node(label: 'film', properties: {name: "Scarface", genre: "drama"})
+    quick_add_node(label: 'film', properties: {name: "Casino", genre: "drama"})
+    quick_add_node(label: 'film', properties: {name: "Mamma Mia", genre: "musical"})
+
+
+    assert_equal(5, @graph.count_nodes)
+    assert_equal(3, @graph.count_nodes(label: 'film'))
+    assert_equal(2, @graph.count_nodes(properties: {genre: "drama"}))
+  end
+
+  def test_limit_nodes
+    10.times do |i|
+      quick_add_node(label: 'token', properties: {number: i})
+    end
+
+    items = @graph.nodes(label: 'token', limit: 5)
+    assert_equal(5, items.size)
+    assert_equal([0,1,2,3,4], items.map{|item| item.properties["number"]})
+  end
+
+  def test_skip_nodes
+    10.times do |i|
+      quick_add_node(label: 'token', properties: {number: i})
+    end
+
+    items = @graph.nodes(label: 'token', limit: 3, skip: 3)
+    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

@@ -6,151 +6,39 @@ class GraphQueriesTest < Minitest::Test
   def setup
     @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
 
-    @al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
-    @john = quick_add_node(label: 'actor', properties: {name: "John Travolta"})
+    @al = quick_add_node(label: 'actor', properties: {name: "Al Pacino", born: 1940})
+    @john = quick_add_node(label: 'actor', properties: {name: "John Travolta", born: 1954})
   end
 
   def teardown
     @graph.delete
   end
 
-  def test_find_node_by_id
-    node = @graph.find_node_by_id(@al.id)
-
-    refute_nil(node)
-    assert_equal("actor", node.label)
-    assert_equal("Al Pacino", node.properties["name"])
-    assert_equal(@al.id, node.id)
-  end
-
-  def test_find_node_by_wrong_id
-    node = @graph.find_node_by_id("-1")
-
-    assert_nil(node)
-  end
-
-  def test_find_all_nodes
-    actors = @graph.nodes
-
-    assert_equal(2, actors.size)
-    assert_includes(actors, @al)
-    assert_includes(actors, @john)
-  end
-
-  def test_find_all_nodes_by_label
-    film = quick_add_node(label: 'film', properties: {name: "Scarface"})
-
-    actors = @graph.nodes(label: 'actor')
-    assert_equal(2, actors.size)
-    assert_includes(actors, @al)
-    assert_includes(actors, @john)
-
-    films = @graph.nodes(label: 'film')
-    assert_equal(1, films.size)
-    assert_includes(films, film)
-  end
-
-  def test_find_all_nodes_by_property
-    scarface = quick_add_node(label: 'film', properties: {name: "Scarface", genre: "drama"})
-    casino = quick_add_node(label: 'film', properties: {name: "Casino", genre: "drama"})
-    mamma_mia = quick_add_node(label: 'film', properties: {name: "Mamma Mia", genre: "musical"})
-
-    dramas = @graph.nodes(properties: {genre: "drama"})
-
-    assert_equal(2, dramas.size)
-    assert_includes(dramas, scarface)
-    assert_includes(dramas, casino)
-  end
-
-  def test_count_nodes
-    quick_add_node(label: 'film', properties: {name: "Scarface", genre: "drama"})
-    quick_add_node(label: 'film', properties: {name: "Casino", genre: "drama"})
-    quick_add_node(label: 'film', properties: {name: "Mamma Mia", genre: "musical"})
-
-
-    assert_equal(5, @graph.count_nodes)
-    assert_equal(3, @graph.count_nodes(label: 'film'))
-    assert_equal(2, @graph.count_nodes(properties: {genre: "drama"}))
+  def test_query_string_attribute
+    result = @graph.query("MATCH (n) RETURN n.name ORDER BY n.name")
+    assert_equal([["Al Pacino"], ["John Travolta"]], result)
   end
 
-  def test_limit_nodes
-    10.times do |i|
-      quick_add_node(label: 'token', properties: {number: i})
-    end
-
-    items = @graph.nodes(label: 'token', limit: 5)
-    assert_equal(5, items.size)
-    assert_equal([0,1,2,3,4], items.map{|item| item.properties["number"]})
+  def test_query_string_and_number_attributes
+    result = @graph.query("MATCH (n) RETURN n.name, n.born ORDER BY n.born")
+    assert_equal([["Al Pacino", 1940], ["John Travolta", 1954]], result)
   end
 
-  def test_skip_nodes
-    10.times do |i|
-      quick_add_node(label: 'token', properties: {number: i})
-    end
-
-    items = @graph.nodes(label: 'token', limit: 3, skip: 3)
-    assert_equal(3, items.size)
-    assert_equal([3,4,5], items.map{|item| item.properties["number"]})
+  def test_query_nodes
+    result = @graph.query("MATCH (n) RETURN n ORDER BY n.born")
+    assert_equal([[@al], [@john]], result)
   end
 
-  def test_find_edge
-    quick_add_edge(type: 'FRIEND_OF', src: @al, dest: @john, properties: {since: 1980})
-    edge = @graph.edges.first
-
-    assert_equal('FRIEND_OF', edge.type)
-    assert_equal(1980, edge.properties["since"])
-    assert_equal(@al, edge.src)
-    assert_equal(@john, edge.dest)
-
-  end
-
-  def test_find_all_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'})
-
-    edges = @graph.edges
-    assert_equal(2, edges.size)
+  def test_query_edge
+    edge = quick_add_edge(type: 'FRIEND_OF', src: @al, dest: @john, properties: {since: 1980})
+    result = @graph.query("MATCH (src)-[edge]->(dest) RETURN edge")
+    assert_equal([[edge]], result)
   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"})
-    other_film = quick_add_node(label: 'film', properties: {name: "Carlito's Way"})
-    e_donvito = quick_add_edge(type: 'ACTOR_IN', src: marlon, dest: film, properties: {role: 'Don Vito'})
-    e_michael = quick_add_edge(type: 'ACTOR_IN', src: @al, dest: film, properties: {role: 'Michael'})
-    e_carlito = quick_add_edge(type: 'ACTOR_IN', src: @al, dest: other_film, properties: {role: 'Carlito'})
-    quick_add_edge(type: 'FRIEND_OF', src: @al, dest: marlon, properties: {since: 1980})
-
-    edges = @graph.edges(type: "FRIEND_OF")
-    assert_equal(1, edges.size)
-
-    edges = @graph.edges(type: "ACTOR_IN")
-    assert_equal(3, edges.size)
-
-    edges = @graph.edges(type: "ACTOR_IN", limit: 2)
-    assert_equal(2, edges.size)
-
-    edges = @graph.edges(type: "ACTOR_IN", skip: 2, limit: 10)
-    assert_equal(1, edges.size)
-
-    edges = @graph.edges(properties: {role: "Carlito"})
-    assert_equal([e_carlito], edges)
-
-    edges = @graph.edges(src: marlon)
-    assert_equal([e_donvito], edges)
-
-    edges = @graph.edges(type: 'ACTOR_IN', dest: film)
-    assert_equal(2, edges.size)
-    assert_includes(edges, e_donvito)
-    assert_includes(edges, e_michael)
-
-    edges = @graph.edges(src: @al, dest: marlon)
-    assert_equal(1, edges.size)
-    edge = edges[0]
-    assert_equal('FRIEND_OF', edge.type)
-    assert_equal(1980, edge.properties["since"])
+  def test_query_node_and_edge
+    edge = quick_add_edge(type: 'FRIEND_OF', src: @al, dest: @john, properties: {since: 1980})
+    result = @graph.query("MATCH (src)-[edge:FRIEND_OF]->(dest) RETURN src, edge")
+    assert_equal([[@al, edge]], result)
   end
 
   private

data/test/graph_test.rb

@@ -12,11 +12,13 @@ class GraphTest < Minitest::Test
   end
 
   def test_list
+    skip unless graph_list_supported?
     list = @graph.list
     assert_includes(list, "foobar")
   end
 
   def test_delete
+    skip unless graph_list_supported?
     assert_includes(@graph.list, "foobar")
 
     @graph.delete
@@ -66,4 +68,15 @@ class GraphTest < Minitest::Test
     )
     graph
   end
+
+  # This command is only supported in the latest version
+  def graph_list_supported?
+    @graph.list
+  rescue Redis::CommandError => e
+    if e.message =~ /ERR unknown command `GRAPH.LIST`/
+      false
+    else
+      true
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redgraph
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Paolo Zaccagnini
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-12 00:00:00.000000000 Z
+date: 2021-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -44,12 +44,16 @@ files:
 - lib/redgraph.rb
 - lib/redgraph/edge.rb
 - lib/redgraph/graph.rb
+- lib/redgraph/graph/edge_methods.rb
+- lib/redgraph/graph/node_methods.rb
 - lib/redgraph/node.rb
 - lib/redgraph/query_response.rb
 - lib/redgraph/version.rb
 - redgraph.gemspec
 - test/graph_connection_test.rb
+- test/graph_edge_methods_test.rb
 - test/graph_manipulation_test.rb
+- test/graph_node_methods_test.rb
 - test/graph_queries_test.rb
 - test/graph_test.rb
 - test/redgraph_test.rb