redisgraph 1.0.0 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbcd7f55a9dd3006c0f4a050171da9987e753f75fd20a99a9e22a1a7094c370b
-  data.tar.gz: 3b0094755a897bb7d8c8ddaed7a97ac741efb59cbd36983d67caa5a743142b3b
+  metadata.gz: 6d49963c89e143060931e2fc7a20c73a0fe41a06f0002ec84494e6182ad28728
+  data.tar.gz: 90b9a339ae932fcea45bbf355518e54db7ddcad137739d5d2ad95bcb72b5bd99
 SHA512:
-  metadata.gz: 22b67bea86caecf0c5dc9822a96395f452d3043dc79975b6c6c0e05d02cdb0e7523d65500f5c3ce4bacd56f7b81b25a556c50707db25c02e5bab007ead7dae34
-  data.tar.gz: 8152ef37023f1ecc2dc3bf4688c3a4e21b3a56bad16af9dcdfaaf11f2f671fe754cedcd81b9d68d9e62f01643535d5594dad52750f947d870676dfe51431e44f
+  metadata.gz: d4b3bc2e45a843c4328786fc1ce99e07873f9f0d09de3773ca572491867ccdc9b0f06653830167160fcf4e036349150166262890cc783e180569faecfd43bc6b
+  data.tar.gz: 8a0f6138c785a35ede21619c98960e3bdf96a557b98cdb3a183f1ee41ad3f99890c1e011ac6588e49efab2bcaa4f998b44cd0a44aff222155b3d0ece2b10f803

data/.circleci/config.yml

@@ -0,0 +1,54 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.4.1-node-browsers
+
+      - image: redislabs/redisgraph:edge
+        port: 6379:6379
+
+    working_directory: ~/repo
+
+    steps:
+      - checkout
+
+      - restore_cache:
+          keys:
+            - v1-dependencies-{{ checksum "Gemfile" }}
+            # fallback to using the latest cache if no exact match is found
+            - v1-dependencies-
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-dependencies-{{ checksum "Gemfile" }}
+
+      # run tests!
+      - run:
+          name: run tests
+          command: bundle exec rspec
+
+workflows:
+  version: 2
+  commit:
+    jobs:
+      - build
+  nightly:
+    triggers:
+      - schedule:
+          cron: "0 0 * * *"
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+      - build

data/.github/release-drafter-config.yml

@@ -0,0 +1,21 @@
+name-template: 'Version $NEXT_PATCH_VERSION'
+tag-template: 'v$NEXT_PATCH_VERSION'
+categories:
+  - title: 'Features'
+    labels:
+      - 'feature'
+      - 'enhancement'
+  - title: 'Bug Fixes'
+    labels:
+      - 'fix'
+      - 'bugfix'
+      - 'bug'
+  - title: 'Maintenance'
+    label: 'chore'
+change-template: '- $TITLE (#$NUMBER)'
+exclude-labels:
+  - 'skip-changelog'
+template: |
+  ## Changes
+
+  $CHANGES

data/.github/workflows/release-drafter.yml

@@ -0,0 +1,20 @@
+name: Release Drafter
+
+on:
+  push:
+    # branches to consider in the event; optional, defaults to all
+    branches:
+      - master
+
+jobs:
+  update_release_draft:
+    runs-on: ubuntu-latest
+    steps:
+      # Drafts your next Release notes as Pull Requests are merged into "master"
+      - uses: release-drafter/release-drafter@v5
+        with:
+          # (Optional) specify config name to use, relative to .github/. Default: release-drafter.yml
+           config-name: release-drafter-config.yml
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+

data/.gitignore

