cubism 0.1.0.pre10 → 0.1.0.pre13

data/lib/cubism/cubicle_store.rb

@@ -0,0 +1,141 @@
+module Cubism
+  class CubicleStore
+    delegate_missing_to :@blocks
+
+    def initialize(key)
+      @blocks = Kredis.hash key
+    end
+
+    def [](key)
+      Marshal.load(@blocks[key]) if @blocks[key]
+    end
+
+    def []=(key, value)
+      mutex.synchronize do
+        @blocks[key] = Marshal.dump value
+      end
+    end
+
+    def fetch(key, value = nil, &block)
+      if self[key].nil?
+        yield value if block
+        self[key] = value
+      end
+
+      self[key]
+    end
+
+    def clear
+      mutex.synchronize do
+        # kredis #remove
+        @blocks.remove
+      end
+    end
+
+    def size
+      @blocks.to_h.size
+    end
+
+    private
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+  end
+
+  # Container for cubicle blocks
+  BlockContainer = Struct.new(
+    :block_location,
+    :block_source,
+    :user_gid,
+    :resource_gid,
+    :scope,
+    keyword_init: true
+  ) do
+    def initialize(*args)
+      super
+
+      @filename, _lineno = block_location.split(":")
+    end
+
+    def user
+      GlobalID::Locator.locate self[:user_gid]
+    end
+
+    def resource
+      GlobalID::Locator.locate self[:resource_gid]
+    end
+
+    def scope
+      self[:scope] || ""
+    end
+
+    def digest
+      resource_user_key = [resource_gid, user_gid, scope].join(":")
+
+      ActiveSupport::Digest.hexdigest("#{block_location}:#{File.read(@filename)}:#{resource_user_key}")
+    end
+
+    def marshal_dump
+      to_h.merge(block_source: block_source.digest)
+    end
+
+    def marshal_load(serialized_item)
+      members.excluding(:block_source).each do |arg|
+        send("#{arg}=", serialized_item[arg])
+      end
+
+      self.block_source = Cubism.source_store[serialized_item[:block_source]]
+    end
+  end
+
+  # Container for cubicle block sources
+  BlockSource = Struct.new(
+    :location,
+    :source,
+    :variable_name,
+    :view_context,
+    keyword_init: true
+  ) do
+    def self.find_or_create(location:, view_context:)
+      instance = new(location: location, view_context: view_context)
+
+      Cubism.source_store.fetch(instance.digest, instance) do |instance|
+        instance.parse!
+      end
+
+      instance
+    end
+
+    def initialize(*args)
+      super
+
+      @filename, @lineno = location.split(":")
+      @lineno = @lineno.to_i
+    end
+
+    def parse!
+      return if location.start_with?("inline template")
+
+      lines = File.readlines(@filename)[@lineno - 1..]
+
+      preprocessor = Cubism::Preprocessor.new(source: lines.join.squish, view_context: view_context)
+      self.variable_name = preprocessor.block_variable_name
+      self.source = preprocessor.process
+    end
+
+    def digest
+      ActiveSupport::Digest.hexdigest("#{location}:#{File.read(@filename)}")
+    end
+
+    def marshal_dump
+      to_h.except(:view_context)
+    end
+
+    def marshal_load(serialized_item)
+      members.excluding(:view_context).each do |arg|
+        send("#{arg}=", serialized_item[arg])
+      end
+    end
+  end
+end

data/lib/cubism/engine.rb

@@ -1,7 +1,28 @@
 module Cubism
   class Engine < ::Rails::Engine
-    initializer "cubism.store" do
-      Cubism.store = Cubism::CubicleBlockStore.new
+    initializer "cubism.stores" do
+      Cubism.block_store = Cubism::CubicleStore.new("cubism-blocks")
+      Cubism.source_store = Cubism::CubicleStore.new("cubism-source")
+    end
+
+    initializer "cubism.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.precompile += %w[
+          cubism.js
+          cubism.min.js
+          cubism.min.js.map
+          cubism.umd.js
+          cubism.umd.min.js
+          cubism.umd.min.js.map
+        ]
+      end
+    end
+
+    initializer "cubism.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << Engine.root.join("lib/cubism/importmap.rb")
+        app.config.importmap.cache_sweepers << Engine.root.join("app/assets/javascripts")
+      end
     end
   end
 end

