grumlin 0.23.0 → 1.0.0.rc1

data/lib/grumlin/request_error_factory.rb

@@ -1,73 +1,71 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class RequestErrorFactory
-    ERRORS = {
-      499 => InvalidRequestArgumentsError,
-      500 => ServerError,
-      597 => ScriptEvaluationError,
-      599 => ServerSerializationError,
-      598 => ServerTimeoutError,
+class Grumlin::RequestErrorFactory
+  ERRORS = {
+    499 => Grumlin::InvalidRequestArgumentsError,
+    500 => Grumlin::ServerError,
+    597 => Grumlin::ScriptEvaluationError,
+    599 => Grumlin::ServerSerializationError,
+    598 => Grumlin::ServerTimeoutError,
 
-      401 => ClientSideError,
-      407 => ClientSideError,
-      498 => ClientSideError
-    }.freeze
+    401 => Grumlin::ClientSideError,
+    407 => Grumlin::ClientSideError,
+    498 => Grumlin::ClientSideError
+  }.freeze
 
-    # Neptune presumably returns message as a JSON string of format
-    # {"detailedMessage":"",
-    #  "requestId":"UUID",
-    #  "code":"ConcurrentModificationException"}
-    # Currently we simply search for substrings to identify the exact error
-    # TODO: parse json and use `code` instead
+  # Neptune presumably returns message as a JSON string of format
+  # {"detailedMessage":"",
+  #  "requestId":"UUID",
+  #  "code":"ConcurrentModificationException"}
+  # Currently we simply search for substrings to identify the exact error
+  # TODO: parse json and use `code` instead
 
-    VERTEX_ALREADY_EXISTS = "Vertex with id already exists:"
-    EDGE_ALREADY_EXISTS = "Edge with id already exists:"
+  VERTEX_ALREADY_EXISTS = "Vertex with id already exists:"
+  EDGE_ALREADY_EXISTS = "Edge with id already exists:"
 
-    CONCURRENT_VERTEX_INSERT_FAILED = "Failed to complete Insert operation for a Vertex due to conflicting concurrent"
+  CONCURRENT_VERTEX_INSERT_FAILED = "Failed to complete Insert operation for a Vertex due to conflicting concurrent"
 
-    CONCURRENT_VERTEX_PROPERTY_INSERT_FAILED =
-      "Failed to complete Insert operation for a VertexProperty due to conflicting concurrent"
-    CONCURRENT_EDGE_PROPERTY_INSERT_FAILED =
-      "Failed to complete Insert operation for a EdgeProperty due to conflicting concurrent"
+  CONCURRENT_VERTEX_PROPERTY_INSERT_FAILED =
+    "Failed to complete Insert operation for a VertexProperty due to conflicting concurrent"
+  CONCURRENT_EDGE_PROPERTY_INSERT_FAILED =
+    "Failed to complete Insert operation for a EdgeProperty due to conflicting concurrent"
 
-    CONCURRENT_EDGE_INSERT_FAILED = "Failed to complete Insert operation for an Edge due to conflicting concurrent"
-    CONCURRENCT_MODIFICATION_FAILED = "Failed to complete operation due to conflicting concurrent"
+  CONCURRENT_EDGE_INSERT_FAILED = "Failed to complete Insert operation for an Edge due to conflicting concurrent"
+  CONCURRENCT_MODIFICATION_FAILED = "Failed to complete operation due to conflicting concurrent"
 
-    class << self
-      def build(request, response)
-        status = response[:status]
-        query = request[:request]
+  class << self
+    def build(request, response)
+      status = response[:status]
+      query = request[:request]
 
-        if (error = ERRORS[status[:code]])
-          return (
-            already_exists_error(status) ||
-            concurrent_modification_error(status) ||
-            error
-          ).new(status, query)
-        end
+      if (error = ERRORS[status[:code]])
+        return (
+          already_exists_error(status) ||
+          concurrent_modification_error(status) ||
+          error
+        ).new(status, query)
+      end
 
-        return unless RequestDispatcher::SUCCESS[status[:code]].nil?
+      return unless Grumlin::RequestDispatcher::SUCCESS[status[:code]].nil?
 
-        UnknownResponseStatus.new(status)
-      end
+      Grumlin::UnknownResponseStatus.new(status)
+    end
 
-      def already_exists_error(status)
-        return VertexAlreadyExistsError if status[:message]&.include?(VERTEX_ALREADY_EXISTS)
-        return EdgeAlreadyExistsError if status[:message]&.include?(EDGE_ALREADY_EXISTS)
-      end
+    def already_exists_error(status)
+      return Grumlin::VertexAlreadyExistsError if status[:message]&.include?(VERTEX_ALREADY_EXISTS)
+      return Grumlin::EdgeAlreadyExistsError if status[:message]&.include?(EDGE_ALREADY_EXISTS)
+    end
 
