futurism 1.2.0.pre7 → 1.2.0.pre10

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: futurism
 version: !ruby/object:Gem::Version
-  version: 1.2.0.pre7
+  version: 1.2.0.pre10
 platform: ruby
 authors:
 - Julian Rubisch
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-05 00:00:00.000000000 Z
+date: 2022-04-04 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -128,14 +142,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0.pre7
+        version: 5.0.0.pre9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0.pre7
+        version: 5.0.0.pre9
 description: Uses custom html elements with attached IntersectionObserver to automatically
   lazy load partials via websockets
 email:
@@ -144,31 +158,83 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Appraisals
+- Appraisals~
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- Gemfile~
 - MIT-LICENSE
 - README.md
+- README.md~
 - Rakefile
-- config/routes.rb
+- app/assets/javascripts/futurism.js
+- app/assets/javascripts/futurism.min.js
+- app/assets/javascripts/futurism.min.js.map
+- app/assets/javascripts/futurism.umd.js
+- app/assets/javascripts/futurism.umd.min.js
+- app/assets/javascripts/futurism.umd.min.js.map
+- app/channels/futurism/channel.rb
+- bin/rails
+- bin/standardize
+- bin/test
+- futurism.gemspec
+- futurism.gemspec~
 - lib/futurism.rb
-- lib/futurism.rb~
-- lib/futurism/channel.rb
-- lib/futurism/channel.rb~
+- lib/futurism/configuration.rb
 - lib/futurism/engine.rb
 - lib/futurism/helpers.rb
-- lib/futurism/helpers.rb~
+- lib/futurism/importmap.rb
 - lib/futurism/message_verifier.rb
 - lib/futurism/options_transformer.rb
-- lib/futurism/options_transformer.rb~
 - lib/futurism/resolver/controller.rb
-- lib/futurism/resolver/controller.rb~
 - lib/futurism/resolver/controller/renderer.rb
-- lib/futurism/resolver/controller/renderer.rb~
 - lib/futurism/resolver/resources.rb
-- lib/futurism/resolver/resources.rb~
 - lib/futurism/shims/deep_transform_values.rb
 - lib/futurism/version.rb
-- lib/futurism/version.rb~
-- lib/tasks/futurism_tasks.rake
-- lib/tasks/futurism_tasks.rake~
+- package.json
+- package.json~
+- rollup.config.js
+- rollup.config.js~
+- test/cable/channel_test.rb
+- test/dummy/app/channels/application_cable/channel.rb
+- test/dummy/app/channels/application_cable/connection.rb
+- test/dummy/app/controllers/application_controller.rb
+- test/dummy/app/controllers/home_controller.rb
+- test/dummy/app/controllers/posts_controller.rb
+- test/dummy/app/helpers/application_helper.rb
+- test/dummy/app/helpers/posts_helper.rb
+- test/dummy/app/jobs/application_job.rb
+- test/dummy/app/models/action_item.rb
+- test/dummy/app/models/application_record.rb
+- test/dummy/app/models/post.rb
+- test/dummy/config/application.rb
+- test/dummy/config/boot.rb
+- test/dummy/config/environment.rb
+- test/dummy/config/environments/development.rb
+- test/dummy/config/environments/production.rb
+- test/dummy/config/environments/test.rb
+- test/dummy/config/initializers/application_controller_renderer.rb
+- test/dummy/config/initializers/backtrace_silencers.rb
+- test/dummy/config/initializers/content_security_policy.rb
+- test/dummy/config/initializers/cookies_serializer.rb
+- test/dummy/config/initializers/filter_parameter_logging.rb
+- test/dummy/config/initializers/inflections.rb
+- test/dummy/config/initializers/mime_types.rb
+- test/dummy/config/initializers/wrap_parameters.rb
+- test/dummy/config/puma.rb
+- test/dummy/config/routes.rb
+- test/dummy/config/spring.rb
+- test/dummy/db/migrate/20200711122838_create_posts.rb
+- test/dummy/db/migrate/2021042923813_create_action_items.rb
+- test/dummy/db/schema.rb
+- test/futurism_test.rb
+- test/helper/helper_test.rb
+- test/integration/navigation_test.rb
+- test/resolver/controller/renderer_test.rb
+- test/resolver/controller_test.rb
+- test/test_helper.rb
+- yarn.lock
 homepage: https://github.com/stimulusreflex/futurism
 licenses:
 - MIT
