grumlin 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d63d3923f895d20e89fd1647495d99bb3a97888689c8f25c34973355d7c80e1
-  data.tar.gz: 878546a65736522f3c1f00f42741b6b207e992a1983321205d05406e0a74ed6b
+  metadata.gz: 0517b4d5ffee800cfaf19b3f91a72bd0b86f82668e4258fd4af6c684e24de0ac
+  data.tar.gz: 938a188adee5be8f8938eb62e8585b2fbebf1946f653ce22c53b461f8a105ba4
 SHA512:
-  metadata.gz: 60bf726b74019b36bb0437c78b97ea1ba78703058ba2a619805e0081d49158f30bb67cc7918b959cf0375c37a5600632a1df805563edccb0266b71c9ab70f1de
-  data.tar.gz: cc7dc9ecfd45c67b28301593d3ba60e471e7a9993460ce39dcb912bbed5fb0aa01ed25bcf52f49634f704d6732ba563d849fb8d492276f19fe83e5e8531a8181
+  metadata.gz: 1bde74b8a4df9db236ac4a73a820214c6518da94df03417c3f0ef92a56d92fdbc49ff177a185ed4c1d5ad9b1d263e8b1f791792ebd844beb303805c489b2a9fd
+  data.tar.gz: 3b670eee69c2d7877312c2365a1208c848997086e172c2584bbd979e60a0dffc5911d1d000e883e84b9dda79024673e76a940d024033210df26352736fffa8a8

data/.rubocop.yml

@@ -44,6 +44,7 @@ Naming/MethodParameterName:
     - outV
     - inVLabel
     - outVLabel
+    - to
 
 RSpec/NamedSubject:
   Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    grumlin (0.17.0)
+    grumlin (0.18.0)
       async-pool (~> 0.3)
       async-websocket (~> 0.19)
       oj (~> 3.12)

data/README.md

@@ -77,8 +77,7 @@ end
 
 **Shortcuts** is a way to share and organize gremlin code. They let developers define their own steps consisting of
 sequences of standard gremlin steps, other shortcuts and even add new initially unsupported by Grumlin steps.
-Remember ActiveRecord scopes? Shortcuts are very similar. `Grumlin::Shortcuts#with_shortcuts` wraps a given object into
-a proxy object that simply proxies all methods existing in the wrapped object to it and handles shortcuts.
+Remember ActiveRecord scopes? Shortcuts are very similar.
 
 **Important**: if a shortcut's name matches a name of a method defined on the wrapped object, this shortcut will be
 be ignored because methods have higher priority. You cannot override supported by Grumlin steps with shortcuts, 
@@ -128,17 +127,18 @@ class MyRepository
 
   # Wrapping a traversal
   def red_triangles
-    with_shortcuts(g).V.hasLabel(:triangle)
-                       .hasColor("red")
-                       .toList
+    g(self.class.shortcuts).V.hasLabel(:triangle)
+       .hasColor("red")
+       .toList
   end
 
   # Wrapping _
   def something_else
