power-compass 0.9.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67f60de7728f8399358473904162a3db899194defdd92942f59f1c1d4d193df7
-  data.tar.gz: 467ca5ce7cf34d6594f0836e043a9826b53707e5a69b8c60f26d8342ea3b7c6e
+  metadata.gz: bf61a684e515eebb2ffbc60245c9a6749a06ef0f9437227f8dc612b73ed078d0
+  data.tar.gz: 9113182a39604aa267b9efcd91f95a543e59e3c8e1d7415da8daef2f64bfedaf
 SHA512:
-  metadata.gz: b4f300c0fab00a8613c8dfac7b8e2e872d4ab3b2040eb6919b32e9e4224b1128312aa1b45644277769a7a13c8df209743841832f8187803ee3f9e60fdd2600db
-  data.tar.gz: 58a7c0089e548d98ee3472ba26f001eb02c761d1d7a2b3f4b27d87440c42153be9cd2a1d18158b8585263b67a0cfc54b97fbde17589f3c37c14be4936cccff94
+  metadata.gz: b306a91383a0af5789beddc4dbe311b2ea83f9fc09aa3dd86ffb8bd792175d1897569c04a0bb12b0122d9e2d67621a8a4e1b7c22864ae1ce348173b94608e08a
+  data.tar.gz: 23f9a16ec5815ca38e9bc3373a66650aabc6150ef49beab94a0730a6dec4dc9bd8d0788bb40264be4d9b2986d520379b120b2bdadf529ca1e71db0b4641b1abb

data/app/components/compass/layout/breadcrumbs.rb

@@ -4,6 +4,27 @@ module Compass
   class Layout
     class Breadcrumbs < ApplicationComponent
       prop :breadcrumbs
+      prop :context
+      prop :max, default: 10
+
+    private
+
+      # Resolves the breadcrumb trail. An explicit +breadcrumbs:+ prop wins;
+      # otherwise the configured strategy is queried via +Compass::Breadcrumb.for+.
+      # Memoized so the template's repeated reads only resolve once per render.
+      def breadcrumbs
+        @resolved_breadcrumbs ||=
+          prop(:breadcrumbs).presence ||
+          Compass::Breadcrumb.for(context: resolved_context, max: prop(:max)) ||
+          []
+      end
+
+      # An explicit +context:+ prop wins; otherwise build the request-scoped
+      # context the same way the controllers do.
+      def resolved_context
+        # bearer:disable ruby_rails_sql_injection
+        prop(:context) || Compass::Context.from(request.env)
+      end
     end
   end
 end

data/app/components/concerns/compass/config_props.rb

@@ -15,7 +15,8 @@ module Compass
     private
 
       def context_id
-        prop(:context_id).presence || instance_exec(&Compass.config.context_id)
+        # bearer:disable ruby_rails_sql_injection
+        prop(:context_id).presence || Compass::Context.from(request.env).context_id
       end
 
       def backends

data/app/controllers/compass/application_controller.rb

@@ -7,19 +7,16 @@ module Compass
     before_action :validate_context
 
     def authenticate
-      head(:forbidden) unless instance_exec(&Compass.config.authenticate)
+      head(:forbidden) unless current_context.authenticate!
     end
 
     def validate_context
-      head(:bad_request) unless current_context_id.to_s.eql?(params[:context_id])
+      head(:bad_request) unless current_context.context_id.to_s.eql?(params[:context_id])
     end
 
     def current_context
-      instance_exec(&Compass.config.context)
-    end
-
-    def current_context_id
-      instance_exec(&Compass.config.context_id)
+      # bearer:disable ruby_rails_sql_injection
+      Compass::Context.from(request.env)
     end
   end
 end

data/app/controllers/compass/info_controller.rb

@@ -13,8 +13,8 @@ module Compass
     end
 
     def auth
-      expiration = Compass.config.client.auth_expires_at&.call(**current_context)
-      token = Compass.config.client.auth_token&.call(**current_context)
+      expiration = current_context.auth_expires_at
+      token = current_context.auth_token
 
       if expiration&.future?
         expires_in(expiration - Time.now)

