spina 1.1.4 → 2.0.1

data/app/controllers/spina/pages_controller.rb

@@ -1,20 +1,18 @@
-module Spina
-  class PagesController < Spina::ApplicationController
-    include Spina::Frontend
+class Spina::PagesController < Spina::ApplicationController
+  include Spina::Frontend
 
-    before_action :current_spina_user_can_view_page?, except: [:robots]
+  before_action :current_spina_user_can_view_page?, except: [:robots]
 
-    helper_method :page
+  helper_method :page
 
-    def homepage
-      render_with_template(page)
-    end
+  def homepage
+    render_with_template(page)
+  end
 
-    private
+  private
 
-      def current_spina_user_can_view_page?
-        raise ActiveRecord::RecordNotFound unless current_spina_user.present? || page.live?
-      end
+    def current_spina_user_can_view_page?
+      raise ActiveRecord::RecordNotFound unless current_spina_user.present? || page.live?
+    end
 
-  end
 end

data/app/controllers/spina/sitemaps_controller.rb

@@ -1,8 +1,8 @@
-module Spina
-  class SitemapsController < Spina::ApplicationController
-    def show
-      I18n.locale = I18n.default_locale
-      @pages = Page.live.sorted
-    end
+class Spina::SitemapsController < Spina::ApplicationController
+  
+  def show
+    I18n.locale = I18n.default_locale
+    @pages = Spina::Page.live.sorted
   end
+  
 end

data/app/helpers/spina/admin/pages_helper.rb

@@ -1,34 +1,36 @@
 module Spina
   module Admin
     module PagesHelper
-      def link_to_add_structure_item_fields(f, &block)
-        item = StructureItem.new
-        fields = f.fields_for(:structure_items, item, child_index: item.object_id) do |builder|
-          build_structure_parts(f.object.page_part.name, item)
-          render("spina/admin/structure_items/fields", f: builder)
+
+      def link_to_add_repeater_fields(f)
+        repeater_content = Spina::Parts::RepeaterContent.new(name: f.object.name, title: f.object.title)
+        fields = f.fields_for(:content, [repeater_content], child_index: repeater_content.object_id) do |builder|
+          render("spina/admin/parts/repeaters/fields", f: builder)
         end
-        link_to '#', class: "add_structure_item_fields button button-link", data: {id: item.object_id, fields: fields.gsub("\n", "")} do
+        link_to '#', class: "add_structure_item_fields button button-link", data: {id: repeater_content.object_id, fields: fields.gsub("\n", "")} do
           icon('plus')
         end
       end
 
-      def build_structure_parts(name, item)
-        structure = current_theme.structures.find { |structure| structure[:name] == name }
-        return item.parts unless structure.present?
-        structure[:structure_parts].map do |attributes|
-          part = item.parts.where(name: attributes[:name]).first_or_initialize(attributes)
-          part.partable = part.partable_type.constantize.new if part.partable.blank?
-          part.options = attributes[:options]
-          part
+      def data_attrs_for_image_collection(f)
+        image = Spina::Parts::Image.new
+        fields = f.fields_for(:images, [image], child_index: image.object_id) do |builder|
+          render("spina/admin/parts/image_collections/fields", f: builder)
         end
+        {fields: fields.gsub("\n", ""), id: image.object_id}
       end
 
-      def partable_partial_namespace(partable)
-        partable_type_partial_namespace(partable.model_name.to_s)
+      def build_parts(partable, parts)
+        I18n.with_locale(@locale) do
+          parts.map do |part|
+            part_attributes = current_theme.parts.find{|p|p[:name].to_s == part.to_s}
+            partable.part(part_attributes)
+          end
+        end
       end
 
