grumlin 0.22.4 → 1.0.0.rc1

data/lib/grumlin/transport.rb

@@ -1,101 +1,99 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Transport
-    # A transport based on https://github.com/socketry/async
-    # and https://github.com/socketry/async-websocket
-
-    include Console
-
-    attr_reader :url
-
-    # Transport is not reusable. Once closed should be recreated.
-    def initialize(url, parent: Async::Task.current, **client_options)
-      @url = url
-      @parent = parent
-      @client_options = client_options
-      @request_channel = Async::Channel.new
-      @response_channel = Async::Channel.new
-    end
+class Grumlin::Transport
+  # A transport based on https://github.com/socketry/async
+  # and https://github.com/socketry/async-websocket
 
-    def connected?
-      !@connection.nil?
-    end
+  include Console
 
-    def connect
-      raise ClientClosedError if @closed
-      raise AlreadyConnectedError if connected?
+  attr_reader :url
 
-      @connection = Async::WebSocket::Client.connect(Async::HTTP::Endpoint.parse(@url), **@client_options)
-      logger.debug(self) { "Connected to #{@url}." }
+  # Transport is not reusable. Once closed should be recreated.
+  def initialize(url, parent: Async::Task.current, **client_options)
+    @url = url
+    @parent = parent
+    @client_options = client_options
+    @request_channel = Async::Channel.new
+    @response_channel = Async::Channel.new
+  end
 
-      @response_task = @parent.async { run_response_task }
+  def connected?
+    !@connection.nil?
+  end
 
-      @request_task = @parent.async { run_request_task }
+  def connect
+    raise ClientClosedError if @closed
+    raise AlreadyConnectedError if connected?
 
-      @response_channel
-    end
+    @connection = Async::WebSocket::Client.connect(Async::HTTP::Endpoint.parse(@url), **@client_options)
+    logger.debug(self) { "Connected to #{@url}." }
 
-    def write(message)
-      raise NotConnectedError unless connected?
+    @response_task = @parent.async { run_response_task }
 
-      @request_channel << message
-    end
+    @request_task = @parent.async { run_request_task }
 
-    def close
-      return if @closed
+    @response_channel
+  end
 
-      @closed = true
+  def write(message)
+    raise NotConnectedError unless connected?
 
-      @request_channel.close
-      @response_channel.close
+    @request_channel << message
+  end
 
-      begin
-        @connection.close
-      rescue StandardError
-        nil
-      end
-      @connection = nil
+  def close
+    return if @closed
 
-      @request_task&.stop(true)
-      @response_task&.stop(true)
-    end
+    @closed = true
+
+    @request_channel.close
+    @response_channel.close
 
-    def wait
-      @request_task.wait
-      @response_task.wait
+    begin
+      @connection.close
+    rescue StandardError
+      nil
     end
+    @connection = nil
 
-    private
+    @request_task&.stop(true)
+    @response_task&.stop(true)
+  end
+
+  def wait
+    @request_task.wait
+    @response_task.wait
+  end
 
-    def run_response_task
-      with_guard do
-        loop do
-          data = @connection.read
-          @response_channel << data
-        end
+  private
+
+  def run_response_task
+    with_guard do
+      loop do
+        data = @connection.read
+        @response_channel << data
       end
     end
+  end
 
-    def run_request_task
-      with_guard do
-        @request_channel.each do |message|
-          @connection.write(message)
-          @connection.flush
-        end
+  def run_request_task
+    with_guard do
+      @request_channel.each do |message|
+        @connection.write(message)
+        @connection.flush
       end
     end
+  end
 
-    def with_guard
-      yield
-    rescue Async::Stop, Async::TimeoutError, StandardError => e
-      logger.debug(self) { "Guard error, closing." }
-      begin
-        @response_channel.exception(e)
-      rescue Async::Channel::ChannelClosedError
-        nil
-      end
-      close
+  def with_guard
+    yield
+  rescue Async::Stop, Async::TimeoutError, StandardError => e
+    logger.debug(self) { "Guard error, closing." }
+    begin
+      @response_channel.exception(e)
+    rescue Async::Channel::ChannelClosedError
+      nil
     end
+    close
   end
 end