data/app/controllers/concerns/compass/conditional_cache.rb

@@ -6,14 +6,8 @@ module Compass
     extend ActiveSupport::Concern
 
     included do
-      etag { current_context_id }
-      etag { context_modified_at }
-
-    private
-
-      def context_modified_at
-        instance_exec(&Compass.config.modified_at)
-      end
+      etag { current_context.context_id }
+      etag { current_context.modified_at }
     end
 
     def with_cache(items, config, etag:)

data/lib/compass/breadcrumb/strategies/cookie.rb

@@ -0,0 +1,106 @@
+require "json"
+
+module Compass
+  module Breadcrumb
+    module Strategies
+      # Stores the breadcrumb trail in a Rails signed cookie.
+      #
+      # The trail is JSON-encoded inside a *signed* cookie so it cannot be
+      # tampered with client-side — the stored URLs are rendered as link hrefs
+      # and must be trusted.
+      #
+      # This is the default strategy. It is stateless and thread-safe: it holds
+      # only its constructor options; all per-request data lives on
+      # +context.request+.
+      #
+      # I.e.:
+      #
+      #   config.breadcrumb.strategy = Compass::Breadcrumb::Strategies::Cookie.new(
+      #     domain: ".example.com"
+      #   )
+      #
+      class Cookie
+        DEFAULT_NAME = "compass_breadcrumbs".freeze
+        DEFAULT_MAX_ENTRIES = 10
+
+        # @param domain [String, nil] cookie domain. When set, the breadcrumb
+        #   cookie is shared across that host scope; when omitted, Rails cookie
+        #   jar defaults apply.
+        # @param name [String] cookie name.
+        # @param max_entries [Integer] maximum crumbs persisted in the cookie.
+        def initialize(domain: nil, name: DEFAULT_NAME, max_entries: DEFAULT_MAX_ENTRIES)
+          @domain = domain
+          @name = name
+          @max_entries = max_entries
+        end
+
+        # Reads the stored trail.
+        #
+        # @param context [Compass::Context, nil] the request-scoped context.
+        # @param max [Integer] maximum number of crumbs to return.
+        # @return [Array<Hash>] up to +max+ crumbs, newest first; +[]+ when there
+        #   is no request or the cookie is missing/invalid.
+        def for(context:, max: DEFAULT_MAX_ENTRIES)
+          request = context&.request
+          return [] unless request
+
+          read(request).first(max)
+        rescue => e
+          Compass.logger&.error "Breadcrumb cookie read error: #{e.message}"
+          []
+        end
+
+        # Prepends a crumb, deduping by label and capping to +max_entries+.
+        #
+        # No-ops when there is no request or the label is blank.
+        #
+        # @param context [Compass::Context, nil] the request-scoped context.
+        # @param url [String] the crumb URL.
+        # @param label [String] the crumb label.
+        # @return [nil]
+        def push(context:, url:, label:)
+          request = context&.request
+          return if request.nil? || label.blank?
+
+          trail = read(request).reject { |crumb| crumb[:label] == label }
+          trail.unshift(url: url, label: label)
+
+          write(request, trail.first(@max_entries))
+          nil
+        rescue => e
+          Compass.logger&.error "Breadcrumb cookie write error: #{e.message}"
+          nil
+        end
+
+      private
+
+        def read(request)
+          raw = request.cookie_jar.signed[@name]
+          parsed = raw.is_a?(String) ? JSON.parse(raw) : raw
+
+          Array(parsed).filter_map do |entry|
+            next unless entry.respond_to?(:to_h)
+
+            crumb = entry.to_h.symbolize_keys
+            { url: crumb[:url], label: crumb[:label] } if crumb[:url] || crumb[:label]
+          end
+        end
+
+        def write(request, trail)
+          request.cookie_jar.signed[@name] = { value: JSON.dump(trail) }.merge(write_options(request))
+        end
+
+        def write_options(request)
+          options = {
+            path: "/",
+            httponly: true,
+            same_site: :lax,
+            secure: request.ssl?
+          }
+          options[:domain] = @domain if @domain
+          options
+        end
+      end
+    end
+  end
+end

