plum-cms 0.1.0

data/app/controllers/plum/cp/nav_items_controller.rb

@@ -0,0 +1,68 @@
+module Plum
+  module Cp
+    class NavItemsController < BaseController
+      before_action :set_nav_menu
+      before_action :set_nav_item, only: [ :edit, :update, :destroy ]
+      before_action :set_form_options, only: [ :new, :create, :edit, :update ]
+      before_action :require_editor, only: [ :new, :create, :edit, :update, :destroy ]
+
+      def new
+        @nav_item = @nav_menu.nav_items.build(site: current_site, position: next_position)
+      end
+
+      def create
+        @nav_item = @nav_menu.nav_items.build(nav_item_params)
+        @nav_item.site = current_site
+
+        if @nav_item.save
+          redirect_to cp_nav_menu_path(@nav_menu), notice: "Navigation item created"
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @nav_item.update(nav_item_params)
+          redirect_to cp_nav_menu_path(@nav_menu), notice: "Navigation item updated"
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @nav_item.destroy
+        redirect_to cp_nav_menu_path(@nav_menu), notice: "Navigation item deleted"
+      end
+
+      private
+
+      def set_nav_menu
+        @nav_menu = current_site.nav_menus.find(params[:nav_menu_id])
+      end
+
+      def set_nav_item
+        @nav_item = @nav_menu.nav_items.find(params[:id])
+      end
+
+      def set_form_options
+        @entries = current_site.entries.includes(:content_type).order(:title)
+        @parent_options = @nav_menu.nav_items.where.not(id: @nav_item&.id).includes(:entry).order(:position, :label)
+      end
+
+      def next_position
+        @nav_menu.nav_items.maximum(:position).to_i + 1
+      end
+
+      def nav_item_params
+        permitted = params.require(:nav_item).permit(:label, :url, :entry_id, :parent_id, :position)
+        permitted[:entry_id] = nil if permitted[:entry_id].blank?
+        permitted[:parent_id] = nil if permitted[:parent_id].blank?
+        permitted[:position] = next_position if permitted[:position].blank?
+        permitted
+      end
+    end
+  end
+end

data/app/controllers/plum/cp/nav_menus_controller.rb

@@ -0,0 +1,56 @@
+module Plum
+  module Cp
+    class NavMenusController < BaseController
+      before_action :set_nav_menu, only: [ :show, :edit, :update, :destroy ]
+      before_action :require_editor, only: [ :new, :create, :edit, :update, :destroy ]
+
+      def index
+        @nav_menus = current_site.nav_menus.includes(:nav_items).order(:name)
+      end
+
+      def show
+        @nav_items = @nav_menu.root_items.includes(:entry, children: :entry)
+      end
+
+      def new
+        @nav_menu = current_site.nav_menus.build
+      end
+
+      def create
+        @nav_menu = current_site.nav_menus.build(nav_menu_params)
+
+        if @nav_menu.save
+          redirect_to cp_nav_menu_path(@nav_menu), notice: "Navigation menu created"
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @nav_menu.update(nav_menu_params)
+          redirect_to cp_nav_menu_path(@nav_menu), notice: "Navigation menu updated"
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @nav_menu.destroy
+        redirect_to cp_nav_menus_path, notice: "Navigation menu deleted"
+      end
+
+      private
+
+      def set_nav_menu
+        @nav_menu = current_site.nav_menus.find(params[:id])
+      end
+
+      def nav_menu_params
+        params.require(:nav_menu).permit(:name, :handle)
+      end
+    end
+  end
+end

data/app/controllers/plum/cp/site_settings_controller.rb