@@ -0,0 +1 @@
+coverage/*

data/Gemfile

@@ -3,5 +3,6 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'redis', '~> 4'
-gem 'terminal-table', '~> 1', '>= 1.8'
+gem 'rspec'
+gem 'codecov', :require => false, :group => :test
 

data/README.md

@@ -1,6 +1,31 @@
+[![license](https://img.shields.io/github/license/RedisGraph/redisgraph-rb.svg)](https://github.com/RedisGraph/redisgraph-rb)
+[![CircleCI](https://circleci.com/gh/RedisGraph/redisgraph-rb/tree/master.svg?style=svg)](https://circleci.com/gh/RedisGraph/redisgraph-rb/tree/master)
+[![GitHub issues](https://img.shields.io/github/release/RedisGraph/redisgraph-rb.svg)](https://github.com/RedisGraph/redisgraph-rb/releases/latest)
+[![Codecov](https://codecov.io/gh/RedisGraph/redisgraph-rb/branch/master/graph/badge.svg)](https://codecov.io/gh/RedisGraph/redisgraph-rb)
+[![Gem Version](https://badge.fury.io/rb/redisgraph.svg)](https://badge.fury.io/rb/redisgraph)
+
 # redisgraph-rb
+[![Forum](https://img.shields.io/badge/Forum-RedisGraph-blue)](https://forum.redislabs.com/c/modules/redisgraph)
+[![Discord](https://img.shields.io/discord/697882427875393627?style=flat-square)](https://discord.gg/gWBRT6P)
+
+`redisgraph-rb` is a Ruby gem client for the [RedisGraph](https://github.com/RedisLabsModules/RedisGraph) module. It relies on `redis-rb` for Redis connection management and provides support for graph QUERY, EXPLAIN, and DELETE commands.
+
+## RedisGraph compatibility
+The current version of `redisgraph-rb` is compatible with RedisGraph versions >= 1.99 (module version: 19900).
+
+### Previous Version
+For RedisGraph versions >= 1.0 and < 2.0 (ie module version: 10202), instead use and refer to
+the redisgraph gem version ~> 1.0.0
+
+which corresponds to the following docker image
+`docker run -p 6379:6379 -it --rm redislabs/redisgraph:1.2.2`
+
+## Installation
+To install, run:
 
-`redisgraph-rb` is a Ruby gem client for the RedisGraph module. It relies on `redis-rb` for Redis connection management and provides support for graph QUERY, EXPLAIN, and DELETE commands.
+`$ gem install redisgraph`
+
+Or include `redisgraph` as a dependency in your Gemfile.
 
 ## Usage
 ```
@@ -20,11 +45,11 @@ cmd = """MATCH ()-[:works]->(e:employer) RETURN e"""
 response = r.query(cmd)
 
 response.print_resultset
-+----------------+
-| e.name         |
-+----------------+
-| Dunder Mifflin |
-+----------------+
+--------------------------------
+| e                            |
+--------------------------------
+| [{"name"=>"Dunder Mifflin"}] |
+--------------------------------
 
 r.delete
  => "Graph removed, internal execution time: 0.416024 milliseconds"
@@ -38,7 +63,13 @@ RedisGraph connects to an active Redis server, defaulting to `host: localhost, p
 These parameters are described fully in the documentation for https://github.com/redis/redis-rb
 
 ## Running tests
-A simple test suite is provided, and can be run with:
-`ruby test/test_suite.rb`
+To ensure prerequisites are installed, run the following:
+`bundle install`
+
 These tests expect a Redis server with the Graph module loaded to be available at localhost:6379
 
+The currently compatible version of the RedisGraph module may be run as follows:
+`docker run -p 6379:6379 -it --rm redislabs/redisgraph:2.0-edge`
+
+A simple test suite is provided, and can be run with:
+`rspec`

data/lib/redisgraph/connection.rb

@@ -1,16 +1,26 @@
 class RedisGraph
   def connect_to_server(options)
     @connection = Redis.new(options)
-    self.verify_module()
+    check_module_version
   end
 
   # Ensure that the connected Redis server supports modules
   # and has loaded the RedisGraph module
-  def verify_module()
+  def check_module_version()
     redis_version = @connection.info["redis_version"]
     major_version = redis_version.split('.').first.to_i
     raise ServerError, "Redis 4.0 or greater required for RedisGraph support." unless major_version >= 4
-    resp = @connection.call("MODULE", "LIST")
-    raise ServerError, "RedisGraph module not loaded." unless resp.first && resp.first.include?("graph")
+
+    begin
+      modules = @connection.call("MODULE", "LIST")
+    rescue Redis::CommandError
+      # Ignore check if the connected server does not support the "MODULE LIST" command
+      return
+    end
+
+    module_graph = modules.detect { |_name_key, name, _ver_key, _ver| name == 'graph' }
+    module_version = module_graph[3] if module_graph
+    raise ServerError, "RedisGraph module not loaded." if module_version.nil?
+    raise ServerError, "RedisGraph module incompatible, expecting >= 1.99." if module_version < 19900
   end
 end

data/lib/redisgraph/errors.rb

@@ -1,10 +1,10 @@
 class RedisGraph
-  class RedisGraphError < RuntimeError
-  end
+  class RedisGraphError < RuntimeError; end
 
-  class ServerError < RedisGraphError
-  end
+  class ServerError < RedisGraphError; end
 
-  class QueryError < RedisGraphError
-  end
+  class CallError < RedisGraphError; end
+  class QueryError < RedisGraphError; end
+  class ExplainError < RedisGraphError; end
+  class DeleteError < RedisGraphError; end
 end

data/lib/redisgraph/query_result.rb

@@ -1,59 +1,171 @@
+# frozen_string_literal: true
+
+# Data types that can be returned in result sets
+module ValueType
+  UNKNOWN = 0
+  NULL = 1
+  STRING = 2
+  INTEGER = 3
+  BOOLEAN = 4
+  DOUBLE = 5
+  ARRAY = 6
+  EDGE = 7
+  NODE = 8
+  PATH = 9 # TODO: not yet implemented
+end
+
 class QueryResult
   attr_accessor :columns
   attr_accessor :resultset
   attr_accessor :stats
 
+  def initialize(response, opts = {})
+    # The response for any query is expected to be a nested array.
+    # If compact (RedisGraph protocol v2)
+    # The resultset is an array w/ three elements:
+    # 0] Node/Edge key names w/ the ordinal position used in [1]
+    #    en lieu of the name to compact the result set.
+    # 1] Node/Edge key/value pairs as an array w/ two elements:
+    #  0] node/edge name id from [0]
+    #  1..matches] node/edge values
+    # 2] Statistics as an array of strings
+
+    @metadata = opts[:metadata]
+
+    @resultset = parse_resultset(response)
+    @stats = parse_stats(response)
+  end
+
   def print_resultset
-    pretty = Terminal::Table.new headings: columns do |t|
-      resultset.each { |record| t << record }
+    return unless columns
+
+    # Compute max length of each column
+    column_sizes = resultset.reduce([]) do |lengths, row|
+      row.each_with_index.map{|iterand, index| [lengths[index] || 0, iterand.to_s.length].max}
+    end
+
+    # Print column headers
+    puts head = '-' * (column_sizes.inject(&:+) + (3 * column_sizes.count) + 1)
+    row = columns.fill(nil, columns.size..(column_sizes.size - 1))
+    row = row.each_with_index.map{|v, i| v = v.to_s + ' ' * (column_sizes[i] - v.to_s.length)}
+    puts '| ' + row.join(' | ') + ' |'
+    puts head
+
+    # Print result set rows
+    resultset.each do |row|
+      row = row.fill(nil, row.size..(column_sizes.size - 1))
+      row = row.each_with_index.map{|v, i| v = v.to_s + ' ' * (column_sizes[i] - v.to_s.length)}
+      puts '| ' + row.join(' | ') + ' |'
     end
-    puts pretty
+    puts head
   end
 
   def parse_resultset(response)
+    # In the v2 protocol, CREATE does not contain an empty row preceding statistics
+    return unless response.length > 1
+
     # Any non-empty result set will have multiple rows (arrays)
-    return nil unless response[0].length > 1
-    # First row is return elements / properties
-    @columns = response[0].shift
-    # Subsequent rows are records
-    @resultset = response[0]
+
+    # First row is header describing the returned records, corresponding
+    # precisely in order and naming to the RETURN clause of the query.
+    header = response[0]
+    @columns = header.map { |(_type, name)| name }
+
+    # Second row is the actual data returned by the query
+    # note handling for encountering an id for propertyKey that is out of
+    # the cached set.
+    data = response[1].map do |row|
+      i = -1
+      header.reduce([]) do |agg, (type, _it)|
+        i += 1
+        el = row[i]
+        case type
+        when 1 # Column of scalars
+          agg << map_scalar(el[0], el[1])
+        when 2 # node
+          props = el[2]
+          agg << props.sort_by { |prop| prop[0] }.map { |prop| map_prop(prop) }
+        when 3 # Column of relations
+          props = el[4]
+          agg << props.sort_by { |prop| prop[0] }.map { |prop| map_prop(prop) }
+        end
+      end
+    end
+
+    data
+  end
+
+  def map_scalar(type, val)
+    map_func = case type
+               when ValueType::NULL
+                 return nil
+               when ValueType::STRING
+                 :to_s
+               when ValueType::INTEGER
+                 :to_i
+               when ValueType::BOOLEAN
+                 # no :to_b
+                 return val == 'true'
+               when ValueType::DOUBLE
+                 :to_f
+               when ValueType::ARRAY
+                 return val.map { |it| map_scalar(it[0], it[1]) }
+               when ValueType::EDGE
+                 props = val[4]
+                 return props.sort_by { |prop| prop[0] }.map { |prop| map_prop(prop) }
+               when ValueType::NODE
+                 props = val[2]
+                 return props.sort_by { |prop| prop[0] }.map { |prop| map_prop(prop) }
+               end
+    val.send(map_func)
+  end
+
+  def map_prop(prop)
+    # maximally a single @metadata.invalidate should occur
+
+    property_keys = @metadata.property_keys
+    prop_index = prop[0]
+    if prop_index >= property_keys.length
+      @metadata.invalidate
+      property_keys = @metadata.property_keys
+    end
+    { property_keys[prop_index] => map_scalar(prop[1], prop[2]) }
   end
 
   # Read metrics about internal query handling
   def parse_stats(response)
-    return nil unless response[1]
+    # In the v2 protocol, CREATE does not contain an empty row preceding statistics
+    stats_offset = response.length == 1 ? 0 : 2
+
+    return nil unless response[stats_offset]
 
+    parse_stats_row(response[stats_offset])
+  end
+
+  def parse_stats_row(response_row)
     stats = {}
 
-    response[1].each do |stat|
+    response_row.each do |stat|
       line = stat.split(': ')
-      val = line[1].split(' ')[0]
+      val = line[1].split(' ')[0].to_i
 
       case line[0]
       when /^Labels added/
-        stats[:labels_added] = val.to_i
+        stats[:labels_added] = val
       when /^Nodes created/
-        stats[:nodes_created] = val.to_i
+        stats[:nodes_created] = val
       when /^Nodes deleted/
-        stats[:nodes_deleted] = val.to_i
+        stats[:nodes_deleted] = val
       when /^Relationships deleted/
-        stats[:relationships_deleted] = val.to_i
+        stats[:relationships_deleted] = val
       when /^Properties set/
-        stats[:properties_set] = val.to_i
+        stats[:properties_set] = val
       when /^Relationships created/
-        stats[:relationships_created] = val.to_i
+        stats[:relationships_created] = val
       when /^Query internal execution time/
-        stats[:internal_execution_time] = val.to_f
+        stats[:internal_execution_time] = val
       end
     end
     stats
   end
-
-  def initialize(response)
-    # The response for any query is expected to be a nested array.
-    # The only top-level values will be the result set and the statistics.
-    @resultset = parse_resultset(response)
-    @stats = parse_stats(response)
-  end
 end
-

data/lib/redisgraph/version.rb

@@ -1,3 +1,3 @@
 class RedisGraph
-  VERSION = '1.0.0'
+  VERSION = '2.0.3'
 end

data/lib/redisgraph.rb

@@ -1,5 +1,4 @@
 require 'redis'
-require 'terminal-table'
 
 require_relative 'redisgraph/errors.rb'
 require_relative 'redisgraph/query_result.rb'
@@ -8,37 +7,73 @@ require_relative 'redisgraph/connection.rb'
 class RedisGraph
   attr_accessor :connection
   attr_accessor :graphname
+  attr_accessor :metadata
+
+  class Metadata
+    def initialize(opts = {})
+      @graphname = opts[:graphname]
+      @connection = opts[:connection]
+
+      # cache semantics around these labels, propertyKeys, and relationshipTypes
+      # defers first read and is invalidated when changed.
+      @labels_proc =  -> { call_procedure('db.labels') }
+      @property_keys_proc = -> { call_procedure('db.propertyKeys') }
+      @relationship_types_proc = -> { call_procedure('db.relationshipTypes') }
+    end
+
+    def invalidate
+      @labels = @property_keys = @relationship_types = nil
+    end
+
+    def labels
+      @labels ||= @labels_proc.call
+    end
+
+    def property_keys
+      @property_keys ||= @property_keys_proc.call
+    end
+
+    def relationship_types
+      @relationship_types ||= @relationship_types_proc.call
+    end
+
+    def call_procedure(procedure)
+      res = @connection.call("GRAPH.QUERY", @graphname, "CALL #{procedure}()")
+      res[1].flatten
+    rescue Redis::CommandError => e
+      raise CallError, e
+    end
+  end
 
   # The RedisGraph constructor instantiates a Redis connection
   # and validates that the graph module is loaded
   def initialize(graph, redis_options = {})
     @graphname = graph
     connect_to_server(redis_options)
+    @metadata = Metadata.new(graphname: @graphname,
+                             connection: @connection)
   end
 
   # Execute a command and return its parsed result
   def query(command)
-    begin
-    resp = @connection.call("GRAPH.QUERY", @graphname, command)
-    rescue Redis::CommandError => e
-      raise QueryError, e
-    end
-
-    QueryResult.new(resp)
+    resp = @connection.call('GRAPH.QUERY', @graphname, command, '--compact')
+    QueryResult.new(resp,
+                    metadata:   @metadata)
+  rescue Redis::CommandError => e
+    raise QueryError, e
   end
 
   # Return the execution plan for a given command
   def explain(command)
-    begin
-    resp = @connection.call("GRAPH.EXPLAIN", @graphname, command)
-    rescue Redis::CommandError => e
-      raise QueryError, e
-    end
+    @connection.call('GRAPH.EXPLAIN', @graphname, command)
+  rescue Redis::CommandError => e
+    raise ExplainError, e
   end
 
   # Delete the graph and all associated keys
   def delete
-    resp = @connection.call("GRAPH.DELETE", @graphname)
+    @connection.call('GRAPH.DELETE', @graphname)
+  rescue Redis::CommandError => e
+    raise DeleteError, e
   end
 end
-

data/redisgraph.gemspec

@@ -20,5 +20,4 @@ Gem::Specification.new do |s|
   s.files = `git ls-files`.split("\n")
 
   s.add_runtime_dependency('redis', '~> 4')
-  s.add_runtime_dependency('terminal-table', '~> 1', '>= 1.8')
 end

data/spec/helper.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'codecov'
+SimpleCov.formatter = SimpleCov::Formatter::Codecov

data/spec/redisgraph_quickstart_spec.rb

@@ -0,0 +1,73 @@
+require 'helper.rb'
+
+require_relative '../lib/redisgraph.rb'
+
+# based on queries extracted from
+describe RedisGraph do
+  before(:all) do
+    begin
+      @r = RedisGraph.new("#{described_class}_test")
+      create_graph
+    rescue Redis::BaseError => e
+      $stderr.puts(e)
+      exit 1
+    end
+  end
+
+  after(:all) do
+    @r.delete if @r
+  end
+
+  def create_graph()
+    q = "CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {name:'Yamaha'})," \
+      "(:Rider {name:'Dani Pedrosa'})-[:rides]->(:Team {name:'Honda'})," \
+      "(:Rider {name:'Andrea Dovizioso'})-[:rides]->(:Team {name:'Ducati'})"
+
+    res = @r.query(q)
+
+    expect(res.resultset).to be_nil
+    stats = res.stats
+    expect(stats).to include(:internal_execution_time)
+    stats.delete(:internal_execution_time)
+    expect(stats).to eq({
+      labels_added:          2,
+      nodes_created:         6,
+      properties_set:        6,
+      relationships_created: 3
+    })
+  end
+
+  context 'quickstart' do
+    it 'should query relations, with a predicate' do
+      q = "MATCH (r:Rider)-[:rides]->(t:Team) WHERE t.name = 'Yamaha' RETURN r.name, t.name"
+
+      res = @r.query(q)
+
+      expect(res.columns).to eq(["r.name", "t.name"])
+      expect(res.resultset).to eq([["Valentino Rossi", "Yamaha"]])
+    end
+
+    # not in the quickstart, but demonstrates multiple rows
+    it 'should query relations, without a predicate' do
+      q = "MATCH (r:Rider)-[:rides]->(t:Team) RETURN r.name, t.name ORDER BY r.name"
+
+      res = @r.query(q)
+
+      expect(res.columns).to eq(["r.name", "t.name"])
+      expect(res.resultset).to eq([
+        ["Andrea Dovizioso", "Ducati"],
+        ["Dani Pedrosa", "Honda"],
+        ["Valentino Rossi", "Yamaha"]
+      ])
+    end
+
+    it 'should query relations, with an aggregate function' do
+      q = "MATCH (r:Rider)-[:rides]->(t:Team {name:'Ducati'}) RETURN count(r)"
+
+      res = @r.query(q)
+
+      expect(res.columns).to eq(["count(r)"])
+      expect(res.resultset).to eq([[1]])
+    end
+  end
+end

data/spec/redisgraph_spec.rb

@@ -0,0 +1,95 @@
+require 'helper.rb'
+
+require_relative '../lib/redisgraph.rb'
+
+describe RedisGraph do
+  # TODO it would be nice to have something like DisposableRedis
+  # Connect to a Redis server on localhost:6379
+  before(:all) do
+    begin
+      @r = RedisGraph.new("#{described_class}_test")
+      create_graph
+    rescue Redis::BaseError => e
+      $stderr.puts(e)
+    end
+  end
+
+  # Ensure that the graph "rubytest" does not exist
+  after(:all) do
+    @r.delete if @r
+  end
+
+  def create_graph()
+    q = """CREATE (t:node {name: 'src'})"""
+
+    res = @r.query(q)
+    expect(res.resultset).to be_nil
+
+    plan = @r.explain(q)
+    expect(plan).to include("Create")
+
+    expect(res.stats[:labels_added]).to eq(1)
+    expect(res.stats[:nodes_created]).to eq(1)
+    expect(res.stats[:properties_set]).to eq(1)
+  end
+
+  # Test functions - each validates one or more EXPLAIN and QUERY calls
+
+  context "bare return" do
+    it "should map values properly" do
+      q = """UNWIND [1, 1.5, null, 'strval', true, false] AS a RETURN a"""
+      res = @r.query(q)
+      expect(res.resultset).to eq([[1], [1.5], [nil], ["strval"], [true], [false]])
+    end
+  end
+
+  context "nodes" do
+    it "should delete nodes properly" do
+      q = """MATCH (t:node) WHERE t.name = 'src' DELETE t"""
+      plan = @r.explain(q)
+      expect(plan).to include("Delete")
+      res = @r.query(q)
+      expect(res.resultset).to be_nil
+      expect(res.stats[:nodes_deleted]).to eq(1)
+    end
+  end
+
+  context "edges" do
+    it "should create edges properly" do
+      q = "CREATE (p:node {name: 'src1', color: 'cyan'})-[:edge { weight: 7.8 }]->(:node {name: 'dest1', color: 'magenta'})," \
+        " (:node {name: 'src2'})-[:edge { weight: 12 }]->(q:node_type_2 {name: 'dest2'})"
+      plan = @r.explain(q)
+      expect(plan).to include("Create")
+      res = @r.query(q)
+      expect(res.resultset).to be_nil
+      expect(res.stats[:nodes_created]).to eq(4)
+      expect(res.stats[:properties_set]).to eq(8)
+      expect(res.stats[:relationships_created]).to eq(2)
+    end
+
+    it "should traverse edges properly" do
+      q = """MATCH (a)-[e:edge]->(b:node) RETURN a.name, b, e"""
+      plan = @r.explain(q)
+      expect(plan.detect { |row| row.include?("Traverse") }).to_not be_nil
+      res = @r.query(q)
+      expect(res.columns).to eq(["a.name", "b", "e"])
+      expect(res.resultset).to eq([["src1", [{"name"=>"dest1"}, {"color"=>"magenta"}], [{"weight"=>7.8}]]])
+    end
+  end
+
+  context "update" do
+    it "should support adding new properties" do
+      q = """MATCH (a {name: 'src1'}) SET a.newval = true"""
+      plan = @r.explain(q)
+      expect(plan.detect { |row| row.include?("Update") }).to_not be_nil
+      res = @r.query(q)
+      expect(res.stats[:properties_set]).to eq(1)
+    end
+
+    it "should print property strings correctly after updates" do
+      q = """MATCH (a {name: 'src1'}) RETURN a"""
+      res = @r.query(q)
+      expect(res.resultset).to eq([[[{"name"=>"src1"}, {"color"=>"cyan"}, {"newval"=>true}]]])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redisgraph
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.3
 platform: ruby
 authors:
 - Redis Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-13 00:00:00.000000000 Z
+date: 2021-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -24,26 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4'
-- !ruby/object:Gem::Dependency
-  name: terminal-table
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
 description: A client that extends redis-rb to provide explicit support for the RedisGraph
   module.
 email: jeffrey@redislabs.com
@@ -51,6 +31,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
+- ".github/release-drafter-config.yml"
+- ".github/workflows/release-drafter.yml"
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
@@ -60,7 +44,9 @@ files:
 - lib/redisgraph/query_result.rb
 - lib/redisgraph/version.rb
 - redisgraph.gemspec
-- test/test_suite.rb
+- spec/helper.rb
+- spec/redisgraph_quickstart_spec.rb
+- spec/redisgraph_spec.rb
 homepage: https://github.com/redislabs/redisgraph-rb
 licenses:
 - BSD-3-Clause
@@ -80,8 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: A client for RedisGraph

data/test/test_suite.rb

@@ -1,89 +0,0 @@
-require_relative '../lib/redisgraph.rb'
-require "test/unit"
-include Test::Unit::Assertions
-
-# Helper functions
-# TODO it would be nice to have something like DisposableRedis
-
-# Connect to a Redis server on localhost:6379
-def connect_test
-  begin
-  @r = RedisGraph.new("rubytest")
-  rescue Redis::BaseError => e
-    puts e
-    puts "RedisGraph tests require that a Redis server with the graph module loaded be running on localhost:6379"
-    exit 1
-  end
-end
-
-# Ensure that the graph "rubytest" does not exist
-def delete_graph
-  @r.delete
-end
-
-# Test functions - each validates one or more EXPLAIN and QUERY calls
-
-def validate_node_creation
-  query_str = """CREATE (t:node {name: 'src'})"""
-  x = @r.query(query_str)
-  plan = @r.explain(query_str)
-  assert(plan =~ /Create/)
-  assert(x.resultset.nil?)
-  assert(x.stats[:labels_added] == 1)
-  assert(x.stats[:nodes_created] == 1)
-  assert(x.stats[:properties_set] == 1)
-  puts "Create node - PASSED"
-end
-
-def validate_node_deletion
-  query_str = """MATCH (t:node) WHERE t.name = 'src' DELETE t"""
-  plan = @r.explain(query_str)
-  assert(plan =~ /Delete/)
-  x = @r.query(query_str)
-  assert(x.resultset.nil?)
-  assert(x.stats[:nodes_deleted] == 1)
-  query_str = """MATCH (t:node) WHERE t.name = 'src' RETURN t"""
-  assert(x.resultset.nil?)
-  puts "Delete node - PASSED"
-end
-
-def validate_edge_creation
-  query_str = """CREATE (p:node {name: 'src1'})-[:edge]->(:node {name: 'dest1'}), (:node {name: 'src2'})-[:edge]->(q:node_type_2 {name: 'dest2'})"""
-  plan = @r.explain(query_str)
-  assert(plan =~ /Create/)
-  x = @r.query(query_str)
-  assert(x.resultset.nil?)
-  assert(x.stats[:nodes_created] == 4)
-  assert(x.stats[:properties_set] == 4)
-  assert(x.stats[:relationships_created] == 2)
-  puts "Add edges - PASSED"
-end
-
-def validate_edge_traversal
-  query_str = """MATCH (a)-[:edge]->(b:node) RETURN a, b"""
-  plan = @r.explain(query_str)
-  assert(plan.include?("Traverse"))
-  x = @r.query(query_str)
-  assert(x.resultset)
-  assert(x.columns.length == 2)
-  assert(x.resultset.length == 1)
-  assert(x.resultset[0] == ["src1", "dest1"])
-  puts "Traverse edge - PASSED"
-end
-
-def test_suite
-  puts "Running RedisGraph tests..."
-  connect_test
-  delete_graph # Clear the graph
-
-  # Test basic functionalities
-  validate_node_creation
-  validate_node_deletion
-  validate_edge_creation
-  validate_edge_traversal
-
-  delete_graph # Clear the graph again
-  puts "RedisGraph tests passed!"
-end
-
-test_suite