collab 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8c6f4ca46b51f7fd05bacdea192bbd5ec7979b6c44f7528665beda336fb6d43
-  data.tar.gz: e2a0748fe7e1686a36a7ace934153433b1a499c18f8a0c930ed689564f9eb90e
+  metadata.gz: 57b6b2acc480ad0a0d40fb20c82a1091b30dbea74b674a5d02339dd1bf8b7f83
+  data.tar.gz: 2a36b774b1ad0693feef4194888a07b58e8899173de10bad52a174d012a6c2f4
 SHA512:
-  metadata.gz: 36feda3ab2009c1a954434893a1ca89eed1f9492b08a20af7872d720abceaf4351398b16a9c6ba63cccf76f318ba387b3be29c85cf0616aba52a20f8fed7f71c
-  data.tar.gz: bd79ab6de7c2c24185f581031d4b25f673d5ef037f2f3794d4b06cb2b2906c772227d8ad9aa3ec4b63b28d82f0a48f2fdd3a54f6835db919b67b628b0c83fdb0
+  metadata.gz: ab13771371259f4294fd94d207889643631f541dfdc26f43dbc6b2e7a454e79de4816dc4be560d1203b70dfe82a2e8b26fb3d1bcc56172743d2ce872060ee40f
+  data.tar.gz: 0a18c044a507454196599921a00ba0ace34fb7b3230dcb2c0a06124774f5893fa77d12a373f34d91cfe556af31a8c0d41a89571da8f3c0a37d8841dd141795e1

data/lib/collab.rb

@@ -6,10 +6,13 @@ require "collab/engine"
 module Collab
   autoload "Channel", "collab/channel"
   autoload "HasCollaborativeDocument", "collab/has_collaborative_document"
+  # autoload "DocumentSelection", "collab/selection"
+  autoload "HasTrackedDocumentPositions", "collab/has_tracked_document_positions"
   
   module Models
     autoload "Base", "collab/models/base"
     autoload "Document", "collab/models/document"
     autoload "Commit", "collab/models/commit"
+    autoload "TrackedPosition", "collab/models/tracked_position"
   end
 end

data/lib/collab/channel.rb

@@ -1,19 +1,18 @@
 module Collab
   module Channel
-    def document; @document end
-
     def subscribed
-      @document = find_document
-
+      reject_unauthorized_connection unless @document = find_document
+  
       starting_version = params[:startingVersion]&.to_i
       raise "missing startingVersion" if starting_version.nil?
+      raise "invalid version" unless @document.possibly_saved_version? starting_version
 
-      stream_for document
+      stream_for @document
       
-      commits = document.commits
-                        .where("document_version > ?", starting_version)
-                        .order(document_version: :asc)
-                        .load
+      commits = @document.commits
+                         .where("document_version > ?", starting_version)
+                         .order(document_version: :asc)
+                         .load
               
       unless commits.empty?
         raise "invalid version" unless commits.first.document_version == (starting_version + 1)
@@ -22,10 +21,25 @@ module Collab
     end
 
     def commit(data)
-      authorize_commit!(data)
-      document.commit_later(data)
+      @document.apply_commit(data)
     end
 
+    # def select(data)
+    #   return unless defined?(_select)
+
+    #   version    = data["v"]&.to_i
+    #   anchor_pos = data["anchor"]&.to_i
+    #   head_pos   = data["head"]&.to_i
+
+    #   return unless version && @document.possibly_saved_version?(version) && anchor_pos && head_pos
+
+    #   @document.resolve_selection(anchor_pos, head_pos, version: version) do |selection|
+    #     _select selection
+    #   end
+
+    #   transmit({ack: "select"})
+    # end
+
     def unsubscribed
       stop_all_streams # this may not be needed
     end

data/lib/collab/config.rb

@@ -16,19 +16,18 @@ module Collab
 
   class Config
     attr_accessor :base_record,
-                  :base_job,
                   :channel,
-                  :commit_job,
                   :commit_model,
                   :document_model,
                   :max_commit_history_length,
                   :num_js_processes,
