turbo_boost-commands 0.0.18 → 0.1.1

data/lib/turbo_boost/state/manager.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../state"
-require_relative "provisional_state"
-
-# Class used to hold ephemeral state related to the rendered UI.
-#
-# Examples:
-#
-# - Sidebar open/closed state
-# - Tree view open/closed state
-# - Accordion collapsed/expanded state
-# - Customized layout / presentation
-# - Applied data filters
-# - Number of data rows to display etc.
-#
-class TurboBoost::State::Manager
-  include ActiveModel::Dirty
-
-  class << self
-    def state_override_blocks
-      @state_overrides ||= {}
-    end
-
-    def add_state_override_block(controller_name, block)
-      state_override_blocks[controller_name] = block
-    end
-
-    def state_override_block(controller)
-      return nil if state_override_blocks.blank?
-      ancestor = controller.class.ancestors.find { |a| state_override_blocks[a.name] }
-      state_override_blocks[ancestor.name]
-    end
-  end
-
-  # For ActiveModel::Dirty tracking
-  define_attribute_methods :state
-
-  attr_reader :controller, :cookie_data, :header_data, :server_data
-
-  def initialize(controller)
-    @controller = controller
-
-    begin
-      @state = TurboBoost::State.new(cookie) # server state as stored in the cookie
-    rescue => error
-      Rails.logger.error "Failed to construct TurboBoost::State! #{error.message}"
-      @state = TurboBoost::State.new
-    end
-
-    # State the server used to render the page last time
-    cookie_state_hash = state.to_h
-
-    # State managed by the server on the backend (redis cache etc.)
-    # SEE: `TurboBoost::State::Manager.state_override_block`
-    server_state_hash = {}
-
-    # State the client expects... related to optimistic UI updates
-    # i.e. Changes made on the client before making this request
-    header_state_hash = {}
-
-    # Apply server state overrides (i.e. state stored in databases like Redis, Postgres, etc...)
-    if TurboBoost::Commands.config.apply_server_state_overrides
-      begin
-        state_override_block = self.class.state_override_block(controller)
-        if state_override_block
-          server_state_hash = controller.instance_eval(&state_override_block).with_indifferent_access
-          server_state_hash.each { |key, val| self[key] = val }
-        end
-      rescue => error
-        Rails.logger.error "Failed to apply `state_override_block` configured in #{controller.class.name} to TurboBoost::State! #{error.message}"
-      end
-    end
-
-    # Apply client state overrides (i.e. optimistic state)
-    # NOTE: Client state HTTP headers are only sent if/when state has changed on the client (only the changes are sent).
-    #       This prevents race conditions (state mismatch) caused when frame and XHR requests emit immediately
-    #       before the <meta id="turbo-boost"> has been updated with the latest state from the server.
-    if TurboBoost::Commands.config.apply_client_state_overrides
-      begin
-        header_state_hash = TurboBoost::State.deserialize_base64(header).with_indifferent_access
-        header_state_hash.each { |key, val| self[key] = val }
-      rescue => error
-        Rails.logger.error "Failed to apply client state from HTTP headers to TurboBoost::State! #{error.message}"
-      end
-    end
-
-    @cookie_data = cookie_state_hash
-    @header_data = header_state_hash
-    @server_data = server_state_hash
-  rescue => error
-    Rails.logger.error "Failed to construct TurboBoost::State! #{error.message}"
-  ensure
-    @state ||= TurboBoost::State.new
-  end
-
-  delegate :cache_key, to: :state
-
-  # Same implementation as ActionController::Base but with public visibility
-  def cookies
-    controller.request.cookie_jar
-  end
-
-  def [](*keys, default: nil)
-    state.read(*keys, default: default)
-  end
-
-  def []=(*keys, value)
-    state_will_change! if value != self[*keys]
-    value.nil? ? state.delete(*keys) : state.write(*keys, value)
-  end
-
-  def provisional_state
-    @provisional_state ||= TurboBoost::State::ProvisionalState.new(self)
-  end
-
-  alias_method :now, :provisional_state
-
-  def clear
-    provisional_state.clear
-    state.clear
-  end
-
-  def payload
-    provisional_state.clear
-    state.shrink!
-    state.payload
-  end
-
-  def ordinal_payload
-    provisional_state.clear
-    state.shrink!
-    state.prune! max_bytesize: TurboBoost::Commands.config.max_cookie_size
-    state.ordinal_payload
-  end
-
-  def write_cookie
-    return unless changed? || cookie.blank?
-    cookies.signed["turbo_boost.state"] = {value: ordinal_payload, path: "/", expires: 1.day.from_now}
-    changes_applied
-  rescue => error
-    Rails.logger.error "Failed to write the TurboBoost::State cookie! #{error.message}"
-  end
-
-  private
-
-  attr_reader :state
-
-  def headers
-    controller.request.headers.select { |(key, _)| key.match?(/TURBOBOOST_STATE/i) }.sort
-  end
-
-  # State that exists on the client.
-  def header
-    headers.map(&:last).join
-  end
-
-  # State that the server last rendered with.
-  def cookie
-    cookies.signed["turbo_boost.state"]
-  end
-end