data/lib/compass/breadcrumb/strategies/http.rb

@@ -0,0 +1,147 @@
+require "json"
+require "uri"
+require "net/http"
+
+module Compass
+  module Breadcrumb
+    module Strategies
+      # Stores and retrieves the breadcrumb trail over HTTP from a remote
+      # backend, using only Ruby's stdlib +Net::HTTP+.
+      #
+      # Backend contract (implemented by the remote app, not by this gem). The
+      # +backend+ URL is used verbatim as the breadcrumbs endpoint:
+      #
+      #   GET  {backend}?max=N -> 200 with JSON [{ "url":, "label": }]
+      #   POST {backend}       -> any 2xx is success; body ignored
+      #
+      # Auth is taken from the context's +auth_token+ and sent as a bearer token.
+      #
+      # The strategy is stateless and thread-safe: it holds only configuration
+      # (backend URL, timeouts, optional transport). The per-request +#for+ cache
+      # lives on +context.request.env+, never on the instance.
+      #
+      # I.e.:
+      #
+      #   config.breadcrumb.strategy = Compass::Breadcrumb::Strategies::Http.new(
+      #     backend: "https://my-app.example.com/compass"
+      #   )
+      #
+      class Http
+        DEFAULT_OPEN_TIMEOUT = 1
+        DEFAULT_READ_TIMEOUT = 2
+        MEMO_KEY = "compass.breadcrumb.http.for".freeze
+
+        # @param backend [String] the breadcrumbs endpoint URL, used verbatim.
+        # @param open_timeout [Numeric] connection open timeout, in seconds.
+        # @param read_timeout [Numeric] response read timeout, in seconds.
+        # @param transport [#call, nil] injectable executor for specs; receives
+        #   +(uri, net_http_request)+ and returns a response responding to
+        #   +#code+ and +#body+. Defaults to a Net::HTTP-backed transport.
+        def initialize(backend:, open_timeout: DEFAULT_OPEN_TIMEOUT, read_timeout: DEFAULT_READ_TIMEOUT, transport: nil)
+          @backend = backend.to_s
+          @open_timeout = open_timeout
+          @read_timeout = read_timeout
+          @transport = transport || method(:net_http_transport)
+        end
+
+        # Fetches the trail, memoized per request so repeated renders on the same
+        # request only hit the backend once.
+        #
+        # @param context [Compass::Context, nil] the request-scoped context.
+        # @param max [Integer] maximum number of crumbs to request.
+        # @return [Array<Hash>] the crumbs, or +[]+ on any failure.
+        def for(context:, max: 10)
+          env = context&.request&.env
+          return fetch(context, max) unless env
+
+          return env[MEMO_KEY] if env.key?(MEMO_KEY)
+
+          env[MEMO_KEY] = fetch(context, max)
+        end
+
+        # Posts a crumb to the backend. The response body is ignored.
+        #
+        # @param context [Compass::Context, nil] the request-scoped context.
+        # @param url [String] the crumb URL.
+        # @param label [String] the crumb label.
+        # @return [nil]
+        def push(context:, url:, label:)
+          uri = build_uri
+          response = @transport.call(uri, post_request(uri, context, url: url, label: label))
+          log_failure(response) unless success?(response)
+          nil
+        rescue => e
+          log(e)
+          nil
+        end
+
+      private
+
+        def fetch(context, max)
+          uri = build_uri("max" => max)
+          response = @transport.call(uri, get_request(uri, context))
+          return [] unless success?(response)
+
+          parse_list(response.body)
+        rescue => e
+          log(e)
+          []
+        end
+
+        def build_uri(query = nil)
+          uri = URI.parse(@backend)
+          uri.query = URI.encode_www_form(query) if query
+          uri
+        end
+
+        def get_request(uri, context)
+          apply_headers(Net::HTTP::Get.new(uri), context)
+        end
+
+        def post_request(uri, context, url:, label:)
+          request = apply_headers(Net::HTTP::Post.new(uri), context)
+          request.body = JSON.dump(url: url, label: label)
+          request
+        end
+
+        def apply_headers(request, context)
+          request["Content-Type"] = "application/json"
+          request["Accept"] = "application/json"
+
+          token = context&.auth_token
+          request["Authorization"] = "Bearer #{token}" if token.present?
+          request
+        end
+
+        def parse_list(body)
+          Array(JSON.parse(body)).filter_map do |entry|
+            next unless entry.respond_to?(:to_h)
+
+            crumb = entry.to_h.symbolize_keys
+            { url: crumb[:url], label: crumb[:label] } if crumb[:url] || crumb[:label]
+          end
+        end
+
+        def success?(response)
+          (200..299).cover?(response.code.to_i)
+        end
+
+        def net_http_transport(uri, request)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http.open_timeout = @open_timeout
+          http.read_timeout = @read_timeout
+          http.request(request)
+        end
+
+        def log(error)
+          Compass.logger&.error "Breadcrumb HTTP error: #{error.message}"
+        end
+
+        def log_failure(response)
+          Compass.logger&.error "Breadcrumb HTTP non-success response: #{response.code}"
+        end
+      end
+    end
+  end
+end

