ruby_cms 0.2.1.1 → 1.0.0

data/app/controllers/concerns/ruby_cms/admin_pagination.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require "ruby_cms/settings"
-
-module RubyCms
-  # Unified pagination concern for all admin index pages.
-  # Uses RubyCms::Preference for per_page when configured via paginates(per_page: proc).
-  module AdminPagination
-    extend ActiveSupport::Concern
-
-    DEFAULT_MIN_PER_PAGE = 5
-    DEFAULT_MAX_PER_PAGE = 200
-
-    included do
-      class_attribute :pagination_per_page, default: 50
-      class_attribute :pagination_turbo_frame, default: nil
-      class_attribute :pagination_min_per_page, default: DEFAULT_MIN_PER_PAGE
-      class_attribute :pagination_max_per_page, default: DEFAULT_MAX_PER_PAGE
-    end
-
-    def set_pagination_vars(collection, per_page: nil, turbo_frame: nil)
-      per_page = calculate_per_page(per_page)
-      turbo_frame ||= self.class.pagination_turbo_frame
-
-      page = sanitize_page_param(params[:page])
-      paginated, total_count, total_pages, offset = paginate_collection_internal(collection, page,
-                                                                                 per_page)
-
-      @pagination = build_pagination_hash(page, per_page, total_count, total_pages, offset)
-      @pagination_path = build_pagination_path_lambda
-      @turbo_frame = turbo_frame
-
-      paginated
-    end
-
-    def paginate_collection(collection, per_page: nil, turbo_frame: nil)
-      set_pagination_vars(collection, per_page:, turbo_frame:)
-    end
-
-    module ClassMethods
-      def paginates(per_page: 50, turbo_frame: nil, min_per_page: nil, max_per_page: nil)
-        self.pagination_per_page = per_page
-        self.pagination_turbo_frame = turbo_frame
-        self.pagination_min_per_page = min_per_page if min_per_page.present?
-        self.pagination_max_per_page = max_per_page if max_per_page.present?
-      end
-    end
-
-    private
-
-    def calculate_per_page(per_page=nil)
-      per_page ||= self.class.pagination_per_page
-      per_page = per_page.call if per_page.respond_to?(:call)
-
-      min = RubyCms::Settings.get(:pagination_min_per_page,
-                                  default: self.class.pagination_min_per_page).to_i
-      max = RubyCms::Settings.get(:pagination_max_per_page,
-                                  default: self.class.pagination_max_per_page).to_i
-      max = [max, min].max
-
-      per_page.to_i.clamp(min, max)
-    end
-
-    def sanitize_page_param(page_param)
-      page = (page_param || params[:page]).to_i
-      [page, 1].max
-    end
-
-    def paginate_collection_internal(collection, page, per_page)
-      if collection.kind_of?(Array)
-        paginate_array(collection, page, per_page)
-      elsif defined?(Kaminari) && collection.respond_to?(:page)
-        paginated = collection.page(page).per(per_page)
-        [paginated, paginated.total_count, paginated.total_pages, paginated.offset_value]
-      else
-        paginate_relation(collection, page, per_page)
-      end
-    end
-
-    def paginate_array(array, page, per_page)
-      total_count = array.size
-      offset = (page - 1) * per_page
-      total_pages = total_count.positive? ? (total_count.to_f / per_page).ceil : 1
-      paginated = array.slice(offset, per_page) || []
-      [paginated, total_count, total_pages, offset]
-    end
-
-    def paginate_relation(collection, page, per_page)
-      total_count = collection.count
-      offset = (page - 1) * per_page
-      total_pages = total_count.positive? ? (total_count.to_f / per_page).ceil : 1
-      paginated = collection.limit(per_page).offset(offset)
-      [paginated, total_count, total_pages, offset]
-    end
-
-    def build_pagination_hash(page, per_page, total_count, total_pages, offset)
-      {
-        current_page: page,
-        total_pages: total_pages,
-        total_count: total_count,
-        per_page: per_page,
-        has_next: page < total_pages,
-        has_previous: page > 1,
-        next_page: page < total_pages ? page + 1 : nil,
-        previous_page: page > 1 ? page - 1 : nil,
-        start_item: total_count.positive? ? offset + 1 : 0,
-        end_item: [offset + per_page, total_count].min
-      }
-    end
-
-    def build_pagination_path_lambda
-      lambda do |page_num|
-        query_params = request.query_parameters.except(:page).merge(page: page_num)
-        base_path = request.path
-        query_string = query_params.to_query
-        query_string.present? ? "#{base_path}?#{query_string}" : base_path
-      end
-    end
-  end
-end