@@ -188,8 +254,46 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: Lazy-load Rails partials via CableReady
-test_files: []
+test_files:
+- test/cable/channel_test.rb
+- test/dummy/app/channels/application_cable/channel.rb
+- test/dummy/app/channels/application_cable/connection.rb
+- test/dummy/app/controllers/application_controller.rb
+- test/dummy/app/controllers/home_controller.rb
+- test/dummy/app/controllers/posts_controller.rb
+- test/dummy/app/helpers/application_helper.rb
+- test/dummy/app/helpers/posts_helper.rb
+- test/dummy/app/jobs/application_job.rb
+- test/dummy/app/models/action_item.rb
+- test/dummy/app/models/application_record.rb
+- test/dummy/app/models/post.rb
+- test/dummy/config/application.rb
+- test/dummy/config/boot.rb
+- test/dummy/config/environment.rb
+- test/dummy/config/environments/development.rb
+- test/dummy/config/environments/production.rb
+- test/dummy/config/environments/test.rb
+- test/dummy/config/initializers/application_controller_renderer.rb
+- test/dummy/config/initializers/backtrace_silencers.rb
+- test/dummy/config/initializers/content_security_policy.rb
+- test/dummy/config/initializers/cookies_serializer.rb
+- test/dummy/config/initializers/filter_parameter_logging.rb
+- test/dummy/config/initializers/inflections.rb
+- test/dummy/config/initializers/mime_types.rb
+- test/dummy/config/initializers/wrap_parameters.rb
+- test/dummy/config/puma.rb
+- test/dummy/config/routes.rb
+- test/dummy/config/spring.rb
+- test/dummy/db/migrate/20200711122838_create_posts.rb
+- test/dummy/db/migrate/2021042923813_create_action_items.rb
+- test/dummy/db/schema.rb
+- test/futurism_test.rb
+- test/helper/helper_test.rb
+- test/integration/navigation_test.rb
+- test/resolver/controller/renderer_test.rb
+- test/resolver/controller_test.rb
+- test/test_helper.rb

data/config/routes.rb

@@ -1,2 +0,0 @@
-Rails.application.routes.draw do
-end

data/lib/futurism/channel.rb~

@@ -1,31 +0,0 @@
-module Futurism
-  class Channel < ActionCable::Channel::Base
-    include CableReady::Broadcaster
-
-    def stream_name
-      ids = connection.identifiers.map { |identifier| send(identifier).try(:id) || send(identifier) }
-      [
-        params[:channel],
-        ids.select(&:present?).join(";")
-      ].select(&:present?).join(":")
-    end
-
-    def subscribed
-      stream_from stream_name
-    end
-
-    def receive(data)
-      resources = data.fetch_values("signed_params", "sgids", "signed_controllers", "urls") { |_key| Array.new(data["signed_params"].length, nil) }.transpose
-
-      resolver = Resolver::Resources.new(resource_definitions: resources, connection: connection, params: @params)
-      resolver.resolve do |selector, html|
-        cable_ready[stream_name].outer_html(
-          selector: selector,
-          html: html
-        )
-      end
-
-      cable_ready.broadcast
-    end
-  end
-end

data/lib/futurism/helpers.rb~