-                  :schema_package
+                  :schema_package,
+                  :tracked_position_model
 
     def initialize
-      self.commit_job = "Collab::CommitJob"
       self.document_model = "Collab::Models::Document"
       self.commit_model = "Collab::Models::Commit"
+      self.tracked_position_model = "Collab::Models::TrackedPosition"
     end
   end
 end

data/lib/collab/engine.rb

@@ -1,6 +1,6 @@
 if defined?(Rails)
   module Collab
-      class Engine < ::Rails::Engine
-      end
+    class Engine < ::Rails::Engine
+    end
   end
 end

data/lib/collab/has_tracked_document_positions.rb

@@ -0,0 +1,34 @@
+module Collab
+  module HasTrackedDocumentPositions
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_tracked_document_position(pos_name, optional: true)
+        has_one   pos_name.to_sym, -> { where(name: pos_name) }, class_name: ::Collab.config.tracked_position_model, as: :owner, dependent: :destroy, autosave: true
+        validates pos_name.to_sym, presence: !optional
+
+        define_method :"#{pos_name}=" do |pos|
+          pos.name = pos_name
+          super(pos)
+        end
+      end
+
+      def has_tracked_document_selection(selection_name)
+        has_tracked_document_position :"#{selection_name}_anchor"
+        has_tracked_document_position :"#{selection_name}_head"
+
+        define_method selection_name do
+          anchor = self.send(:"#{selection_name}_anchor")
+          head   = self.send(:"#{selection_name}_head")
+
+          ::Collab::DocumentSelection.new anchor, head
+        end
+
+        define_method :"#{selection_name}=" do |sel|
+          self.send(:"#{selection_name}_anchor=", sel&.anchor)
+          self.send(:"#{selection_name}_head=", sel&.head)
+        end
+      end
+    end
+  end
+end

data/lib/collab/js.rb

@@ -21,20 +21,26 @@ module Collab
         queue << js
       end
 
-      def call(name, data = nil, schema_name:)
-        with_js { |js| js.call(name, *arguments, &block) }
+      def call(name, data = nil, schema_name = nil)
+        req = {name: name, data: data, schemaPackage: ::Collab.config.schema_package}
+        req[:schemaName] = schema_name if schema_name
+        with_js { |js| js.call(JSON.generate(req)) }
       end
       
-      def apply_commit(document, commit, schema_name:)
-        call("applyCommit", {doc: document, commit: commit}, schema_name: schema_name)
+      def apply_commit(document, commit, pos: nil, map_steps_through:, schema_name:)
+        call("applyCommit", {doc: document, commit: commit, mapStepsThrough: map_steps_through, pos: pos},schema_name)
       end
 
       def html_to_document(html, schema_name:)
-        call("htmlToDoc", html, schema_name: schema_name)
+        call("htmlToDoc", html, schema_name)
       end
 
       def document_to_html(document, schema_name:)
-        call("docToHtml", document, schema_name: schema_name)
+        call("docToHtml", document, schema_name)
+      end
+
+      def map_through(steps:, pos:)
+        call("mapThru", {steps: steps, pos: pos})
       end
 
       private 
@@ -58,9 +64,8 @@ module Collab
                  end
       end
 
-      def call(name, data = nil, schema_name:)
-        req = {name: name, data: data, schemaPackage: ::Collab.config.schema_package, schemaName: schema_name}
-        @node.puts(JSON.generate(req))
+      def call(req)
+        @node.puts(req)
         res = JSON.parse(@node.gets)
         raise ::Collab::JS::JSRuntimeError.new(res["error"]) if res["error"]
         res["result"]
@@ -68,7 +73,7 @@ module Collab
 
       private
       def open_node
-        IO.popen(["node", "-e", "require('rails-collab-server')"], "r+")
+        IO.popen(["node", "-e", "require('@pmcp/authority/dist/rpc')"], "r+")
       end
     end
 

data/lib/collab/models/commit.rb

@@ -2,52 +2,26 @@ module Collab
   class Models::Commit < ::Collab::Models::Base
     belongs_to :document, class_name: ::Collab.config.document_model
 
