releaf-core 2.1.1 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e433968eea67f1a5bf1a38732598a5a75564bd8a0175acb24ff2b6f2b7bbca6
-  data.tar.gz: a812e881410e8de7d927c99512c46b22174e4689967daf9b7ee0b29a4b8af934
+  metadata.gz: faa9d0a6ff3255fb86e0b98bb23aa58ec88acbd010125ff1eb1a39c707454c67
+  data.tar.gz: d624883646f5d56b5b9261f9fb8e09f0e2a348235a5aef111725e15e501f0fc0
 SHA512:
-  metadata.gz: 76f9fa3b888da36b90f5098ed43728979414f4762823d7d3e1c09113e5ae9e0d7ea0b641e1fd1fc1b20f908be3017866e351d8643b775b22d953a523141cf32b
-  data.tar.gz: 3c6e17e2949ab440c275d73e92b054a8b40106fd24fec896782c713f1c63c2ff629727c104cc096275f8eaa018f8c3e61c27aac07f1bbe1cb02eaa7e002f0203
+  metadata.gz: 2da526978e85e75d245ec0006acd05ede0ef50ee7ab86ac8b2ddc8b7968efadeb93ee1c036c798171542a3beb8d491b30a1011edfc6039f96569423d62218059
+  data.tar.gz: 72c8729ab6d1cb96e1d975a7369091e5506f88923c11d5fd2411335d9f5ef334993ac1acef65cfbe945b4a9643078a9a59620f02113ad4d6338364a1b1f1e116

data/app/assets/javascripts/ckeditor/config.js

@@ -1,10 +1,4 @@
-/**
- * @license Copyright (c) 2003-2018, CKSource - Frederico Knabben. All rights reserved.
- * For licensing, see https://ckeditor.com/legal/ckeditor-oss-license
- */
-
-CKEDITOR.editorConfig = function( config ) {
-	// Define changes to default configuration here. For example:
-	// config.language = 'fr';
-	// config.uiColor = '#AADC6E';
-};
+CKEDITOR.editorConfig = function (config){
+    config.removePlugins = 'exportpdf'
+    true
+}

data/app/lib/releaf/action_controller/exceptions.rb

@@ -7,10 +7,10 @@ module Releaf::ActionController::Exceptions
   end
 
   def page_not_found
-    respond_with(nil, responder: action_responder(:page_not_found))
+    render "releaf/error_pages/page_not_found", status: :not_found, formats: :html
   end
 
   def access_denied
-    respond_with(nil, responder: action_responder(:access_denied))
+    render "releaf/error_pages/forbidden", status: :forbidden, formats: :html
   end
 end

data/app/lib/releaf/responders.rb

@@ -11,8 +11,6 @@ module Releaf::Responders
       update: Releaf::Responders::AfterSaveResponder,
       confirm_destroy: Releaf::Responders::ConfirmDestroyResponder,
       destroy: Releaf::Responders::DestroyResponder,
-      access_denied: Releaf::Responders::AccessDeniedResponder,
-      page_not_found: Releaf::Responders::PageNotFoundResponder,
     }
   end
 

data/app/models/releaf/settings.rb

@@ -1,4 +1,32 @@
-class Releaf::Settings < RailsSettings::Base
+class Releaf::Settings < ActiveRecord::Base
+
+  self.table_name = table_name_prefix + "settings"
+
+  class SettingNotFound < RuntimeError; end
+
+  belongs_to :thing, polymorphic: true, optional: true
+
+  # get the value field, YAML decoded
+  def value
+    YAML.load(self[:value], permitted_classes: [DateTime, Time, Date]) if self[:value].present?
+  end
+
+  # set the value field, YAML encoded
+  def value=(new_value)
+    self[:value] = new_value.to_yaml
+  end
+
+  def rewrite_cache
+    Rails.cache.write(cache_key, value)
+  end
+
+  def expire_cache
+    Rails.cache.delete(cache_key)
+  end
+
+  def cache_key
+    self.class.cache_key(var, thing)
+  end
 
   scope :registered, -> { where(var: registered_keys, thing_type: nil, thing_id: nil).order(:var) }
 
@@ -36,4 +64,129 @@ class Releaf::Settings < RailsSettings::Base
   def self.supported_types
     [:boolean, :date, :time, :datetime, :integer, :float, :decimal, :email, :text, :textarea, :richtext]
   end