@@ -1,118 +0,0 @@
-module Futurism
-  module Helpers
-    def futurize(records_or_string = nil, extends:, **options, &block)
-      if Rails.env.test? && Futurism.skip_in_test
-        if records_or_string.nil?
-          return render(**options)
-        else
-          return render(records_or_string, **options)
-        end
-      end
-
-      options[:eager] = true unless block_given?
-
-      if records_or_string.is_a?(ActiveRecord::Base) || records_or_string.is_a?(ActiveRecord::Relation)
-        futurize_active_record(records_or_string, extends: extends, **options, &block)
-      elsif records_or_string.is_a?(String)
-        html_options = options.delete(:html_options)
-        futurize_with_options(extends: extends, partial: records_or_string, locals: options, html_options: html_options, &block)
-      else
-        futurize_with_options(extends: extends, **options, &block)
-      end
-    end
-
-    def futurize_with_options(extends:, **options, &block)
-      collection = options.delete(:collection)
-      if collection.nil?
-        placeholder = capture(&block) if block_given?
-
-        WrappingFuturismElement.new(extends: extends, placeholder: placeholder, options: options).render
-      else
-        collection_class_name = collection.try(:klass).try(:name) || collection.first.class.to_s
-        as = options.delete(:as) || collection_class_name.underscore
-        broadcast_each = options.delete(:broadcast_each) || false
-
-        collection.each_with_index.map { |record, index|
-          placeholder = capture(record, index, &block) if block_given?
-
-          WrappingFuturismElement.new(extends: extends, placeholder: placeholder, options: options.deep_merge(
-            broadcast_each: broadcast_each,
-            locals: {as.to_sym => record, "#{as}_counter".to_sym => index}
-          )).render
-        }.join.html_safe
-      end
-    end
-
-    def futurize_active_record(records, extends:, **options, &block)
-      Array(records).map.with_index { |record, index|
-        placeholder = capture(record, index, &block) if block_given?
-
-        WrappingFuturismElement.new(extends: extends, options: options.merge(model: record), placeholder: placeholder).render
-      }.join.html_safe
-    end
-
-    # wraps functionality for rendering a futurism element
-    class WrappingFuturismElement
-      include ActionView::Helpers
-      include Futurism::MessageVerifier
-
-      attr_reader :extends, :placeholder, :html_options, :data_attributes, :model, :options, :eager, :broadcast_each, :controller
-
-      def initialize(extends:, placeholder:, options:)
-        @extends = extends
-        @placeholder = placeholder
-        @eager = options.delete(:eager)
-        @broadcast_each = options.delete(:broadcast_each)
-        @controller = options.delete(:controller)
-        @html_options = options.delete(:html_options) || {}
-        @data_attributes = html_options.fetch(:data, {}).except(:sgid, :signed_params)
-        @model = options.delete(:model)
-        @options = data_attributes.any? ? options.merge(data: data_attributes) : options
-      end
-
-      def dataset
-        data_attributes.merge({
-          signed_params: signed_params,
-          sgid: model && model.to_sgid.to_s,
-          eager: eager.presence,
-          broadcast_each: broadcast_each.presence,
-          signed_controller: signed_controller
-        })
-      end
-
-      def render
-        case extends
-        when :li
-          content_tag :li, placeholder, html_options.deep_merge({data: dataset, is: "futurism-li"})
-        when :tr
-          content_tag :tr, placeholder, html_options.deep_merge({data: dataset, is: "futurism-table-row"})
-        else
-          content_tag :"futurism-element", placeholder, html_options.deep_merge({data: dataset})
-        end
-      end
-
-      def transformed_options
-        require_relative "shims/deep_transform_values" unless options.respond_to? :deep_transform_values
-
-        options.deep_transform_values do |value|
-          next(value) unless value.respond_to?(:to_global_id)
-          next(value) if value.is_a?(ActiveRecord::Base) && value.new_record?
-
-          value.to_global_id.to_s
-        end
-      end
-
-      private
-
-      def signed_params
-        message_verifier.generate(transformed_options)
-      end
-
-      def signed_controller
-        return unless controller.present?
-
-        message_verifier.generate(controller.to_s)
-      end
-    end
-  end
-end

data/lib/futurism/resolver/controller/renderer.rb~

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module Futurism
-  module Resolver
-    class Controller
-      class Renderer
-        HTTP_METHODS = [:get, :post, :put, :patch, :delete]
-
-        def self.for(controller:, connection:, url:, params:)
-          new(controller: controller, connection: connection, url: url, params: params).renderer
-        end
-
-        def initialize(controller:, connection:, url:, params:)
-          @controller = controller
-          @connection = connection
-          @url = url || ""
-          @params = params || {}
-
-          setup_env!
-        end
-
-        def renderer
-          @renderer ||= controller.renderer
-        end
-
-        private
-
-        attr_reader :controller, :connection, :url, :params
-        attr_writer :renderer
-
-        def setup_env!
-          if url.present?
-            uri = URI.parse(url)
-            path = ActionDispatch::Journey::Router::Utils.normalize_path(uri.path)
-            query_hash = Rack::Utils.parse_nested_query(uri.query)
-
-            path_params = recognize_url(url) # use full url to be more likely to match a url with subdomain constraints
-
-            self.renderer =
-              renderer.new(
-                "rack.request.query_hash" => query_hash,
-                "rack.request.query_string" => uri.query,
-                "ORIGINAL_SCRIPT_NAME" => "",
-                "ORIGINAL_FULLPATH" => path,
-                Rack::SCRIPT_NAME => "",
-                Rack::PATH_INFO => path,
-                Rack::REQUEST_PATH => path,
-                Rack::QUERY_STRING => uri.query,
-                ActionDispatch::Http::Parameters::PARAMETERS_KEY => params.symbolize_keys.merge(path_params).merge(query_hash)
-              )
-          end
-
-          # Copy connection env to renderer to fix some RACK related issues from gems like
-          # Warden or Devise
-          new_env = connection.env.merge(renderer.instance_variable_get(:@env))
-          renderer.instance_variable_set(:@env, new_env)
-        end
-
-        def recognize_url(url)
-          HTTP_METHODS.each do |http_method|
-            path = Rails.application.routes.recognize_path(url, method: http_method)
-            return path if path
-          rescue ActionController::RoutingError
-            # Route not matched, try next
-          end
-
-          warn "We were unable to find a matching rails route for '#{url}'. " \
-               "This may be because there are proc-based routing constraints for this particular url, or " \
-               "it truly is an unrecognizable url."
-
-          {}
-        end
-      end
-    end
-  end
-end

