spina 2.0.2 → 2.1.0

data/lib/generators/spina/templates/config/initializers/themes/demo.rb

@@ -1,73 +1,72 @@
-::Spina::Theme.register do |theme|
+# Theme configuration file
+# ========================
+# This file is used for all theme configuration.
+# It's where you define everything that's editable in Spina CMS.
 
+Spina::Theme.register do |theme|
+  # All views are namespaced based on the theme's name
   theme.name = 'demo'
   theme.title = 'Demo theme'
 
-  theme.layout_parts = ['line', 'body']
+  # Parts 
+  # Define all editable parts you want to use in your view templates
+  # 
+  # Built-in part types:
+  # - Line
+  # - MultiLine
+  # - Text (Rich text editor)
+  # - Image
+  # - ImageCollection
+  # - Attachment
+  # - Option
+  # - Repeater
+  theme.parts = [
+    {name: 'repeater', title: "Repeater", part_type: "Spina::Parts::Repeater", parts: %w(line image headline)}, 
+    {name: 'line', title: "Line", part_type: "Spina::Parts::Line"}, 
+    {name: 'body', title: "Body", part_type: "Spina::Parts::Text"}, 
+    {name: "image_collection", title: "Image collection", part_type: "Spina::Parts::ImageCollection"}
+    {name: 'image', title: "Image", part_type: "Spina::Parts::Image"}, 
+    {name: 'headline', title: "Headline", part_type: "Spina::Parts::Line"}, 
+    {name: 'footer', title: "Footer", part_type: "Spina::Parts::Text"}
+  ]
 
-  # New config
-  theme.parts = [{
-    name: 'repeater',
-    title: "Repeater",
-    part_type: "Spina::Parts::Repeater",
-    parts: ['line', 'image', 'headline', 'image_collection']
-  }, {
-    name: 'line',
-    title: "Line",
-    part_type: "Spina::Parts::Line"
-  }, {
-    name: 'body',
-    title: "Body",
-    part_type: "Spina::Parts::Text"
-  }, {
-    name: "image_collection",
-    title: "Image collection",
-    part_type: "Spina::Parts::ImageCollection"
-  }, {
-    name: 'image',
-    title: "Image",
-    part_type: "Spina::Parts::Image"
-  }, {
-    name: 'headline',
-    title: "Headline",
-    part_type: "Spina::Parts::Line"
-  }, {
-    name: 'footer',
-    title: "Footer",
-    part_type: "Spina::Parts::Text"
-  }]
+  # View templates
+  # Every page has a view template stored in app/views/my_theme/pages/*
+  # You define which parts you want to enable for every view template
+  # by referencing them from the theme.parts configuration above.
+  theme.view_templates = [
+    {name: 'homepage', title: 'Homepage', parts: %w(headline body image_collection)}, 
+    {name: 'show', title: 'Default', parts: %w(body image repeater)}, 
+    {name: 'demo', title: 'Demo', parts: %w(body image_collection image repeater)}
+  ]
 
-  theme.view_templates = [{
-    name: 'homepage',
-    title: 'Homepage',
-    page_parts: [],
-    parts: ['headline', 'body', 'image_collection']
-  }, {
-    name: 'show',
-    title: 'Default',
-    usage: 'Use for your content',
-    page_parts: [],
-    parts: ['body', 'image', 'repeater']
-  }, {
-    name: 'demo',
-    title: 'Demo',
-    description: 'Contains examples of every page part',
-    page_parts: [],
-    parts: ['body', 'image_collection', 'image', 'repeater']
-  }]
-
-  theme.custom_pages = [{
-    name:           'homepage',
-    title:          'Homepage',
-    deletable:      false,
-    view_template:  'homepage'
-  }, {
-    name:           'demo',
-    title:          'Demo',
-    deletable:      true,
-    view_template:  'demo'
-  }]
+  # Custom pages
+  # Some pages should not be created by the user, but generated automatically.
+  # By naming them you can reference them in your code.
+  theme.custom_pages = [
+    {name: 'homepage', title: 'Homepage', deletable: false, view_template: 'homepage'}, 
+    {name: 'demo', title: 'Demo', deletable: true, view_template: 'demo'}
+  ]
+  
+  # Navigations (optional)
+  # If your project has multiple navigations, it can be useful to configure multiple
+  # navigations.
+  theme.navigations = [
+    {name: 'main', label: 'Main navigation'}
+  ]
+  
+  # Layout parts (optional)
+  # You can create global content that doesn't belong to one specific page. We call these layout parts.
+  # You only have to reference the name of the parts you want to have here.
+  theme.layout_parts = []
+  
+  # Resources (optional)
+  # Think of resources as a collection of pages. They are managed separately in Spina
+  # allowing you to separate these pages from the 'main' collection of pages.
+  theme.resources = [
+    {name: 'articles', label: "Articles", view_template: "article", slug: "articles"}
+  ]
 
