RubyGems - super_settings - Versions diffs - 0.0.0.rc1 - Mend

super_settings 0.0.0.rc1

Files changed (43) hide show

checksums.yaml +7 -0
data/CHANGELOG.md +9 -0
data/MIT-LICENSE +20 -0
data/README.md +313 -0
data/VERSION +1 -0
data/app/helpers/super_settings/settings_helper.rb +32 -0
data/app/views/layouts/super_settings/settings.html.erb +20 -0
data/config/routes.rb +13 -0
data/db/migrate/20210414004553_create_super_settings.rb +34 -0
data/lib/super_settings/application/api.js +88 -0
data/lib/super_settings/application/helper.rb +119 -0
data/lib/super_settings/application/images/edit.svg +1 -0
data/lib/super_settings/application/images/info.svg +1 -0
data/lib/super_settings/application/images/plus.svg +1 -0
data/lib/super_settings/application/images/slash.svg +1 -0
data/lib/super_settings/application/images/trash.svg +1 -0
data/lib/super_settings/application/index.html.erb +169 -0
data/lib/super_settings/application/layout.html.erb +22 -0
data/lib/super_settings/application/layout_styles.css +193 -0
data/lib/super_settings/application/scripts.js +718 -0
data/lib/super_settings/application/styles.css +122 -0
data/lib/super_settings/application.rb +38 -0
data/lib/super_settings/attributes.rb +24 -0
data/lib/super_settings/coerce.rb +66 -0
data/lib/super_settings/configuration.rb +144 -0
data/lib/super_settings/controller_actions.rb +81 -0
data/lib/super_settings/encryption.rb +76 -0
data/lib/super_settings/engine.rb +70 -0
data/lib/super_settings/history_item.rb +26 -0
data/lib/super_settings/local_cache.rb +306 -0
data/lib/super_settings/rack_middleware.rb +210 -0
data/lib/super_settings/rest_api.rb +195 -0
data/lib/super_settings/setting.rb +599 -0
data/lib/super_settings/storage/active_record_storage.rb +123 -0
data/lib/super_settings/storage/http_storage.rb +279 -0
data/lib/super_settings/storage/redis_storage.rb +293 -0
data/lib/super_settings/storage/test_storage.rb +158 -0
data/lib/super_settings/storage.rb +254 -0
data/lib/super_settings/version.rb +5 -0
data/lib/super_settings.rb +213 -0
data/lib/tasks/super_settings.rake +9 -0
data/super_settings.gemspec +35 -0
metadata +113 -0

data/lib/super_settings/application/styles.css ADDED Viewed

@@ -0,0 +1,122 @@
+#settings-table td p {
+  margin-top: 0;
+  margin-bottom: 0.5rem;
+}
+#settings-table td p:last-of-type {
+  margin-bottom: 0;
+}
+#settings-table input[type=text], #settings-table input[type=number], #settings-table input[type=date], #settings-table input[type=time], #settings-table textarea {
+  width: 100%;
+}
+.super-settings-edit-row {
+  background-color: #f2fdf2 !important;
+}
+#settings-table tr[data-deleted] td {
+  background-color: #ffd1d8 !important;
+  color: darkred;
+  text-decoration: line-through;
+}
+#settings-table tr[data-newrecord] .js-show-history {
+  display: none;
+}
+.super-settings-key {
+  overflow-wrap: break-word;
+  max-width: 30rem;
+  min-width: 15rem;
+}
+.super-settings-value {
+  overflow-wrap: break-word;
+  max-width: 30rem;
+  min-width: 15rem;
+}
+.super-settings-value-type {
+  width: 7rem;
+}
+.super-settings-description {
+  min-width: 20rem;
+}
+.super-settings-controls {
+  width: 6rem;
+  white-space: nowrap;
+  text-align: right;
+  text-decoration: none !important;
+}
+.super-settings-history-key {
+  font-weight: normal;
+  color: royalblue;
+}
+.super-settings-modal {
+  z-index: 1000000000000;
+  display: none;
+  padding-top: 5rem;
+  position: fixed;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+  overflow: auto;
+  background-color: rgba(0,0,0,0.4);
+}
+.super-settings-modal-dialog {
+  margin: auto;
+  background-color: #fff;
+  position: relative;
+  outline: 0;
+  padding: 2em;
+  box-shadow: 3px 3px 7px 3px rgba(0, 0, 0, 0.6);
+  border-radius: 4px;
+  width: 80%;
+  height: 80%;
+}
+.super-settings-modal-content {
+  height: 100%;
+  overflow: auto;
+}
+.super-settings-modal-close {
+  display: block;
+  position: absolute;
+  top: 0;
+  right: 0;
+  border: 0;
+  padding: 1ex;
+  background-color: inherit;
+  font-size: 1.5rem;
+  font-weight: 500;
+}
+.super-settings-sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0,0,0,0);
+  border: 0;
+}
+.super-settings-text-nowrap {
+  white-space: nowrap !important;
+}
+.super-settings-sticky-top {
+  position: sticky;
+  top: 0;
+  padding: 1rem 0;
+  background-color: white;
+}