data/lib/cubism/importmap.rb

@@ -0,0 +1,2 @@
+pin "cable_ready", to: "cable_ready.min.js", preload: true
+pin "cubism", to: "cubism.min.js", preload: true

data/lib/cubism/preprocessor.rb

@@ -1,8 +1,11 @@
 module Cubism
   class Preprocessor
+    attr_reader :block_variable_name
+
     def initialize(source:, view_context:)
-      match_data = /<%=\s+cubicle_for.+\|.+\|\s+%>/.match(source)
+      match_data = /<%=\s+cubicle_for.+?\|(\w+)\|\s+%>/.match(source)
       start_pos = match_data&.end(0) || 0
+      @block_variable_name = match_data[1] if match_data
       @source = source[start_pos..]
       @view_context = view_context
     end

data/lib/cubism/version.rb

@@ -1,3 +1,3 @@
 module Cubism
-  VERSION = "0.1.0.pre10"
+  VERSION = "0.1.0.pre13"
 end

data/lib/cubism.rb

@@ -3,7 +3,7 @@ require "kredis"
 require "cubism/version"
 require "cubism/engine"
 require "cubism/broadcaster"
-require "cubism/cubicle_block_store"
+require "cubism/cubicle_store"
 require "cubism/preprocessor"
 
 module Cubism
@@ -14,5 +14,6 @@ module Cubism
 
   mattr_accessor :user_class, instance_writer: false, instance_reader: false
 
-  mattr_accessor :store, instance_reader: false
+  mattr_accessor :block_store, instance_reader: false
+  mattr_accessor :source_store, instance_reader: false
 end

data/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@minthesize/cubism",
+  "version": "0.1.0-pre13",
+  "description": "Lightweight Resource-Based Presence Solution with CableReady.",
+  "main": "./dist/cubism.umd.min.js",
+  "module": "./dist/cubism.min.js",
+  "files": [
+    "dist/*",
+    "javascript/*"
+  ],
+  "scripts": {
+    "lint": "yarn run prettier-standard:check",
+    "format": "yarn run prettier-standard:format",
+    "prettier-standard:check": "yarn run prettier-standard --check ./javascript/**/*.js rollup.config.js",
+    "prettier-standard:format": "yarn run prettier-standard ./javascript/**/*.js rollup.config.js",
+    "build": "yarn rollup -c",
+    "watch": "yarn rollup -wc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/julianrubisch/cubism.git"
+  },
+  "keywords": [
+    "presence"
+  ],
+  "author": "Julian Rubisch",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/julianrubisch/cubism/issues"
+  },
+  "homepage": "https://github.com/julianrubisch/cubism#readme",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^21.0.3",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.1.3",
+    "prettier-standard": "^16.4.1",
+    "rollup": "^2.70.1",
+    "rollup-plugin-terser": "^7.0.2"
+  },
+  "dependencies": {
+    "cable_ready": "^5.0.0-pre9"
+  }
+}

data/package.json~

@@ -0,0 +1,33 @@
+{
+  "name": "@minthesize/cubism",
+  "version": "0.1.0-pre12",
+  "description": "Lightweight Resource-Based Presence Solution with CableReady.",
+  "main": "./javascript/index.js",
+  "module": "./javascript/index.js",
+  "files": ["javascript/**/*.js"],
+  "scripts": {
+    "lint": "yarn run prettier-standard:check",
+    "format": "yarn run prettier-standard:format",
+    "prettier-standard:check": "yarn run prettier-standard --check ./javascript/**/*.js",
+    "prettier-standard:format": "yarn run prettier-standard ./javascript/**/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/julianrubisch/cubism.git"
+  },
+  "keywords": [
+    "presence"
+  ],
+  "author": "Julian Rubisch",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/julianrubisch/cubism/issues"
+  },
+  "homepage": "https://github.com/julianrubisch/cubism#readme",
+  "devDependencies": {
+    "prettier-standard": "^16.4.1"
+  },
+  "dependencies": {
+    "cable_ready": "5.0.0-pre8"
+  }
+}

