ruby_cms 0.1.9 → 0.2.0

data/lib/generators/ruby_cms/admin_page_generator.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module Generators
+    class AdminPageGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path("templates/admin_page", __dir__)
+
+      class_option :permission, type: :string, default: nil,
+                                desc: "Permission key (default: manage_<name>)"
+      class_option :icon, type: :string, default: "folder",
+                          desc: "Named icon from RubyCms::Icons (e.g. archive_box, bell, clock). " \
+                                "Run RubyCms::Icons.available for the full list."
+      class_option :section, type: :string, default: "main",
+                             desc: "Navigation section: main or settings"
+      class_option :order, type: :numeric, default: 10,
+                           desc: "Sort order within the nav section"
+
+      def validate_options
+        raise ArgumentError, "--section must be 'main' or 'settings', got '#{section_name}'" unless %w[main settings].include?(section_name)
+
+        icon_sym = icon_name.to_sym
+        return if RubyCms::Icons::REGISTRY.key?(icon_sym)
+
+        say "Warning: icon '#{icon_name}' is not in RubyCms::Icons::REGISTRY. " \
+            "Available: #{RubyCms::Icons.available.join(', ')}", :yellow
+      end
+
+      def create_controller
+        template "controller.rb.tt",
+                 File.join("app/controllers/admin", "#{file_name}_controller.rb")
+      end
+
+      def create_view
+        template "index.html.erb.tt",
+                 File.join("app/views/admin", file_name, "index.html.erb")
+      end
+
+      def add_route
+        routes_path = Rails.root.join("config/routes.rb")
+        return unless routes_path.exist?
+
+        content = File.read(routes_path)
+        route_line = "    resources :#{plural_name}, only: [:index], controller: \"admin/#{file_name}\""
+
+        if content.include?("resources :#{plural_name}") && content.include?("admin/#{file_name}")
+          say "Route already exists, skipping.", :yellow
+          return
+        end
+
+        if content.match?(/namespace\s+:admin\s+do/)
+          inject_into_file routes_path.to_s, after: /namespace\s+:admin\s+do\s*\n/ do
+            "#{route_line}\n"
+          end
+        else
+          route <<~RUBY
+            namespace :admin do
+            #{route_line}
+            end
+          RUBY
+        end
+        say "Route: added admin/#{plural_name}", :green
+      end
+
+      def add_page_registration
+        pages_file = Rails.root.join("config/initializers/ruby_cms_pages.rb")
+
+        registration = register_page_code
+
+        if pages_file.exist?
+          content = File.read(pages_file)
+          if content.include?("key: :#{file_name}")
+            say "Page registration already exists, skipping.", :yellow
+            return
+          end
+          append_to_file pages_file.to_s, "\n#{registration}\n"
+        else
+          create_file pages_file.to_s, "# frozen_string_literal: true\n\n#{registration}\n"
+        end
+        say "Registered page :#{file_name} in config/initializers/ruby_cms_pages.rb", :green
+      end
+
+      def show_next_steps
+        say "\nAdmin page '#{file_name}' created.", :green
+        say "Next: rails ruby_cms:seed_permissions", :cyan
+      end
+
+      private
+
+      def permission_key
+        options[:permission].presence || "manage_#{file_name}"
+      end
+
+      def icon_name
+        options[:icon]
+      end
+
+      def section_name
+        options[:section]
+      end
+
+      def order_value
+        options[:order]
+      end
+
+      def path_helper_name
+        "admin_#{plural_name}_path"
+      end
+
+      def register_page_code
+        <<~RUBY
+          Rails.application.config.to_prepare do
+            RubyCms.register_page(
+              key: :#{file_name},
+              label: "#{human_name}",
+              path: :#{path_helper_name},
+              icon: :#{icon_name},
+              section: :#{section_name},
+              permission: :#{permission_key},
+              order: #{order_value}
+            )
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/generators/ruby_cms/templates/admin_page/controller.rb.tt

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Admin::<%= class_name %>Controller < RubyCms::Admin::BaseController
+  cms_page :<%= file_name %>
+
+  def index
+  end
+end

data/lib/generators/ruby_cms/templates/admin_page/index.html.erb.tt