-    validates :steps, presence: true
-    validates :document_version, presence: true
-    validates :ref, length: { maximum: 36 }
+    validates :steps, length: { in: 0..10, allow_nil: false }
+    validates :document_version, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
+    validates :ref, length: { maximum: 36 }, if: :ref
 
     after_create_commit :broadcast
 
-    def self.from_json(data)
-      new(document_version: data["v"]&.to_i, steps: data["steps"], ref: data["ref"])
+    def steps
+      super || []
     end
 
-    def as_json
-      {
-        v: document_version,
-        steps: steps,
-        ref: ref
-      }
-    end
-
-    def apply_later
-      raise "cannot apply persisted commit" if self.persisted?
-      raise "commit not valid" unless self.valid?
-      return false if self.document.document_version != self.document_version
-
-      ::Collab.config.commit_job.constantize.perform_later(self.document, as_json)
-    end
-
-    def apply!
-      raise "cannot apply persisted commit" if self.persisted?
-      raise "commit not valid" unless self.valid?
-      return false if self.document.document_version != self.document_version # optimization, prevents need to apply lock if outdated
-
-      self.document.with_lock do
-        return false if self.document.document_version != self.document_version
-        
-        return false unless result = ::Collab::JS.apply_commit(self.document, self.to_json, schema_name: self.document.schema_name)
-        
-        self.document.document = result["doc"]
-        self.document.document_version = self.document_version
-        
-        self.document.save!
-        self.save!
-      end
+    def broadcast
+      ::Collab.config.channel.constantize.broadcast_to(document, {
+        "v" => document_version,
+        "steps" => steps,
+        "ref" => ref
+      })
     end
 
-    def broadcast
-      ::Collab.config.channel_name.constantize.broadcast_to(document, as_json)
+    def self.steps
+      pluck(:steps).flatten(1)
     end
   end
 end

data/lib/collab/models/document.rb

@@ -1,7 +1,11 @@
 module Collab
   class Models::Document < ::Collab::Models::Base
     belongs_to :attached, polymorphic: true
-    has_many :commits, class_name: ::Collab.config.commit_model, foreign_key: :document_id
+
+    with_options foreign_key: :document_id do
+      has_many :commits,           class_name: ::Collab.config.commit_model
+      has_many :tracked_positions, class_name: ::Collab.config.tracked_position_model
+    end
 
     validates :content, presence: true
     validates :document_version, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
@@ -24,12 +28,49 @@ module Collab
       end
     end
 
-    def from_html(html)
-      self.content = ::Collab::JS.html_to_document(html, schema_name: schema_name)
+    def apply_commit(data)
+      base_version = data["v"]&.to_i
+      steps = data["steps"]
+
+      return false unless base_version
+      return false unless steps.is_a?(Array) && !steps.empty?
+
+      self.with_lock do
+        return false unless self.possibly_saved_version? base_version
+
+        self.document_version += 1
+
+        original_positions = self.tracked_positions.current.distinct.pluck(:pos, :assoc).map { |(pos, assoc)| {pos: pos, assoc: assoc} }
+        
+        result = ::Collab::JS.apply_commit content,
+                                          {steps: steps},
+                                           map_steps_through: self.commits.where("document_version > ?", base_version).steps,
+                                           pos: original_positions,
+                                           schema_name: schema_name
+
+        self.content = result["doc"]
+
+        commits.create!({
+          steps: result["steps"],
+          ref: data["ref"],
+          document_version: self.document_version
+        })
+
+        self.save!
+
+        original_positions.lazy.zip(result["pos"]) do |original, res|
+          if res["deleted"]
+            tracked_positions.current.where(original).update_all deleted_at_version: self.document_version
+          elsif original[:pos] != res["pos"]
+            tracked_positions.current.where(original).update_all pos: res["pos"]
+          end
+        end
+      end
+
     end
 
-    def commit_later(data)
-      commits.from_json(data).apply_later
+    def from_html(html)
+      self.content = ::Collab::JS.html_to_document(html, schema_name: schema_name)
     end
 
     def as_json