data/rollup.config.js

@@ -0,0 +1,77 @@
+import resolve from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'
+import json from '@rollup/plugin-json'
+import { terser } from 'rollup-plugin-terser'
+
+const pretty = () => {
+  return terser({
+    mangle: false,
+    compress: false,
+    format: {
+      beautify: true,
+      indent_level: 2
+    }
+  })
+}
+
+const minify = () => {
+  return terser({
+    mangle: true,
+    compress: true
+  })
+}
+
+const esConfig = {
+  format: 'es',
+  inlineDynamicImports: true
+}
+
+const umdConfig = {
+  name: 'Cubism',
+  format: 'umd',
+  exports: 'named',
+  globals: {
+    cable_ready: 'CableReady'
+  }
+}
+
+const distFolders = ['dist/', 'app/assets/javascripts/']
+
+const output = distFolders
+  .map(distFolder => [
+    {
+      ...esConfig,
+      file: `${distFolder}/cubism.js`,
+      plugins: [pretty()]
+    },
+    {
+      ...esConfig,
+      file: `${distFolder}/cubism.min.js`,
+      sourcemap: true,
+      plugins: [minify()]
+    },
+    {
+      ...umdConfig,
+      file: `${distFolder}/cubism.umd.js`,
+      plugins: [pretty()]
+    },
+    {
+      ...umdConfig,
+      file: `${distFolder}/cubism.umd.min.js`,
+      sourcemap: true,
+      plugins: [minify()]
+    }
+  ])
+  .flat()
+
+export default [
+  {
+    external: ['cable_ready'],
+    input: 'javascript/index.js',
+    output,
+    plugins: [commonjs(), resolve(), json()],
+    watch: {
+      include: 'javascript/**'
+    }
+  }
+]

data/test/block_container_test.rb

@@ -0,0 +1,105 @@
+require "test_helper"
+
+class BlockContainerTest < ActiveSupport::TestCase
+  FIXTURES_DIR = File.expand_path("./fixtures", __dir__)
+
+  setup do
+    @cwd = Dir.pwd
+    @tmp_dir = Dir.mktmpdir
+
+    FileUtils.cp_r FIXTURES_DIR, @tmp_dir
+    Dir.chdir @tmp_dir
+
+    @post = posts(:one)
+    @user = users(:one)
+  end
+
+  teardown do
+    Dir.chdir @cwd
+    FileUtils.rm_r @tmp_dir
+  end
+
+  test "block container digest changes when file contents change" do
+    template = "fixtures/_cubicle_partial"
+
+    digest1 = Cubism::BlockContainer.new(
+      block_location: "#{template_tmp_path(template)}.html.erb:1",
+      resource_gid: @post.to_gid.to_s,
+      user_gid: @user.to_gid.to_s
+    ).digest
+
+    change_template(template)
+
+    digest2 = Cubism::BlockContainer.new(
+      block_location: "#{template_tmp_path(template)}.html.erb:1",
+      resource_gid: @post.to_gid.to_s,
+      user_gid: @user.to_gid.to_s
+    ).digest
+
+    refute_equal digest1, digest2
+  end
+
+  test "block container digest changes when user changes" do
+    template = "fixtures/_cubicle_partial"
+
+    digest1 = Cubism::BlockContainer.new(
+      block_location: "#{template_tmp_path(template)}.html.erb:1",
+      resource_gid: @post.to_gid.to_s,
+      user_gid: @user.to_gid.to_s
+    ).digest
+
+    digest2 = Cubism::BlockContainer.new(
+      block_location: "#{template_tmp_path(template)}.html.erb:1",
+      resource_gid: @post.to_gid.to_s,
+      user_gid: users(:two).to_gid.to_s
+    ).digest
+
+    refute_equal digest1, digest2
+  end
+
+  test "block container digest changes when resource changes" do
+    template = "fixtures/_cubicle_partial"
+
+    digest1 = Cubism::BlockContainer.new(
+      block_location: "#{template_tmp_path(template)}.html.erb:1",
+      resource_gid: @post.to_gid.to_s,
+      user_gid: @user.to_gid.to_s
+    ).digest
+
+    digest2 = Cubism::BlockContainer.new(
+      block_location: "#{template_tmp_path(template)}.html.erb:1",
+      resource_gid: posts(:two).to_gid.to_s,
+      user_gid: @user.to_gid.to_s
+    ).digest
+
+    refute_equal digest1, digest2
+  end
+
+  test "block container digest changes when block_location changes" do
+    template = "fixtures/_cubicle_partial"
+
+    digest1 = Cubism::BlockContainer.new(
+      block_location: "#{template_tmp_path(template)}.html.erb:1",
+      resource_gid: @post.to_gid.to_s,
+      user_gid: @user.to_gid.to_s
+    ).digest
+
+    digest2 = Cubism::BlockContainer.new(
+      block_location: "#{template_tmp_path(template)}.html.erb:2",
+      resource_gid: @post.to_gid.to_s,
+      user_gid: @user.to_gid.to_s
+    ).digest
+
+    refute_equal digest1, digest2
+  end
+
+  private
+
+  def template_tmp_path(template)
+    Pathname.new(@tmp_dir).join(template).to_path
+  end
+
+  def change_template(template)
+    File.write("#{template}.html.erb", "\nTHIS WAS CHANGED!")
+  end
+end