data/app/controllers/concerns/ruby_cms/admin_turbo_table.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  module AdminTurboTable
-    extend ActiveSupport::Concern
-
-    # Check if this is a Turbo Frame request
-    # @return [Boolean]
-    def turbo_frame_request?
-      request.headers["Turbo-Frame"].present?
-    end
-
-    # Render index action with Turbo Frame support
-    # If Turbo Frame request, renders only the table content
-    # Otherwise renders full page
-    # @param turbo_frame_id [String] Turbo Frame ID (default: "admin_table_content")
-    def turbo_render_index(turbo_frame_id: "admin_table_content")
-      if turbo_frame_request?
-        render partial: turbo_frame_id, layout: false
-      else
-        render :index
-      end
-    end
-
-    # Redirect with Turbo Frame support
-    # If Turbo Frame request, renders Turbo Stream redirect
-    # Otherwise performs normal redirect
-    # @param url [String] URL to redirect to
-    # @param options [Hash] Redirect options (notice, alert, etc.)
-    def turbo_redirect_to(url, **)
-      if turbo_frame_request?
-        # For Turbo Frame requests, we can't redirect directly
-        # Instead, we should render a Turbo Stream that updates the frame
-        # or redirect the parent window
-      else
-        redirect_to(url, **)
-      end
-    end
-
-    # Get Turbo Frame ID from request
-    # @return [String, nil]
-    def turbo_frame_id
-      request.headers["Turbo-Frame"]
-    end
-
-    # Check if request expects Turbo Stream response
-    # @return [Boolean]
-    def turbo_stream_request?
-      request.headers["Accept"]&.include?("text/vnd.turbo-stream.html")
-    end
-
-    # Render Turbo Stream update for table
-    # @param turbo_frame_id [String] Turbo Frame ID
-    # @param partial [String] Partial to render (default: turbo_frame_id)
-    def turbo_stream_update_table(turbo_frame_id: "admin_table_content", partial: nil)
-      partial ||= turbo_frame_id
-      render turbo_stream: turbo_stream.update(turbo_frame_id, partial:)
-    end
-
-    # Render Turbo Stream replace for table
-    # @param turbo_frame_id [String] Turbo Frame ID
-    # @param partial [String] Partial to render (default: turbo_frame_id)
-    def turbo_stream_replace_table(turbo_frame_id: "admin_table_content", partial: nil)
-      partial ||= turbo_frame_id
-      render turbo_stream: turbo_stream.replace(turbo_frame_id, partial:)
-    end
-  end
-end

data/app/controllers/concerns/ruby_cms/page_tracking.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  # Include in controllers to track page views via Ahoy.
-  # Requires the host app to have Ahoy installed (via RubyCMS install generator).
-  #
-  # Usage:
-  #   class PagesController < ApplicationController
-  #     include RubyCms::PageTracking
-  #   end
-  #
-  # Sets @page_name to controller_name by default. Override in actions:
-  #   @page_name = "custom_page_name"
-  #
-  # Event naming conventions (keep property keys consistent across the app):
-  #   Page views (tracked automatically):
-  #     ahoy.track RubyCms::Analytics::Report::EVENT_PAGE_VIEW,
-  #                page_name: "home", request_path: request.path
-  #
-  #   Conversions (tracked by host app controllers/forms):
-  #     ahoy.track RubyCms::Analytics::Report::EVENT_CONVERSION,
-  #                goal: "contact_form", path: request.path
-  #     ahoy.track RubyCms::Analytics::Report::EVENT_CONVERSION,
-  #                goal: "newsletter_signup", path: request.path
-  #
-  # Convention for property keys:
-  #   page_view:  page_name (String), request_path (String)
-  #   conversion: goal (String, required), path (String, optional)
-  #
-  module PageTracking
-    extend ActiveSupport::Concern
-
-    included do
-      before_action :set_page_name
-      after_action :track_page_view
-    end
-
-    private
-
-    def set_page_name
-      @page_name = controller_name if @page_name.blank?
-    end
-
-    def track_page_view
-      return unless should_track_page_view?
-
-      ahoy.track "page_view",
-                 page_name: @page_name,
-                 request_path: request.path
-    rescue StandardError => e
-      Rails.logger.error "[RubyCMS] Failed to track page view: #{e.message}"
-    end
-
-    def should_track_page_view?
-      # Only track if @page_name is set
-      return false if @page_name.blank?
-
-      # Skip admin paths
-      return false if request.path.start_with?("/admin")
-
-      # Skip Turbo frame requests (optional - adjust based on needs)
-      return false if request.headers["Turbo-Frame"].present?
-
-      true
-    end
-  end
-end

