grumlin 0.1.0 → 0.3.0

data/lib/grumlin/step.rb

@@ -1,46 +1,35 @@
 # frozen_string_literal: true
 
 module Grumlin
-  class Step
-    attr_reader :client, :name, :args
+  class Step < AnonymousStep
+    attr_reader :client
 
-    # TODO: add support for bytecode
-    def initialize(client, name, *args, previous_steps: [])
-      @client = client
-      @name = name
-      @previous_steps = previous_steps
-      @args = args
+    def initialize(pool, name, *args, previous_steps: [])
+      super(name, *args, previous_steps: previous_steps)
+      @pool = pool
     end
 
-    %w[addV addE V E limit count drop property valueMap select from to as].each do |step|
-      define_method step do |*args|
-        Step.new(@client, step, *args, previous_steps: steps)
-      end
+    def next
+      @enum ||= toList.to_enum
+      @enum.next
     end
 
-    alias addVertex addV
-    alias addEdge addE
-
-    # TODO: add support for next
-    # TODO: add support for iterate
-    # TODO: memoization
     def toList # rubocop:disable Naming/MethodName
-      @client.query(*steps)
-    end
-
-    def inspect
-      "<Step #{self}>" # TODO: substitute bindings
+      @pool.acquire do |client|
+        client.write(*steps)
+      end
     end
 
-    # TODO: memoization
-    def to_s(*)
-      Translator.to_string(steps)
+    def iterate
+      @pool.acquire do |client|
+        client.write(*(steps + [nil]))
+      end
     end
 
-    alias to_gremlin to_s
+    private
 
-    def steps
-      (@previous_steps + [self])
+    def add_step(step_name, args, previous_steps:)
+      self.class.new(@pool, step_name, *args, previous_steps: previous_steps)
     end
   end
 end

data/lib/grumlin/sugar.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Sugar
+    # TODO: how to use it in specs?
+    HELPERS = [
+      Grumlin::U,
+      Grumlin::T,
+      Grumlin::P,
+      Grumlin::Pop,
+      Grumlin::Order
+    ].freeze
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def const_missing(name)
+        helper = HELPERS.find { |h| h.const_defined?(name) }
+        super if helper.nil?
+
+        const_set(name, helper)
+      end
+    end
+
+    def const_missing(name)
+      helper = HELPERS.find { |h| h.const_defined?(name) }
+      super if helper.nil?
+
+      const_set(name, helper)
+    end
+
+    def __
+      Grumlin::U
+    end
+
+    def g
+      Grumlin::Traversal.new
+    end
+  end
+end

data/lib/grumlin/t.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module T
+    module T
+      T_ID = { :@type => "g:T", :@value => "id" }.freeze # TODO: replace with a class?
+      T_LABEL = { :@type => "g:T", :@value => "label" }.freeze # TODO: replace with a class?
+
+      extend self # rubocop:disable Style/ModuleFunction
+
+      def id
+        T_ID
+      end
+
+      def label
+        T_LABEL
+      end
+    end
+
+    extend T
+  end
+end

data/lib/grumlin/test/rspec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "grumlin/test/rspec/db_cleaner_context"
+require "grumlin/test/rspec/gremlin_context"
+
+module Grumlin
+  module Test
+    module RSpec
+    end
+  end
+end

data/lib/grumlin/test/rspec/db_cleaner_context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Test
+    module RSpec
+      module DBCleanerContext
+      end
+
+      ::RSpec.shared_context DBCleanerContext do
+        include DBCleanerContext
+
+        before do
+          g.V().drop.iterate
+        end
+      end
+    end
+  end
+end

data/lib/grumlin/test/rspec/gremlin_context.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Test
+    module RSpec
+      module GremlinContext
+      end
+
+      ::RSpec.shared_context GremlinContext do
+        include GremlinContext
+
+        let(:g) { Grumlin::Traversal.new }
+
+        after do
+          Grumlin.config.default_pool.close
+          Grumlin.config.reset!
+        end
+      end
+    end
+  end
+end

data/lib/grumlin/translator.rb

@@ -3,38 +3,39 @@
 module Grumlin
   module Translator
     class << self
-      def to_string_query(steps) # rubocop:disable Metrics/MethodLength
-        counter = 0
-        string_steps, bindings = steps.each_with_object([[], {}]) do |step, (acc_g, acc_b)|
-          args = step.args.map do |arg|
-            binding_name(counter).tap do |b|
-              acc_b[b] = arg
-              counter += 1
-            end
-          end.join(", ")
-
-          acc_g << "#{step.name}(#{args})"
-        end
+      def to_bytecode(steps)
+        return arg_to_bytecode(steps) if steps.is_a?(AnonymousStep)
 
-        ["g.#{string_steps.join(".")}", bindings]
+        steps.map do |step|
+          arg_to_bytecode(step)
+        end
       end
 
       def to_bytecode_query(steps)
         steps.map do |step|
-          [step.name, *step.args.flatten]
+          arg_to_query_bytecode(step)
         end
       end
 
-      def to_string(steps)
-        "g." + steps.map do |step| # rubocop:disable Style/StringConcatenation
-          "#{step.name}(#{step.args.map(&:inspect).join(", ")})"
-        end.join(".")
+      private
+
+      def arg_to_bytecode(arg)
+        return arg unless arg.is_a?(AnonymousStep)
+
+        args = arg.args.flatten.map do |a|
+          a.instance_of?(AnonymousStep) ? to_bytecode(a.steps) : arg_to_bytecode(a)
+        end
+        [arg.name, *args]
       end
 