data/lib/super_settings/application.rb ADDED Viewed

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require_relative "application/helper"
+module SuperSettings
+  # Simple class for rendering ERB templates for the HTML application.
+  class Application
+    include Helper
+    # @param layout [String, Symbol] path to an ERB template to use as the layout around the application UI. You can
+    #                                pass the symbol `:default` to use the default layout that ships with the gem.
+    # @param add_to_head [String] HTML code to add to the <head> element on the page.
+    def initialize(layout = nil, add_to_head = nil)
+      if layout
+        layout = File.expand_path(File.join("application", "layout.html.erb"), __dir__) if layout == :default
+        @layout = ERB.new(File.read(layout))
+        @add_to_head = add_to_head
+      end
+    end
+    # Render the specified ERB file in the lib/application directory distributed with the gem.
+    def render(erb_file)
+      template = ERB.new(File.read(File.expand_path(File.join("application", erb_file), __dir__)))
+      html = template.result(binding)
+      if @layout
+        render_layout { html }
+      else
+        html
+      end
+    end
+    private
+    def render_layout
+      @layout.result(binding)
+    end
+  end
+end

data/lib/super_settings/attributes.rb ADDED Viewed

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module SuperSettings
+  # Interface to expose mass setting attributes on an object. Setting attributes with a
+  # hash will simply call the attribute writers for each key in the hash.
+  module Attributes
+    class UnknownAttributeError < StandardError
+    end
+    def initialize(attributes = nil)
+      self.attributes = attributes if attributes
+    end
+    def attributes=(values)
+      values.each do |name, value|
+        if respond_to?("#{name}=", true)
+          send("#{name}=", value)
+        else
+          raise UnknownAttributeError.new("unknown attribute #{name.to_s.inspect} for #{self.class}")
+        end
+      end
+    end
+  end
+end

data/lib/super_settings/coerce.rb ADDED Viewed

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module SuperSettings
+  # Utility functions for coercing values to other data types.
+  class Coerce
+    # rubocop:disable Lint/BooleanSymbol
+    FALSE_VALUES = [
+      false, 0,
+      "0", :"0",
+      "f", :f,
+      "F", :F,
+      "false", :false,
+      "FALSE", :FALSE,
+      "off", :off,
+      "OFF", :OFF
+    ].to_set.freeze
+    # rubocop:enable Lint/BooleanSymbol
+    class << self
+      # Cast variations of booleans (i.e. "true", "false", 1, 0, etc.) to actual boolean objects.
+      # @param value [Object]
+      # @return [Boolean]
+      def boolean(value)
+        if value == false
+          false
+        elsif blank?(value)
+          nil
+        else
+          !FALSE_VALUES.include?(value)
+        end
+      end
+      # Cast a value to a Time object.
+      def time(value)
+        value = nil if value.nil? || value.to_s.empty?
+        return nil if value.nil?
+        time = if value.is_a?(Numeric)
+          Time.at(value)
+        elsif value.respond_to?(:to_time)
+          value.to_time
+        else
+          Time.parse(value.to_s)
+        end
+        if time.respond_to?(:in_time_zone) && Time.respond_to?(:zone)
+          time = time.in_time_zone(Time.zone)
+        end
+        time
+      end
+      # @return true if the value is nil or empty.
+      def blank?(value)
+        return true if value.nil?
+        if value.respond_to?(:empty?)
+          value.empty?
+        else
+          value.to_s.empty?
+        end
+      end
+      # @return true if the value is not nil and not empty.
+      def present?(value)
+        !blank?(value)
+      end
+    end
+  end
+end

