spina 2.0.2 → 2.3.0

data/lib/spina.rb

@@ -1,40 +1,87 @@
 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'
+require 'spina/authentication/sessions'
+require 'spina/authentication/basic'
 
 module Spina
-
   include ActiveSupport::Configurable
 
   PARTS = []
   PLUGINS = []
   THEMES = []
 
-  config_accessor :backend_path, 
+  config_accessor :api_key,
+                  :api_path,
+                  :authentication,
+                  :backend_path, 
+                  :importmap,
                   :frontend_parent_controller,
                   :disable_frontend_routes,
-                  :max_page_depth, 
+                  :disable_decorator_load,
                   :locales, 
-                  :embedded_image_size
+                  :embedded_image_size,
+                  :thumbnail_image_size,
+                  :party_pooper,
+                  :tailwind_purge_content,
+                  :queues,
+                  :transliterations
 
-  # Specify a backend path. Defaults to /admin.
+  # Defaults
+  self.api_key = nil
+  self.api_path = "api"
+  self.authentication = "Spina::Authentication::Sessions"
   self.backend_path = 'admin'
-  
-  # The parent controller all frontend Spina controllers inherit from
-  # Default is ApplicationController
-  self.frontend_parent_controller = "ApplicationController"
-
   self.disable_frontend_routes = false
-
-  self.max_page_depth = 5
-
+  self.disable_decorator_load = false
+  self.embedded_image_size = [2000, 2000]
+  self.thumbnail_image_size = [400, 400]
+  self.frontend_parent_controller = "ApplicationController"
   self.locales = [I18n.default_locale]
+  self.party_pooper = false
+  self.transliterations = %i(latin)
+  
+  # Queues for background jobs
+  # - config.queues.page_updates
+  self.queues = ActiveSupport::InheritableOptions.new
+  
+  # An importmap specifically meant for Spina
+  self.importmap = ActiveSupport::OrderedOptions.new
+  self.importmap.paths = Importmap::Paths.new
+    
+  # 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")
 
   # 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
 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/authentication/basic.rb

@@ -0,0 +1,24 @@
+module Spina
+  module Authentication
+    module Basic
+      extend ActiveSupport::Concern
+      
+      included do
+        helper_method :logged_in?
+      end
+      
+      def logged_in?
+        authenticate
+      end
+      
+      private
+      
+        def authenticate
+          authenticate_or_request_with_http_basic do |username, password|
+            username == Rails.application.credentials.dig(:spina, :username) && password == Rails.application.credentials.dig(:spina, :password)
+          end
+        end
+    
+    end
+  end
+end

data/lib/spina/authentication/sessions.rb

@@ -0,0 +1,32 @@
+module Spina
+  module Authentication
+    module Sessions
+      extend ActiveSupport::Concern
+      
+      included do
+        helper_method :current_spina_user
+        helper_method :logged_in?
+        helper_method :logout_path
+      end
+      
+      def current_spina_user
+        Spina::Current.user ||= User.find_by(id: session[:spina_user_id]) if session[:spina_user_id]
+      end
+      
+      def logged_in?
+        current_spina_user
+      end
+      
+      def logout_path
+        spina.admin_logout_path
+      end
+      
+      private
+      
+        def authenticate
+          redirect_to admin_login_path, flash: {information: I18n.t('spina.notifications.login')} unless logged_in?
+        end
+    
+    end
+  end
+end

data/lib/spina/engine.rb

@@ -1,27 +1,29 @@
-require 'haml-rails'
 require 'sass-rails'
-require 'coffee-rails'
-require 'jquery-rails'
-require 'turbolinks'
+require 'importmap-rails'
+require 'turbo-rails'
+require 'stimulus-rails'
 require 'ancestry'
 require 'breadcrumbs_on_rails'
 require 'kaminari'
 require 'mobility'
 require 'rack-rewrite'
-require 'jsonb_accessor'
+require 'babosa'
 require 'attr_json'
+require 'view_component/engine'
+require 'jsonapi/serializer'
 
 module Spina
   class Engine < ::Rails::Engine
-
     isolate_namespace Spina
 
     config.autoload_paths += %W( #{config.root}/lib )
 
-    config.to_prepare do    
+    config.to_prepare do
       # Require decorators from main application
-      [Rails.root].flatten.map { |p| Dir[p.join('app', 'decorators', '**', '*_decorator.rb')]}.flatten.uniq.each do |decorator|
-        Rails.configuration.cache_classes ? require(decorator) : load(decorator)
+      unless Spina.config.disable_decorator_load
+        Dir.glob(Rails.root + "app/decorators/**/*_decorator.rb").each do |decorator|
+          require_dependency(decorator)
+        end
       end
 
       # Register JSON part types for editing content
@@ -36,5 +38,17 @@ module Spina
         Spina::Parts::Attachment
       )
     end
+    
+    initializer "spina.importmap" do
+      Spina.config.importmap.paths.tap do |paths|
+        # Stimulus & Turbo
+        paths.asset "@hotwired/stimulus", path: "stimulus"
+        paths.asset "@hotwired/stimulus-autoloader", path: "stimulus-autoloader"
+        paths.asset "@hotwired/turbo-rails", path: "turbo"
+        
+        paths.assets_in Spina::Engine.root.join("app/assets/javascripts/spina"), append_base_path: true
+      end
+    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)
+    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