data/lib/grumlin/traversal_start.rb

@@ -1,42 +1,40 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class TraversalStart < Steppable
-    include WithExtension
-
-    class TraversalError < Grumlin::Error; end
-    class AlreadyBoundToTransactionError < TraversalError; end
-
-    def tx
-      raise AlreadyBoundToTransactionError if @session_id
-
-      transaction = tx_class.new(self.class, pool: @pool)
-      return transaction unless block_given?
-
-      begin
-        yield transaction.begin
-      rescue Grumlin::Rollback
-        transaction.rollback
-      rescue StandardError
-        transaction.rollback
-        raise
-      else
-        transaction.commit
-      end
+class Grumlin::TraversalStart < Grumlin::Steppable
+  include Grumlin::WithExtension
+
+  class TraversalError < Grumlin::Error; end
+  class AlreadyBoundToTransactionError < TraversalError; end
+
+  def tx
+    raise AlreadyBoundToTransactionError if @session_id
+
+    transaction = tx_class.new(self.class, pool: @pool, middlewares: @middlewares)
+    return transaction unless block_given?
+
+    begin
+      yield transaction.begin
+    rescue Grumlin::Rollback
+      transaction.rollback
+    rescue StandardError
+      transaction.rollback
+      raise
+    else
+      transaction.commit
     end
+  end
 
-    def to_s(*)
-      self.class.to_s
-    end
+  def to_s(*)
+    self.class.to_s
+  end
 
-    def inspect
-      self.class.inspect
-    end
+  def inspect
+    self.class.inspect
+  end
 
-    private
+  private
 
-    def tx_class
-      Grumlin.features.supports_transactions? ? Transaction : DummyTransaction
-    end
+  def tx_class
+    Grumlin.features.supports_transactions? ? Grumlin::Transaction : Grumlin::DummyTransaction
   end
 end

data/lib/grumlin/traversal_strategies/options_strategy.rb

@@ -1,11 +1,7 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module TraversalStrategies
-    class OptionsStrategy < TypedValue
-      def initialize(value)
-        super(type: "OptionsStrategy", value: value)
-      end
-    end
+class Grumlin::TraversalStrategies::OptionsStrategy < Grumlin::TypedValue
+  def initialize(value)
+    super(type: "OptionsStrategy", value: value)
   end
 end

data/lib/grumlin/traverser.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Traverser
-    attr_reader :bulk, :value
+class Grumlin::Traverser
+  attr_reader :bulk, :value
 
-    def initialize(value)
-      @bulk = value.dig(:bulk, :@value) || 1
-      @value = Typing.cast(value[:value])
-    end
+  def initialize(value)
+    @bulk = value.dig(:bulk, :@value) || 1
+    @value = Grumlin::Typing.cast(value[:value])
   end
 end

data/lib/grumlin/typed_value.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class TypedValue
-    attr_reader :type, :value
+class Grumlin::TypedValue
+  attr_reader :type, :value
 
-    def initialize(type: nil, value: nil)
-      @type = type
-      @value = value
-    end
+  def initialize(type: nil, value: nil)
+    @type = type
+    @value = value
+  end
 
-    def inspect
-      "<#{type}.#{value}>"
-    end
+  def inspect
+    "<#{type}.#{value}>"
+  end
 
-    def to_s
-      inspect
-    end
+  def to_s
+    inspect
   end
 end

data/lib/grumlin/typing.rb