data/lib/super_settings/configuration.rb ADDED Viewed

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+require "singleton"
+module SuperSettings
+  # Configuration for the gem when run as a Rails engine. Default values and behaviors
+  # on the controller and model can be overridden with the configuration.
+  #
+  # The configuration is a singleton instance.
+  class Configuration
+    include Singleton
+    # Configuration for the controller.
+    class Controller
+      # @api private
+      attr_reader :enhancement
+      # Superclass for the controller. This should normally be set to one of your existing
+      # base controller classes since these probably have authentication methods, etc. defined
+      # on them. If this is not defined, the superclass will be `SuperSettings::ApplicationController`.
+      # It can be set to either a class or a class name. Setting to a class name is preferrable
+      # since it will be compatible with class reloading in a development environment.
+      attr_writer :superclass
+      def superclass
+        if @superclass.is_a?(String)
+          @superclass.constantize
+        else
+          @superclass
+        end
+      end
+      # Optinal name of the application displayed in the view.
+      attr_accessor :application_name
+      # Optional mage URL for the application logo.
+      attr_accessor :application_logo
+      # Optional URL for a link back to the rest of the application.
+      attr_accessor :application_link
+      # Javascript to inject into the settings application HTML page. This can be used, for example,
+      # to set authorization credentials stored client side to access the settings API.
+      attr_accessor :javascript
+      # Enhance the controller. You can define methods or call controller class methods like
+      # `before_action`, etc. in the block. These will be applied to the engine controller.
+      # This is essentially the same a monkeypatching the controller class.
+      def enhance(&block)
+        @enhancement = block
+      end
+      # Define how the `changed_by` attibute on the setting history will be filled from the controller.
+      # The block will be evaluated in the context of the controller when the settings are changed.
+      # The value returned by the block will be stored in the changed_by attribute. For example, if
+      # your base controller class defines a method `current_user` and you'd like the name to be stored
+      # in the history, you could call `define_changed_by { current_user.name }`
+      def define_changed_by(&block)
+        @changed_by_block = block
+      end
+      # Return the value of `define_changed_by` block.
+      #
+      # @api private
+      def changed_by(controller)
+        if defined?(@changed_by_block) && @changed_by_block
+          controller.instance_eval(&@changed_by_block)
+        end
+      end
+    end
+    # Configuration for the models.
+    class Model
+      # Specify the cache implementation to use for caching the last updated timestamp for reloading
+      # changed records. Defaults to `Rails.cache`
+      attr_accessor :cache
+      attr_writer :storage
+      # Specify the storage engine to use for persisting settings. The value can either be specified
+      # as a full class name or an underscored class name for a storage classed defined in the
+      # `SuperSettings::Storage` namespace. The default storage engine is `SuperSettings::Storage::ActiveRecord`.
+      def storage
+        if defined?(@storage) && @storage
+          @storage
+        else
+          :active_record
+        end
+      end
+      # @return [Class]
+      # @api private
+      def storage_class
+        if storage.is_a?(Class)
+          storage
+        else
+          class_name = storage.to_s.camelize
+          if Storage.const_defined?("#{class_name}Storage")
+            Storage.const_get("#{class_name}Storage")
+          else
+            class_name.constantize
+          end
+        end
+      end
+    end
+    # Return the model specific configuration object.
+    attr_reader :model
+    # Return the controller specific configuration object.
+    attr_reader :controller
+    # Set the secret used for encrypting secret settings. Defaults to the value of the
+    # SUPER_SETTINGS_SECRET environment variable. An array can be provided if you need to
+    # roll the secret with the first value being the current one.
+    attr_accessor :secret
+    # Set the number of seconds that settings will be cached locally before the database
+    # is checked for updates. Defaults to 5 seconds.
+    attr_accessor :refresh_interval
+    def initialize
+      @model = Model.new
+      @controller = Controller.new
+    end
+    # Defer the execution of a block that will be yielded to with the config object. This
+    # is needed in a Rails environment during initialization so that all the frameworks can
+    # load before loading the settings.
+    #
+    # @api private
+    def defer(&block)
+      @block = block
+    end
+    # Call the block deferred during initialization.
+    #
+    # @api private
+    def call
+      @block&.call(self)
+      @block = nil
+    end
+  end
+end

