neo4j-ruby-driver 0.1.1

data/ffi/neo4j/driver/internal/summary/internal_summary_counters.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Summary
+        class InternalSummaryCounters
+          def initialize(stats)
+            @stats = stats || RecursiveOpenStruct.new
+          end
+
+          def contains_updates?
+            @stats.to_h.values.any?(&:positive?)
+          end
+
+          def method_missing(method)
+            @stats.send(method) || 0
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/util/metadata_extractor.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Util
+        class MetadataExtractor
+          def initialize(result_available_after_metadata_key, result_consumed_after_metadata_key); end
+
+          def extract_bookmarks(metadata); end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/base_time_value.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module BaseTimeValue
+          NANO_FACTOR = 1_000_000_000
+
+          def time(nano_of_day_local, offset_seconds = nil)
+            min, sec = Rational(nano_of_day_local, NANO_FACTOR).divmod(60)
+            Time.new(0, 1, 1, *min.divmod(60), sec, offset_seconds)
+          end
+
+          def to_neo_values(local_time)
+            ((local_time.hour * 60 + local_time.min) * 60 + local_time.sec) * NANO_FACTOR + local_time.nsec
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/date_value.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module DateValue
+          CODE = :D
+          extend StructureValue
+          EPOCH = Date.parse('1970-01-01')
+
+          class << self
+            def to_ruby_value(epoch_day)
+              EPOCH + epoch_day
+            end
+
+            def to_neo_values(date)
+              (date - EPOCH).to_i
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/duration_value.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module DurationValue
+          CODE = :E
+          extend StructureValue
+
+          class << self
+            def to_ruby_value(months, days, seconds, nanoseconds)
+              ActiveSupport::Duration.months(months) +
+                ActiveSupport::Duration.days(days) +
+                ActiveSupport::Duration.seconds(seconds) +
+                ActiveSupport::Duration.seconds(nanoseconds * BigDecimal('1e-9'))
+            end
+
+            def to_neo_values(object)
+              DurationNormalizer.normalize(object)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/local_date_time_value.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module LocalDateTimeValue
+          CODE = :d
+          extend StructureValue
+
+          class << self
+            def to_ruby_value(epoch_second_utc, nsec)
+              Types::LocalDateTime.new(Time.at(epoch_second_utc, nsec, :nsec).utc)
+            end
+
+            def to_neo_values(local_date_time)
+              [local_date_time.to_i, local_date_time.nsec]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/local_time_value.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module LocalTimeValue
+          CODE = :t
+          extend StructureValue
+          extend BaseTimeValue
+
+          def self.to_ruby_value(nano_of_day_local)
+            Types::LocalTime.new(time(nano_of_day_local))
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/node_value.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module NodeValue
+          CODE = :N
+          extend StructureValue
+
+          def self.to_ruby_value(id, labels, properties)
+            Types::Node.new(id, labels, properties)
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/offset_time_value.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module OffsetTimeValue
+          CODE = :T
+          extend StructureValue
+          extend BaseTimeValue
+
+          class << self
+            def to_ruby_value(nano_of_day_local, offset_seconds)
+              Types::OffsetTime.new(time(nano_of_day_local, offset_seconds))
+            end
+
+            def to_neo_values(offset_time)
+              [super, offset_time.utc_offset]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/path_value.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module PathValue
+          CODE = :P
+          extend StructureValue
+          class << self
+            def to_ruby_value(uniq_nodes, uniq_rels, sequence)
+              prev_node = uniq_nodes.first
+              nodes = [prev_node] # Start node is always 0, and isn't encoded in the sequence
+              rels = []
+              path = Types::Path.new(nodes, rels)
+              sequence.in_groups_of(2) do |node_idx, rel_idx|
+                node = uniq_nodes[node_idx]
+                nodes << node
+                rel = uniq_rels[rel_idx.abs - 1] # -1 because rel idx are 1-indexed
+                update(rel, prev_node, node, rel_idx.negative?)
+                rels << rel
+                path << Types::Path::Segment.new(prev_node, rel, node)
+                prev_node = node
+              end
+              path
+            end
+
+            private
+
+            def update(rel, prev_node, node, inversed)
+              # Negative rel index means this rel was traversed "inversed" from its direction
+              prev_node, node = node, prev_node if inversed
+              rel.start_node_id = prev_node.id
+              rel.end_node_id = node.id
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/point2_d_value.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module Point2DValue
+          CODE = :X
+          extend StructureValue
+
+          class << self
+            def to_ruby_value(srid, x, y)
+              Types::Point.new(srid: srid, x: x, y: y)
+            end
+
+            def to_neo_values(point)
+              [point.srid.to_i, *point.coordinates]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/point3_d_value.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module Point3DValue
+          CODE = :Y
+          extend StructureValue
+
+          class << self
+            def to_ruby_value(srid, x, y, z)
+              Types::Point.new(srid: srid, x: x, y: y, z: z)
+            end
+
+            def to_neo_values(point)
+              [point.srid.to_i, *point.coordinates]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/relationship_value.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module RelationshipValue
+          CODE = :R
+          extend StructureValue
+
+          def self.to_ruby_value(id, start_node_id, end_node_id, type, properties)
+            Types::Relationship.new(id, start_node_id, end_node_id, type, properties)
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/structure_value.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module StructureValue
+          def self.extended(mod)
+            code = mod.const_get('CODE').to_s.getbyte(0)
+            (@modules ||= {})[code] = mod
+            mod.define_singleton_method(:code) { code }
+          end
+
+          def self.to_ruby(value)
+            @modules[Bolt::Structure.code(value)]&.to_ruby_specific(value)
+          end
+
+          def to_ruby_specific(value)
+            to_ruby_value(*Array.new(size, &method(:ruby_value).curry.call(value)))
+          end
+
+          def to_neo(value, object)
+            Bolt::Value.format_as_structure(value, code, size)
+            Array(to_neo_values(object)).each_with_index do |elem, index|
+              ValueAdapter.to_neo(Bolt::Structure.value(value, index), elem)
+            end
+          end
+
+          private
+
+          def ruby_value(value, index)
+            ValueAdapter.to_ruby(Bolt::Structure.value(value, index))
+          end
+
+          def size
+            @size ||= method(:to_ruby_value).arity
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/time_with_zone_id_value.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module TimeWithZoneIdValue
+          CODE = :f
+          extend StructureValue
+
+          class << self
+            def to_ruby_value(epoch_second_local, nsec, zone_id_string)
+              time = Time.at(epoch_second_local, nsec, :nsec).in_time_zone(TZInfo::Timezone.get(zone_id_string))
+              time - time.utc_offset
+            end
+
+            def to_neo_values(time)
+              [time.to_i + time.utc_offset, time.nsec, time.time_zone.tzinfo.identifier]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/time_with_zone_offset_value.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module TimeWithZoneOffsetValue
+          CODE = :F
+          extend StructureValue
+
+          class << self
+            def to_ruby_value(epoch_second_local, nsec, offset)
+              time = Time.at(epoch_second_local, nsec, :nsec).utc
+              Time.new(time.year, time.month, time.mday, time.hour, time.min, time.sec + Rational(nsec, 1_000_000_000),
+                       offset)
+              # In ruby 2.6.x
+              # Time.at(sec, nsec, :nsec, tz: offset)
+            end
+
+            def to_neo_values(time)
+              [time.to_i + time.utc_offset, time.nsec, time.utc_offset]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/unbound_relationship_value.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module UnboundRelationshipValue
+          CODE = :r
+          extend StructureValue
+
+          def self.to_ruby_value(id, type, properties)
+            Types::Relationship.new(id, nil, nil, type, properties)
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/value_adapter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module ValueAdapter
+          class << self
+            def to_ruby(value)
+              case Bolt::Value.type(value)
+              when :bolt_null
+                nil
+              when :bolt_boolean
+                Bolt::Boolean.get(value) == 1
+              when :bolt_integer
+                Bolt::Integer.get(value)
+              when :bolt_float
+                Bolt::Float.get(value)
+              when :bolt_bytes
+                Types::ByteArray.from_bytes(Array.new(Bolt::Value.size(value)) { |i| Bolt::Bytes.get(value, i) })
+              when :bolt_string
+                Bolt::String.get(value).read_string(Bolt::Value.size(value))
+              when :bolt_dictionary
+                Array.new(Bolt::Value.size(value)) do |i|
+                  [to_ruby(Bolt::Dictionary.key(value, i)).to_sym, to_ruby(Bolt::Dictionary.value(value, i))]
+                end.to_h
+              when :bolt_list
+                Array.new(Bolt::Value.size(value)) { |i| to_ruby(Bolt::List.value(value, i)) }
+              when :bolt_structure
+                StructureValue.to_ruby(value)
+              else
+                raise Exception, 'unsupported neo4j type'
+              end
+            end
+
+            def to_neo(value, object)
+              case object
+              when nil
+                Bolt::Value.format_as_null(value)
+              when TrueClass
+                Bolt::Value.format_as_boolean(value, 1)
+              when FalseClass
+                Bolt::Value.format_as_boolean(value, 0)
+              when Integer
+                Bolt::Value.format_as_integer(value, object)
+              when Float
+                Bolt::Value.format_as_float(value, object)
+              when Types::ByteArray
+                Bolt::Value.format_as_bytes(value, object, object.size)
+              when String
+                Bolt::Value.format_as_string(value, object, object.size)
+              when Array
+                Bolt::Value.format_as_list(value, object.size)
+                object.each_with_index { |elem, index| to_neo(Bolt::List.value(value, index), elem) }
+              when Hash
+                Bolt::Value.format_as_dictionary(value, object.size)
+                object.each_with_index do |(key, elem), index|
+                  key = key.to_s
+                  Bolt::Dictionary.set_key(value, index, key, key.size)
+                  to_neo(Bolt::Dictionary.value(value, index), elem)
+                end
+              when Date
+                DateValue.to_neo(value, object)
+              when ActiveSupport::Duration
+                DurationValue.to_neo(value, object)
+              when Neo4j::Driver::Types::Point
+                case object.coordinates.size
+                when 2
+                  Point2DValue
+                when 3
+                  Point3DValue
+                else
+                  raise Exception
+                end&.to_neo(value, object)
+              when Types::OffsetTime
+                OffsetTimeValue.to_neo(value, object)
+              when Types::LocalTime
+                LocalTimeValue.to_neo(value, object)
+              when Types::LocalDateTime
+                LocalDateTimeValue.to_neo(value, object)
+              when ActiveSupport::TimeWithZone
+                TimeWithZoneIdValue.to_neo(value, object)
+              when Time
+                TimeWithZoneOffsetValue.to_neo(value, object)
+              else
+                raise Exception, 'unsupported ruby type'
+              end
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end