grumlin 0.15.3 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b44c62fb657fac1ce08d4a4dcb05456a2750284dddcd5adbbd20f56bb2b9ef9c
-  data.tar.gz: eccc2648799e68be2225ce606a06411b49953ce586e4b8249156dc680fc3522e
+  metadata.gz: 4a18e5e39768c0142eb219751991d67cb8512dd6d8cbeaa42494be193d44b694
+  data.tar.gz: 3c6833ffce68c409d78a656a892a81801b7820b9ea793dc60600e69c96315f76
 SHA512:
-  metadata.gz: dfc9f36a53d49749425df0014005e18ddd47b91e5c35bdc4dd4c7dfc0ec3309ba15df4e8a3367a8dba4c92494a2f70cab9fe4a846ded833100dc09937bf4ff9b
-  data.tar.gz: d315dfb2945c27091f76a21af2e30f77eb8753042519cf2bd7813ef544cb805f4970808158a550e5abdc1891c1526d4c3441bda46334bae67e2bf49a8ff9bd87
+  metadata.gz: 2c48059b03c81f68ff26802268f150c8d8af5476659e8f730de3c64c90f45896cdfa08dfd3bcc2db85240c34ef601b26317cbde269f3f834d6e3dd9f27a99f3e
+  data.tar.gz: 8033907ed22e1aa349b39ce3f247977242221d28aeea2f34c721e2bc6ec807f0a08dd21e450ef183fb989dac04534dc4fedbc1358e805ce5c8c57b59ab18b968

data/.rubocop.yml

@@ -60,6 +60,9 @@ RSpec/MultipleExpectations:
 RSpec/DescribeClass:
   Enabled: false
 
+RSpec/MultipleMemoizedHelpers:
+  Max: 7
+
 Style/WordArray:
   Exclude:
     - spec/**/*_spec.rb
@@ -77,3 +80,10 @@ Style/Documentation:
 
 Style/MultilineBlockChain:
   Enabled: false
