neospace 0.0.1 → 1.7.0

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Summary
+        class InternalServerInfo
+          attr_reader :address, :version
+
+          def initialize(bolt_connection)
+            address = Bolt::Connection.remote_endpoint(bolt_connection)
+            @address = %i[host port].map { |method| Bolt::Address.send(method, address).first }.join(':')
+            @version = Bolt::Connection.server(bolt_connection).first
+          end
+        end
+      end
+    end
+  end
+end

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.map(&:to_sym), 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