@@ -1,89 +1,87 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Typing
-    TYPES = {
-      "g:List" => ->(value) { cast_list(value) },
-      "g:Set" => ->(value) { cast_list(value).to_set },
-      "g:Map" => ->(value) { cast_map(value) },
-      "g:Vertex" => ->(value) { cast_entity(Grumlin::Vertex, value) },
-      "g:Edge" => ->(value) { cast_entity(Grumlin::Edge, value) },
-      "g:Path" => ->(value) { cast_entity(Grumlin::Path, value) },
-      "g:Traverser" => ->(value) { cast_entity(Grumlin::Traverser, value) },
-      "g:Property" => ->(value) { cast_entity(Grumlin::Property, value) },
-      "g:Int64" => ->(value) { cast_int(value) },
-      "g:Int32" => ->(value) { cast_int(value) },
-      "g:Double" => ->(value) { cast_double(value) },
-      "g:Direction" => ->(value) { value },
-      "g:VertexProperty" => ->(value) { cast_entity(Grumlin::VertexProperty, value) },
-      "g:TraversalMetrics" => ->(value) { cast_map(value[:@value]) },
-      "g:Metrics" => ->(value) { cast_map(value[:@value]) },
-      "g:T" => ->(value) { Grumlin::Expressions::T.public_send(value) }
-    }.freeze
-
-    CASTABLE_TYPES = [Hash, String, Integer, TrueClass, FalseClass, NilClass].freeze
-
-    class << self
-      def cast(value)
-        verify_type!(value)
-
-        return value unless value.is_a?(Hash)
-
-        type = TYPES[value[:@type]]
-
-        verify_castable_hash!(value, type)
-
-        type.call(value[:@value])
-      end
+module Grumlin::Typing
+  TYPES = {
+    "g:List" => ->(value) { cast_list(value) },
+    "g:Set" => ->(value) { cast_list(value).to_set },
+    "g:Map" => ->(value) { cast_map(value) },
+    "g:Vertex" => ->(value) { cast_entity(Grumlin::Vertex, value) },
+    "g:Edge" => ->(value) { cast_entity(Grumlin::Edge, value) },
+    "g:Path" => ->(value) { cast_entity(Grumlin::Path, value) },
+    "g:Traverser" => ->(value) { cast_entity(Grumlin::Traverser, value) },
+    "g:Property" => ->(value) { cast_entity(Grumlin::Property, value) },
+    "g:Int64" => ->(value) { cast_int(value) },
+    "g:Int32" => ->(value) { cast_int(value) },
+    "g:Double" => ->(value) { cast_double(value) },
+    "g:Direction" => ->(value) { value },
+    "g:VertexProperty" => ->(value) { cast_entity(Grumlin::VertexProperty, value) },
+    "g:TraversalMetrics" => ->(value) { cast_map(value[:@value]) },
+    "g:Metrics" => ->(value) { cast_map(value[:@value]) },
+    "g:T" => ->(value) { Grumlin::Expressions::T.public_send(value) }
+  }.freeze
+
+  CASTABLE_TYPES = [Hash, String, Integer, TrueClass, FalseClass, NilClass].freeze
+
+  class << self
+    def cast(value)
+      verify_type!(value)
+
+      return value unless value.is_a?(Hash)
+
+      type = TYPES[value[:@type]]
+
+      verify_castable_hash!(value, type)
+
+      type.call(value[:@value])
+    end
 
-      private
+    private
 
-      def verify_type!(value)
-        raise TypeError, "#{value.inspect} cannot be casted" unless CASTABLE_TYPES.include?(value.class)
-      end
+    def verify_type!(value)
+      raise TypeError, "#{value.inspect} cannot be casted" unless CASTABLE_TYPES.include?(value.class)
+    end
 
-      def verify_castable_hash!(value, type)
-        raise TypeError, "#{value} cannot be casted, @type is missing" if value[:@type].nil?
-        raise(UnknownTypeError, value[:@type]) if type.nil?
-        raise TypeError, "#{value} cannot be casted, @value is missing" if value[:@value].nil?
-      end
+    def verify_castable_hash!(value, type)
+      raise TypeError, "#{value} cannot be casted, @type is missing" if value[:@type].nil?
+      raise(UnknownTypeError, value[:@type]) if type.nil?
+      raise TypeError, "#{value} cannot be casted, @value is missing" if value[:@value].nil?
+    end
 
-      def cast_int(value)
-        raise TypeError, "#{value} is not an Integer" unless value.is_a?(Integer)
+    def cast_int(value)
+      raise TypeError, "#{value} is not an Integer" unless value.is_a?(Integer)
 
-        value
-      end
+      value
+    end
 
-      def cast_double(value)
-        raise TypeError, "#{value} is not a Double" unless value.is_a?(Float)
+    def cast_double(value)
+      raise TypeError, "#{value} is not a Double" unless value.is_a?(Float)
 
-        value
-      end
+      value
+    end
 