+
+
+# TODO:
+# Style/SymbolArray:
+#   EnforcedStyle: brackets
+# Style/WordArray:
+#   EnforcedStyle: brackets

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.16.0] - 2022-03-11
+
+- Query building is rewritten from scratch. No public APIs were changed. [Details](https://github.com/babbel/grumlin/pull/64)
+- Add support for [TextP](https://tinkerpop.apache.org/javadocs/current/core/org/apache/tinkerpop/gremlin/process/traversal/TextP.html)
+
+## [0.15.4] - 2022-01-20
+
+- Move step and expression definitions to a yaml file for better diffs
+- Add `definitions:format` rake task
+
 ## [0.15.3] - 2022-01-18
 
 - Fix passing nils as step arguments. Even if they are not supported by the server, they should not be omitted.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    grumlin (0.15.3)
+    grumlin (0.16.0)
       async-pool (~> 0.3)
       async-websocket (~> 0.19)
       oj (~> 3.12)
@@ -28,7 +28,7 @@ GEM
       protocol-http (~> 0.22.0)
       protocol-http1 (~> 0.14.0)
       protocol-http2 (~> 0.14.0)
-    async-io (1.32.2)
+    async-io (1.33.0)
       async
     async-pool (0.3.9)
       async (>= 1.25)

data/README.md

@@ -258,6 +258,10 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, 
 push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+### Adding new steps and expressions
+To add a new step or an expression simple put it to the corresponding list in [definitions.yml](lib/definitions.yml)
+and run `rake definitions:format`. You don't need to properly sort the lists manually, the rake task will do it for you.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/zhulik/grumlin. This project is intended to 

data/Rakefile

@@ -1,12 +1,30 @@
 # frozen_string_literal: true
 
+require "yaml"
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
 
-require "rubocop/rake_task"
+task default: %i[rubocop spec]
 
-RuboCop::RakeTask.new
+namespace :definitions do
+  desc "Format definitions.yml"
+  task :format do
+    path = File.join(__dir__, "lib", "definitions.yml")
+    definitions = YAML.safe_load(File.read(path))
+
+    definitions.each_value do |kind|
+      kind.each do |name, list|
+        next if name == "with_options"
+
+        list.sort!
+      end
+    end
 
-task default: %i[spec rubocop]
+    File.write(path, YAML.dump(definitions))
+  end
+end

data/lib/definitions.yml

@@ -0,0 +1,114 @@
+---
+steps:
+  regular:
+  - E
+  - V
+  - addE
+  - addV
+  - aggregate
+  - and
+  - as
+  - both
+  - bothE
+  - by
+  - choose
+  - coalesce
+  - constant
+  - count
+  - dedup
+  - drop
+  - elementMap
+  - emit
+  - fold
+  - from
+  - group
+  - groupCount
+  - has
+  - hasId
+  - hasLabel
+  - hasNot
+  - id
+  - identity
+  - in
+  - inE
+  - inV
+  - inject
+  - is
+  - label
+  - limit
+  - map
+  - none
+  - not
+  - option
+  - or
+  - order
+  - out
+  - outE
+  - outV
+  - path
+  - project
+  - properties
+  - property
+  - range
+  - repeat
+  - sack
+  - select
+  - sideEffect
+  - skip
+  - sum
+  - tail
+  - timeLimit
+  - to
+  - unfold
+  - union
+  - until
+  - valueMap
+  - values
+  - where
+  - with
+  start:
+  - E
+  - V
+  - addE
+  - addV
+  - inject
+  configuration:
+  - withSack
+  - withSideEffect
+expressions:
+  operator:
+  - addAll
+  - and
+  - assign
+  - div
+  - max
+  - min
+  - minus
+  - mult
+  - or
+  - sum
+  order:
+  - asc
+  - desc
+  - shuffle
+  pop:
+  - all
+  - first
+  - last
+  - mixed
+  scope:
+  - local
+  t:
+  - id
+  - label
+  with_options:
+    tokens: "~tinkerpop.valueMap.tokens"
+    none: 0
+    ids: 1
+    labels: 2
+    keys: 4
+    values: 8
+    all: 15
+    indexer: "~tinkerpop.index.indexer"
+    list: 0
+    map: 1

data/lib/grumlin/action.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class Action
+    START_STEPS = Grumlin.definitions.dig(:steps, :start).map(&:to_sym).freeze
+    CONFIGURATION_STEPS = Grumlin.definitions.dig(:steps, :configuration).map(&:to_sym).freeze
+    REGULAR_STEPS = Grumlin.definitions.dig(:steps, :regular).map(&:to_sym).freeze
+
+    ALL_STEPS = START_STEPS + CONFIGURATION_STEPS + REGULAR_STEPS
+
+    attr_reader :name, :args, :params, :shortcuts, :next_step, :configuration_steps, :previous_step
+
+    def initialize(name, args: [], params: {}, previous_step: nil, shortcuts: {}, pool: Grumlin.default_pool)
+      @name = name.to_sym
+      @args = args # TODO: add recursive validation: only json types or Action
+      @params = params # TODO: add recursive validation: only json types
+      @previous_step = previous_step
+      @shortcuts = shortcuts
+      @pool = pool
+    end
+
+    ALL_STEPS.each do |step|
+      define_method step do |*args, **params|
+        step(step, *args, **params)
+      end
+    end
+
+    def step(name, *args, **params)
+      Action.new(name, args: args, params: params, previous_step: self, shortcuts: @shortcuts, pool: @pool)
+    end
+
+    def configuration_step?
+      CONFIGURATION_STEPS.include?(@name)
+    end
+
+    def start_step?
+      START_STEPS.include?(@name)
+    end
+
+    def regular_step?
+      REGULAR_STEPS.include?(@name)
+    end
+
+    def supported_step?
+      ALL_STEPS.include?(@name)
+    end
+
+    def shortcut?
+      @shortcuts.key?(@name)
+    end
+
+    def arguments
+      @arguments ||= [*@args].tap do |args|
+        args << @params if @params.any?
+      end
+    end
+
+    def method_missing(name, *args, **params)
+      return step(name, *args, **params) if @shortcuts.key?(name)
+
+      super
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        @name == other.name &&
+        @args == other.args &&
+        @params == other.params &&
+        @previous_step == other.previous_step &&
+        @shortcuts == other.shortcuts
+    end
+
+    def steps
+      @steps ||= Steps.from(self)
+    end
+
+    def to_s(**params)
+      StepsSerializers::String.new(steps, **params).serialize
+    end
+
+    # TODO: add human readable mode
+    def inspect
+      conf_steps, regular_steps = StepsSerializers::HumanReadableBytecode.new(steps).serialize
+      "#{conf_steps.any? ? conf_steps : nil}#{regular_steps}"
+    end
+
+    def bytecode(no_return: false)
+      StepsSerializers::Bytecode.new(steps, no_return: no_return)
+    end
+
+    def next
+      to_enum.next
+    end
+
+    def hasNext # rubocop:disable Naming/MethodName
+      to_enum.peek
+      true
+    rescue StopIteration
+      false
+    end
+
+    def to_enum
+      @to_enum ||= toList.to_enum
+    end
+
+    def toList
+      @pool.acquire do |client|
+        client.write(bytecode)
+      end
+    end
+
+    def iterate
+      @pool.acquire do |client|
+        client.write(bytecode(no_return: true))
+      end
+    end
+
+    private
+
+    def respond_to_missing?(name, _include_private = false)
+      @shortcuts.key?(name)
+    end
+  end
+end

data/lib/grumlin/client.rb

@@ -97,7 +97,7 @@ module Grumlin
     def write(bytecode)
       raise NotConnectedError unless connected?
 
-      request = to_query(bytecode.to_bytecode)
+      request = to_query(bytecode)
       channel = @request_dispatcher.add_request(request)
       @transport.write(request)
 
@@ -130,7 +130,7 @@ module Grumlin
         op: "bytecode",
         processor: "traversal",
         args: {
-          gremlin: bytecode,
+          gremlin: { :@type => "g:Bytecode", :@value => bytecode.serialize },
           aliases: { g: :g }
         }
       }

data/lib/grumlin/expressions/operator.rb

@@ -3,7 +3,7 @@
 module Grumlin
   module Expressions
     module Operator
-      SUPPORTED_STEPS = %i[addAll and assign div max min minus mult or sum].freeze
+      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :operator).map(&:to_sym).freeze
 
       class << self
         extend Expression

