not_pressed-core 0.1.0

data/lib/not_pressed/hooks.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module NotPressed
+  # Global event and filter system for the NotPressed engine.
+  #
+  # Hooks are one-shot event callbacks. Filters are value-transforming chains.
+  # All methods are thread-safe via an internal mutex.
+  #
+  # @example Registering and firing a hook
+  #   Hooks.register(:after_page_save) { |page| log(page.title) }
+  #   Hooks.fire(:after_page_save, page)
+  #
+  # @example Using filters
+  #   Hooks.register_filter(:page_content) { |html, page| html + "<footer>...</footer>" }
+  #   result = Hooks.apply_filter(:page_content, "<p>Hello</p>", page)
+  module Hooks
+    class << self
+      # Registers a callback for the given event.
+      #
+      # Callbacks are sorted by priority (lower values execute first).
+      #
+      # @param event [Symbol] event name
+      # @param priority [Integer] execution priority (default 10)
+      # @yield callback block invoked when the event fires
+      # @return [void]
+      def register(event, priority: 10, &callback)
+        mutex.synchronize do
+          hooks[event] ||= []
+          hooks[event] << { callback: callback, priority: priority }
+          hooks[event].sort_by! { |h| h[:priority] }
+        end
+      end
+
+      # Invokes all callbacks registered for the event, in priority order.
+      #
+      # @param event [Symbol] event name
+      # @param args [Object] arguments passed to each callback
+      # @return [void]
+      def fire(event, *args)
+        callbacks_for(event).each { |entry| entry[:callback].call(*args) }
+      end
+
+      # Wraps a block with all callbacks for the event.
+      #
+      # Each callback receives the arguments plus a +&next_block+ to continue
+      # the chain. If no callbacks are registered, the core block is called directly.
+      #
+      # @param event [Symbol] event name
+      # @param args [Object] arguments passed to each callback
+      # @yield the core operation to wrap
+      # @return [Object] the return value of the innermost block
+      def around(event, *args, &block)
+        chain = callbacks_for(event)
+        if chain.empty?
+          block.call
+        else
+          build_around_chain(chain, args, block).call
+        end
+      end
+
+      # Registers a filter callback for the given name.
+      #
+      # Filters are chained: each receives the return value of the previous
+      # filter (or the initial value) plus any extra arguments.
+      #
+      # @param name [Symbol] filter name
+      # @param priority [Integer] execution priority (default 10)
+      # @yield [value, *args] receives the current value and extra arguments, must return the new value
+      # @return [void]
+      def register_filter(name, priority: 10, &callback)
+        mutex.synchronize do
+          filters[name] ||= []
+          filters[name] << { callback: callback, priority: priority }
+          filters[name].sort_by! { |f| f[:priority] }
+        end
+      end
+
+      # Runs the value through all registered filters for the given name.
+      #
+      # @param name [Symbol] filter name
+      # @param value [Object] initial value to filter
+      # @param args [Object] extra arguments passed to each filter callback
+      # @return [Object] the final filtered value
+      def apply_filter(name, value, *args)
+        filters_for(name).reduce(value) do |val, entry|
+          entry[:callback].call(val, *args)
+        end
+      end
+
+      # Returns a snapshot of all registered hooks.
+      #
+      # @return [Hash{Symbol => Array<Hash>}]
+      def registered
+        mutex.synchronize { hooks.dup }
+      end
+
+      # Returns callbacks registered for a specific event.
+      #
+      # @param event [Symbol] event name
+      # @return [Array<Hash>] each hash has :callback and :priority keys
+      def registered_for(event)
+        mutex.synchronize { (hooks[event] || []).dup }
+      end
+
+      # Removes a specific callback from an event.
+      #
+      # @param event [Symbol] event name
+      # @param callback [Proc] the exact callback object to remove
+      # @return [void]
+      def unregister(event, callback)
+        mutex.synchronize do
+          hooks[event]&.reject! { |entry| entry[:callback] == callback }
+        end
+      end
+
+      # Removes a specific filter callback.
+      #
+      # @param name [Symbol] filter name
+      # @param callback [Proc] the exact callback object to remove
+      # @return [void]
+      def unregister_filter(name, callback)
+        mutex.synchronize do
+          filters[name]&.reject! { |entry| entry[:callback] == callback }
+        end
+      end
+
+      # Clears all hooks and filters.
+      #
+      # @return [void]
+      def reset!
+        mutex.synchronize do
+          @hooks = {}
+          @filters = {}
+        end
+      end
+
+      private
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+
+      def hooks
+        @hooks ||= {}
+      end
+
+      def filters
+        @filters ||= {}
+      end
+
+      def callbacks_for(event)
+        mutex.synchronize { (hooks[event] || []).dup }
+      end
+
+      def filters_for(name)
+        mutex.synchronize { (filters[name] || []).dup }
+      end
+
+      def build_around_chain(chain, args, core_block)
+        chain.reverse.reduce(core_block) do |next_block, entry|
+          proc { entry[:callback].call(*args, &next_block) }
+        end
+      end
+    end
+  end
+end