-      def concurrent_modification_error(status) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        return ConcurrentVertexInsertFailedError if status[:message]&.include?(CONCURRENT_VERTEX_INSERT_FAILED)
-        if status[:message]&.include?(CONCURRENT_VERTEX_PROPERTY_INSERT_FAILED)
-          return ConcurrentVertexPropertyInsertFailedError
-        end
-        return ConcurrentEdgeInsertFailedError if status[:message]&.include?(CONCURRENT_EDGE_INSERT_FAILED)
-        if status[:message]&.include?(CONCURRENT_EDGE_PROPERTY_INSERT_FAILED)
-          return ConcurrentEdgePropertyInsertFailedError
-        end
-        return ConcurrentModificationError if status[:message]&.include?(CONCURRENCT_MODIFICATION_FAILED)
+    def concurrent_modification_error(status) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      return Grumlin::ConcurrentVertexInsertFailedError if status[:message]&.include?(CONCURRENT_VERTEX_INSERT_FAILED)
+      if status[:message]&.include?(CONCURRENT_VERTEX_PROPERTY_INSERT_FAILED)
+        return Grumlin::ConcurrentVertexPropertyInsertFailedError
+      end
+      return Grumlin::ConcurrentEdgeInsertFailedError if status[:message]&.include?(CONCURRENT_EDGE_INSERT_FAILED)
+      if status[:message]&.include?(CONCURRENT_EDGE_PROPERTY_INSERT_FAILED)
+        return Grumlin::ConcurrentEdgePropertyInsertFailedError
       end
+      return Grumlin::ConcurrentModificationError if status[:message]&.include?(CONCURRENCT_MODIFICATION_FAILED)
     end
   end
 end

data/lib/grumlin/shortcut.rb

@@ -1,32 +1,30 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Shortcut
-    extend Forwardable
+class Grumlin::Shortcut
+  extend Forwardable
 
-    attr_reader :name, :block
+  attr_reader :name, :block
 
-    def_delegator :@block, :arity
-    def_delegator :@block, :source_location
+  def_delegator :@block, :arity
+  def_delegator :@block, :source_location
 
-    def initialize(name, lazy: true, &block)
-      @name = name
-      @lazy = lazy
-      @block = block
-    end
+  def initialize(name, lazy: true, &block)
+    @name = name
+    @lazy = lazy
+    @block = block
+  end
 
-    def ==(other)
-      @name == other.name && @block == other.block
-    end
+  def ==(other)
+    @name == other.name && @block == other.block
+  end
 
-    def lazy?
-      @lazy
-    end
+  def lazy?
+    @lazy
+  end
 
-    # TODO: to_s, inspect, preview
+  # TODO: to_s, inspect, preview
 
-    def apply(object, *args, **params)
-      object.instance_exec(*args, **params, &@block)
-    end
+  def apply(object, *args, **params)
+    object.instance_exec(*args, **params, &@block)
   end
 end

data/lib/grumlin/shortcuts/properties.rb

@@ -1,24 +1,20 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Shortcuts
-    module Properties
-      extend Grumlin::Shortcuts
+module Grumlin::Shortcuts::Properties
+  extend Grumlin::Shortcuts
 
-      shortcut :props do |cardinality = nil, **props|
-        props.reduce(self) do |tt, (prop, value)|
-          next tt if value.nil? # nils are not supported
-          next tt.property(prop, value) if cardinality.nil?
+  shortcut :props do |cardinality = nil, **props|
+    props.reduce(self) do |tt, (prop, value)|
+      next tt if value.nil? # nils are not supported
+      next tt.property(prop, value) if cardinality.nil?
 
-          tt.property(cardinality, prop, value)
-        end
-      end
+      tt.property(cardinality, prop, value)
+    end
+  end
 
-      shortcut :hasAll do |**props|
-        props.reduce(self) do |tt, (prop, value)|
-          tt.has(prop, value)
-        end
-      end
+  shortcut :hasAll do |**props|
+    props.reduce(self) do |tt, (prop, value)|
+      tt.has(prop, value)
     end
   end
 end

data/lib/grumlin/shortcuts/storage.rb

@@ -1,99 +1,92 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Shortcuts
-    class Storage
-      extend Forwardable
-
-      class << self
-        def [](other)
-          new(other)
-        end
+class Grumlin::Shortcuts::Storage
+  extend Forwardable
 
-        def empty
-          @empty ||= new
-        end
-      end
+  class << self
+    def [](other)
+      new(other)
+    end
 
-      def initialize(storage = {})
-        @storage = storage
-        storage.each do |n, s|
-          add(n, s)
-        end
-      end
+    def empty
+      @empty ||= new
+    end
+  end
 