+  # Plugins (optional)
   theme.plugins = ['reviews']
-
 end

data/lib/spina.rb

@@ -1,11 +1,14 @@
+require 'spina/importmap_helper'
 require 'spina/engine'
+require 'spina/admin_sectionable'
 require 'spina/railtie'
 require 'spina/plugin'
 require 'spina/theme'
+require 'spina/tailwind_purger'
 require 'spina/attr_json_spina_parts_model'
+require 'spina/attr_json_monkeypatch'
 
 module Spina
-
   include ActiveSupport::Configurable
 
   PARTS = []
@@ -15,9 +18,12 @@ module Spina
   config_accessor :backend_path, 
                   :frontend_parent_controller,
                   :disable_frontend_routes,
-                  :max_page_depth, 
+                  :max_page_depth,
                   :locales, 
-                  :embedded_image_size
+                  :embedded_image_size,
+                  :party_pooper,
+                  :tailwind_purge_content,
+                  :queues
 
   # Specify a backend path. Defaults to /admin.
   self.backend_path = 'admin'
@@ -31,10 +37,45 @@ module Spina
   self.max_page_depth = 5
 
   self.locales = [I18n.default_locale]
+  
+  # Queues
+  self.queues = ActiveSupport::InheritableOptions.new
+  
+  # Don't like confetti?
+  self.party_pooper = false
 
   # Images that are embedded in the Trix editor are resized to fit
   # You can optimize this for your website and go for a smaller (or larger) size
   # Default: 2000x2000px
-  self.embedded_image_size = "2000x2000>"
+  class << self
+    alias_method :config_original, :config
+    
+    def config
+      config_obj = self.config_original
+      
+      def config_obj.embedded_image_size=(image_size)
+        if image_size.is_a? String
+          ActiveSupport::Deprecation.warn("Spina embedded_image_size should be set to an array of arguments to be passed to the :resize_to_limit ImageProcessing macro. https://github.com/janko/image_processing/blob/master/doc/minimagick.md#resize_to_limit")
+        end
+        
+        self[:embedded_image_size] = image_size
+      end
+      
+      config_obj
+    end
+  end
+  
+  self.embedded_image_size = [2000, 2000]
+
+  
+  # Tailwind purging
+  # Spina will by default purge all unused Tailwind classes by scanning
+  # the files listed below. You probably don't want to override this in 
+  # your main app. Spina Plugins can add files to this array.
+  self.tailwind_purge_content = Spina::Engine.root.glob("app/views/**/*.*") + 
+                                Spina::Engine.root.glob("app/components/**/*.*") + 
+                                Spina::Engine.root.glob("app/helpers/**/*.*") + 
+                                Spina::Engine.root.glob("app/assets/javascripts/**/*.js") +
+                                Spina::Engine.root.glob("app/**/tailwind/custom.css")
 
 end

data/lib/spina/admin_sectionable.rb

@@ -0,0 +1,23 @@
+module Spina
+  module AdminSectionable 
+    extend ActiveSupport::Concern
+    
+    included do |base|
+      extend ClassMethods
+      
+      helper_method :admin_section
+      attr_accessor :admin_section
+    end
+    
+    module ClassMethods
+    
+      def admin_section(name)
+        before_action do |controller|
+          controller.send(:admin_section=, name.to_sym)
+        end
+      end
+      
+    end
+  
+  end
+end

data/lib/spina/attr_json_monkeypatch.rb

@@ -0,0 +1,28 @@
+module Spina
+  module AttrJsonMonkeypatch 
+    extend ActiveSupport::Concern
+    
+    included do |base|
+      extend ClassMethods
+    end
+    
+    module ClassMethods
+    
+      def attr_json_setter_monkeypatch(name)
+        # Ruby bug in 3.0.0 related to defined?(super) returning true
+        # https://github.com/jrochkind/attr_json/issues/112
+        if RUBY_VERSION == "3.0.0" && RUBY_PATCHLEVEL == 0
+          define_method("#{name}=") do |value|
+            # This next line is uncommented in the attr_json gem
+            # We don't care about super here, so let's just comment it for now
+            # super(value) if defined?(super)
+            attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
+            public_send(attribute_def.container_attribute)[attribute_def.store_key] = attribute_def.cast(value)
+          end
+        end
+      end
+      
+    end
+  
+  end
+end