-    with_shortcuts(g).V.hasColor("red")
-                       .repeat(with_shortcuts(__)
-                       .out(:has)
-                       .hasColor("blue")).toList
+    g(self.class.shortcuts).V.hasColor("red")
+       .repeat(__(self.class.shortcuts))
+       .out(:has)
+       .hasColor("blue")
+       .toList
   end
 end
 ```
@@ -183,6 +183,14 @@ Each `return_mode` is mapped to a particular termination step:
 - `:none` - `iterate`
 - `:traversal` - do not execute the query and return the traversal as is
 
+`Grumlin::Repository` also provides a set of generic CRUD operations:
+- `add_vertex(label, id = nil, **properties)`
+- `add_edge(label, id = nil, from:, to:, **properties)`
+- `drop_vertex(id)`
+- `drop_edge(id = nil, from: nil, to: nil, label: nil)`
+- `upsert_vertex(label, id, create_properties: {}, update_properties: {})`
+- `upsert_edge(label, from:, to:, create_properties: {}, update_properties: {})`
+
 **Usage**
 
 To execute the query defined in a query block one simply needs to call a method with the same name:

data/lib/grumlin/action.rb

@@ -49,12 +49,6 @@ module Grumlin
       @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)
 

data/lib/grumlin/repository.rb

@@ -10,6 +10,8 @@ module Grumlin
     }.freeze
 
     module InstanceMethods
+      include Grumlin::Expressions
+
       def __
         TraversalStart.new(self.class.shortcuts)
       end
@@ -17,11 +19,79 @@ module Grumlin
       def g
         TraversalStart.new(self.class.shortcuts)
       end
+
+      def drop_vertex(id)
+        g.V(id).drop.iterate
+      end
+
+      def drop_edge(id = nil, from: nil, to: nil, label: nil) # rubocop:disable Metrics/AbcSize
+        raise ArgumentError, "either id or from:, to: and label: must be passed" if [id, from, to, label].all?(&:nil?)
+        return g.E(id).drop.iterate unless id.nil?
+
+        raise ArgumentError, "from:, to: and label: must be passed" if [from, to, label].any?(&:nil?)
+
+        g.V(from).outE(label).where(__.inV.hasId(to)).limit(1).drop.iterate
+      end
+
+      def add_vertex(label, id = nil, **properties)
+        id ||= properties[T.id]
+        properties = except(properties, T.id)
+
+        t = g.addV(label)
+        t = t.props(T.id => id) unless id.nil?
+        t.props(**properties).next
+      end
+
+      def add_edge(label, id = nil, from:, to:, **properties)
+        id ||= properties[T.id]
+        properties = except(properties, T.label)
+        properties[T.id] = id
+
+        g.addE(label).from(__.V(from)).to(__.V(to)).props(**properties).next
+      end
+
+      def upsert_vertex(label, id, create_properties: {}, update_properties: {}) # rubocop:disable Metrics/AbcSize
+        create_properties = except(create_properties, T.id, T.label)
+        update_properties = except(update_properties, T.id, T.label)
+        g.V(id)
+         .fold
+         .coalesce(
+           __.unfold,
+           __.addV(label).props(**create_properties.merge(T.id => id))
+         ).props(**update_properties)
+         .next
+      end
+
+      # Only from and to are used to find the existing edge, if one wants to assign an id to a created edge,
+      # it must be passed as T.id in via create_properties.
+      def upsert_edge(label, from:, to:, create_properties: {}, update_properties: {}) # rubocop:disable Metrics/AbcSize
+        create_properties = except(create_properties, T.label)
+        update_properties = except(update_properties, T.id, T.label)
+
+        g.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).next
+      end
+
+      private
+
+      # A polyfill for Hash#except for ruby 2.x environments without ActiveSupport
+      # TODO: delete and use native Hash#except when after ruby 2.7 is deprecated.
+      def except(hash, *keys)
+        return hash.except(*keys) if hash.respond_to?(:except)
+
+        hash.each_with_object({}) do |(k, v), res|
+          res[k] = v unless keys.include?(k)
+        end
+      end
     end
 
     def self.extended(base)
       base.extend(Grumlin::Shortcuts)
-      base.include(Grumlin::Expressions)
       base.include(InstanceMethods)
 
       base.shortcuts_from(Grumlin::Shortcuts::Properties)

data/lib/grumlin/shortcuts/properties.rb

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

data/lib/grumlin/shortcuts_applyer.rb

@@ -18,7 +18,7 @@ module Grumlin
 
       Steps.new(shortcuts).tap do |processed_steps|
         (configuration_steps + regular_steps).each do |step|
-          processed_steps.add(step.name, step.arguments)
+          processed_steps.add(step.name, args: step.args, params: step.params)
         end
       end
     end
@@ -27,20 +27,20 @@ module Grumlin
 
     def process_steps(steps, shortcuts) # rubocop:disable Metrics/AbcSize
       steps.each_with_object([]) do |step, result|
-        arguments = step.arguments.map do |arg|
+        args = step.args.map do |arg|
           arg.is_a?(Steps) ? ShortcutsApplyer.call(arg) : arg
         end
 
         if shortcuts.include?(step.name)
           t = TraversalStart.new(shortcuts)
-          action = shortcuts[step.name].apply(t, *arguments)
+          action = shortcuts[step.name].apply(t, *args, **step.params)
           next if action.nil? || action == t # Shortcut did not add any steps
 
           new_steps = ShortcutsApplyer.call(Steps.from(action))
           result.concat(new_steps.configuration_steps)
           result.concat(new_steps.steps)
         else
-          result << StepData.new(step.name, arguments)
+          result << StepData.new(step.name, args: args, params: step.params)
         end
       end
     end

data/lib/grumlin/step_data.rb

@@ -2,17 +2,19 @@
 
 module Grumlin
   class StepData
-    attr_reader :name, :arguments
+    attr_reader :name, :args, :params
 
-    def initialize(name, arguments)
+    def initialize(name, args: [], params: {})
       @name = name
-      @arguments = arguments
+      @args = args
+      @params = params
     end
 
     def ==(other)
       self.class == other.class &&
         @name == other.name &&
-        @arguments == other.arguments
+        @args == other.args &&
+        @params == other.params
     end
   end
 end

data/lib/grumlin/steps.rb

@@ -18,7 +18,7 @@ module Grumlin
 
       new(shortcuts).tap do |chain|
         actions.each do |act|
-          chain.add(act.name, act.arguments)
+          chain.add(act.name, args: act.args, params: act.params)
         end
       end
     end
@@ -31,10 +31,10 @@ module Grumlin
       @steps = steps
     end
 
-    def add(name, arguments)
-      return add_configuration_step(name, arguments) if CONFIGURATION_STEPS.include?(name)
+    def add(name, args: [], params: {})
+      return add_configuration_step(name, args: args, params: params) if CONFIGURATION_STEPS.include?(name)
 
-      StepData.new(name, cast_arguments(arguments)).tap do |step|
+      StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
         @steps << step
       end
     end
@@ -56,16 +56,16 @@ module Grumlin
 
     def shortcuts?(steps_ary)
       steps_ary.any? do |step|
-        @shortcuts.include?(step.name) || step.arguments.any? do |arg|
+        @shortcuts.include?(step.name) || step.args.any? do |arg|
           arg.is_a?(Steps) ? arg.uses_shortcuts? : false
         end
       end
     end
 
-    def add_configuration_step(name, arguments)
+    def add_configuration_step(name, args: [], params: {})
       raise ArgumentError, "cannot use configuration steps after start step was used" unless @steps.empty?
 
-      StepData.new(name, cast_arguments(arguments)).tap do |step|
+      StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
         @configuration_steps << step
       end
     end

data/lib/grumlin/steps_serializers/bytecode.rb

@@ -6,7 +6,7 @@ module Grumlin
       # constructor params: no_return: true|false, default false
       # TODO: add pretty
 
-      NONE_STEP = StepData.new("none", [])
+      NONE_STEP = StepData.new("none")
 
       def serialize
         steps = ShortcutsApplyer.call(@steps)
@@ -22,7 +22,7 @@ module Grumlin
       private
 
       def serialize_step(step)
-        [step.name, *step.arguments.map { |arg| serialize_arg(arg) }]
+        [step.name, *step.args.map { |arg| serialize_arg(arg) }, step.params.any? ? step.params : nil].compact
       end
 
       def serialize_arg(arg)

data/lib/grumlin/steps_serializers/human_readable_bytecode.rb

@@ -2,22 +2,16 @@
 
 module Grumlin
   module StepsSerializers
-    class HumanReadableBytecode < Serializer
+    class HumanReadableBytecode < Bytecode
       def serialize
         steps = ShortcutsApplyer.call(@steps)
-        [serialize_steps(steps.configuration_steps), serialize_steps(steps.steps)]
-      end
-
-      def serialize_steps(steps)
-        steps.map { |s| serialize_step(s) }
+        [steps.configuration_steps, steps.steps].map do |stps|
+          stps.map { |s| serialize_step(s) }
+        end
       end
 
       private
 
-      def serialize_step(step)
-        [step.name, *step.arguments.map { |arg| serialize_arg(arg) }]
-      end
-
       def serialize_arg(arg)
         return arg.to_s if arg.is_a?(TypedValue)
         return serialize_predicate(arg) if arg.is_a?(Expressions::P::Predicate)

data/lib/grumlin/steps_serializers/string.rb

@@ -10,14 +10,21 @@ module Grumlin
       def serialize
         steps = @params[:apply_shortcuts] ? ShortcutsApplyer.call(@steps) : @steps
 
-        configuration_steps = serialize_steps(steps.configuration_steps)
-        regular_steps = serialize_steps(steps.steps)
+        steps = [steps.configuration_steps, steps.steps].map do |stps|
+          stps.map { |step| serialize_step(step) }
+        end
 
-        "#{prefix}.#{(configuration_steps + regular_steps).join(".")}"
+        "#{prefix}.#{(steps[0] + steps[1]).join(".")}"
       end
 
       private
 
+      def serialize_step(step)
+        "#{step.name}(#{(step.args + [step.params.any? ? step.params : nil].compact).map do |a|
+          serialize_arg(a)
+        end.join(", ")})"
+      end
+
       def prefix
         @prefix ||= @params[:anonymous] ? "__" : "g"
       end
@@ -31,12 +38,6 @@ module Grumlin
 
         StepsSerializers::String.new(arg, anonymous: true, **@params).serialize
       end
-
-      def serialize_steps(steps)
-        steps.map do |step|
-          "#{step.name}(#{step.arguments.map { |a| serialize_arg(a) }.join(", ")})"
-        end
-      end
     end
   end
 end

data/lib/grumlin/typing.rb

@@ -18,7 +18,7 @@ module Grumlin
       # "g:VertexProperty"=> ->(value) { value }, # TODO: implement me
       "g:TraversalMetrics" => ->(value) { cast_map(value[:@value]) },
       "g:Metrics" => ->(value) { cast_map(value[:@value]) },
-      "g:T" => ->(value) { value.to_sym }
+      "g:T" => ->(value) { T.public_send(value) }
     }.freeze
 
     CASTABLE_TYPES = [Hash, String, Integer, TrueClass, FalseClass].freeze

data/lib/grumlin/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grumlin
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-30 00:00:00.000000000 Z
+date: 2022-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-pool