grumlin 0.22.4 → 1.0.0.rc1

data/lib/grumlin/expressions/p.rb

@@ -1,39 +1,35 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    class P
-      class Predicate
-        attr_reader :namespace, :name, :value, :type
+class Grumlin::Expressions::P
+  class Predicate
+    attr_reader :namespace, :name, :value, :type
 
-        def initialize(namespace, name, value:, type: nil)
-          @namespace = namespace
-          @name = name
-          @value = value
-          @type = type
-        end
-      end
+    def initialize(namespace, name, value:, type: nil)
+      @namespace = namespace
+      @name = name
+      @value = value
+      @type = type
+    end
+  end
 
-      class << self
-        # TODO: support more predicates
-        %i[eq gt lt neq].each do |predicate|
-          define_method predicate do |*args|
-            Predicate.new("P", predicate, value: args[0])
-          end
-        end
+  class << self
+    # TODO: support more predicates
+    [:eq, :gt, :lt, :neq].each do |predicate|
+      define_method predicate do |*args|
+        Predicate.new("P", predicate, value: args[0])
+      end
+    end
 
-        %i[within without].each do |predicate|
-          define_method predicate do |*args|
-            args = if args.count == 1 && args[0].is_a?(Array)
-                     args[0]
-                   elsif args.count == 1 && args[0].is_a?(Set)
-                     args[0].to_a
-                   else
-                     args.to_a
-                   end
-            Predicate.new("P", predicate, value: args, type: "List")
-          end
-        end
+    [:within, :without].each do |predicate|
+      define_method predicate do |*args|
+        args = if args.count == 1 && args[0].is_a?(Array)
+                 args[0]
+               elsif args.count == 1 && args[0].is_a?(Set)
+                 args[0].to_a
+               else
+                 args.to_a
+               end
+        Predicate.new("P", predicate, value: args, type: "List")
       end
     end
   end

data/lib/grumlin/expressions/pop.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Pop
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :pop).map(&:to_sym).freeze
+module Grumlin::Expressions::Pop
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :pop).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Pop")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Pop")
   end
 end

data/lib/grumlin/expressions/scope.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module Scope
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :scope).map(&:to_sym).freeze
+module Grumlin::Expressions::Scope
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :scope).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "Scope")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "Scope")
   end
 end

data/lib/grumlin/expressions/t.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    module T
-      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :t).map(&:to_sym).freeze
+module Grumlin::Expressions::T
+  SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :t).map(&:to_sym).freeze
 
-      class << self
-        extend Expression
+  class << self
+    extend Grumlin::Expressions::Expression
 
-        define_steps(SUPPORTED_STEPS, "T")
-      end
-    end
+    define_steps(SUPPORTED_STEPS, "T")
   end
 end

data/lib/grumlin/expressions/text_p.rb

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    class TextP < P
-      class << self
-        %i[containing endingWith notContaining notEndingWith notStartingWith startingWith].each do |predicate|
-          define_method predicate do |*args|
-            P::Predicate.new("TextP", predicate, value: args[0])
-          end
-        end
+class Grumlin::Expressions::TextP < Grumlin::Expressions::P
+  class << self
+    [:containing, :endingWith, :notContaining, :notEndingWith, :notStartingWith, :startingWith].each do |predicate|
+      define_method predicate do |*args|
+        P::Predicate.new("TextP", predicate, value: args[0])
       end
     end
   end

data/lib/grumlin/expressions/with_options.rb

@@ -1,31 +1,27 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Expressions
-    class WithOptions
-      WITH_OPTIONS = Grumlin.definitions.dig(:expressions, :with_options).freeze
+class Grumlin::Expressions::WithOptions
+  WITH_OPTIONS = Grumlin.definitions.dig(:expressions, :with_options).freeze
 
-      class << self
-        WITH_OPTIONS.each do |k, v|
-          define_method k do
-            name = "@#{k}"
-            return instance_variable_get(name) if instance_variable_defined?(name)
+  class << self
+    WITH_OPTIONS.each do |k, v|
+      define_method k do
+        name = "@#{k}"
+        return instance_variable_get(name) if instance_variable_defined?(name)
 
-            instance_variable_set(name, WithOptions.new(k, v))
-          end
-        end
+        instance_variable_set(name, WithOptions.new(k, v))
       end
+    end
+  end
 
-      attr_reader :name, :value
+  attr_reader :name, :value
 
-      def initialize(name, value)
-        @name = name
-        @value = value
-      end
+  def initialize(name, value)
+    @name = name
+    @value = value
+  end
 
-      def to_s
-        "WithOptions.#{@name}"
-      end
-    end
+  def to_s
+    "WithOptions.#{@name}"
   end
 end

data/lib/grumlin/features/feature_list.rb