data/app/controllers/concerns/ruby_cms/visitor_error_capture.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  # Include in ApplicationController to capture public-site errors to VisitorError.
-  # Skips admin controllers (paths under /admin) and development environment by default.
-  #
-  # Usage in ApplicationController:
-  #   include RubyCms::VisitorErrorCapture
-  #   rescue_from StandardError, with: :handle_visitor_error
-  #
-  # Or use the class method to add both:
-  #   RubyCms::VisitorErrorCapture.install(self)
-  module VisitorErrorCapture
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def install(controller_class)
-        controller_class.include RubyCms::VisitorErrorCapture
-        controller_class.rescue_from StandardError, with: :handle_visitor_error
-      end
-    end
-
-    private
-
-    def handle_visitor_error(exception)
-      return if skip_visitor_error_capture?
-
-      RubyCms::VisitorError.log_error(exception, request)
-    ensure
-      raise exception
-    end
-
-    def skip_visitor_error_capture?
-      return true if Rails.env.development?
-
-      false
-    end
-  end
-end

data/app/controllers/ruby_cms/admin/analytics_controller.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-require "ipaddr"
-
-module RubyCms
-  module Admin
-    class AnalyticsController < BaseController
-      before_action { require_permission!(:manage_analytics) }
-      before_action :set_date_range
-      before_action :validate_date_range
-
-      def index
-        report = RubyCms::Analytics::Report.new(
-          start_date: @start_date,
-          end_date: @end_date,
-          period: @period
-        )
-        @stats = report.dashboard_stats
-        @stats.each {|key, value| instance_variable_set(:"@#{key}", value) }
-        @active_users = active_users_count
-      end
-
-      def page_details
-        @page_name = sanitize_page_name(params[:page_name])
-        unless @page_name
-          return redirect_to ruby_cms_admin_analytics_path,
-                             alert: t("ruby_cms.admin.analytics.invalid_page_name",
-                                      default: "Invalid page name.")
-        end
-
-        report = RubyCms::Analytics::Report.new(
-          start_date: @start_date,
-          end_date: @end_date,
-          period: @period
-        )
-        data = report.page_stats(@page_name)
-        @page_views = data[:page_views]
-        @page_stats = data[:stats]
-      end
-
-      def visitor_details
-        @ip_address = sanitize_ip_address(params[:ip_address])
-        unless @ip_address
-          return redirect_to ruby_cms_admin_analytics_path,
-                             alert: t("ruby_cms.admin.analytics.invalid_ip_address",
-                                      default: "Invalid IP address.")
-        end
-
-        report = RubyCms::Analytics::Report.new(
-          start_date: @start_date,
-          end_date: @end_date,
-          period: @period
-        )
-        data = report.visitor_stats(@ip_address)
-        @visitor_views = data[:visitor_views]
-        @visitor_stats = data[:stats]
-      end
-
-      private
-
-      def set_date_range
-        @period = sanitize_period(params[:period]) || default_period
-
-        @start_date, @end_date = parsed_date_range || default_date_range
-      rescue Date::Error
-        @start_date, @end_date = fallback_date_range
-      end
-
-      def validate_date_range
-        max_days = RubyCms::Settings.get(:analytics_max_date_range_days, default: 365).to_i
-        return if valid_date_range?(max_days)
-
-        redirect_to ruby_cms_admin_analytics_path,
-                    alert: "Invalid date range. Maximum range is #{max_days} days."
-      end
-
-      def active_users_count
-        Ahoy::Event
-          .where(name: RubyCms::Analytics::Report::EVENT_PAGE_VIEW)
-          .where(time: 5.minutes.ago..)
-          .joins(:visit)
-          .distinct
-          .count(:visitor_token)
-      rescue StandardError
-        nil
-      end
-
-      def sanitize_period(value)
-        %w[day week month year].include?(value.to_s) ? value.to_s : nil
-      end
-
-      def default_period
-        RubyCms::Settings.get(:analytics_default_period, default: "week").to_s
-      rescue StandardError
-        "week"
-      end
-
-      def period_start_date(period, end_date)
-        case period
-        when "day" then end_date
-        when "week" then end_date - 6.days
-        when "month" then end_date - 29.days
-        else end_date - 364.days
-        end
-      end
-
-      def sanitize_page_name(page_name)
-        page_name.to_s.gsub(%r{[^a-zA-Z0-9_\-/]}, "").presence
-      end
-
-      def sanitize_ip_address(ip_address)
-        return nil if ip_address.blank?
-
-        IPAddr.new(ip_address)
-        ip_address
-      rescue IPAddr::InvalidAddressError
-        nil
-      end
-
-      helper_method :format_chart_date, :format_chart_date_short, :format_chart_date_axis
-
-      def format_chart_date(date_string)
-        format_chart_date_by_granularity(date_string, long: true)
-      rescue Date::Error
-        date_string.to_s
-      end
-
-      def format_chart_date_short(date_string)
-        format_chart_date_by_granularity(date_string, long: false)
-      rescue Date::Error
-        date_string.to_s
-      end
-
-      # Compact x-axis tick for daily chart (month view: day number only to avoid crowded labels)
-      def format_chart_date_axis(date_string)
-        date = Date.parse(date_string.to_s)
-        return date.day.to_s if @period == "month"
-
-        format_chart_date_short(date_string)
-      rescue Date::Error
-        date_string.to_s
-      end
-
-      def format_daily_date(date_string)
-        date = Date.parse(date_string.to_s)
-        if @period == "month"
-          end_date = [date + 2.days, @end_date].min
-          return "#{date.strftime('%b %d')} - #{end_date.strftime('%b %d')}" if date != end_date
-        end
-        date.strftime("%B %d, %Y")
-      end
-
-      def format_daily_date_short(date_string)
-        date = Date.parse(date_string.to_s)
-        if @period == "month"
-          end_date = [date + 2.days, @end_date].min
-          return "#{date.strftime('%m/%d')}-#{end_date.strftime('%m/%d')}" if date != end_date
-        end
-        date.strftime("%m/%d")
-      end
-
-      def parsed_date_range
-        return nil unless params[:start_date].present? && params[:end_date].present?
-
-        [
-          Date.parse(params[:start_date]),
-          Date.parse(params[:end_date])
-        ]
-      end
-
-      def default_date_range
-        end_date = Date.current
-        [period_start_date(@period, end_date), end_date]
-      end
-
-      def fallback_date_range
-        end_date = Date.current
-        [end_date - 6.days, end_date]
-      end
-
-      def valid_date_range?(max_days)
-        return false unless @end_date.between?(@start_date, Date.current)
-
-        (@end_date - @start_date).to_i <= max_days
-      end
-
-      def format_chart_date_by_granularity(date_string, long:)
-        str = date_string.to_s
-
-        if str.match?(/\A\d{4}-\d{2}-\d{2}\z/)
-          return long ? format_daily_date(str) : format_daily_date_short(str)
-        end
-
-        if str.match?(/\A\d{4}-\d{2}\z/)
-          format_monthly_date(str, long:)
-        elsif str.match?(/\A\d{2}\z/)
-          format_hourly_date(str, long:)
-        else
-          str
-        end
-      end
-
-      def format_monthly_date(date_string, long:)
-        date = Date.parse("#{date_string}-01")
-        long ? date.strftime("%B %Y") : date.strftime("%b")
-      end
-
-      def format_hourly_date(date_string, long:)
-        long ? "#{date_string}:00" : "#{date_string}h"
-      end
-    end
-  end
-end