@@ -0,0 +1,87 @@
+module Plum
+  module Cp
+    class SiteSettingsController < BaseController
+      helper_method :theme_setting_input_id,
+        :theme_setting_input_name,
+        :theme_setting_value,
+        :theme_setting_checked?
+
+      before_action :set_site_settings
+      before_action :set_theme_options
+      before_action :require_admin, only: [ :edit, :update ]
+
+      def show
+        redirect_to edit_cp_site_settings_path
+      end
+
+      def edit
+      end
+
+      def update
+        settings_attributes = site_settings_params
+        theme_settings_by_theme = settings_attributes.delete(:theme_settings_by_theme).to_h
+        @site_settings.assign_attributes(settings_attributes)
+
+        if @site_settings.save
+          current_site.update!(theme_settings: theme_settings_for(@site_settings.theme_name, theme_settings_by_theme))
+          redirect_to edit_cp_site_settings_path, notice: "Site settings updated"
+        else
+          set_theme_options
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      private
+
+      def set_site_settings
+        @site_settings = SiteSetting.instance(current_site)
+      end
+
+      def set_theme_options
+        registry = ThemeRegistry.new
+        @themes = registry.all
+        @current_theme = registry.fetch(@site_settings.theme_name)
+      end
+
+      def theme_settings_for(theme_name, theme_settings_by_theme)
+        theme = ThemeRegistry.new.fetch(theme_name)
+        raw_settings = theme_settings_by_theme[theme.handle] || {}
+        ThemeSettingsParams.new(theme).normalize(raw_settings)
+      end
+
+      def theme_setting_input_id(theme, field)
+        "theme_settings_#{theme.handle.parameterize}_#{field['handle'].to_s.parameterize}"
+      end
+
+      def theme_setting_input_name(theme, field)
+        "site_setting[theme_settings_by_theme][#{theme.handle}][#{field['handle']}]"
+      end
+
+      def theme_setting_value(field)
+        settings = current_site.theme_settings.to_h
+        handle = field["handle"].to_s
+
+        settings.key?(handle) ? settings[handle] : field["default"]
+      end
+
+      def theme_setting_checked?(field)
+        ActiveModel::Type::Boolean.new.cast(theme_setting_value(field))
+      end
+
+      def site_settings_params
+        params.require(:site_setting).permit(
+          :name,
+          :tagline,
+          :logo,
+          :favicon,
+          :seo_title,
+          :seo_description,
+          :primary_color,
+          :support_email,
+          :theme_name,
+          theme_settings_by_theme: {}
+        )
+      end
+    end
+  end
+end

data/app/controllers/plum/cp/taxonomies_controller.rb

@@ -0,0 +1,56 @@
+module Plum
+  module Cp
+    class TaxonomiesController < BaseController
+      before_action :set_taxonomy, only: [ :show, :edit, :update, :destroy ]
+      before_action :require_admin, only: [ :new, :create, :edit, :update, :destroy ]
+
+      def index
+        @taxonomies = current_site.taxonomies.order(:name)
+      end
+
+      def show
+        @terms = @taxonomy.terms.ordered
+      end
+
+      def new
+        @taxonomy = current_site.taxonomies.build
+      end
+
+      def create
+        @taxonomy = current_site.taxonomies.build(taxonomy_params)
+
+        if @taxonomy.save
+          redirect_to "#{cp_prefix}/taxonomies/#{@taxonomy.id}", notice: "Taxonomy created"
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @taxonomy.update(taxonomy_params)
+          redirect_to "#{cp_prefix}/taxonomies/#{@taxonomy.id}", notice: "Taxonomy updated"
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @taxonomy.destroy
+        redirect_to "#{cp_prefix}/taxonomies", notice: "Taxonomy deleted"
+      end
+
+      private
+
+      def set_taxonomy
+        @taxonomy = current_site.taxonomies.find(params[:id])
+      end
+
+      def taxonomy_params
+        params.require(:taxonomy).permit(:name, :handle, :slug)
+      end
+    end
+  end
+end

data/app/controllers/plum/cp/terms_controller.rb

@@ -0,0 +1,55 @@
+module Plum
+  module Cp
+    class TermsController < BaseController
+      before_action :set_taxonomy
+      before_action :set_term, only: [ :edit, :update, :destroy ]
+      before_action :require_admin, only: [ :new, :create, :edit, :update, :destroy ]
+
+      def new
+        @term = @taxonomy.terms.build(site: current_site)
+      end
+
+      def create
+        @term = @taxonomy.terms.build(term_params)
+        @term.site = current_site
+        @term.position = @taxonomy.terms.maximum(:position).to_i + 1
+
+        if @term.save
+          redirect_to "#{cp_prefix}/taxonomies/#{@taxonomy.id}", notice: "Term created"
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @term.update(term_params)
+          redirect_to "#{cp_prefix}/taxonomies/#{@taxonomy.id}", notice: "Term updated"
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @term.destroy
+        redirect_to "#{cp_prefix}/taxonomies/#{@taxonomy.id}", notice: "Term deleted"
+      end
+
+      private
+
+      def set_taxonomy
+        @taxonomy = current_site.taxonomies.find(params[:taxonomy_id])
+      end
+
+      def set_term
+        @term = @taxonomy.terms.find(params[:id])
+      end
+
+      def term_params
+        params.require(:term).permit(:name, :slug)
+      end
+    end
+  end
+end

