redgraph 0.1.1 → 0.2.1

data/lib/redgraph/node_model/persistence.rb

@@ -0,0 +1,56 @@
+module Redgraph
+  module NodeModel
+    module Persistence
+      # 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)
+        raise MissingGraphError unless graph
+        item = allow_duplicates ? graph.add_node(to_node) : graph.merge_node(to_node)
+        self.id = item.id
+        self
+      end
+
+      # Creates a new record or updates the existing
+      #
+      def save
+        if persisted?
+          item = graph.update_node(to_node)
+          self.class.reify_from_node(item)
+        else
+          add_to_graph
+        end
+      end
+
+      def persisted?
+        id.present?
+      end
+
+      def reload
+        item = self.class.find(id)
+        @label = item.label
+        assign_attributes(item.attributes)
+        self
+      end
+
+      # Deletes the record from the graph
+      #
+      def destroy
+        @destroyed = true
+        if graph.destroy_node(self)
+          self
+        else
+          false
+        end
+      end
+
+      # Returns true if this object has been destroyed, otherwise returns false.
+      #
+      def destroyed?
+        !!@destroyed
+      end
+    end
+  end
+end

data/lib/redgraph/query_response.rb

@@ -10,8 +10,35 @@ 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
+
+      case @response.size
+      when 3
+        @header_row = @response[0]
+        @result_rows = @response[1]
+        @query_statistics = @response[2]
+      when 1 # queries with no RETURN clause
+        @header_row = []
+        @result_rows = []
+        @query_statistics = @response[0]
+      end
     end
 
     def stats
@@ -26,24 +53,83 @@ 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
         when /^Nodes created/
           stats[:nodes_created] = value.to_i
+        when /^Nodes deleted/
+          stats[:nodes_deleted] = value.to_i
         when /^Relationships created/
           stats[:relationships_created] = value.to_i
         when /^Properties set/
@@ -58,8 +144,8 @@ module Redgraph
 
     # The resultset has one element per entity (as described by the header)
     def parse_resultset
-      @response[1].map do |item|
-        out = {}
+      @result_rows.map do |item|
+        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.1"
+  VERSION = "0.2.1"
 end

data/redgraph.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0")
@@ -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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class GraphEdgeMethodsTest < Minitest::Test
+  include TestHelpers
+
+  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_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"})
+    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
+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
@@ -17,6 +19,35 @@ class GraphManipulationTest < Minitest::Test
     assert_predicate result, :persisted?
   end
 
+  def test_add_node_with_special_chars
+    [
+      "apo'str",
+      "two''apos",
+      "Foø'bÆ®",
+      "aa\nbb",
+      'aaa "bbb" ccc'
+    ].each do |name|
+
+      node = Redgraph::Node.new(label: 'actor', properties: {name: name})
+      result = @graph.add_node(node)
+      assert_predicate result, :persisted?
+
+      item = @graph.find_node_by_id(node.id)
+
+      assert_equal(name, item.properties["name"])
+    end
+  end
+
+  def test_add_node_with_nil_value
+    node = Redgraph::Node.new(label: 'actor', properties: {name: nil})
+    result = @graph.add_node(node)
+    assert_predicate result, :persisted?
+
+    item = @graph.find_node_by_id(node.id)
+
+    assert_equal("", item.properties["name"])
+  end
+
   def test_add_edge
     actor = Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"})
     @graph.add_node(actor)
@@ -29,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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class GraphNodeMethodsTest < Minitest::Test
+  include TestHelpers
+
+  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
+end