-      def_delegator :@storage, :[]
-      def_delegator :@storage, :include?, :known?
-      def_delegator :@storage, :keys, :names
+  def initialize(storage = {})
+    @storage = storage
+    storage.each do |n, s|
+      add(n, s)
+    end
+  end
 
-      def ==(other)
-        @storage == other.storage
-      end
+  def_delegator :@storage, :[]
+  def_delegator :@storage, :include?, :known?
+  def_delegator :@storage, :keys, :names
+  def_delegator :self, :__, :g
 
-      def add(name, shortcut)
-        @storage[name] = shortcut
+  def ==(other)
+    @storage == other.storage
+  end
 
-        sc = step_class
+  def add(name, shortcut)
+    @storage[name] = shortcut
 
-        shortcut_methods_module.define_method(name) do |*args, **params|
-          next sc.new(name, args: args, params: params, previous_step: self, pool: Grumlin.default_pool)
-        end
-        extend_traversal_classes(shortcut) unless shortcut.lazy?
-      end
+    sc = step_class
 
-      def add_from(other)
-        other.storage.each do |name, shortcut|
-          add(name, shortcut)
-        end
-      end
+    shortcut_methods_module.define_method(name) do |*args, **params|
+      next sc.new(name, args: args, params: params, previous_step: self, pool: Grumlin.default_pool)
+    end
+    extend_traversal_classes(shortcut) unless shortcut.lazy?
+  end
 
-      def g
-        __
-      end
+  def add_from(other)
+    other.storage.each do |name, shortcut|
+      add(name, shortcut)
+    end
+  end
 
-      def __
-        traversal_start_class.new(pool: Grumlin.default_pool)
-      end
+  def __
+    traversal_start_class.new(pool: Grumlin.default_pool)
+  end
 
-      def traversal_start_class
-        @traversal_start_class ||= shortcut_aware_class(TraversalStart)
-      end
+  def traversal_start_class
+    @traversal_start_class ||= shortcut_aware_class(Grumlin::TraversalStart)
+  end
 
-      def step_class
-        @step_class ||= shortcut_aware_class(Step)
-      end
+  def step_class
+    @step_class ||= shortcut_aware_class(Grumlin::Step)
+  end
 
-      protected
+  protected
 
-      attr_reader :storage
+  attr_reader :storage
 
-      private
+  private
 
-      def shortcut_methods_module
-        @shortcut_methods_module ||= begin
-          shorts = self
-          Module.new do
-            define_method :shortcuts do
-              shorts
-            end
-          end
+  def shortcut_methods_module
+    @shortcut_methods_module ||= begin
+      shorts = self
+      Module.new do
+        define_method :shortcuts do
+          shorts
         end
       end
+    end
+  end
 
-      def shortcut_aware_class(base)
-        methods = shortcut_methods_module
-        Class.new(base) do
-          include methods
-        end
-      end
+  def shortcut_aware_class(base)
+    methods = shortcut_methods_module
+    Class.new(base) do
+      include methods
+    end
+  end
 
-      def extend_traversal_classes(shortcut)
-        m = Module.new do
-          define_method(shortcut.name, &shortcut.block)
-        end
-        step_class.include(m)
-        traversal_start_class.include(m)
-      end
+  def extend_traversal_classes(shortcut)
+    m = Module.new do
+      define_method(shortcut.name, &shortcut.block)
     end
+    step_class.include(m)
+    traversal_start_class.include(m)
   end
 end

data/lib/grumlin/shortcuts/upserts.rb

@@ -1,28 +1,24 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Shortcuts
-    module Upserts
-      extend Grumlin::Shortcuts
+module Grumlin::Shortcuts::Upserts
+  extend Grumlin::Shortcuts
 
-      shortcut :upsertV do |label, id, create_properties = {}, update_properties = {}|
-        self.V(id)
-            .fold
-            .coalesce(
-              __.unfold,
-              __.addV(label).props(Cardinality.single, **create_properties.merge(T.id => id))
-            ).props(Cardinality.single, **update_properties)
-      end
+  shortcut :upsertV do |label, id, create_properties = {}, update_properties = {}|
+    self.V(id)
+        .fold
+        .coalesce(
+          __.unfold,
+          __.addV(label).props(Cardinality.single, **create_properties.merge(T.id => id))
+        ).props(Cardinality.single, **update_properties)
+  end
 
-      shortcut :upsertE do |label, from, to, create_properties = {}, update_properties = {}|
-        self.V(from)
-            .outE(label).where(__.inV.hasId(to))
-            .fold
-            .coalesce(
-              __.unfold,
-              __.addE(label).from(__.V(from)).to(__.V(to)).props(**create_properties)
-            ).props(**update_properties)
-      end
-    end
+  shortcut :upsertE do |label, from, to, create_properties = {}, update_properties = {}|
+    self.V(from)
+        .outE(label).where(__.inV.hasId(to))
+        .fold
+        .coalesce(
+          __.unfold,
+          __.addE(label).from(__.V(from)).to(__.V(to)).props(**create_properties)
+        ).props(**update_properties)
   end
 end