data/lib/super_settings/controller_actions.rb ADDED Viewed

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require "erb"
+module SuperSettings
+  # Module used to build the SuperSettings::SettingsController for Rails applications.
+  # This controller is defined at runtime since it is assumed that the superclass will
+  # be one of the application's own base controller classes since the application will
+  # want to define authentication and authorization criteria.
+  #
+  # The controller is built by extending the class defined by the Configuration object and
+  # then mixing in this module.
+  module ControllerActions
+    def self.included(base)
+      base.layout "super_settings/settings"
+      base.helper SettingsHelper
+      base.protect_from_forgery with: :exception, if: :protect_from_forgery?
+    end
+    # Render the HTML application for managing settings.
+    def root
+      html = SuperSettings::Application.new.render("index.html.erb")
+      render html: html.html_safe, layout: true
+    end
+    # API endpoint for getting active settings. See SuperSettings::RestAPI for details.
+    def index
+      render json: SuperSettings::RestAPI.index
+    end
+    # API endpoint for getting a setting. See SuperSettings::RestAPI for details.
+    def show
+      setting = SuperSettings::RestAPI.show(params[:key])
+      if setting
+        render json: setting
+      else
+        render json: nil, status: 404
+      end
+    end
+    # API endpoint for updating settings. See SuperSettings::RestAPI for details.
+    def update
+      changed_by = Configuration.instance.controller.changed_by(self)
+      result = SuperSettings::RestAPI.update(params[:settings], changed_by)
+      if result[:success]
+        render json: result
+      else
+        render json: result, status: 422
+      end
+    end
+    # API endpoint for getting the history of a setting. See SuperSettings::RestAPI for details.
+    def history
+      setting_history = SuperSettings::RestAPI.history(params[:key], offset: params[:offset], limit: params[:limit])
+      if setting_history
+        render json: setting_history
+      else
+        render json: nil, status: 404
+      end
+    end
+    # API endpoint for getting the last time a setting was changed. See SuperSettings::RestAPI for details.
+    def last_updated_at
+      render json: SuperSettings::RestAPI.last_updated_at
+    end
+    # API endpoint for getting settings that have changed since specified time. See SuperSettings::RestAPI for details.
+    def updated_since
+      render json: SuperSettings::RestAPI.updated_since(params[:time])
+    end
+    protected
+    # Return true if CSRF protection needs to be enabled for the request.
+    # By default it is only enabled on stateful requests that include Basic authorization
+    # or cookies in the request so that stateless REST API calls are allowed.
+    def protect_from_forgery?
+      request.cookies.present? || request.authorization.to_s.split(" ", 2).first&.match?(/\ABasic/i)
+    end
+  end
+end

data/lib/super_settings/encryption.rb ADDED Viewed

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+module SuperSettings
+  module Encryption
+    SALT = "0c54a781"
+    private_constant :SALT
+    # Error thrown when the secret is invalid
+    class InvalidSecretError < StandardError
+      def initialize
+        super("Cannot decrypt. Invalid secret provided.")
+      end
+    end
+    class << self
+      # Set the secret key used for encrypting secret values. If this is not set,
+      # the value will be loaded from the `SUPER_SETTINGS_SECRET` environment
+      # variable. If that value is not set, arguments will not be encrypted.
+      #
+      # You can set multiple secrets by passing an array if you need to roll your secrets.
+      # The left most value in the array will be used as the encryption secret, but
+      # all the values will be tried when decrypting. That way if you have existing keys
+      # that were encrypted with a different secret, you can still make it available
+      # when decrypting. If you are using the environment variable, separate the keys
+      # with spaces.
+      #
+      # @param value [String] One or more secrets to use for encrypting arguments.
+      # @return [void]
+      def secret=(value)
+        @encryptors = make_encryptors(value)
+      end
+      # Encrypt a value for use with secret settings.
+      # @api private
+      def encrypt(value)
+        return nil if Coerce.blank?(value)
+        encryptor = encryptors.first
+        return value if encryptor.nil?
+        encryptor.encrypt(value)
+      end
+      # Decrypt a value for use with secret settings.
+      # @api private
+      def decrypt(value)
+        return nil if Coerce.blank?(value)
+        return value if encryptors.empty? || encryptors == [nil]
+        encryptors.each do |encryptor|
+          begin
+            return encryptor.decrypt(value) if encryptor
+          rescue OpenSSL::Cipher::CipherError
+            # Not the right key, try the next one
+          end
+        end
+        raise InvalidSecretError
+      end
+      # @return [Boolean] true if the value is encrypted in the storage engine.
+      def encrypted?(value)
+        SecretKeys::Encryptor.encrypted?(value)
+      end
+      private
+      def encryptors
+        if !defined?(@encryptors) || @encryptors.empty?
+          @encryptors = make_encryptors(ENV["SUPER_SETTINGS_SECRET"].to_s.split)
+        end
+        @encryptors
+      end
+      def make_encryptors(secrets)
+        Array(secrets).map { |val| val.nil? ? nil : SecretKeys::Encryptor.from_password(val, SALT) }
+      end
+    end
+  end
+end