data/app/controllers/ruby_cms/admin/base_controller.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module RubyCms
-  module Admin
-    # Base for all /admin controllers. Ensures authentication and permission enforcement.
-    # Inherits from the host's ApplicationController (or config.admin_base_controller).
-    # This layout must not be used for public pages.
-    class BaseController < Rails.application.config.ruby_cms.admin_base_controller.constantize
-      layout -> { Rails.application.config.ruby_cms.admin_layout.presence || "admin/admin" }
-      before_action :set_cms_locale
-      before_action :require_cms_access
-
-      rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
-
-      helper_method :current_user_cms, :require_permission!
-
-      # Expose the engine's route helpers (ruby_cms_admin_*_path) in controllers.
-      # The host's _routes does not expose the mounted engine's named routes to
-      # the engine's own controllers; we keep _routes as the host's for
-      # new_session_path, root_path, etc.
-      include RubyCms::Engine.routes.url_helpers
-
-      # Declare which registered page this controller serves.
-      # Looks up the permission from the nav_registry entry and sets a before_action.
-      # Usage: cms_page :backups (requires a matching register_page call with key: :backups)
-      def self.cms_page(key)
-        page_key = key.to_sym
-        before_action do
-          entry = RubyCms.nav_registry.find {|e| e[:key] == page_key }
-          if entry.nil?
-            if defined?(Rails.logger)
-              Rails.logger.warn("[RubyCMS] cms_page :#{page_key} has no matching register_page entry. " \
-                                "Only manage_admin is enforced.")
-            end
-          elsif entry[:permission].present?
-            require_permission!(entry[:permission].to_sym)
-          end
-        end
-      end
-
-      # Public API: dashboard block +data procs and host code may call this on the controller instance.
-      def current_user_cms
-        @current_user_cms ||= resolve_current_user
-      end
-
-      private
-
-      def resolve_current_user
-        if respond_to?(:current_user, true)
-          send(:current_user)
-        else
-          Rails.application.config.ruby_cms.current_user_resolver&.call(self)
-        end
-      end
-
-      def require_cms_access
-        ensure_authenticated
-        require_permission!(:manage_admin)
-      end
-
-      def ensure_authenticated
-        return if current_user_cms
-
-        if respond_to?(:require_authentication, true)
-          send(:require_authentication)
-        else
-          redirect_to cms_redirect_path, alert: t("ruby_cms.admin.base.authentication_required")
-        end
-      end
-
-      # Forbid (403) or redirect with flash. Default-deny: unknown permission = forbidden.
-      def require_permission!(permission_key, record: nil)
-        return if current_user_cms&.can?(permission_key, record:)
-
-        respond_to do |format|
-          format.html do
-            redirect_to(cms_redirect_path, alert: t("ruby_cms.admin.base.not_authorized"))
-          end
-          format.any { head :forbidden }
-        end
-      end
-
-      # Optional role gate. Example: before_action { require_role!(:admin) } in a subclass.
-      # Uses user.admin? when role is :admin (if the host's User responds to :admin?).
-      def require_role!(role)
-        return if current_user_cms.nil?
-        return if role == :admin && current_user_cms.respond_to?(:admin?) && current_user_cms.admin?
-
-        respond_to do |format|
-          format.html do
-            redirect_to cms_redirect_path, alert: t("ruby_cms.admin.base.not_authorized")
-          end
-          format.any { head :forbidden }
-        end
-      end
-
-      def cms_redirect_path
-        Rails.application.config.ruby_cms.unauthorized_redirect_path.presence || "/"
-      end
-
-      def render_not_found
-        render "ruby_cms/errors/not_found",
-               status: :not_found,
-               layout: Rails.application.config.ruby_cms.admin_layout.presence || "admin/admin"
-      end
-
-      def set_cms_locale
-        locale = session[:ruby_cms_locale].presence || session[:admin_locale].presence
-        return if locale.blank?
-
-        locale = locale.to_sym
-        return unless I18n.available_locales.include?(locale)
-
-        # Keep both session keys in sync for host app + engine controllers.
-        session[:ruby_cms_locale] = locale
-        session[:admin_locale] = locale
-        I18n.locale = locale
-      end
-
-      # Resolve parameter key for model params
-      # Checks if a specific key exists in params, otherwise falls back to model's param_key
-      # @param model_class [Class] The model class (e.g., ContentBlock)
-      # @param param_name [Symbol] The expected parameter name (e.g., :page)
-      # @return [Symbol] The resolved parameter key
-      def model_param_key(model_class, param_name)
-        params.key?(param_name) ? param_name : model_class.model_name.param_key.to_sym
-      end
-
-      public :current_user_cms
-    end
-  end
-end