data/lib/grumlin/expressions/order.rb

@@ -3,7 +3,7 @@
 module Grumlin
   module Expressions
     module Order
-      SUPPORTED_STEPS = %i[asc desc shuffle].freeze
+      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :order).map(&:to_sym).freeze
 
       class << self
         extend Expression

data/lib/grumlin/expressions/p.rb

@@ -2,28 +2,23 @@
 
 module Grumlin
   module Expressions
-    module P
-      class << self
-        class Predicate < TypedValue
-          def initialize(name, args:, arg_type: nil)
-            super(type: "P")
-            @name = name
-            @args = args
-            @arg_type = arg_type
-          end
+    class P
+      class Predicate
+        attr_reader :namespace, :name, :value, :type
 
-          def value
-            @value ||= {
-              predicate: @name,
-              value: TypedValue.new(type: @arg_type, value: @args).to_bytecode
-            }
-          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 neq].each do |predicate|
           define_method predicate do |*args|
-            Predicate.new(predicate, args: args[0])
+            Predicate.new("P", predicate, value: args[0])
           end
         end
 
@@ -36,7 +31,7 @@ module Grumlin
                    else
                      args.to_a
                    end
-            Predicate.new(predicate, args: args, arg_type: "List")
+            Predicate.new("P", predicate, value: args, type: "List")
           end
         end
       end

data/lib/grumlin/expressions/pop.rb

@@ -3,7 +3,7 @@
 module Grumlin
   module Expressions
     module Pop
-      SUPPORTED_STEPS = %i[all first last mixed].freeze
+      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :pop).map(&:to_sym).freeze
 
       class << self
         extend Expression

data/lib/grumlin/expressions/scope.rb

@@ -3,7 +3,7 @@
 module Grumlin
   module Expressions
     module Scope
-      SUPPORTED_STEPS = %i[local].freeze
+      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :scope).map(&:to_sym).freeze
 
       class << self
         extend Expression

data/lib/grumlin/expressions/t.rb

@@ -3,7 +3,7 @@
 module Grumlin
   module Expressions
     module T
-      SUPPORTED_STEPS = %i[id label].freeze
+      SUPPORTED_STEPS = Grumlin.definitions.dig(:expressions, :t).map(&:to_sym).freeze
 
       class << self
         extend Expression