data/lib/spina/engine.rb

@@ -1,19 +1,16 @@
-require 'haml-rails'
 require 'sass-rails'
-require 'coffee-rails'
-require 'jquery-rails'
-require 'turbolinks'
+require 'turbo-rails'
+require 'stimulus-rails'
 require 'ancestry'
 require 'breadcrumbs_on_rails'
 require 'kaminari'
 require 'mobility'
 require 'rack-rewrite'
-require 'jsonb_accessor'
 require 'attr_json'
+require 'view_component/engine'
 
 module Spina
   class Engine < ::Rails::Engine
-
     isolate_namespace Spina
 
     config.autoload_paths += %W( #{config.root}/lib )
@@ -36,5 +33,11 @@ module Spina
         Spina::Parts::Attachment
       )
     end
+
+    initializer "spina.helpers" do
+      Rails.application.config.assets.configure do |env|
+        env.context_class.class_eval { include Spina::ImportmapHelper }
+      end
+    end
   end
 end

data/lib/spina/importmap_helper.rb

@@ -0,0 +1,37 @@
+module Spina
+  module ImportmapHelper
+  
+    def spina_importmap_with_stimulus_from(*paths)
+      [ %("stimulus": "#{asset_path("stimulus/libraries/stimulus")}"), spina_importmap_from(*paths) ].reject(&:blank?).join(",\n")
+    end
+  
+    def spina_importmap_from(*paths, prepend: "spina")
+      Array(paths).flat_map do |path|
+        if (absolute_path = absolute_root_of(path)).exist?
+          find_javascript_files_in_tree(absolute_path).collect do |filename|
+            module_filename = filename.relative_path_from(absolute_path)
+            module_name     = importmap_module_name_from(module_filename)
+            module_path     = asset_path("#{prepend}/" + absolute_path.basename.join(module_filename).to_s)
+      
+            %("#{module_name}": "#{module_path}")
+          end
+        end
+      end.compact.join(",\n")
+    end
+  
+    private
+      
+      # Strip off the extension and any versioning data for an absolute module name.
+      def importmap_module_name_from(filename)
+        filename.basename.to_s.remove(filename.extname).split("@").first
+      end
+    
+      def find_javascript_files_in_tree(path)
+        Dir[path.join("**/*.js{,m}")].collect { |file| Pathname.new(file) }.select(&:file?)
+      end
+    
+      def absolute_root_of(path)
+        (pathname = Pathname.new(path)).absolute? ? pathname : Rails.root.join(path)
+      end
+  end
+end

data/lib/spina/plugin.rb

@@ -8,7 +8,13 @@ module Spina
       plugin_name = namespace
 
       klass = Class.new(::Spina::Setting) do
-        jsonb_accessor :preferences, class_settings
+        include AttrJson::Record
+        include Spina::AttrJsonMonkeypatch
+        
+        class_settings.each do |setting|
+          attr_json *setting, container_attribute: "preferences"
+          attr_json_setter_monkeypatch setting.first
+        end
 
         default_scope { where(plugin: "#{plugin_name}") }
       end

data/lib/spina/railtie.rb

@@ -2,7 +2,11 @@ module Spina
   class Railtie < Rails::Railtie
 
     initializer "spina.assets.precompile" do |app|
-      app.config.assets.precompile += %w(spina_manifest.js)
+      app.config.assets.precompile += %w(spina/manifest spina/importmap.json)
+    end
+    
+    ActiveSupport.on_load(:action_controller) do
+      ::ActionController::Base.send(:include, Spina::AdminSectionable)
     end
 
   end

data/lib/spina/tailwind_purger.rb