data/lib/grumlin/shortcuts.rb

@@ -1,36 +1,34 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Shortcuts
-    def self.extended(base)
-      base.include(Grumlin::Expressions)
-    end
+module Grumlin::Shortcuts
+  def self.extended(base)
+    base.include(Grumlin::Expressions)
+  end
 
-    def inherited(subclass)
-      super
-      subclass.shortcuts_from(self)
-    end
+  def inherited(subclass)
+    super
+    subclass.shortcuts_from(self)
+  end
 
-    def shortcut(name, shortcut = nil, override: false, lazy: true, &block)
-      name = name.to_sym
-      lazy = false if override
+  def shortcut(name, shortcut = nil, override: false, lazy: true, &block)
+    name = name.to_sym
+    lazy = false if override
 
-      if Grumlin::Step::REGULAR_STEPS.include?(name) && !override
-        raise ArgumentError,
-              "overriding standard gremlin steps is not allowed, if you know what you're doing, pass `override: true`"
-      end
+    if Grumlin::Step::REGULAR_STEPS.include?(name) && !override
+      raise ArgumentError,
+            "overriding standard gremlin steps is not allowed, if you know what you're doing, pass `override: true`"
+    end
 
-      raise ArgumentError, "either shortcut or block must be passed" if [shortcut, block].count(&:nil?) != 1
+    raise ArgumentError, "either shortcut or block must be passed" if [shortcut, block].count(&:nil?) != 1
 
-      shortcuts.add(name, shortcut || Shortcut.new(name, lazy: lazy, &block))
-    end
+    shortcuts.add(name, shortcut || Grumlin::Shortcut.new(name, lazy: lazy, &block))
+  end
 
-    def shortcuts_from(other_shortcuts)
-      shortcuts.add_from(other_shortcuts.shortcuts)
-    end
+  def shortcuts_from(other_shortcuts)
+    shortcuts.add_from(other_shortcuts.shortcuts)
+  end
 
-    def shortcuts
-      @shortcuts ||= Storage.new
-    end
+  def shortcuts
+    @shortcuts ||= Storage.new
   end
 end

data/lib/grumlin/shortcuts_applyer.rb

@@ -1,41 +1,39 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class ShortcutsApplyer
-    class << self
-      def call(steps)
-        return steps if !steps.is_a?(Steps) || !steps.uses_shortcuts?
-
-        shortcuts = steps.shortcuts
-
-        steps = [
-          *process_steps(steps.configuration_steps, shortcuts),
-          *process_steps(steps.steps, shortcuts)
-        ]
-
-        Steps.new(shortcuts).tap do |processed_steps|
-          steps.each do |step|
-            processed_steps.add(step.name, args: step.args, params: step.params)
-          end
+class Grumlin::ShortcutsApplyer
+  class << self
+    def call(steps)
+      return steps if !steps.is_a?(Grumlin::Steps) || !steps.uses_shortcuts?
+
+      shortcuts = steps.shortcuts
+
+      steps = [
+        *process_steps(steps.configuration_steps, shortcuts),
+        *process_steps(steps.steps, shortcuts)
+      ]
+
+      Grumlin::Steps.new(shortcuts).tap do |processed_steps|
+        steps.each do |step|
+          processed_steps.add(step.name, args: step.args, params: step.params)
         end
       end
+    end
 
-      private
+    private
 
-      def process_steps(steps, shortcuts) # rubocop:disable Metrics/AbcSize
-        steps.each_with_object([]) do |step, result|
-          args = step.args.map { |arg| call(arg) }
+    def process_steps(steps, shortcuts) # rubocop:disable Metrics/AbcSize
+      steps.each_with_object([]) do |step, result|
+        args = step.args.map { |arg| call(arg) }
 
-          shortcut = shortcuts[step.name]
-          next result << StepData.new(step.name, args: args, params: step.params) unless shortcut&.lazy?
+        shortcut = shortcuts[step.name]
+        next result << Grumlin::StepData.new(step.name, args: args, params: step.params) unless shortcut&.lazy?
 
-          t = shortcuts.__
-          step = shortcut.apply(t, *args, **step.params)
-          next if step.nil? || step == t # Shortcut did not add any steps
+        t = shortcuts.__
+        step = shortcut.apply(t, *args, **step.params)
+        next if step.nil? || step == t # Shortcut did not add any steps
 
-          new_steps = call(Steps.from(step))
-          result.concat(new_steps.configuration_steps, new_steps.steps)
-        end
+        new_steps = call(Grumlin::Steps.from(step))
+        result.concat(new_steps.configuration_steps, new_steps.steps)
       end
     end
   end