@@ -41,12 +82,29 @@ module Collab
       self.serialized_html = nil
     end
 
+    def possibly_saved_version?(version)
+      self.document_version >= version && self.oldest_saved_commit_version <= version
+    end
+
+    def oldest_saved_commit_version
+      v = document_version - ::Collab.config.max_commit_history_length
+      v > 0 ? v : 0
+    end
+
+    def resolve_positions(*positions, **kwargs, &block)
+      ::Collab.config.tracked_position_model.constantize.resolve(self, *positions, **kwargs, &block)
+    end
+    alias :resolve_position :resolve_positions
+
+    def resolve_selection(anchor_pos, head_pos, version:, &block)
+      ::Collab::DocumentSelection.resolve(self, anchor_pos, head_pos, version: version, &block)
+    end
+
     private
 
     def delete_old_commits
-      cutoff = document_version - ::Collab.config.max_commit_history_length
-      return if cutoff <= 0
-      commits.where("document_version < ?", cutoff).delete_all
+      return if oldest_saved_commit_version == 0
+      commits.where("document_version < ?", oldest_saved_commit_version).delete_all
     end
   end
 end

data/lib/collab/models/tracked_position.rb

@@ -0,0 +1,45 @@
+module Collab
+  # Represents a position in the document which is tracked between commits
+  # 
+  # If the position is deleted through mapping, deleted_at_version will be set, the position will
+  # no longer be tracked,
+  #
+  class Models::TrackedPosition < ::Collab::Models::Base
+    belongs_to :document, class_name: ::Collab.config.document_model
+    belongs_to :owner, polymorphic: true
+
+    validates :pos, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
+    validates :assoc, presence: true, inclusion: {in: [-1, 1]}, numericality: {only_integer: true}
+
+    validates :deleted_at_version, numericality: {only_integer: true, greater_than_or_equal_to: 0}, if: :deleted_at_version
+
+    scope :current, -> { where(deleted_at_version: nil) }
+
+    # Resolves a set of positions and yields them to the block given, returning the result of the block
+    # The document will be locked IN SHARE MODE during resolution and the block execution
+    # Positions should consist of {"pos" => number, "assoc": number}
+    # Returns false if invalid version or any position has been deleted
+    def self.resolve(document, *positions, version:)
+      raise false unless document.possibly_saved_version? version
+
+      document.with_lock("FOR SHARE") do
+        unless document.document_version == version 
+          steps = document.commits.where("document_version > ?", @mapped_to).order(document_version: :asc).pluck(:steps).flatten(1)
+
+          map_results = ::Collab::JS.map_through(steps: steps, pos: positions)["pos"]
+
+          map_results.each_with_index do |r, i|
+            return false if r["deleted"]
+            positions[i]["pos"] = r["pos"]
+          end
+        end
+
+        positions.map! do |p|
+          document.tracked_positions.current.find_or_initialize_by(pos: p["pos"], assoc: p["assoc"])
+        end
+
+        yield(*positions)
+      end
+    end
+  end
+end

data/lib/collab/selection.rb

@@ -0,0 +1,21 @@
+# module Collab
+#   class DocumentSelection
+#     attr_reader :anchor, :head
+#     def initialize(anchor, head)
+#       @anchor = anchor
+#       @head = head
+#     end
+
+#     def self.resolve(document, anchor_pos, head_pos, version:)
+#       anchor_assoc = anchor_pos > head_pos ? -1 : 1
+
+#       document.resolve_positions(
+#         {"pos" => anchor_pos, "assoc" => anchor_assoc},
+#         {"pos" => head_pos, "assoc" => anchor_assoc * -1},
+#         version: version
+#       ) do |anchor, head|
+#         yield new anchor, head
+#       end
+#     end
+#   end
+# end

data/lib/collab/version.rb

@@ -1,3 +1,3 @@
 module Collab
-  VERSION = '0.3.1'
+  VERSION = '0.5.0'
 end