data/test/block_source_test.rb

@@ -0,0 +1,102 @@
+require "test_helper"
+
+class BlockSourceTest < ActionView::TestCase
+  FIXTURES_DIR = File.expand_path("./fixtures", __dir__)
+
+  setup do
+    @cwd = Dir.pwd
+    @tmp_dir = Dir.mktmpdir
+
+    FileUtils.cp_r FIXTURES_DIR, @tmp_dir
+    Dir.chdir @tmp_dir
+
+    @post = posts(:one)
+    @user = users(:one)
+  end
+
+  teardown do
+    Dir.chdir @cwd
+    FileUtils.rm_r @tmp_dir
+  end
+
+  test "block source digest changes when file contents change" do
+    template = "fixtures/_cubicle_partial"
+
+    digest1 = Cubism::BlockSource.new(
+      location: "#{template_tmp_path(template)}.html.erb:1",
+      view_context: self
+    ).digest
+
+    change_template(template)
+
+    digest2 = Cubism::BlockSource.new(
+      location: "#{template_tmp_path(template)}.html.erb:1",
+      view_context: self
+    ).digest
+
+    refute_equal digest1, digest2
+  end
+
+  test "block source digest changes when block_location changes" do
+    template = "fixtures/_cubicle_partial"
+
+    digest1 = Cubism::BlockSource.new(
+      location: "#{template_tmp_path(template)}.html.erb:1",
+      view_context: self
+    ).digest
+
+    digest2 = Cubism::BlockSource.new(
+      location: "#{template_tmp_path(template)}.html.erb:2",
+      view_context: self
+    ).digest
+
+    refute_equal digest1, digest2
+  end
+
+  test "can be created in the store by source location" do
+    template = "fixtures/_cubicle_partial"
+
+    assert_equal 0, Cubism.source_store.size
+
+    Cubism::BlockSource.any_instance.expects(:parse!).once
+
+    Cubism::BlockSource.find_or_create(
+      location: "#{template_tmp_path(template)}.html.erb:1",
+      view_context: self
+    )
+
+    assert_equal 1, Cubism.source_store.size
+  end
+
+  test "existing block source is returned and not parsed" do
+    template = "fixtures/_cubicle_partial"
+
+    instance = Cubism::BlockSource.new(
+      location: "#{template_tmp_path(template)}.html.erb:1",
+      view_context: self
+    )
+
+    Cubism.source_store[instance.digest] = instance
+
+    assert_equal 1, Cubism.source_store.size
+
+    Cubism::BlockSource.any_instance.expects(:parse!).never
+
+    Cubism::BlockSource.find_or_create(
+      location: "#{template_tmp_path(template)}.html.erb:1",
+      view_context: self
+    )
+
+    assert_equal 1, Cubism.source_store.size
+  end
+
+  private
+
+  def template_tmp_path(template)
+    Pathname.new(@tmp_dir).join(template).to_path
+  end
+
+  def change_template(template)
+    File.write("#{template}.html.erb", "\nTHIS WAS CHANGED!")
+  end
+end