-      def cast_entity(entity, value)
-        entity.new(**value)
-      rescue ArgumentError, TypeError
-        raise TypeError, "#{value} cannot be casted to #{entity.name}"
-      end
+    def cast_entity(entity, value)
+      entity.new(**value)
+    rescue ArgumentError, TypeError
+      raise TypeError, "#{value} cannot be casted to #{entity.name}"
+    end
 
-      def cast_map(value)
-        Hash[*value].transform_keys do |key|
-          next key.to_sym if key.respond_to?(:to_sym)
-          next cast(key) if key[:@type] # TODO: g.V.group.by(:none_existing_property).next
+    def cast_map(value)
+      Hash[*value].transform_keys do |key|
+        next key.to_sym if key.respond_to?(:to_sym)
+        next cast(key) if key[:@type] # TODO: g.V.group.by(:none_existing_property).next
 
-          raise UnknownMapKey, key, value
-        end.transform_values { |v| cast(v) }
-      rescue ArgumentError
-        raise TypeError, "#{value} cannot be casted to Hash"
-      end
+        raise UnknownMapKey, key, value
+      end.transform_values { |v| cast(v) }
+    rescue ArgumentError
+      raise TypeError, "#{value} cannot be casted to Hash"
+    end
 
-      def cast_list(value)
-        value.each_with_object([]) do |item, result|
-          casted_value = cast(item)
-          next (result << casted_value) unless casted_value.instance_of?(Traverser)
+    def cast_list(value)
+      value.each_with_object([]) do |item, result|
+        casted_value = cast(item)
+        next (result << casted_value) unless casted_value.instance_of?(Grumlin::Traverser)
 
-          casted_value.bulk.times { result << casted_value.value }
-        end
+        casted_value.bulk.times { result << casted_value.value }
       end
     end
   end

data/lib/grumlin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Grumlin
-  VERSION = "0.22.4"
+  VERSION = "1.0.0.rc1"
 end

data/lib/grumlin/vertex.rb

@@ -1,24 +1,22 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class Vertex
-    attr_reader :label, :id
+class Grumlin::Vertex
+  attr_reader :label, :id
 
-    def initialize(label:, id:)
-      @label = label
-      @id = Typing.cast(id)
-    end
+  def initialize(label:, id:)
+    @label = label
+    @id = Grumlin::Typing.cast(id)
+  end
 
-    def ==(other)
-      self.class == other.class && @label == other.label && @id == other.id
-    end
+  def ==(other)
+    self.class == other.class && @label == other.label && @id == other.id
+  end
 
-    def inspect
-      "v[#{@id}]"
-    end
+  def inspect
+    "v[#{@id}]"
+  end
 
-    def to_s
-      inspect
-    end
+  def to_s
+    inspect
   end
 end

data/lib/grumlin/vertex_property.rb

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

data/lib/grumlin/with_extension.rb

@@ -1,27 +1,25 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module WithExtension
-    def with(name, value)
-      prev = self
-      strategy = if is_a?(with_action_class)
-                   prev = previous_step
-                   TraversalStrategies::OptionsStrategy.new(args.first.value.merge(name => value))
-                 else
-                   TraversalStrategies::OptionsStrategy.new({ name => value })
-                 end
-      with_action_class.new(:withStrategies, args: [strategy], previous_step: prev)
-    end
+module Grumlin::WithExtension
+  def with(name, value)
+    prev = self
+    strategy = if is_a?(with_step_class)
+                 prev = previous_step
+                 Grumlin::TraversalStrategies::OptionsStrategy.new(args.first.value.merge(name => value))
+               else
+                 Grumlin::TraversalStrategies::OptionsStrategy.new({ name => value })
+               end
+    with_step_class.new(:withStrategies, args: [strategy], previous_step: prev)
+  end
 
-    private
+  private
 
-    def with_action_class
-      @with_action_class ||= Class.new(shortcuts.action_class) do
-        include WithExtension
+  def with_step_class
+    @with_step_class ||= Class.new(shortcuts.step_class) do
+      include Grumlin::WithExtension
 
-        def with_action_class
-          self.class
-        end
+      def with_step_class
+        self.class
       end
     end
   end