+
+  class << self
+    def cache_prefix(&block)
+      @cache_prefix = block
+    end
+
+    def cache_key(var_name, scope_object)
+      scope = ["rails_settings_cached"]
+      scope << @cache_prefix.call if @cache_prefix
+      scope << "#{scope_object.class.name}-#{scope_object.id}" if scope_object
+      scope << var_name.to_s
+      scope.join("/")
+    end
+
+    def [](key)
+      return super(key) unless rails_initialized?
+      val = Rails.cache.fetch(cache_key(key, @object)) do
+        super(key)
+      end
+      val
+    end
+
+    # set a setting value by [] notation
+    def []=(var_name, value)
+      super
+      Rails.cache.write(cache_key(var_name, @object), value)
+      value
+    end
+
+    # get or set a variable with the variable as the called method
+    # rubocop:disable Style/MethodMissing
+    def method_missing(method, *args)
+      method_name = method.to_s
+      super(method, *args)
+    rescue NoMethodError
+      # set a value for a variable
+      if method_name[-1] == "="
+        var_name = method_name.sub("=", "")
+        value = args.first
+        self[var_name] = value
+      else
+        # retrieve a value
+        self[method_name]
+      end
+    end
+
+    # destroy the specified settings record
+    def destroy(var_name)
+      var_name = var_name.to_s
+      obj = object(var_name)
+      raise SettingNotFound, "Setting variable \"#{var_name}\" not found" if obj.nil?
+
+      obj.destroy
+      true
+    end
+
+    # retrieve all settings as a hash (optionally starting with a given namespace)
+    def get_all(starting_with = nil)
+      vars = thing_scoped.select("var, value")
+      vars = vars.where("var LIKE '#{starting_with}%'") if starting_with
+      result = {}
+      vars.each { |record| result[record.var] = record.value }
+      result.reverse_merge!(default_settings(starting_with))
+      result.with_indifferent_access
+    end
+
+    def where(sql = nil)
+      vars = thing_scoped.where(sql) if sql
+      vars
+    end
+
+    # get a setting value by [] notation
+    def [](var_name)
+      val = object(var_name)
+      return val.value if val
+    end
+
+    # set a setting value by [] notation
+    def []=(var_name, value)
+      var_name = var_name.to_s
+
+      record = object(var_name) || thing_scoped.new(var: var_name)
+      record.value = value
+      record.save!
+
+      value
+    end
+
+    def merge!(var_name, hash_value)
+      raise ArgumentError unless hash_value.is_a?(Hash)
+
+      old_value = self[var_name] || {}
+      raise TypeError, "Existing value is not a hash, can't merge!" unless old_value.is_a?(Hash)
+
+      new_value = old_value.merge(hash_value)
+      self[var_name] = new_value if new_value != old_value
+
+      new_value
+    end
+
+    def object(var_name)
+      return nil unless table_exists?
+      thing_scoped.where(var: var_name.to_s).first
+    end
+
+    def thing_scoped
+      unscoped.where("thing_type is NULL and thing_id is NULL")
+    end
+
+    def source(filename)
+      Default.source(filename)
+    end
+
+    def rails_initialized?
+      Rails.application && Rails.application.initialized?
+    end
+
+    private
+
+    def default_settings(starting_with = nil)
+      return {} unless Default.enabled?
+      return Default.instance if starting_with.nil?
+      Default.instance.select { |key, _| key.to_s.start_with?(starting_with) }
+    end
+  end
 end

data/lib/releaf/root/settings_manager.rb

@@ -1,8 +1,16 @@
 module Releaf::Root
   class SettingsManager
+    CAST_MAP = {
+      "false" => false,
+      "true" => true,
+    }
 
     def self.read(controller:, key:)
-      controller.send(:cookies)[key]
+      value = controller.send(:cookies)[key]
+
+      return CAST_MAP[value] if CAST_MAP.key? value
+
+      value
     end
 
     def self.write(controller:, key:, value:)

data/lib/releaf-core.rb

@@ -1,4 +1,3 @@
-require 'rails-settings-cached'
 require 'ckeditor_rails'
 require 'will_paginate'
 require 'font-awesome-rails'