data/lib/compass/breadcrumb.rb

@@ -3,24 +3,28 @@ module Compass
   # It leverages the configured breadcrumb strategy to fetch and push breadcrumb items.
   #
   module Breadcrumb
-    autoload :Middleware, "compass/breadcrumb/middleware"
+    # Bundled breadcrumb strategies.
+    module Strategies
+      autoload :Cookie, "compass/breadcrumb/strategies/cookie"
+      autoload :Http, "compass/breadcrumb/strategies/http"
+    end
 
     # Fetch breadcrumb for the given context, using the configured strategy.
     #
     # I.e.:
     #
-    #   Compass::Breadcrumb.for(context_id, context: { current_user: }, max: 5)
+    #   Compass::Breadcrumb.for(context: current_context, max: 5)
     #    => [
     #      { url: "/home", label: "Home" },
     #      { url: "/section", label: "Section" },
     #      { url: "/section/page", label: "Page" }
     #    ]
     #
-    # @param context_id [String] The context identifier.
-    # @param context [Hash] The context hash.
+    # @param context [Compass::Context, nil] The request-scoped context. Strategies
+    #   that need the request read it from +context.request+.
     # @param max [Integer] The maximum number of items to return.
-    # @return [Array<Hash>,nil] The breadcrumb items.
-    def self.for(context: {}, max: 10)
+    # @return [Array<Hash>,nil] The breadcrumb items, or nil when no strategy is configured.
+    def self.for(context:, max: 10)
       Compass.config.breadcrumb.strategy&.for(context: context, max: max)
     end
 
@@ -29,17 +33,17 @@ module Compass
     # I.e.:
     #
     #   Compass::Breadcrumb.push(
-    #     context_id,
-    #     context: { current_user: },
+    #     context: current_context,
     #     url: "/section/page",
     #     label: "Page"
     #   )
     #
-    # @param context_id [String] The context identifier.
-    # @param context [Hash] The context hash.
+    # @param context [Compass::Context, nil] The request-scoped context. Strategies
+    #   that need the request read it from +context.request+.
     # @param url [String] The URL of the breadcrumb item.
     # @param label [String] The label of the breadcrumb item.
-    def self.push(context: {}, url:, label:)
+    # @return [nil]
+    def self.push(context:, url:, label:)
       Compass.config.breadcrumb.strategy&.push(context: context, url: url, label: label)
     end
   end

data/lib/compass/configuration/breadcrumb.rb

@@ -2,23 +2,26 @@ module Compass
   module Configuration::Breadcrumb
     include ActiveSupport::Configurable
 
-    # Strategy class for breadcrumb functionality.
-    # Applications must provide their own implementation.
+    # Strategy instance for breadcrumb functionality.
+    #
+    # Defaults to a signed-cookie strategy. Assign another strategy instance to
+    # override it, or assign +nil+ to disable breadcrumbs entirely.
     #
     # I.e.:
-    #   config.breadcrumb.strategy = MyAppBreadcrumbService
+    #   config.breadcrumb.strategy = Compass::Breadcrumb::Strategies::Http.new(backend: "...")
+    #   config.breadcrumb.strategy = nil # disable
     #
     # @see Compass::Breadcrumb for method signatures.
     #
-    config_accessor :strategy, default: nil
+    config_accessor :strategy, default: Compass::Breadcrumb::Strategies::Cookie.new
 
     # Proc to determine if a request should be tracked for breadcrumbs.
-    # It receives the request and context as parameters.
+    # It receives the context and the request as parameters.
     #
     # I.e.:
-    #   config.breadcrumb.should_track = ->(request, context) { request.path != "/login" }
+    #   config.breadcrumb.should_track = ->(context, request) { request.path != "/login" }
     #
     # @return [Proc] The tracking determination proc.
-    config_accessor :should_track, default: ->(request, context) { true }
+    config_accessor :should_track, default: ->(context, request) { true }
   end
 end

data/lib/compass/configuration/client.rb

@@ -8,18 +8,5 @@ module Compass
     #   config.client.backends = [ "http://localhost:3000/compass" ]
     #
     config_accessor :backends, default: Set.new
-
-    # Authentication configuration
-    #
-    # I.e.:
-    #   config.client.auth_token = -> { "1234567890" }
-    #   config.client.auth_expires_at = -> { 1.hour.from_now }
-    #
-    # @return [Proc] The authentication token proc.
-    config_accessor :auth_token, default: ->(**) { }
-
-    # Proc to determine the authentication expiration time.
-    # @return [Proc] The authentication expiration time proc.
-    config_accessor :auth_expires_at, default: ->(**) { }
   end
 end

data/lib/compass/configuration.rb

@@ -7,13 +7,10 @@ module Compass
   # To configure, use the `configure` method. For example:
   #
   #  Compass.configure do |config|
-  #   config.authenticate = -> do
-  #     authenticate_or_request_with_http_token do |token, options|
-  #       @current_user = User.find_by(token: token)
-  #     end
-  #   end
-  #   config.context = -> { { current_user: } }
-  #   config.etag = -> { current_user.id }
+  #   # A Compass::Context subclass, instantiated per request. It is responsible
+  #   # for authentication, context identification, caching timestamps and client
+  #   # auth. See Compass::Context.
+  #   config.context = CompassContext
   #
   #   # Configure menu
   #   config.menu.items = %w[ TestMenu ]
@@ -33,11 +30,9 @@ module Compass
     included do
       include ActiveSupport::Configurable
 
-      # Backend context authentication and context identification
-      config_accessor :authenticate, default: -> { false }
-      config_accessor :context, default: -> { {} }
-      config_accessor :context_id, default: -> { }
-      config_accessor :modified_at, default: -> { }
+      # The request-scoped context class. It must be a Compass::Context subclass
+      # and is instantiated with the current request on every Compass request.
+      config_accessor :context, default: Compass::Context
 
       # Client configuration
       config_accessor :client, default: Compass::Configuration::Client

data/lib/compass/context.rb