@@ -0,0 +1,147 @@
+# This TailwindPurger was originally written by DHH in the tailwindcss-rails gem
+# and is licensed under the following MIT License. This class has been edited
+# slightly to make it work with Spina's use case.
+# 
+# Copyright (c) 2020 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+class Spina::TailwindPurger
+  CLASS_NAME_PATTERN = /[:A-Za-z0-9_-]+[\.]*[\\\/:A-Za-z0-9_-]*/
+
+  CLASS_BREAK = /(?![-_a-z0-9\\])/i # `\b` for class selectors
+
+  COMMENT = /#{Regexp.escape "/*"}.*?#{Regexp.escape "*/"}/m
+  COMMENTS_AND_BLANK_LINES = /\A(?:^#{COMMENT}?[ \t]*(?:\n|\z)|[ \t]*#{COMMENT})+/
+
+  AT_RULE = /@[^{]+/
+  CLASSLESS_SELECTOR_GROUP = /[^.{]+/
+  CLASSLESS_BEGINNING_OF_BLOCK = /\A\s*(?:#{AT_RULE}|#{CLASSLESS_SELECTOR_GROUP})\{\n?/
+
+  SELECTOR_GROUP = /[^{]+/
+  BEGINNING_OF_BLOCK = /\A#{SELECTOR_GROUP}\{\n?/
+
+  PROPERTY_NAME = /[-_a-z0-9]+/i
+  PROPERTY_VALUE = /(?:[^;]|;\S)+/
+  PROPERTIES = /\A(?:\s*#{PROPERTY_NAME}:#{PROPERTY_VALUE};\n?)+/
+
+  END_OF_BLOCK = /\A\s*\}\n?/
+
+  attr_reader :keep_these_class_names
+
+  class << self
+    def purge(input, keeping_class_names_from_files:)
+      new(extract_class_names_from(keeping_class_names_from_files)).purge(input)
+    end
+
+    def extract_class_names(string)
+      string.scan(CLASS_NAME_PATTERN).uniq.sort!
+    end
+
+    def extract_class_names_from(files)
+      Array(files).flat_map { |file| extract_class_names(file.read) }.uniq.sort!
+    end
+
+    def escape_class_selector(class_name)
+      class_name.gsub(/\A\d|[^-_a-z0-9]/, '\\\\\0')
+    end
+  end
+
+  def initialize(keep_these_class_names)
+    @keep_these_class_names = keep_these_class_names
+  end
+
+  def purge(input)
+    conveyor = Conveyor.new(input)
+
+    until conveyor.done?
+      conveyor.discard(COMMENTS_AND_BLANK_LINES) \
+      or conveyor.conditionally_keep(PROPERTIES) { conveyor.staged_output.last != "" } \
+      or conveyor.conditionally_keep(END_OF_BLOCK) { not conveyor.staged_output.pop } \
+      or conveyor.stage_output(CLASSLESS_BEGINNING_OF_BLOCK) \
+      or conveyor.stage_output(BEGINNING_OF_BLOCK) { |match| purge_beginning_of_block(match.to_s) } \
+      or raise "infinite loop"
+    end
+
+    conveyor.output
+  end
+
+  private
+    def keep_these_selectors_pattern
+      @keep_these_selectors_pattern ||= begin
+        escaped_classes = @keep_these_class_names.map { |name| Regexp.escape self.class.escape_class_selector(name) }
+        /(?:\A|,)[^.,{]*(?:[.](?:#{escaped_classes.join("|")})#{CLASS_BREAK}[^.,{]*)*(?=[,{])/
+      end
+    end
+
+    def purge_beginning_of_block(string)
+      purged = string.scan(keep_these_selectors_pattern).join
+      unless purged.empty?
+        purged.sub!(/\A,\s*/, "")
+        purged.rstrip!
+        purged << " {\n"
+      end
+      purged
+    end
+
+    class Conveyor
+      attr_reader :output, :staged_output
+
+      def initialize(input, output = +"")
+        @input = input
+        @output = output
+        @staged_output = []
+      end
+
+      def consume(pattern)
+        match = pattern.match(@input)
+        @input = match.post_match if match
+        match
+      end
+      alias :discard :consume
+
+      def stage_output(pattern)
+        if match = consume(pattern)
+          string = block_given? ? (yield match) : match.to_s
+          @staged_output << string
+          string
+        end
+      end
+
+      def keep(pattern)
+        if match = consume(pattern)
+          string = block_given? ? (yield match) : match.to_s
+          @output << @staged_output.shift until @staged_output.empty?
+          @output << string
+          string
+        end
+      end
+
+      def conditionally_keep(pattern)
+        keep(pattern) do |match|
+          (yield match) ? match.to_s : (break "")
+        end
+      end
+
+      def done?
+        @input.empty?
+      end
+    end
+end