@@ -0,0 +1,11 @@
+<%% content_for :title, "<%= human_name %>" %>
+
+<div class="px-4 py-6 sm:px-6 lg:px-8">
+  <div class="sm:flex sm:items-center sm:justify-between">
+    <h1 class="text-2xl font-bold text-gray-900"><%= human_name %></h1>
+  </div>
+
+  <div class="mt-6">
+    <p class="text-gray-500">Start building your <%= human_name.downcase %> page here.</p>
+  </div>
+</div>

data/lib/ruby_cms/dashboard_blocks.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Loaded from lib/ruby_cms.rb and from lib/ruby_cms/engine.rb so dashboard API exists even when
+# the host only requires "ruby_cms/engine" (without loading lib/ruby_cms.rb first).
+module RubyCms
+  mattr_accessor :dashboard_registry
+  self.dashboard_registry = []
+
+  # Register a dashboard block (stats row or main row). Host apps can add blocks or replace defaults by key.
+  def self.dashboard_register(
+    key:, label:, section:, order:, partial: nil, render: nil, permission: nil,
+    enabled: true, default_visible: true, span: :single, data: nil
+  )
+    normalized_key = key.to_sym
+    normalized_section = section.to_sym
+    raise ArgumentError, "section must be :stats or :main" unless %i[stats main].include?(normalized_section)
+
+    raise ArgumentError, "partial or render is required" if partial.blank? && !render.respond_to?(:call)
+
+    entry = {
+      key: normalized_key,
+      label: label.to_s,
+      section: normalized_section,
+      order: order.to_i,
+      partial: partial,
+      render: render,
+      permission: permission&.to_sym,
+      enabled: enabled ? true : false,
+      default_visible: default_visible ? true : false,
+      span: span.to_sym == :double ? :double : :single,
+      data: data
+    }
+
+    self.dashboard_registry = dashboard_registry.reject {|e| e[:key] == normalized_key }
+    self.dashboard_registry += [entry]
+
+    register_dashboard_setting!(entry)
+    entry
+  end
+
+  def self.visible_dashboard_blocks(user: nil)
+    dashboard_registry
+      .select {|e| e[:enabled] }
+      .select {|e| dashboard_block_visible?(e, user:) }
+      .sort_by {|e| [e[:section] == :stats ? 0 : 1, e[:order], e[:label]] }
+  rescue StandardError => e
+    Rails.logger.error("[RubyCMS] Error filtering dashboard blocks: #{e.message}") if defined?(Rails.logger)
+    []
+  end
+
+  class << self
+    private
+
+    def register_dashboard_setting!(entry)
+      RubyCms::SettingsRegistry.register(
+        key: :"dashboard_show_#{entry[:key]}",
+        type: :boolean,
+        default: entry.fetch(:default_visible, true),
+        category: :dashboard,
+        description: "Show #{entry[:label]} on the admin dashboard"
+      )
+    rescue StandardError => e
+      Rails.logger.warn("[RubyCMS] Failed to register dashboard setting for #{entry[:key]}: #{e.message}") if defined?(Rails.logger)
+    end
+
+    def dashboard_block_visible?(entry, user:)
+      return false unless setting_enabled_for_dashboard_block?(entry)
+      return false unless permission_allows_dashboard_block?(entry, user:)
+
+      true
+    end
+
+    def setting_enabled_for_dashboard_block?(entry)
+      pref_key = :"dashboard_show_#{entry[:key]}"
+      RubyCms::Settings.get(pref_key, default: entry.fetch(:default_visible, true))
+    rescue StandardError
+      entry.fetch(:default_visible, true)
+    end
+
+    def permission_allows_dashboard_block?(entry, user:)
+      permission_key = entry[:permission]
+      return true if permission_key.blank?
+      return false if user.nil?
+      return true unless user.respond_to?(:can?)
+
+      user.can?(permission_key)
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/ruby_cms/engine/admin_permissions.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module EngineAdminPermissions
+    def grant_admin_permissions_to_admin_users
+      return unless defined?(::User) && User.column_names.include?("admin")
+
+      permission_keys = RubyCms::Permission.all_keys
+      permissions = RubyCms::Permission.where(key: permission_keys).index_by(&:key)
+      User.where(admin: true).find_each do |u|
+        permission_keys.each do |key|
+          perm = permissions[key]
+          next if perm.nil?
+
+          RubyCms::UserPermission.find_or_create_by!(user: u, permission: perm)
+        end
+      end
+    end
+
+    def extract_email_from_args(args)
+      args[:email] || ENV["email"] || ENV.fetch("EMAIL", nil)
+    end
+
+    def validate_email_present(email)
+      return if email.present?
+
+      warn "Usage: rails ruby_cms:grant_manage_admin " \
+           "email=user@example.com"
+      raise "Email is required"
+    end
+
+    def find_user_by_email(email)
+      user_class = Rails.application.config.ruby_cms.user_class_name
+                        .constantize
+      find_user_by_email_address(user_class, email) ||
+        find_user_by_email_column(user_class, email)
+    end
+
+    def find_user_by_email_address(user_class, email)
+      return unless user_class.column_names.include?("email_address")
+
+      user_class.find_by(email_address: email)
+    end
+
+    def find_user_by_email_column(user_class, email)
+      return unless user_class.column_names.include?("email")
+
+      user_class.find_by(email:)
+    end
+
+    def validate_user_found(user, email)
+      return if user
+
+      warn "User not found: #{email}"
+      raise "User not found: #{email}"
+    end
+
+    def grant_manage_admin_permission(user, email)
+      RubyCms::Permission.ensure_defaults!
+      RubyCms::Permission.all_keys.each do |key|
+        perm = RubyCms::Permission.find_by(key:)
+        next unless perm
+
+        RubyCms::UserPermission.find_or_create_by!(user: user, permission: perm)
+      end
+      puts "Granted full admin permissions to #{email}" # rubocop:disable Rails/Output
+    end
+  end
+end