data/lib/super_settings/engine.rb ADDED Viewed

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+module SuperSettings
+  # Engine that is loaded in a Rails environment. The engine will take care of applying any
+  # settings overriding behavior in the Configuration as well as eager loading the settings
+  # into memory.
+  class Engine < Rails::Engine
+    isolate_namespace ::SuperSettings
+    config.after_initialize do
+      # Call the deferred initialization block.
+      configuration = Configuration.instance
+      configuration.call
+      SuperSettings.refresh_interval = configuration.refresh_interval unless configuration.refresh_interval.nil?
+      reloader = if defined?(Rails.application.reloader.to_prepare)
+        Rails.application.reloader
+      elsif defined?(ActiveSupport::Reloader.to_prepare)
+        ActiveSupport::Reloader
+      elsif defined?(ActionDispatch::Reloader.to_prepare)
+        ActionDispatch::Reloader
+      end
+      create_controller = lambda do
+        klass = Class.new(configuration.controller.superclass || ::ApplicationController)
+        if defined?(SuperSettings::SettingsController)
+          SuperSettings.send(:remove_const, :SettingsController)
+        end
+        SuperSettings.const_set(:SettingsController, klass)
+        klass.include(ControllerActions)
+        if configuration.controller.enhancement
+          klass.class_eval(&configuration.controller.enhancement)
+        end
+      end
+      # Setup the controller.
+      ActiveSupport.on_load(:action_controller) do
+        create_controller.call
+        if reloader && !Rails.configuration.cache_classes
+          reloader.to_prepare(&create_controller)
+        end
+      end
+      model_load_block = proc do
+        Setting.cache = (configuration.model.cache || Rails.cache)
+        Setting.storage = configuration.model.storage_class
+        if configuration.secret.present?
+          SuperSettings.secret = configuration.secret
+          configuration.secret = nil
+        end
+        if !SuperSettings.loaded?
+          begin
+            SuperSettings.load_settings
+          rescue => e
+            Rails.logger&.warn(e)
+          end
+        end
+      end
+      if configuration.model.storage.to_s == "active_record"
+        ActiveSupport.on_load(:active_record, &model_load_block)
+      else
+        model_load_block.call
+      end
+    end
+  end
+end

data/lib/super_settings/history_item.rb ADDED Viewed

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module SuperSettings
+  # Model for each item in a setting's history. When a setting is changed, the system
+  # will track the value it is changed to, who it was changed by, and when.
+  class HistoryItem
+    include Attributes
+    attr_accessor :key, :value, :changed_by, :created_at
+    attr_writer :deleted
+    def deleted?
+      # Stupid strict mode...
+      !!(defined?(@deleted) && @deleted)
+    end
+    # The method could be overriden to change how the changed_by attribute is displayed.
+    # For instance, you could store a user id in the changed_by column and add an association
+    # on this model `belongs_to :user, class_name: "User", foreign_key: :changed_by` and then
+    # define this method as `user.name`.
+    # @return [String]
+    def changed_by_display
+      changed_by
+    end
+  end
+end