data/lib/not_pressed/navigation/builder.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Navigation
+    class Builder
+      SOURCE_PRIORITY = { config: 0, partial: 1, route: 2, page: 3 }.freeze
+
+      def initialize(configuration: nil)
+        @configuration = configuration
+        @cache = {}
+      end
+
+      def build(menu_name = "main")
+        menu_name = menu_name.to_s
+        root = Node.new(label: menu_name, path: "/", source: :config)
+        known_paths = {}
+
+        # a. DSL-defined menu items (highest priority)
+        add_dsl_items(root, menu_name, known_paths)
+
+        # b. Auto-discovered routes
+        if config.auto_discover_navigation
+          add_route_items(root, known_paths)
+        end
+
+        # c. CMS pages
+        add_page_items(root, known_paths)
+
+        # d. Sort all children by position
+        root.sort_children!
+
+        root
+      end
+
+      def build_page_nodes(pages = nil)
+        pages ||= Page.visible.roots.ordered
+        pages.map do |page|
+          node = Node.new(
+            label: page.title,
+            path: "/#{page.slug}",
+            source: :page,
+            page_id: page.id,
+            position: page.position || 0
+          )
+
+          child_pages = page.children.visible.ordered
+          child_pages.each do |child_page|
+            child_nodes = build_page_nodes([child_page])
+            child_nodes.each { |cn| node.add_child(cn) }
+          end
+
+          node
+        end
+      end
+
+      def cached_build(menu_name = "main")
+        menu_name = menu_name.to_s
+        if config.cache_navigation && @cache.key?(menu_name)
+          return @cache[menu_name]
+        end
+
+        result = build(menu_name)
+        @cache[menu_name] = result if config.cache_navigation
+        result
+      end
+
+      def invalidate_cache!
+        @cache = {}
+      end
+
+      private
+
+      def config
+        @configuration || NotPressed.configuration
+      end
+
+      def add_dsl_items(root, menu_name, known_paths)
+        menu = config.menus[menu_name]
+        return unless menu
+
+        menu.items.each do |menu_item|
+          node = menu_item_to_node(menu_item)
+          known_paths[node.path] = :config
+          root.add_child(node)
+          collect_child_paths(node, known_paths, :config)
+        end
+      end
+
+      def add_route_items(root, known_paths)
+        inspector = RouteInspector.new
+        routes = inspector.navigable_routes
+
+        routes.each do |route_entry|
+          path = route_entry.path
+          next if known_paths.key?(path)
+
+          label = route_entry.name&.titleize || path
+          node = Node.new(label: label, path: path, source: :route, position: 100)
+          known_paths[path] = :route
+          root.add_child(node)
+        end
+      rescue StandardError
+        # RouteInspector may fail in test environments without full Rails routing
+        nil
+      end
+
+      def add_page_items(root, known_paths)
+        page_nodes = build_page_nodes
+
+        page_nodes.each do |node|
+          next if known_paths.key?(node.path) && higher_priority?(known_paths[node.path], :page)
+
+          known_paths[node.path] = :page
+          root.add_child(node)
+        end
+      rescue StandardError
+        # Page model may not be available in all environments
+        nil
+      end
+
+      def menu_item_to_node(menu_item)
+        children = menu_item.children.map { |child| menu_item_to_node(child) }
+
+        Node.new(
+          label: menu_item.label,
+          path: menu_item.path,
+          source: :config,
+          icon: menu_item.icon,
+          position: menu_item.position,
+          css_class: menu_item.css_class,
+          visible: menu_item.visible,
+          children: children
+        )
+      end
+
+      def collect_child_paths(node, known_paths, source)
+        node.children.each do |child|
+          known_paths[child.path] = source
+          collect_child_paths(child, known_paths, source)
+        end
+      end
+
+      def higher_priority?(existing_source, new_source)
+        (SOURCE_PRIORITY[existing_source] || 99) <= (SOURCE_PRIORITY[new_source] || 99)
+      end
+    end
+  end
+end