data/app/controllers/plum/cp/theme_previews_controller.rb

@@ -0,0 +1,27 @@
+module Plum
+  module Cp
+    class ThemePreviewsController < BaseController
+      def show
+        theme = ThemeRegistry.new.find(params[:handle])
+        return render file: Rails.public_path.join("404.html"), status: :not_found, layout: false unless theme
+
+        context = LiquidContext.new(
+          controller: self,
+          site: current_site,
+          theme_name: theme.handle,
+          theme_settings: preview_theme_settings(theme)
+        )
+
+        html = LiquidRenderer.render_template("index", context.to_h)
+        render html: html.html_safe, layout: false
+      end
+
+      private
+
+      def preview_theme_settings(theme)
+        raw_settings = params.fetch(:theme_settings, {}).permit!.to_h if params[:theme_settings].respond_to?(:permit!)
+        ThemeSettingsParams.new(theme).normalize(raw_settings.presence || current_site.theme_settings)
+      end
+    end
+  end
+end

data/app/controllers/plum/cp/themes_controller.rb

@@ -0,0 +1,98 @@
+module Plum
+  module Cp
+    class ThemesController < BaseController
+      helper_method :theme_screenshot_url,
+        :theme_initials,
+        :theme_setting_input_id,
+        :theme_setting_input_name,
+        :theme_setting_value,
+        :theme_setting_checked?
+
+      before_action :set_themes
+      before_action :require_admin, only: [ :create, :update ]
+
+      def index
+      end
+
+      def create
+        installer = ThemePackageInstaller.new(params[:theme_package])
+
+        if installer.install
+          redirect_to cp_themes_path, notice: "Theme installed"
+        else
+          @theme_package_errors = installer.errors
+          render :index, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        theme = ThemeRegistry.new.find(params[:id])
+
+        if theme
+          site_settings.update!(theme_name: theme.handle)
+          current_site.update!(
+            theme_name: theme.handle,
+            theme_settings: ThemeSettingsParams.new(theme).normalize(theme_settings_params_for(theme))
+          )
+          redirect_to cp_themes_path, notice: theme_update_notice(theme)
+        else
+          redirect_to cp_themes_path, alert: "Theme not found"
+        end
+      end
+
+      private
+
+      def set_themes
+        registry = ThemeRegistry.new
+
+        @themes = registry.all
+        @active_theme = registry.fetch(site_settings.theme_name)
+      end
+
+      def theme_screenshot_url(theme)
+        return if theme.screenshot_path.blank?
+
+        theme_asset_path(theme.handle, theme.screenshot_path)
+      end
+
+      def theme_initials(theme)
+        theme.name.split.first(2).map { |part| part.first.to_s.upcase }.join.presence || theme.handle.first.to_s.upcase
+      end
+
+      def theme_setting_input_id(theme, field)
+        "theme_settings_#{theme.handle.parameterize}_#{field['handle'].to_s.parameterize}"
+      end
+
+      def theme_setting_input_name(field)
+        "theme_settings[#{field['handle']}]"
+      end
+
+      def theme_setting_value(field)
+        settings = current_site.theme_settings.to_h
+        handle = field["handle"].to_s
+
+        settings.key?(handle) ? settings[handle] : field["default"]
+      end
+
+      def theme_setting_checked?(field)
+        ActiveModel::Type::Boolean.new.cast(theme_setting_value(field))
+      end
+
+      def theme_settings_params_for(theme)
+        raw_settings = params[:theme_settings].respond_to?(:permit!) ? params[:theme_settings].permit!.to_h : nil
+        return raw_settings if raw_settings
+        return current_site.theme_settings if current_site.theme_name == theme.handle
+
+        {}
+      end
+
+      def theme_update_notice(theme)
+        params[:theme_settings].present? && current_site.theme_name == theme.handle ? "Theme settings updated" : "Theme activated"
+      end
+
+      def site_settings
+        @site_settings ||= SiteSetting.instance(current_site)
+      end
+    end
+  end
+end

data/app/controllers/plum/form_submissions_controller.rb