data/lib/grumlin/expressions/text_p.rb

@@ -0,0 +1,15 @@
+# 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
+      end
+    end
+  end
+end

data/lib/grumlin/expressions/with_options.rb

@@ -2,27 +2,30 @@
 
 module Grumlin
   module Expressions
-    module WithOptions
-      WITH_OPTIONS = {
-        tokens: "~tinkerpop.valueMap.tokens",
-        none: 0,
-        ids: 1,
-        labels: 2,
-        keys: 4,
-        values: 8,
-        all: 15,
-        indexer: "~tinkerpop.index.indexer",
-        list: 0,
-        map: 1
-      }.freeze
+    class WithOptions
+      WITH_OPTIONS = Grumlin.definitions.dig(:expressions, :with_options).freeze
 
       class << self
         WITH_OPTIONS.each do |k, v|
           define_method k do
-            v
+            name = "@#{k}"
+            return instance_variable_get(name) if instance_variable_defined?(name)
+
+            instance_variable_set(name, WithOptions.new(k, v))
           end
         end
       end
+
+      attr_reader :name, :value
+
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+
+      def to_s
+        "WithOptions.#{@name}"
+      end
     end
   end
 end

data/lib/grumlin/repository.rb

@@ -4,11 +4,11 @@ module Grumlin
   module Repository
     module InstanceMethods
       def __
-        with_shortcuts(Grumlin::Expressions::U)
+        TraversalStart.new(self.class.shortcuts)
       end
 
       def g
-        with_shortcuts(Grumlin::Traversal.new)
+        TraversalStart.new(self.class.shortcuts)
       end
     end
 

data/lib/grumlin/shortcut.rb

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

data/lib/grumlin/shortcuts/properties.rb

@@ -5,13 +5,17 @@ module Grumlin
     module Properties
       extend Grumlin::Shortcuts
 
-      shortcut :props do |*_args, **props|
+      shortcut :props do |props|
+        next if props.nil? # TODO: fixme, add proper support for **params
+
         props.reduce(self) do |tt, (prop, value)|
           tt.property(prop, value)
         end
       end
 
-      shortcut :hasAll do |*, **props|
+      shortcut :hasAll do |props|
+        next if props.nil? # TODO: fixme, add proper support for **params
+
         props.reduce(self) do |tt, (prop, value)|
           tt.has(prop, value)
         end

data/lib/grumlin/shortcuts.rb

@@ -2,14 +2,7 @@
 
 module Grumlin
   module Shortcuts
-    module InstanceMethods
-      def with_shortcuts(obj)
-        ShortcutProxy.new(obj, self.class.shortcuts, parent: self)
-      end
-    end
-
     def self.extended(base)
-      base.include(InstanceMethods)
       base.include(Grumlin::Expressions)
     end
 
@@ -18,19 +11,28 @@ module Grumlin
       subclass.shortcuts_from(self)
     end
 
-    def shortcut(name, &block)
+    def shortcut(name, shortcut = nil, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       name = name.to_sym
       # TODO: blocklist of names to avoid conflicts with standard methods?
-      raise ArgumentError, "cannot use names of standard gremlin steps" if Grumlin.supported_steps.include?(name)
+      if Grumlin::Action::REGULAR_STEPS.include?(name)
+        raise ArgumentError,
+              "cannot use names of standard gremlin steps"
+      end
+
+      if (shortcut.nil? && block.nil?) || (shortcut && block)
+        raise ArgumentError, "either shortcut or block must be passed"
+      end
+
+      shortcut ||= Shortcut.new(name, &block)
 
-      raise ArgumentError, "shortcut '#{name}' already exists" if shortcuts.key?(name) && shortcuts[name] != block
+      raise ArgumentError, "shortcut '#{name}' already exists" if shortcuts.key?(name) && shortcuts[name] != shortcut
 
-      shortcuts[name] = block
+      shortcuts[name] = shortcut
     end
 
     def shortcuts_from(other_shortcuts)
-      other_shortcuts.shortcuts.each do |name, block|
-        shortcut(name, &block)
+      other_shortcuts.shortcuts.each do |name, shortcut|
+        shortcut(name, shortcut)
       end
     end