data/lib/not_pressed/navigation/menu.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Navigation
+    class Menu
+      attr_reader :name, :items
+
+      def initialize(name:, items: [])
+        @name = name
+        @items = items.dup.freeze
+        freeze
+      end
+
+      def self.build(name, &block)
+        builder = Builder.new
+        block&.call(builder)
+        new(name: name, items: builder.items)
+      end
+
+      class Builder
+        attr_reader :items
+
+        def initialize
+          @items = []
+          @position_counter = 0
+        end
+
+        def item(label, path, **options, &block)
+          children = if block
+                       sub_builder = Builder.new
+                       block.call(sub_builder)
+                       sub_builder.items
+                     else
+                       []
+                     end
+
+          position = options.fetch(:position, @position_counter)
+          @position_counter += 1
+
+          @items << MenuItem.new(
+            label: label,
+            path: path,
+            icon: options[:icon],
+            position: position,
+            visible: options.fetch(:visible, true),
+            children: children,
+            css_class: options[:css_class],
+            target: options[:target]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/not_pressed/navigation/menu_item.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Navigation
+    class MenuItem
+      attr_reader :label, :path, :icon, :position, :visible, :children, :css_class, :target
+
+      def initialize(label:, path:, icon: nil, position: 0, visible: true, children: [], css_class: nil, target: nil)
+        @label = label
+        @path = path
+        @icon = icon
+        @position = position
+        @visible = visible
+        @children = children.dup.freeze
+        @css_class = css_class
+        @target = target
+        freeze
+      end
+
+      def visible?
+        if visible.respond_to?(:call)
+          visible.call
+        else
+          !!visible
+        end
+      end
+
+      def leaf?
+        children.empty?
+      end
+    end
+  end
+end

data/lib/not_pressed/navigation/node.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Navigation
+    class Node
+      attr_reader :label, :path, :source, :icon, :position, :children, :page_id, :css_class
+      attr_accessor :visible
+
+      def initialize(label:, path:, source:, icon: nil, position: 0, children: [], page_id: nil, css_class: nil, visible: true)
+        @label = label
+        @path = path
+        @source = source
+        @icon = icon
+        @position = position
+        @children = children.dup
+        @page_id = page_id
+        @css_class = css_class
+        @visible = visible
+      end
+
+      def visible?
+        if visible.respond_to?(:call)
+          visible.call
+        else
+          !!visible
+        end
+      end
+
+      def page?
+        source == :page
+      end
+
+      def add_child(node)
+        @children << node
+        self
+      end
+
+      def sort_children!
+        @children.sort_by!(&:position)
+        @children.each(&:sort_children!)
+        self
+      end
+    end
+  end
+end

data/lib/not_pressed/navigation/partial_parser.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Navigation
+    class PartialParser
+      LinkReference = Struct.new(:label, :path, :line, keyword_init: true)
+
+      NAV_PARTIAL_GLOBS = %w[
+        **/_nav*.html.erb
+        **/_navigation*.html.erb
+        **/_menu*.html.erb
+        **/_header*.html.erb
+        **/_sidebar*.html.erb
+      ].freeze
+
+      LINK_TO_PATTERN = /<%=\s*link_to\s+"([^"]+)"\s*,\s*(.+?)\s*%>/
+
+      def initialize(view_paths: nil)
+        @view_paths = view_paths || Rails.application.paths["app/views"].to_a
+      end
+
+      def discover_nav_partials
+        seen = Set.new
+        partials = []
+
+        @view_paths.each do |view_path|
+          NAV_PARTIAL_GLOBS.each do |glob|
+            Dir.glob(File.join(view_path, glob)).each do |file|
+              canonical = File.expand_path(file)
+              next if seen.include?(canonical)
+
+              seen.add(canonical)
+              partials << canonical
+            end
+          end
+        end
+
+        partials.sort
+      end
+
+      def extract_links(partial_path)
+        return [] unless File.exist?(partial_path)
+
+        links = []
+
+        File.readlines(partial_path).each_with_index do |line_content, index|
+          next if line_content =~ /link_to\b.*\bdo\b/
+
+          if (match = line_content.match(LINK_TO_PATTERN))
+            label = match[1]
+            raw_path = match[2].strip
+            # Remove trailing content after the path argument (e.g., class: or html options)
+            raw_path = clean_path_argument(raw_path)
+
+            links << LinkReference.new(label: label, path: raw_path, line: index + 1)
+          end
+        end
+
+        links
+      end
+
+      def scan
+        results = {}
+
+        discover_nav_partials.each do |partial_path|
+          links = extract_links(partial_path)
+          results[partial_path] = links if links.any?
+        end
+
+        results
+      end
+
+      private
+
+      def clean_path_argument(raw)
+        # If the path is a quoted string, extract it
+        if raw.start_with?('"')
+          raw.match(/\A"([^"]*)"/)&.then { |m| return m[1] }
+        end
+
+        # If it's a path helper with or without parens, take up to the first comma
+        # that's outside of parentheses (indicating html_options)
+        depth = 0
+        raw.each_char.with_index do |char, i|
+          depth += 1 if char == "("
+          depth -= 1 if char == ")"
+          if char == "," && depth.zero?
+            return raw[0...i].strip
+          end
+        end
+
+        raw.strip
+      end
+    end
+  end
+end