data/lib/generators/collab/install/templates/channel.rb

@@ -1,6 +1,14 @@
 class CollabDocumentChannel < ApplicationCable::Channel
   include Collab::Channel
 
+  def commit(data)
+    if false # replace with your own authorization logic
+      raise "authorization not implemented"
+    end
+
+    super # make sure to call super in order to process the commit
+  end
+
   private
 
   # Find the document to subscribe to based on the params passed to the channel
@@ -8,15 +16,14 @@ class CollabDocumentChannel < ApplicationCable::Channel
   def find_document
     Collab::Models::Document.find(params[:document_id]).tap do |document|
       # TODO: Replace with your own authorization logic
-      raise "authorization not implemented"
+      reject_unauthorized_connection
     end
   end
 
-  # Called a commit is first received for processing
-  # Throw an error to prevent the commit from being processed
-  # You should consider adding some type of rate-limiting here
-  def authorize_commit!(data)
-    # TODO: Replace with your own authorization logic
-    raise "authorization not implemented"
-  end
+  # Uncomment this line to receive the user's selection
+  # You must allow enable syncSelection on the client
+  #
+  # def _select(selection)
+  #   ...
+  # end
 end

data/lib/generators/collab/install/templates/create_collab_tables.rb.erb

@@ -24,5 +24,18 @@ class CreateCollabTables < ActiveRecord::Migration[6.0]
 
       t.datetime :created_at, null: false
     end
+
+    create_table :collab_tracked_positions<%= ", id: #{@primary_key_type.inspect}" if @primary_key_type %> do |t|
+      t.references :document, null: false, foreign_key: {to_table: :collab_documents}, index: false<%= ", type: #{@primary_key_type.inspect}" if @primary_key_type %>
+      t.references :owner, null: false, polymorphic: true, index: false<%= ", type: #{@primary_key_type.inspect}" if @primary_key_type %>
+      t.string     :name, null: false
+      
+      t.integer    :pos,   null: false
+      t.integer    :assoc, null: false, default: 1
+      t.integer    :deleted_at_version
+
+      t.index      [:document_id, :deleted_at_version, :pos], name: "index_collab_tracked_positions_on_document_pos"
+      t.index      [:owner_type, :name, :owner_id], name: "index_collab_tracked_positions_on_owner"
+    end
   end
 end

data/lib/generators/collab/install/templates/initializer.rb

@@ -12,11 +12,6 @@ Collab.config do |c|
   # If you change this, you must pass the value as {channel: "[ChannelName]"} in the params from the ActionCable client
   c.channel = "CollabDocumentChannel"
 
-  # The class which jobs in the gem should inherit from
-  c.base_job = "ApplicationJob"
-  # The jobs to use, if you want to implement your own jobs
-  # c.commit_job = "..."
-
   # The class which models in the gem should inherit from
   c.base_record = "ApplicationRecord"
   # The models to use, if you want to implement your own models

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: collab
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Ben Aubin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-01 00:00:00.000000000 Z
+date: 2020-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -44,6 +44,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webpacker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 - ben@benaubin.com
@@ -52,16 +80,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Rakefile
-- app/jobs/collab/commit_job.rb
 - lib/collab.rb
 - lib/collab/channel.rb
 - lib/collab/config.rb
 - lib/collab/engine.rb
 - lib/collab/has_collaborative_document.rb
+- lib/collab/has_tracked_document_positions.rb
 - lib/collab/js.rb
 - lib/collab/models/base.rb
 - lib/collab/models/commit.rb
 - lib/collab/models/document.rb
+- lib/collab/models/tracked_position.rb
+- lib/collab/selection.rb
 - lib/collab/version.rb
 - lib/generators/collab/install/install_generator.rb
 - lib/generators/collab/install/templates/channel.rb

data/app/jobs/collab/commit_job.rb

@@ -1,7 +0,0 @@
-class Collab::CommitJob < ::Collab.config.base_job.constantize
-  queue_as :default
-
-  def perform(document, data)
-    document.commits.from_json(data).apply!
-  end
-end