data/lib/ruby_cms/engine/content_blocks_tasks.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module EngineContentBlocksTasks
+    def parse_locales_dir(locales_dir_arg)
+      return nil unless locales_dir_arg.presence
+
+      Pathname.new(locales_dir_arg)
+    end
+
+    def parse_import_options
+      {
+        create_missing: ENV["create_missing"] != "false",
+        update_existing: ENV["update_existing"] != "false",
+        published: ENV["published"] == "true"
+      }
+    end
+
+    def display_export_summary(summary)
+      if summary.empty?
+        puts "No content blocks found to export." # rubocop:disable Rails/Output
+      else
+        puts "Exported content blocks to locale files:" # rubocop:disable Rails/Output
+        summary.each do |locale, count|
+          # rubocop:disable Rails/Output
+          puts "  #{locale}: #{count} block(s) updated " \
+               "in config/locales/#{locale}.yml"
+          # rubocop:enable Rails/Output
+        end
+      end
+    end
+
+    def display_import_summary(summary)
+      $stdout.puts "Import summary:"
+      $stdout.puts "  Created: #{summary[:created]}"
+      $stdout.puts "  Updated: #{summary[:updated]}"
+      $stdout.puts "  Skipped: #{summary[:skipped]}"
+      return unless summary[:errors].any?
+
+      $stdout.puts "  Errors:"
+      summary[:errors].each {|e| $stdout.puts "    - #{e}" }
+    end
+
+    def display_sync_summary(result, import_after)
+      display_export_results(result[:export])
+      display_import_results(result[:import], import_after) if import_after
+    end
+
+    def display_export_results(export_data)
+      $stdout.puts "Sync complete!"
+      $stdout.puts "\nExport summary:"
+      export_data.each do |locale, count|
+        $stdout.puts "  #{locale}: #{count} block(s) updated"
+      end
+    end
+
+    def display_import_results(import_data, import_after)
+      return unless import_after && import_data.any?
+
+      $stdout.puts "\nImport summary:"
+      $stdout.puts "  Created: #{import_data[:created]}"
+      $stdout.puts "  Updated: #{import_data[:updated]}"
+      $stdout.puts "  Skipped: #{import_data[:skipped]}"
+    end
+  end
+end

data/lib/ruby_cms/engine/css.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module EngineCss
+    def compile_admin_css(dest_path)
+      gem_root = begin
+        root
+      rescue StandardError
+        Pathname.new(File.expand_path("../..", __dir__))
+      end
+      RubyCms::CssCompiler.compile(gem_root, dest_path)
+    end
+  end
+end