@@ -1,19 +1,15 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Features
-    class FeatureList
-      def user_supplied_ids?
-        raise(NotImplementedError) if @user_supplied_ids.nil?
+class Grumlin::Features::FeatureList
+  def user_supplied_ids?
+    raise(NotImplementedError) if @user_supplied_ids.nil?
 
-        @user_supplied_ids
-      end
+    @user_supplied_ids
+  end
 
-      def supports_transactions?
-        raise(NotImplementedError) if @supports_transactions.nil?
+  def supports_transactions?
+    raise(NotImplementedError) if @supports_transactions.nil?
 
-        @supports_transactions
-      end
-    end
+    @supports_transactions
   end
 end

data/lib/grumlin/features/neptune_features.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Features
-    class NeptuneFeatures < FeatureList
-      def initialize
-        super
-        @user_supplied_ids = true
-        @supports_transactions = true
-      end
-    end
+class Grumlin::Features::NeptuneFeatures < Grumlin::Features::FeatureList
+  def initialize
+    super
+    @user_supplied_ids = true
+    @supports_transactions = true
   end
 end

data/lib/grumlin/features/tinkergraph_features.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Features
-    class TinkergraphFeatures < FeatureList
-      def initialize
-        super
-        @user_supplied_ids = true
-        @supports_transactions = false
-      end
-    end
+class Grumlin::Features::TinkergraphFeatures < Grumlin::Features::FeatureList
+  def initialize
+    super
+    @user_supplied_ids = true
+    @supports_transactions = false
   end
 end

data/lib/grumlin/features.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Features
-    class << self
-      FEATURES = {
-        neptune: NeptuneFeatures.new,
-        tinkergraph: TinkergraphFeatures.new
-      }.freeze
+module Grumlin::Features
+  class << self
+    FEATURES = {
+      neptune: NeptuneFeatures.new,
+      tinkergraph: TinkergraphFeatures.new
+    }.freeze
 
-      def for(provider)
-        FEATURES[provider]
-      end
+    def for(provider)
+      FEATURES[provider]
     end
   end
 end

data/lib/grumlin/middlewares/apply_shortcuts.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::ApplyShortcuts < Grumlin::Middlewares::Middleware
+  def call(env)
+    env[:steps_without_shortcuts] = Grumlin::ShortcutsApplyer.call(env[:steps])
+    @app.call(env)
+  end
+end

data/lib/grumlin/middlewares/build_query.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::BuildQuery < Grumlin::Middlewares::Middleware
+  def call(env)
+    env[:query] = {
+      requestId: SecureRandom.uuid,
+      op: :bytecode,
+      processor: env[:session_id] ? :session : :traversal,
+      args: {
+        gremlin: {
+          :@type => "g:Bytecode",
+          :@value => env[:bytecode]
+        },
+        aliases: { g: :g },
+        session: env[:session_id]
+      }.compact
+    }
+    @app.call(env)
+  end
+end

data/lib/grumlin/middlewares/builder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::Builder < ::Middleware::Builder
+  def similar?(other)
+    stack == other.stack
+  end
+
+  def include?(middleware)
+    stack.any? { |m| m.first == middleware }
+  end
+
+  def to_app
+    @to_app ||= super
+  end
+end

data/lib/grumlin/middlewares/cast_results.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::CastResults < Grumlin::Middlewares::Middleware
+  def call(env)
+    env[:parsed_results] = @app.call(env).flat_map { |item| Grumlin::Typing.cast(item) }
+  end
+end

data/lib/grumlin/middlewares/find_blocklisted_steps.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::FindBlocklistedSteps < Grumlin::Middlewares::Middleware
+  def initialize(app, *steps)
+    super(app)
+    @validator = Grumlin::QueryValidators::BlocklistedStepsValidator.new(*steps)
+  end
+
+  def call(env)
+    @validator.validate!(env[:steps_without_shortcuts])
+    @app.call(env)
+    env[:parsed_results] = @app.call(env).flat_map { |item| Grumlin::Typing.cast(item) }
+  end
+end

data/lib/grumlin/middlewares/find_mutating_steps.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::FindMutatingSteps < Grumlin::Middlewares::FindBlocklistedSteps
+  MUTATING_STEPS = [:addV, :addE, :property, :drop].freeze
+
+  def initialize(app)
+    super(app, *MUTATING_STEPS)
+  end
+end

data/lib/grumlin/middlewares/middleware.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::Middleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    raise NotImplementedError
+  end
+end

data/lib/grumlin/middlewares/run_query.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::RunQuery < Grumlin::Middlewares::Middleware
+  def call(env)
+    env[:results] = env[:pool].acquire { |c| c.write(env[:query]) }
+  end
+end

data/lib/grumlin/middlewares/serialize_to_bytecode.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::SerializeToBytecode < Grumlin::Middlewares::Middleware
+  def call(env)
+    env[:bytecode] = Grumlin::StepsSerializers::Bytecode.new(env[:steps_without_shortcuts],
+                                                             no_return: !env[:need_results]).serialize
+    @app.call(env)
+  end
+end