@@ -0,0 +1,93 @@
+module Compass
+  # The request-scoped Compass context.
+  #
+  # An application subclasses this and assigns the subclass to
+  # `Compass.config.context`. `Compass::Middleware` instantiates it once per
+  # request with the Rack env and stores it in `env[Compass::Context::ENV_KEY]`,
+  # so the same instance is reused for authentication, identification, caching,
+  # and client authentication across the whole request. It also acts as the
+  # context passed to Menu, Search, and Notification providers.
+  #
+  # Use `Compass::Context.from(env)` to retrieve the context for a request.
+  #
+  # I.e.:
+  #
+  #   class CompassContext < Compass::Context
+  #     def authenticate!
+  #       current_user.present?
+  #     end
+  #
+  #     def context_id     = current_user&.id
+  #     def modified_at    = current_user&.updated_at
+  #     def auth_token     = current_user&.api_token
+  #     def auth_expires_at = current_user&.token_expires_at
+  #
+  #     # Exposed to providers and view locals.
+  #     def to_hash = { current_user: current_user }
+  #
+  #     def current_user
+  #       @current_user ||= User.find_by(token: request.authorization.to_s.remove("Bearer "))
+  #     end
+  #   end
+  #
+  #   Compass.configure do |config|
+  #     config.context = CompassContext
+  #   end
+  #
+  class Context
+    include Compass::MustImplement
+
+    # Rack env key under which the request context is memoized.
+    ENV_KEY = "compass.context".freeze
+
+    # The context for the given Rack env. Builds the configured context and
+    # memoizes it in the env when absent, guaranteeing a single context per
+    # request.
+    #
+    # @param env [Hash] the Rack environment
+    # @return [Compass::Context]
+    def self.from(env)
+      env[ENV_KEY] ||= Compass.config.context.new(env)
+    end
+
+    # The Rack environment the context was built from.
+    # @return [Hash]
+    attr_reader :env
+
+    # The request object wrapping the request env
+    attr_reader :request
+
+    # @param env [Hash] the Rack environment
+    def initialize(env, request = ActionDispatch::Request.new(env))
+      @env = env
+      @request = request
+    end
+
+    # Authenticates the current request.
+    # @return [Boolean] whether the request is authenticated.
+    def authenticate! = false
+
+    # The context identifier. Used to namespace the Compass API paths and as an
+    # ETag source.
+    # @return [String, Integer, nil]
+    def context_id = must_implement(:context_id)
+
+    # Timestamp used for HTTP ETag caching.
+    # @return [Time, nil]
+    def modified_at = must_implement(:modified_at)
+
+    # Bearer token exposed through the client auth endpoint.
+    # @return [String, nil]
+    def auth_token = nil
+
+    # Expiration time for the auth token.
+    # @return [Time, nil]
+    def auth_expires_at = nil
+
+    # Hash representation of the context. It is splatted into Menu, Search, and
+    # Notification providers as well as into Search view locals, so applications
+    # should override it to expose the data providers depend on.
+    # @return [Hash]
+    def to_hash = {}
+  end
+end

data/lib/compass/engine.rb

@@ -44,7 +44,7 @@ module Compass
     end
 
     initializer "compass.middleware" do |app|
-      app.middleware.use Compass::Breadcrumb::Middleware
+      app.middleware.use Compass::Middleware
     end
   end
 end

data/lib/compass/middleware.rb

@@ -0,0 +1,44 @@
+module Compass
+  # Rack middleware that establishes the request-scoped Compass context.
+  #
+  # It builds the configured `Compass::Context` once per request and memoizes
+  # it in the Rack env under `Compass::Context::ENV_KEY`, so controllers and
+  # components reuse the same instance via `Compass::Context.from(env)`.
+  #
+  # It also runs per-request Compass features with that context — currently
+  # breadcrumb tracking, which uses the configured breadcrumb strategy to save
+  # breadcrumb items for requests that should be tracked.
+  #
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+      # bearer:disable ruby_rails_sql_injection
+      context = Compass::Context.from(env)
+
+      save_breadcrumb!(context, request) if should_track?(context, request)
+    rescue => e
+      # Silently handle errors - don't break the request
+      Compass.logger&.error "Compass middleware error: #{e.message}"
+    ensure
+      return @app.call(env)
+    end
+
+  private
+
+    def save_breadcrumb!(context, request)
+      ::Compass::Breadcrumb.push(
+        context: context,
+        label: request.params[:mt],
+        url: request.url
+      )
+    end
+
+    def should_track?(context, request)
+      Compass.config.breadcrumb.should_track.call(context, request)
+    end
+  end
+end

data/lib/compass/must_implement.rb

@@ -0,0 +1,7 @@
+module Compass
+  module MustImplement
+    def must_implement(method)
+      raise NotImplementedError, "#{self.class} must implement ##{method}"
+    end
+  end
+end

data/lib/compass/notification/provider.rb

@@ -2,6 +2,7 @@ module Compass
   module Notification
     class Provider
       include Compass::JsonFormatter