@@ -0,0 +1,44 @@
+module Plum
+  class FormSubmissionsController < ApplicationController
+    def create
+      form_definition = current_site.form_definitions.find_by!(handle: params[:handle])
+      submission = form_definition.form_submissions.build(
+        site: current_site,
+        data: submission_data(form_definition)
+      )
+
+      if submission.save
+        deliver_submission_notification(submission)
+        redirect_to safe_return_path, notice: "Form submitted"
+      else
+        redirect_to safe_return_path, alert: submission.errors.full_messages.to_sentence
+      end
+    end
+
+    private
+
+    def deliver_submission_notification(submission)
+      return if submission.form_definition.notification_email.blank?
+
+      Plum::FormMailer.submission_notification(submission).deliver_later
+    rescue StandardError => e
+      Rails.logger.error("[Plum] form notification could not be enqueued: #{e.message}")
+    end
+
+    def submission_data(form_definition)
+      raw_data = params.dig(:form_submission, :data)
+      data = raw_data.respond_to?(:permit!) ? raw_data.permit!.to_h : {}
+
+      form_definition.field_handles.index_with { |handle| data[handle] }
+    end
+
+    def safe_return_path
+      return root_path unless params[:return_to].is_a?(String)
+
+      return_to = params[:return_to]
+      return root_path if return_to.blank? || return_to.start_with?("//") || return_to.match?(%r{\A[a-z][a-z0-9+.-]*://}i)
+
+      return_to
+    end
+  end
+end

data/app/controllers/plum/pages_controller.rb

@@ -0,0 +1,161 @@
+module Plum
+  class PagesController < ApplicationController
+    HOMEPAGE_SLUG = "home".freeze
+
+    def home
+      @site_settings = SiteSetting.instance(current_site)
+      @entry = Entry.for_site(current_site).live
+                    .includes(:content_type, terms: :taxonomy)
+                    .find_by(slug: HOMEPAGE_SLUG)
+
+      template = @entry ? "entries/#{@entry.content_type.handle}" : "index"
+      html = Plum::LiquidRenderer.render_template(template, build_context(@entry).to_h)
+      render html: html.html_safe, layout: false
+    end
+
+    def search
+      query = params[:q].to_s.strip
+      context = build_context
+      results = Entry.for_site(current_site).live.search(query)
+                     .includes(:content_type)
+                     .order(published_at: :desc)
+                     .limit(50)
+
+      context_hash = context.to_h.merge(
+        "search" => {
+          "query" => query,
+          "results" => results.map { |e| context.send(:entry_context, e) },
+          "total" => results.size
+        }
+      )
+      html = Plum::LiquidRenderer.render_template("search", context_hash)
+      render html: html.html_safe, layout: false
+    end
+
+    def show
+      slug = params[:slug]
+
+      @content_type = ContentType.for_site(current_site).find_by(handle: slug)
+      if @content_type
+        return render_collection(@content_type)
+      end
+
+      if slug.include?("/")
+        parts = slug.split("/", 2)
+        content_type = ContentType.for_site(current_site).find do |candidate|
+          candidate.route_prefix == parts[0]
+        end
+        if content_type
+          @entry = Entry.for_site(current_site).live
+                        .includes(:content_type, terms: :taxonomy)
+                        .find_by!(content_type: content_type, slug: parts[1])
+          html = Plum::LiquidRenderer.render_template("entries/#{content_type.handle}", build_context(@entry).to_h)
+          return render html: html.html_safe, layout: false
+        end
+
+        taxonomy = Taxonomy.for_site(current_site).find_by(slug: parts[0])
+        if taxonomy
+          term = taxonomy.terms.find_by!(slug: parts[1])
+          return render_term_page(taxonomy, term)
+        end
+      else
+        taxonomy = Taxonomy.for_site(current_site).find_by(slug: slug)
+        return render_taxonomy_index(taxonomy) if taxonomy
+      end
+
+      @entry = Entry.for_site(current_site).live
+                    .includes(:content_type, terms: :taxonomy)
+                    .find_by!(slug: slug)
+      template = "entries/#{@entry.content_type.handle}"
+      html = Plum::LiquidRenderer.render_template(template, build_context(@entry).to_h)
+      render html: html.html_safe, layout: false
+    rescue ActiveRecord::RecordNotFound
+      render file: Rails.public_path.join("404.html"), status: :not_found, layout: false
+    end
+
+    private
+
+    PER_PAGE = 12
+
+    def render_collection(content_type)
+      context = build_context
+      page = [ params.fetch(:page, 1).to_i, 1 ].max
+      all_entries = Entry.for_site(current_site).live
+                        .where(content_type: content_type)
+                        .order(published_at: :desc, created_at: :desc)
+      total = all_entries.count
+      total_pages = (total / PER_PAGE.to_f).ceil
+      page = [ page, [ total_pages, 1 ].max ].min
+      entries = all_entries.offset((page - 1) * PER_PAGE).limit(PER_PAGE)
+
+      context_hash = context.to_h.merge(
+        "collection" => {
+          "title" => content_type.name,
+          "handle" => content_type.handle,
+          "entries" => entries.map { |e| context.send(:entry_context, e) }
+        },
+        "pagination" => {
+          "current_page" => page,
+          "total_pages" => total_pages,
+          "total_entries" => total,
+          "per_page" => PER_PAGE,
+          "previous_url" => page > 1 ? "#{request.path}?page=#{page - 1}" : nil,
+          "next_url" => page < total_pages ? "#{request.path}?page=#{page + 1}" : nil
+        }
+      )
+      template = "collections/#{content_type.handle}"
+      html = Plum::LiquidRenderer.render_template(template, context_hash)
+      render html: html.html_safe, layout: false
+    end
+
+    def render_term_page(taxonomy, term)
+      context = build_context
+      page = [ params.fetch(:page, 1).to_i, 1 ].max
+      all_entries = Entry.for_site(current_site).live
+                        .joins(:entry_terms)
+                        .where(plum_entry_terms: { term_id: term.id })
+                        .order(published_at: :desc)
+      total = all_entries.count
+      total_pages = [ (total / PER_PAGE.to_f).ceil, 1 ].max
+      page = [ page, total_pages ].min
+      entries = all_entries.offset((page - 1) * PER_PAGE).limit(PER_PAGE)
+
+      context_hash = context.to_h.merge(
+        "taxonomy" => { "name" => taxonomy.name, "handle" => taxonomy.handle, "slug" => taxonomy.slug },
+        "term" => { "name" => term.name, "slug" => term.slug },
+        "collection" => {
+          "title" => "#{taxonomy.name}: #{term.name}",
+          "entries" => entries.map { |e| context.send(:entry_context, e) }
+        },
+        "pagination" => {
+          "current_page" => page, "total_pages" => total_pages, "total_entries" => total, "per_page" => PER_PAGE,
+          "previous_url" => page > 1 ? "#{request.path}?page=#{page - 1}" : nil,
+          "next_url" => page < total_pages ? "#{request.path}?page=#{page + 1}" : nil
+        }
+      )
+      template = "taxonomies/#{taxonomy.handle}"
+      html = Plum::LiquidRenderer.render_template(template, context_hash)
+      render html: html.html_safe, layout: false
+    end
+
+    def render_taxonomy_index(taxonomy)
+      context = build_context
+      terms = taxonomy.terms.ordered
+      context_hash = context.to_h.merge(
+        "taxonomy" => {
+          "name" => taxonomy.name,
+          "handle" => taxonomy.handle,
+          "slug" => taxonomy.slug,
+          "terms" => terms.map { |t| { "name" => t.name, "slug" => t.slug, "url" => "/#{taxonomy.slug}/#{t.slug}", "entries_count" => t.entries.live.count } }
+        }
+      )
+      template = "taxonomies/#{taxonomy.handle}_index"
+      html = Plum::LiquidRenderer.render_template(template, context_hash)
+      render html: html.html_safe, layout: false
+    end
+
+    def build_context(entry = nil)
+      LiquidContext.new(controller: self, site: current_site, entry: entry)
+    end
+  end
+end

data/app/controllers/plum/sessions_controller.rb

@@ -0,0 +1,25 @@
+module Plum
+  class SessionsController < ApplicationController
+    layout "plum/session"
+
+    def new
+      redirect_to cp_root_path if logged_in?
+    end
+
+    def create
+      user = Plum::User.find_by(email: params[:email])
+      if user&.authenticate(params[:password])
+        session[:plum_user_id] = user.id
+        redirect_to cp_root_path, notice: "Welcome back!"
+      else
+        flash.now[:alert] = "Invalid email or password"
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      session[:plum_user_id] = nil
+      redirect_to login_path, notice: "You have been logged out"
+    end
+  end
+end

data/app/controllers/plum/theme_assets_controller.rb

@@ -0,0 +1,14 @@
+require "rack/mime"
+
+module Plum
+  class ThemeAssetsController < ApplicationController
+    def show
+      asset_path = ThemeResolver.new.find_asset(params[:theme_handle], params[:path])
+      return head :not_found unless asset_path
+
+      send_file asset_path,
+        type: Rack::Mime.mime_type(asset_path.extname, "application/octet-stream"),
+        disposition: "inline"
+    end
+  end
+end