data/lib/ruby_cms/engine/dashboard_registration.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module EngineDashboardRegistration
+    def register_default_dashboard_blocks
+      RubyCms.dashboard_register(
+        key: :content_blocks_stats,
+        label: "Content blocks",
+        section: :stats,
+        order: 1,
+        partial: "ruby_cms/admin/dashboard/blocks/content_blocks_stats",
+        permission: :manage_content_blocks
+      )
+      RubyCms.dashboard_register(
+        key: :users_stats,
+        label: "Users",
+        section: :stats,
+        order: 2,
+        partial: "ruby_cms/admin/dashboard/blocks/users_stats",
+        permission: :manage_permissions
+      )
+      RubyCms.dashboard_register(
+        key: :permissions_stats,
+        label: "Permissions",
+        section: :stats,
+        order: 3,
+        partial: "ruby_cms/admin/dashboard/blocks/permissions_stats",
+        permission: :manage_permissions
+      )
+      RubyCms.dashboard_register(
+        key: :visitor_errors_stats,
+        label: "Visitor errors",
+        section: :stats,
+        order: 4,
+        partial: "ruby_cms/admin/dashboard/blocks/visitor_errors_stats",
+        permission: :manage_visitor_errors
+      )
+      RubyCms.dashboard_register(
+        key: :quick_actions,
+        label: "Quick actions",
+        section: :main,
+        order: 1,
+        span: :single,
+        partial: "ruby_cms/admin/dashboard/blocks/quick_actions"
+      )
+      RubyCms.dashboard_register(
+        key: :recent_errors,
+        label: "Recent errors",
+        section: :main,
+        order: 2,
+        span: :single,
+        partial: "ruby_cms/admin/dashboard/blocks/recent_errors",
+        permission: :manage_visitor_errors
+      )
+      RubyCms.dashboard_register(
+        key: :analytics_overview,
+        label: "Analytics",
+        section: :main,
+        order: 3,
+        span: :single,
+        partial: "ruby_cms/admin/dashboard/blocks/analytics_overview",
+        permission: :manage_analytics
+      )
+    end
+  end
+end

data/lib/ruby_cms/engine/navigation_registration.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RubyCms
+  module EngineNavigationRegistration
+    def register_main_nav_items
+      RubyCms.register_page(
+        key: :dashboard,
+        label: "Dashboard",
+        path: lambda(&:ruby_cms_admin_root_path),
+        icon: :home,
+        permission: :manage_admin,
+        order: 1
+      )
+      RubyCms.register_page(
+        key: :visual_editor,
+        label: "Visual editor",
+        path: lambda(&:ruby_cms_admin_visual_editor_path),
+        icon: :pencil_square,
+        permission: :manage_content_blocks,
+        order: 2
+      )
+      RubyCms.register_page(
+        key: :content_blocks,
+        label: "Content blocks",
+        path: lambda(&:ruby_cms_admin_content_blocks_path),
+        icon: :document_duplicate,
+        permission: :manage_content_blocks,
+        order: 3
+      )
+    end
+
+    def register_settings_nav_items
+      RubyCms.register_page(
+        key: :analytics,
+        label: "Analytics",
+        path: lambda(&:ruby_cms_admin_analytics_path),
+        icon: :chart_bar,
+        section: :settings,
+        permission: :manage_analytics,
+        order: 1
+      )
+      RubyCms.register_page(
+        key: :permissions,
+        label: "Permissions",
+        path: lambda(&:ruby_cms_admin_permissions_path),
+        icon: :shield_check,
+        section: :settings,
+        permission: :manage_permissions,
+        order: 2
+      )
+      RubyCms.register_page(
+        key: :visitor_errors,
+        label: "Visitor errors",
+        path: lambda(&:ruby_cms_admin_visitor_errors_path),
+        icon: :exclamation_triangle,
+        section: :settings,
+        permission: :manage_visitor_errors,
+        order: 3
+      )
+      RubyCms.register_page(
+        key: :users,
+        label: "Users",
+        path: lambda(&:ruby_cms_admin_users_path),
+        icon: :user_group,
+        section: :settings,
+        permission: :manage_permissions,
+        order: 4
+      )
+      RubyCms.register_page(
+        key: :settings,
+        label: "Settings",
+        path: lambda(&:ruby_cms_admin_settings_path),
+        icon: :cog_6_tooth,
+        section: :settings,
+        permission: :manage_admin,
+        order: 5
+      )
+    end
+  end
+end