data/lib/turbo_boost/state/provisional_state.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../state"
-
-class TurboBoost::State::ProvisionalState
-  def initialize(state_manager)
-    @state_manager = state_manager
-    @keys = Set.new
-  end
-
-  attr_reader :keys
-
-  def [](*keys, default: nil)
-    state_manager[*keys, default: default]
-  end
-
-  def []=(*keys, value)
-    key = TurboBoost::State.key_for(*keys)
-    value.nil? ? self.keys.delete(key) : self.keys.add(key)
-    state_manager[key] = value
-  end
-
-  def clear
-    keys.each { |key| state_manager[key] = nil }
-    keys.clear
-  end
-
-  private
-
-  attr_reader :state_manager
-end

data/lib/turbo_boost/state.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "state/errors"
-
-class TurboBoost::State
-  class << self
-    def serialize_base64(data)
-      Base64.urlsafe_encode64 data.to_json, padding: false
-    end
-
-    def deserialize_base64(string)
-      return {} if string.blank?
-      JSON.parse Base64.urlsafe_decode64(string)
-    rescue => error
-      raise TurboBoost::State::DeserializationError, "Unable to decode and parse Base64 string! \"#{string}\" #{error.message}"
-    end
-
-    def serialize(data)
-      dump = Marshal.dump(data)
-      deflated = Zlib::Deflate.deflate(dump, Zlib::BEST_COMPRESSION)
-      Base64.urlsafe_encode64 deflated
-    end
-
-    def deserialize(string)
-      return {} if string.blank?
-      decoded = Base64.urlsafe_decode64(string)
-      inflated = Zlib::Inflate.inflate(decoded)
-      Marshal.load inflated
-    rescue => error
-      raise TurboBoost::State::DeserializationError, "Unable to decode, inflate, and load Base64 string! \"#{string}\" #{error.message}"
-    end
-
-    def key_for(*keys)
-      keys.map { |key| key.try(:cache_key) || key.to_s }.join("/")
-    end
-  end
-
-  def initialize(ordinal_payload = nil)
-    @internal_data = {}.with_indifferent_access
-    @internal_keys = []
-
-    deserialize(ordinal_payload).each do |(key, value)|
-      write key, value
-    end
-  end
-
-  delegate :deserialize, :key_for, :serialize, :serialize_base64, to: "self.class"
-  delegate :size, to: :internal_data
-  delegate :include?, :has_key?, :key?, :member?, to: :internal_data
-
-  def cache_key
-    "turbo-boost/ui-state/#{Digest::SHA2.base64digest(payload)}"
-  end
-
-  def read(*keys, default: nil)
-    value = internal_data[key_for(*keys)]
-    value = write(*keys, default) if value.nil? && default
-    value
-  end
-
-  def write(*keys, value)
-    key = key_for(*keys)
-    internal_keys.delete key if internal_keys.include?(key)
-    internal_keys << key
-    internal_data[key] = value
-    value
-  end
-
-  def delete(*keys)
-    key = key_for(*keys)
-    internal_keys.delete key
-    internal_data.delete key
-  end
-
-  def payload
-    serialize_base64 internal_data
-  end
-
-  def ordinal_payload
-    serialize internal_list
-  end
-
-  def clear
-    internal_keys.clear
-    internal_data.clear
-  end
-
-  def shrink!
-    @internal_data = shrink(internal_data).with_indifferent_access
-    @internal_keys = internal_keys & internal_data.keys
-  end
-
-  def prune!(max_bytesize: 2.kilobytes)
-    return if internal_keys.blank?
-    return if internal_data.blank?
-
-    percentage = (max_bytesize > 0) ? ordinal_payload.bytesize / max_bytesize.to_f : 0
-    while percentage > 1
-      keys_to_keep = internal_keys.slice((internal_keys.length - (internal_keys.length / percentage).floor)..-1)
-      keys_to_remove = internal_keys - keys_to_keep
-      @internal_keys = keys_to_keep
-      keys_to_remove.each { |key| internal_data.delete key }
-      percentage = (max_bytesize > 0) ? ordinal_payload.bytesize / max_bytesize.to_f : 0
-    end
-  end
-
-  # Returns a copy of the data as a Hash
-  def to_h
-    internal_data.deep_dup
-  end
-
-  private
-
-  attr_reader :internal_keys
-  attr_reader :internal_data
-
-  def internal_list
-    internal_keys.map { |key| [key, internal_data[key]] }
-  end
-
-  def shrink(obj)
-    case obj
-    when Array
-      obj.each_with_object([]) do |value, memo|
-        value = shrink(value)
-        memo << value if value.present?
-      end
-    when Hash
-      obj.each_with_object({}.with_indifferent_access) do |(key, value), memo|
-        value = shrink(value)
-        memo[key] = value if value.present?
-      end
-    else
-      obj
-    end
-  end
-end