data/lib/not_pressed/navigation/route_inspector.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Navigation
+    class RouteInspector
+      RouteEntry = Struct.new(:path, :name, :controller, :action, :verb, :engine, keyword_init: true)
+
+      EXCLUDED_PATH_PATTERNS = %r{/(rails|active_storage|action_mailbox|action_cable|turbo)/}.freeze
+      ID_SEGMENT_PATTERN = /:\w*id\b/.freeze
+
+      def initialize(app: Rails.application)
+        @app = app
+      end
+
+      def inspect_routes
+        @app.routes.routes.filter_map do |route|
+          defaults = route.defaults
+          next if defaults.blank? || defaults[:controller].blank?
+
+          RouteEntry.new(
+            path: route.path.spec.to_s.sub(/\(\.:\w+\)\z/, ""),
+            name: route.name,
+            controller: defaults[:controller],
+            action: defaults[:action],
+            verb: route.verb,
+            engine: nil
+          )
+        end
+      end
+
+      def navigable_routes
+        engine_mount_path = engine_path
+
+        inspect_routes
+          .select { |entry| entry.verb == "GET" }
+          .select { |entry| entry.name.present? }
+          .reject { |entry| entry.path.match?(EXCLUDED_PATH_PATTERNS) }
+          .reject { |entry| entry.path.match?(ID_SEGMENT_PATTERN) }
+          .reject { |entry| engine_mount_path && entry.path.start_with?(engine_mount_path) }
+          .sort_by(&:path)
+      end
+
+      def route_tree
+        routes = navigable_routes
+        root = { path: "/", name: "root", controller: nil, action: nil, children: [] }
+
+        routes.each do |entry|
+          segments = entry.path.split("/").reject(&:blank?)
+          insert_into_tree(root, segments, entry, "")
+        end
+
+        root
+      end
+
+      private
+
+      def engine_path
+        @app.routes.routes.each do |route|
+          if route.app.respond_to?(:app) && route.app.app == NotPressed::Engine
+            return route.path.spec.to_s.sub(/\(\.:\w+\)\z/, "")
+          end
+        end
+        nil
+      end
+
+      def insert_into_tree(node, segments, entry, current_path)
+        return if segments.empty?
+
+        segment = segments.first
+        child_path = "#{current_path}/#{segment}"
+
+        existing = node[:children].find { |c| c[:path] == child_path }
+
+        if segments.length == 1
+          if existing
+            existing[:controller] = entry.controller
+            existing[:action] = entry.action
+            existing[:name] = entry.name
+          else
+            node[:children] << {
+              path: entry.path,
+              name: entry.name,
+              controller: entry.controller,
+              action: entry.action,
+              children: []
+            }
+          end
+        else
+          unless existing
+            existing = { path: child_path, name: nil, controller: nil, action: nil, children: [] }
+            node[:children] << existing
+          end
+          insert_into_tree(existing, segments[1..], entry, child_path)
+        end
+      end
+    end
+  end
+end

data/lib/not_pressed/navigation.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module NotPressed
+  module Navigation
+  end
+end