data/test/broadcaster_test.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+
+class BroadcasterTest < ActionView::TestCase
+  include CableReady::StreamIdentifier
+
+  setup do
+    @post = posts(:one)
+    @post.stubs(:cubicle_element_ids).returns(%w[foo bar])
+    @post.stubs(:present_users_for_element_id_and_scope).with("foo", "").returns([users(:one)])
+    @post.stubs(:present_users_for_element_id_and_scope).with("bar", "").returns([users(:two)])
+
+    @post_2 = posts(:two)
+    @post_2.stubs(:cubicle_element_ids).returns(%w[baz])
+    @post_2.stubs(:present_users_for_element_id_and_scope).with("baz", :edit).returns([users(:one)])
+    @post_2.stubs(:present_users_for_element_id_and_scope).with("baz", :show).returns([])
+
+    block_source_foo = Cubism::BlockSource.new(location: "test:1", variable_name: "users", source: "<div><%= users.map(&:username).to_sentence %></div>", view_context: self)
+    block_source_bar = Cubism::BlockSource.new(location: "test:1", variable_name: "present_users", source: "<div><%= present_users.map(&:username).to_sentence %></div>", view_context: self)
+
+    Cubism.stubs(:block_store).returns({
+      "foo" => Cubism::BlockContainer.new(block_location: "test:1", block_source: block_source_foo, user_gid: users(:one).to_gid.to_s, resource_gid: posts(:one).to_gid.to_s),
+      "bar" => Cubism::BlockContainer.new(block_location: "test:1", block_source: block_source_bar, user_gid: users(:two).to_gid.to_s, resource_gid: posts(:one).to_gid.to_s),
+      "baz" => Cubism::BlockContainer.new(block_location: "test:1", block_source: block_source_foo, user_gid: users(:one).to_gid.to_s, resource_gid: posts(:two).to_gid.to_s, scope: :edit)
+    })
+  end
+
+  test "it broadcasts to all registered element ids with default scopes" do
+    with_mocked_cable_ready({"foo" => {"" => users(:one)}, "bar" => {"" => users(:two)}}, @post) do |cable_ready_mock|
+      @broadcaster = Cubism::Broadcaster.new(resource: @post)
+
+      @broadcaster.expects(:cable_ready).returns(cable_ready_mock).times(3)
+
+      @broadcaster.broadcast
+    end
+  end
+
+  test "it broadcasts to all registered element ids and respects scopes" do
+    with_mocked_cable_ready({"baz" => {"edit" => users(:one)}}, @post_2) do |cable_ready_mock|
+      @broadcaster = Cubism::Broadcaster.new(resource: @post_2)
+
+      @broadcaster.expects(:cable_ready).returns(cable_ready_mock).twice
+
+      @broadcaster.broadcast
+    end
+  end
+end
+
+def with_mocked_cable_ready(elements_with_users_and_scopes, resource)
+  cable_ready_mock = mock
+  cable_ready_mock.expects(:broadcast).once
+
+  elements_with_users_and_scopes.each do |element_id, scoped_users|
+    cable_ready_channel = mock
+    scoped_users.each do |scope, user|
+      cable_ready_channel
+        .expects(:inner_html)
+        .with({
+          selector: "cubicle-element#cubicle-#{element_id}[identifier='#{signed_stream_identifier(resource.to_global_id.to_s)}']",
+          html: "<div>#{user.username}</div>"
+        })
+    end
+    cable_ready_mock.expects(:[]).with(element_id).returns(cable_ready_channel)
+  end
+
+  yield cable_ready_mock
+end