+      include Compass::MustImplement
 
       format :icon, :color, id: :required, title: :required, body: :required, url: :required, date: :required
 
@@ -36,10 +37,6 @@ module Compass
 
     private
 
-      def must_implement(method)
-        raise NotImplementedError, "#{self.class} must implement ##{method}"
-      end
-
       def log_error(error)
         Compass.logger&.error(
           "[ Compass::Notification::Provider ] #{self.class}: #{error.class}: #{error.message}"

data/lib/compass/search/provider.rb

@@ -3,6 +3,7 @@ module Compass
     class Provider
       include Compass::Search::Rendering
       include Compass::JsonFormatter
+      include Compass::MustImplement
 
       format :url, :label, :category, :tag, :html, :confirm, :extra
 
@@ -29,12 +30,6 @@ module Compass
           search_options: search_options
         }
       end
-
-    private
-
-      def must_implement(method)
-        raise NotImplementedError, "#{self.class} must implement ##{method}"
-      end
     end
   end
 end

data/lib/compass/version.rb

@@ -1,3 +1,3 @@
 module Compass
-  VERSION = "0.9.1"
+  VERSION = "1.0.0"
 end

data/lib/compass.rb

@@ -9,10 +9,13 @@ module Compass
     attr_accessor :logger
   end
 
+  autoload :Context, "compass/context"
+  autoload :Middleware, "compass/middleware"
   autoload :Menu, "compass/menu"
   autoload :Search, "compass/search"
   autoload :Notification, "compass/notification"
   autoload :Breadcrumb, "compass/breadcrumb"
+  autoload :MustImplement, "compass/must_implement"
   autoload :LazyAttribute, "compass/lazy_attribute"
   autoload :JsonFormatter, "compass/json_formatter"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: power-compass
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Carlos Palhares
@@ -83,7 +83,8 @@ files:
 - config/routes.rb
 - lib/compass.rb
 - lib/compass/breadcrumb.rb
-- lib/compass/breadcrumb/middleware.rb
+- lib/compass/breadcrumb/strategies/cookie.rb
+- lib/compass/breadcrumb/strategies/http.rb
 - lib/compass/configuration.rb
 - lib/compass/configuration/breadcrumb.rb
 - lib/compass/configuration/client.rb
@@ -91,12 +92,15 @@ files:
 - lib/compass/configuration/menu.rb
 - lib/compass/configuration/notification.rb
 - lib/compass/configuration/search.rb
+- lib/compass/context.rb
 - lib/compass/engine.rb
 - lib/compass/json_formatter.rb
 - lib/compass/lazy_attribute.rb
 - lib/compass/menu.rb
 - lib/compass/menu/item.rb
 - lib/compass/menu/item_list.rb
+- lib/compass/middleware.rb
+- lib/compass/must_implement.rb
 - lib/compass/notification.rb
 - lib/compass/notification/provider.rb
 - lib/compass/rspec.rb

data/lib/compass/breadcrumb/middleware.rb

@@ -1,44 +0,0 @@
-module Compass
-  # Compass breadcrumb handling module.
-  # It leverages the configured breadcrumb strategy to fetch and push breadcrumb items.
-  #
-  module Breadcrumb
-    # Middleware to track breadcrumb items based on requests.
-    # It uses the configured breadcrumb strategy to save breadcrumb items
-    # for requests that should be tracked.
-    #
-    class Middleware
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        @request = ActionDispatch::Request.new(env)
-        context = instance_exec(&Compass.config.context)
-
-        save_breadcrumb!(context) if should_track?(context)
-      rescue => e
-        # Silently handle breadcrumb errors - don't break the request
-        Compass.logger&.error "Breadcrumb middleware error: #{e.message}"
-      ensure
-        return @app.call(env)
-      end
-
-    private
-
-      attr_reader :request
-
-      def save_breadcrumb!(context)
-        ::Compass::Breadcrumb.push(
-          context: context,
-          label: @request.params[:mt],
-          url: @request.url
-        )
-      end
-
-      def should_track?(context)
-        Compass.config.breadcrumb.should_track.call(@request, context)
-      end
-    end
-  end
-end