-      private
+      def arg_to_query_bytecode(arg)
+        return ["none"] if arg.nil?
+        return arg unless arg.is_a?(AnonymousStep)
 
-      def binding_name(num)
-        "b_#{num.to_s(16)}"
+        args = arg.args.flatten.map do |a|
+          a.instance_of?(AnonymousStep) ? Typing.to_bytecode(to_bytecode(a.steps)) : arg_to_query_bytecode(a)
+        end
+        [arg.name, *args]
       end
     end
   end

data/lib/grumlin/transport.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class Transport
+    # A transport based on https://github.com/socketry/async
+    # and https://github.com/socketry/async-websocket
+    def initialize(url, parent: Async::Task.current)
+      @endpoint = Async::HTTP::Endpoint.parse(url)
+      @parent = parent
+      @request_queue = Async::Queue.new
+      @response_queue = Async::Queue.new
+      reset!
+    end
+
+    def url
+      @endpoint.url
+    end
+
+    def connected?
+      @connected
+    end
+
+    def connect # rubocop:disable Metrics/MethodLength
+      raise AlreadyConnectedError if connected?
+
+      @connection = Async::WebSocket::Client.connect(@endpoint)
+
+      @response_task = @parent.async do
+        loop do
+          data = @connection.read
+          @response_queue << data
+        end
+      rescue Async::Stop
+        @response_queue << nil
+      end
+
+      @request_task = @parent.async do
+        @request_queue.each do |message|
+          @connection.write(message)
+          @connection.flush
+        end
+      end
+
+      @connected = true
+
+      @response_queue
+    end
+
+    def write(message)
+      raise NotConnectedError unless connected?
+
+      @request_queue << message
+    end
+
+    def close
+      raise NotConnectedError unless connected?
+
+      @request_queue << nil
+      @request_task.wait
+
+      @response_task.stop
+      @response_task.wait
+
+      @connection.close
+
+      reset!
+    end
+
+    private
+
+    def reset!
+      @connected = false
+      @connection = nil
+      @response_task = nil
+      @request_task = nil
+    end
+  end
+end

data/lib/grumlin/traversal.rb

@@ -4,21 +4,14 @@ module Grumlin
   class Traversal
     attr_reader :connection
 
-    def initialize(client_or_url, &block)
-      @client = if client_or_url.is_a?(String)
-                  Grumlin::Client.new(client_or_url)
-                else
-                  client_or_url
-                end
-
-      return if block.nil?
-
-      TraversingContext.new(self).instance_exec(&block)
+    def initialize(pool = Grumlin.config.default_pool)
+      @pool = pool
     end
 
+    # TODO: add other start steps
     %w[addV addE V E].each do |step|
       define_method step do |*args|
-        Step.new(@client, step, *args)
+        Step.new(@pool, step, *args)
       end
     end
 

data/lib/grumlin/typing.rb

@@ -4,15 +4,19 @@ module Grumlin
   module Typing
     TYPES = {
       "g:List" => ->(value) { value.map { |item| cast(item) } },
+      "g:Set" => ->(value) { Set.new(value.map { |item| cast(item) }) },
       "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:Int64" => ->(value) { cast_int(value) },
       "g:Int32" => ->(value) { cast_int(value) },
-      "g:Traverser" => ->(value) { cast(value[:value]) } # TODO: wtf is bulk?
+      "g:Double" => ->(value) { cast_double(value) },
+      "g:Traverser" => ->(value) { cast(value[:value]) }, # TODO: wtf is bulk?
+      "g:T" => ->(value) { value.to_sym }
     }.freeze
 
-    CASTABLE_TYPES = [Hash, String, Integer].freeze
+    CASTABLE_TYPES = [Hash, String, Integer, TrueClass, FalseClass].freeze
 
     class << self
       def cast(value)
@@ -27,6 +31,13 @@ module Grumlin
         type.call(value[:@value])
       end
 
+      def to_bytecode(step)
+        {
+          "@type": "g:Bytecode",
+          "@value": { step: step }
+        }
+      end
+
       private
 
       def castable_type?(value); end
@@ -47,6 +58,12 @@ module Grumlin
         value
       end
 
+      def cast_double(value)
+        raise TypeError, "#{value} is not a Double" unless value.is_a?(Float)
+
+        value
+      end
+
       def cast_entity(entity, value)
         entity.new(**value)
       rescue ArgumentError, TypeError
@@ -54,12 +71,15 @@ module Grumlin
       end
 
       def cast_map(value)
-        Hash[*value].transform_keys(&:to_sym).transform_values { |v| cast(v) }
+        Hash[*value].transform_keys do |key|
+          next key.to_sym if key.respond_to?(:to_sym)
+          next cast(key) if key[:@type]
+
+          raise UnknownMapKey, key, value
+        end.transform_values { |v| cast(v) }
       rescue ArgumentError
         raise TypeError, "#{value} cannot be casted to Hash"
       end
-
-      def cast_traverser(value); end
     end
   end
 end

data/lib/grumlin/u.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module U
+    module U
+      extend self # rubocop:disable Style/ModuleFunction
+
+      %w[addV V has count out values unfold].each do |step|
+        define_method step do |*args|
+          AnonymousStep.new(step, *args)
+        end
+      end
+    end
+
+    # TODO: add alias __
+    extend U
+  end
+end

data/lib/grumlin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Grumlin
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end