data/lib/futurism/resolver/controller.rb~

@@ -1,17 +0,0 @@
-module Futurism
-  module Resolver
-    class Controller
-      def self.from(signed_string:)
-        if signed_string.present?
-          Futurism::MessageVerifier
-            .message_verifier
-            .verify(signed_string)
-            .to_s
-            .safe_constantize
-        else
-          Futurism.default_controller
-        end
-      end
-    end
-  end
-end

data/lib/futurism/resolver/resources.rb~

@@ -1,101 +0,0 @@
-module Futurism
-  module Resolver
-    class Resources
-      include Futurism::MessageVerifier
-
-      # resource definitions are an array of [signed_params, sgid, signed_controller, url, broadcast_each]
-      def initialize(resource_definitions:, connection:, params:)
-        @connection = connection
-        @params = params
-        @resources_with_sgids, @resources_without_sgids = resource_definitions
-          .partition { |signed_params, sgid, *| sgid.present? }
-          .map { |partition| partition.map { |definition| ResourceDefinition.new(definition) } }
-      end
-
-      def resolve
-        resolved_models.zip(@resources_with_sgids).each do |model, resource_definition|
-          html = renderer_for(resource_definition: resource_definition).render(model)
-
-          yield(resource_definition.selector, html, resource_definition.broadcast_each)
-        end
-
-        @resources_without_sgids.each do |resource_definition|
-          resource = lookup_resource(resource_definition)
-          renderer = renderer_for(resource_definition: resource_definition)
-          html =
-            begin
-              renderer.render(resource)
-            rescue => exception
-              error_renderer.render(exception)
-            end
-
-          yield(resource_definition.selector, html, resource_definition.broadcast_each)
-        end
-      end
-
-      private
-
-      def error_renderer
-        ErrorRenderer.new
-      end
-
-      class ResourceDefinition
-        attr_reader :signed_params, :sgid, :signed_controller, :url
-
-        def initialize(resource_definition)
-          @signed_params, @sgid, @signed_controller, @url, @broadcast_each = resource_definition
-        end
-
-        def selector
-          selector = "[data-signed-params='#{@signed_params}']"
-          selector << "[data-sgid='#{@sgid}']" if @sgid.present?
-          selector
-        end
-
-        def controller
-          Resolver::Controller.from(signed_string: @signed_controller)
-        end
-
-        def broadcast_each
-          @broadcast_each == "true"
-        end
-      end
-
-      class ErrorRenderer
-        include ActionView::Helpers::TagHelper
-
-        def render(exception)
-          return "" unless render?
-
-          Futurism.logger.error(exception.to_s)
-          Futurism.logger.error(exception.backtrace)
-
-          tag.div { tag.span(exception.to_s) + tag.div(exception.backtrace.join("\n"), style: "display: none;") }
-        end
-
-        def render?
-          Rails.env.development? || Rails.env.test?
-        end
-
-        attr_accessor :output_buffer
-      end
-
-      def renderer_for(resource_definition:)
-        Resolver::Controller::Renderer.for(controller: resource_definition.controller,
-                                           connection: @connection,
-                                           url: resource_definition.url,
-                                           params: @params)
-      end
-
-      def resolved_models
-        GlobalID::Locator.locate_many_signed @resources_with_sgids.map(&:sgid)
-      end
-
-      def lookup_resource(resource_definition)
-        message_verifier
-          .verify(resource_definition.signed_params)
-          .deep_transform_values { |value| value.is_a?(String) && value.start_with?("gid://") ? GlobalID::Locator.locate(value) : value }
-      end
-    end
-  end
-end

data/lib/futurism/version.rb~