-      def partable_type_partial_namespace(partable_type)
-        partable_type.tableize.sub(/\Aspina\//, '')
+      def parts_partial_namespace(part_type)
+        part_type.tableize.sub(/\Aspina\/parts\//, '')
       end
 
       def flatten_nested_hash(hash)
@@ -36,14 +38,14 @@ module Spina
       end
 
       def page_ancestry_options(page)
-        pages = Spina::Page.active.regular_pages
+        pages = Spina::Page.active.regular_pages.includes(:translations)
         pages = pages.where.not(id: page.subtree.ids) unless page.new_record? || !page.methods.include?(:subtree)
 
         (flatten_nested_hash(pages.arrange(order: :position)).map do |page|
           next if page.depth >= Spina.config.max_page_depth - 1
           page_menu_title = page.depth.zero? ? page.menu_title : " #{page.menu_title}".indent(page.depth, '-')
           [page_menu_title, page.id]
-        end << [page.parent&.menu_title, page&.parent_id].compact).uniq.compact
+        end << [page.parent&.menu_title, page&.parent_id].compact).map(&:presence).uniq.compact
       end
 
       def option_label(part, value)

data/app/helpers/spina/{files_helper.rb → attachments_helper.rb}

@@ -1,5 +1,5 @@
 module Spina
-  module FilesHelper
+  module AttachmentsHelper
 
     def file_url(file)
       main_app.rails_service_blob_path(file.signed_id, file.filename)

data/app/helpers/spina/images_helper.rb

@@ -1,24 +1,15 @@
 module Spina
   module ImagesHelper
 
-    # We wrap some Rails logic inside our own helper method
-    # because the resolve directive in ActiveStorage's routes
-    # doesn't work outside the main app in 5.2.0.rc2
-    def variant(image, options)
-      if image.attached? && image.variable?
-        variant = image.variant(options)
-        main_app.rails_blob_representation_path(variant.blob.signed_id, variant.variation.key, variant.blob.filename)
-      elsif image.image?
-        # Allows SVGs to be displayed as they are not variable. Requires:
-        # - https://github.com/Dreamersoul/administrate-field-active_storage/issues/36#issuecomment-608446819 to be applied
-        #
-        # Additionally, https://github.com/hopsoft/active_storage_svg_sanitizer/
-        # should be added if users are able to upload their own SVG content due to:
-        # https://github.com/rails/rails/issues/34665#issuecomment-445888009
-        main_app.url_for(image)
-      else
-        "https://placehold.it/100x100.png"
-      end
+    def thumbnail_url(image)
+      return "" if image.nil?
+      main_app.url_for(image.variant(resize: "400x300^", crop: "400x300+0+0"))
     end
+
+    def embedded_image_url(image)
+      return "" if image.nil?
+      main_app.url_for(image.variant(resize: Spina.config.embedded_image_size))
+    end
+
   end
 end

data/app/helpers/spina/pages_helper.rb

@@ -1,17 +1,36 @@
 module Spina
   module PagesHelper
 
-    def content(part_name)
-      current_page.content(part_name)
+    def content(part_name = nil)
+      Current.page.content(part_name)
     end
 
     def has_content?(part_name)
-      current_page.has_content?(part_name)
+      Current.page.has_content?(part_name)
+    end
+
+    def repeater(part)
+      part = Current.page.find_part(part)&.content unless part.is_a? Array
+      part&.each do |repeater_content|
+        repeater_content.view_context = self
+        yield(repeater_content)
+      end
+    end
+
+    def images(part)
+      part = Current.page.find_part(part)&.content unless part.is_a? Array
+      part&.each do |image|
+        yield(image)
+      end
     end
 
     def current_page
       Current.page
     end
 
+    def current_account
+      Current.account
+    end
+
   end
-end
+end

data/app/models/concerns/spina/partable.rb

@@ -2,23 +2,35 @@ module Spina
   module Partable
     extend ActiveSupport::Concern
 
+    attr_accessor :view_context
+
     included do
+
       def part(attributes)
-        part = parts.where(name: attributes[:name]).first_or_initialize(attributes)
-        part.partable = part.partable_type.constantize.new if part.partable.blank?
-        part.options = attributes[:options]
+        part = find_part(attributes[:name]) || attributes[:part_type].constantize.new
+
+        # Copy all attributes to part
+        %w(name title options).each do |attribute|
+          part.public_send("#{attribute}=", attributes[attribute.to_sym]) if part.respond_to?(attribute)
+        end
+
         part
       end
 
       def has_content?(name)
-        content(name).present?
+        find_part(name).present?
       end
 
-      def content(name)
-        part = parts.find_by(name: name)
-        part.try(:content)
+      def content(name = nil)
+        name ? find_part(name)&.content : content_presenter
       end
 
+      private
+
+        def content_presenter
+          @content_presenter ||= ContentPresenter.new(view_context, self)
+        end
+
     end
   end
 end

data/app/models/concerns/spina/translated_content.rb

@@ -0,0 +1,19 @@
+module Spina
+  module TranslatedContent
+    extend ActiveSupport::Concern
+
+    included do
+      
+      # Store each locale's content in [locale]_content as an array of parts
+      Spina.config.locales.each do |locale|
+        attr_json "#{locale}_content".to_sym, AttrJson::Type::SpinaPartsModel.new, array: true, default: -> { [] }
+        attr_json_accepts_nested_attributes_for "#{locale}_content".to_sym
+      end
+
+      def find_part(name)
+        send("#{I18n.locale}_content").find{|part| part.name.to_s == name.to_s}
+      end
+
+    end
+  end
+end

data/app/models/spina/account.rb

@@ -1,25 +1,18 @@
 module Spina
   class Account < ApplicationRecord
+    include AttrJson::Record
+    include AttrJson::NestedAttributes
     include Partable
+    include TranslatedContent
 
     serialize :preferences
 
-    has_many :layout_parts, dependent: :destroy
-    accepts_nested_attributes_for :layout_parts, allow_destroy: true
-
-    alias_attribute :layout_part, :part
-    alias_attribute :parts, :layout_parts
-
     after_save :bootstrap_website
 
     def to_s
       name
     end
 
-    def content(layout_part)
-      layout_parts.find_by(name: layout_part).try(:content)
-    end
-
     def self.serialized_attr_accessor(*args)
       args.each do |method_name|
         define_method method_name do

data/app/models/spina/attachment.rb

@@ -2,10 +2,6 @@ module Spina
   class Attachment < ApplicationRecord
     has_one_attached :file
 
-    has_one :page_part, as: :page_partable
-    has_many :structure_parts, as: :structure_partable
-    has_and_belongs_to_many :attachment_collections, join_table: 'spina_attachment_collections_attachments'
-
     attr_accessor :_destroy
 
     scope :sorted, -> { order('file ASC') }

data/app/models/spina/current.rb

@@ -1,5 +1,6 @@
 module Spina
   class Current < ActiveSupport::CurrentAttributes
     attribute :page
+    attribute :account
   end
 end

data/app/models/spina/image.rb

@@ -4,11 +4,7 @@ module Spina
 
     has_one_attached :file
 
-    has_many :page_parts, as: :page_partable
-    has_many :structure_parts, as: :structure_partable
-
     scope :sorted, -> { order('created_at DESC') }
-    scope :sorted_by_image_collection, -> { order('position') }
 
     def name
       file.try(:filename).to_s

data/app/models/spina/page.rb

@@ -1,16 +1,14 @@
 module Spina
   class Page < ApplicationRecord
     extend Mobility
+    include AttrJson::Record
+    include AttrJson::NestedAttributes
     include Partable
+    include TranslatedContent
 
     # Stores the old path when generating a new materialized_path
     attr_accessor :old_path
 
-    # Page contains multiple parts called PageParts
-    has_many :page_parts, dependent: :destroy, inverse_of: :page
-    alias_attribute :parts, :page_parts
-    accepts_nested_attributes_for :page_parts, allow_destroy: true
-
     # Orphaned pages are adopted by parent pages if available, otherwise become root
     has_ancestry orphan_strategy: :adopt
 
@@ -28,10 +26,12 @@ module Spina
     scope :live, -> { active.where(draft: false) }
     scope :in_menu, -> { where(show_in_menu: true) }
 
+    # Copy resource from parent
+    before_save :set_resource_from_parent, if: -> { parent.present? }
+
     # Save children to update all materialized_paths
     after_save :save_children
     after_save :touch_navigations
-    after_save -> { page_parts.each(&:save) }
 
     # Create a 301 redirect if materialized_path changed
     after_save :rewrite_rule
@@ -41,7 +41,7 @@ module Spina
 
     translates :title, fallbacks: true
     translates :description, :materialized_path
-    translates :menu_title, :seo_title, default: -> { title }
+    translates :menu_title, :seo_title, :url_title, default: -> { title }
 
     def to_s
       name
@@ -51,8 +51,8 @@ module Spina
       id
     end
 
-    def url_title
-      title.try(:parameterize)
+    def slug
+      url_title&.parameterize
     end
 
     def custom_page?
@@ -74,12 +74,17 @@ module Spina
     def next_sibling
       siblings.where('position > ?', position).sorted.first
     end
-
+    
     def set_materialized_path
       self.old_path = materialized_path
       self.materialized_path = localized_materialized_path
-      self.materialized_path = localized_materialized_path + "-#{Page.i18n.where(materialized_path: materialized_path).count}" if Page.i18n.where(materialized_path: materialized_path).where.not(id: id).count > 0
-      materialized_path
+      
+      # Append counter to duplicate materialized_path
+      i = 0
+      while duplicate_materialized_path?
+        i += 1
+        self.materialized_path = localized_materialized_path.concat("-#{i}")
+      end
     end
 
     def cache_key
@@ -91,12 +96,12 @@ module Spina
       theme.view_templates.find { |template| template[:name] == view_template_name }
     end
 
-    def view_template_page_parts(theme)
-      theme.page_parts.select { |page_part| page_part[:name].in? view_template_config(theme)[:page_parts] }
-    end
-
     private
 
+      def set_resource_from_parent
+        self.resource_id = parent.resource_id 
+      end
+
       def touch_navigations
         navigations.update_all(updated_at: Time.zone.now)
       end
@@ -114,11 +119,14 @@ module Spina
       end
 
       def generate_materialized_path
-        if root?
-          name == 'homepage' ? '' : "#{url_title}"
-        else
-          ancestors.collect(&:url_title).append(url_title).join('/')
-        end
+        path_fragments = [resource&.slug]
+        path_fragments.append *ancestors.collect(&:slug)
+        path_fragments.append(slug) unless name == 'homepage'
+        path_fragments.compact.map(&:parameterize).join('/')
+      end
+      
+      def duplicate_materialized_path?
+        self.class.where.not(id: id).i18n.where(materialized_path: materialized_path).exists?
       end
 
   end

data/app/models/spina/parts/attachment.rb

@@ -0,0 +1,22 @@
+module Spina
+  module Parts
+    class Attachment < Base
+      attr_json :attachment_id, :integer, default: nil
+      attr_json :signed_blob_id, :string, default: nil
+      attr_json :filename, :string, default: ""
+
+      def content
+        self
+      end
+
+      def present?
+        signed_blob_id.present?
+      end
+      
+      def signed_id
+        signed_blob_id
+      end
+      
+    end
+  end
+end