data/lib/grumlin/middlewares/serialize_to_steps.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Grumlin::Middlewares::SerializeToSteps < Grumlin::Middlewares::Middleware
+  def call(env)
+    env[:steps] = Grumlin::Steps.from(env[:traversal])
+    @app.call(env)
+  end
+end

data/lib/grumlin/path.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Path
-    attr_reader :objects
+class Grumlin::Path
+  attr_reader :objects
 
-    def initialize(path)
-      @labels = Typing.cast(path[:labels])
-      @objects = Typing.cast(path[:objects])
-    end
+  def initialize(path)
+    @labels = Grumlin::Typing.cast(path[:labels])
+    @objects = Grumlin::Typing.cast(path[:objects])
+  end
 
-    def inspect
-      "p[#{@objects}]"
-    end
+  def inspect
+    "p[#{@objects}]"
+  end
 
-    def to_s
-      inspect
-    end
+  def to_s
+    inspect
   end
 end

data/lib/grumlin/property.rb

@@ -1,24 +1,22 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Property
-    attr_reader :key, :value
+class Grumlin::Property
+  attr_reader :key, :value
 
-    def initialize(value)
-      @key = value[:key]
-      @value = Typing.cast(value[:value])
-    end
+  def initialize(value)
+    @key = value[:key]
+    @value = Grumlin::Typing.cast(value[:value])
+  end
 
-    def inspect
-      "p[#{key}->#{value}]"
-    end
+  def inspect
+    "p[#{key}->#{value}]"
+  end
 
-    def to_s
-      inspect
-    end
+  def to_s
+    inspect
+  end
 
-    def ==(other)
-      self.class == other.class && @key == other.key && @value == other.value
-    end
+  def ==(other)
+    self.class == other.class && @key == other.key && @value == other.value
   end
 end

data/lib/grumlin/query_validators/blocklisted_steps_validator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Grumlin::QueryValidators::BlocklistedStepsValidator < Grumlin::QueryValidators::Validator
+  def initialize(*names)
+    super()
+    @names = names.to_set
+  end
+
+  protected
+
+  def validate(steps, errors)
+    (steps.configuration_steps + steps.steps).each do |step|
+      if @names.include?(step.name)
+        errors[:blocklisted_steps] ||= []
+        errors[:blocklisted_steps] << step.name
+      end
+      step.args.each do |arg|
+        validate(arg, errors) if arg.is_a?(Grumlin::Steps)
+      end
+    end
+  end
+end

data/lib/grumlin/query_validators/validator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Grumlin::QueryValidators::Validator
+  class ValidationError < Grumlin::Error
+    attr_reader :errors, :steps
+
+    def initialize(steps, errors)
+      super("Query is invalid: #{errors}")
+      @steps = steps
+      @errors = errors
+    end
+  end
+
+  # steps is an instance of `Steps` after shortcuts applied
+  def validate!(steps)
+    return unless (err = errors(steps)).any?
+
+    raise ValidationError.new(steps, err)
+  end
+
+  def valid?(steps)
+    errors(steps).empty?
+  end
+
+  protected
+
+  def errors(steps)
+    {}.tap do |errors|
+      validate(steps, errors)
+    end
+  end
+
+  def validate(steps, errors)
+    raise NotImplementedError
+  end
+end

data/lib/grumlin/repository/error_handling_strategy.rb

@@ -1,44 +1,40 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Repository
-    class ErrorHandlingStrategy
-      def initialize(mode: :retry, **params)
-        @mode = mode
-        @params = params
-        @on_exceptions = params[:on]
-      end
-
-      def raise?
-        @mode == :raise
-      end
-
-      def ignore?
-        @mode == :ignore
-      end
-
-      def retry?
-        @mode == :retry
-      end
-
-      def apply!(&block)
-        return yield if raise?
-        return ignore_errors!(&block) if ignore?
-
-        retry_errors!(&block)
-      end
-
-      private
-
-      def ignore_errors!
-        yield
-      rescue *@on_exceptions
-        # ignore errors
-      end
-
-      def retry_errors!(&block)
-        Retryable.retryable(**@params, &block)
-      end
-    end
+class Grumlin::Repository::ErrorHandlingStrategy
+  def initialize(mode: :retry, **params)
+    @mode = mode
+    @params = params
+    @on_exceptions = params[:on]
+  end
+
+  def raise?
+    @mode == :raise
+  end
+
+  def ignore?
+    @mode == :ignore
+  end
+
+  def retry?
+    @mode == :retry
+  end
+
+  def apply!(&block)
+    return yield if raise?
+    return ignore_errors!(&block) if ignore?
+
+    retry_errors!(&block)
+  end
+
+  private
+
+  def ignore_errors!
+    yield
+  rescue *@on_exceptions
+    # ignore errors
+  end
+
+  def retry_errors!(&block)
+    Retryable.retryable(**@params, &block)
   end
 end