@@ -1,3 +0,0 @@
-module Futurism
-  VERSION = "1.2.0.pre6"
-end

data/lib/futurism.rb~

@@ -1,30 +0,0 @@
-require "rails"
-require "action_cable"
-require "cable_ready"
-require "futurism/engine"
-require "futurism/message_verifier"
-require "futurism/resolver/resources"
-require "futurism/resolver/controller"
-require "futurism/resolver/controller/renderer"
-require "futurism/channel"
-require "futurism/helpers"
-
-module Futurism
-  extend ActiveSupport::Autoload
-
-  autoload :Helpers, "futurism/helpers"
-
-  mattr_accessor :skip_in_test, default: false
-
-  mattr_writer :default_controller
-  def self.default_controller
-    (@@default_controller || "::ApplicationController").to_s.constantize
-  end
-
-  ActiveSupport.on_load(:action_view) do
-    include Futurism::Helpers
-  end
-
-  mattr_accessor :logger
-  self.logger ||= Rails.logger ? Rails.logger.new : Logger.new($stdout)
-end

data/lib/tasks/futurism_tasks.rake

@@ -1,39 +0,0 @@
-require "fileutils"
-
-namespace :futurism do
-  desc "Let's look into a brighter future with futurism and CableReady"
-  task install: :environment do
-    system "yarn add @stimulus_reflex/futurism"
-
-    filepath = %w[
-      app/javascript/channels/index.js
-      app/javascript/channels/index.ts
-      app/javascript/packs/application.js
-      app/javascript/packs/application.ts
-    ]
-      .select { |path| File.exist?(path) }
-      .map { |path| Rails.root.join(path) }
-      .first
-
-    puts "Updating #{filepath}"
-    lines = File.open(filepath, "r") { |f| f.readlines }
-
-    unless lines.find { |line| line.start_with?("import * as Futurism") }
-      matches = lines.select { |line| line =~ /\A(require|import)/ }
-      lines.insert lines.index(matches.last).to_i + 1, "import * as Futurism from '@stimulus_reflex/futurism'\n"
-    end
-
-    unless lines.find { |line| line.start_with?("import consumer") }
-      matches = lines.select { |line| line =~ /\A(require|import)/ }
-      lines.insert lines.index(matches.last).to_i + 1, "import consumer from '../channels/consumer'\n"
-    end
-
-    initialize_line = lines.find { |line| line.start_with?("Futurism.initializeElements") }
-    lines << "Futurism.initializeElements()\n" unless initialize_line
-
-    subscribe_line = lines.find { |line| line.start_with?("Futurism.createSubscription") }
-    lines << "Futurism.createSubscription(consumer)\n" unless subscribe_line
-
-    File.open(filepath, "w") { |f| f.write lines.join }
-  end
-end

data/lib/tasks/futurism_tasks.rake~

@@ -1,39 +0,0 @@
-require "fileutils"
-
-namespace :futurism do
-  desc "Let's look into a brighter future with futurism and CableReady"
-  task install: :environment do
-    system "yarn add @minthesize/futurism"
-
-    filepath = %w[
-      app/javascript/channels/index.js
-      app/javascript/channels/index.ts
-      app/javascript/packs/application.js
-      app/javascript/packs/application.ts
-    ]
-      .select { |path| File.exist?(path) }
-      .map { |path| Rails.root.join(path) }
-      .first
-
-    puts "Updating #{filepath}"
-    lines = File.open(filepath, "r") { |f| f.readlines }
-
-    unless lines.find { |line| line.start_with?("import * as Futurism") }
-      matches = lines.select { |line| line =~ /\A(require|import)/ }
-      lines.insert lines.index(matches.last).to_i + 1, "import * as Futurism from '@minthesize/futurism'\n"
-    end
-
-    unless lines.find { |line| line.start_with?("import consumer") }
-      matches = lines.select { |line| line =~ /\A(require|import)/ }
-      lines.insert lines.index(matches.last).to_i + 1, "import consumer from '../channels/consumer'\n"
-    end
-
-    initialize_line = lines.find { |line| line.start_with?("Futurism.initializeElements") }
-    lines << "Futurism.initializeElements()\n" unless initialize_line
-
-    subscribe_line = lines.find { |line| line.start_with?("Futurism.createSubscription") }
-    lines << "Futurism.createSubscription(consumer)\n" unless subscribe_line
-
-    File.open(filepath, "w") { |f| f.write lines.join }
-  end
-end