super_settings 0.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: db0bf91c463e76358f1c6b9721960e4dc2b08a25959c71ee1ffce819ff859874
+  data.tar.gz: 2c91970c4246df25e14f7f2928f15a449d5abb246442aff56d7fbbe5a98d27b9
+SHA512:
+  metadata.gz: 7e18d007ff8754192e9165e4b2339e630123852b1d9a2e1be898af1f71a823f461977b7151e9935f4965691be73837ac07b5f5c66f96d15eff722e37283cd123
+  data.tar.gz: 7fd370930d84ab992824866d45220962baa51533f23101e847bf5a4a9a109a0b0dea0397a0c7e2692c57cd5d3bec9d5b4e1e3969d55f7ee1cd113fa8f1771587

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+### Added
+- Everything!

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Brian Durand
+
+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.

data/README.md

@@ -0,0 +1,313 @@
+# SuperSettings
+
+[![Continuous Integration](https://github.com/bdurand/super_settings/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/super_settings/actions/workflows/continuous_integration.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+
+This gem provides a framework for maintaining runtime application settings. Settings are persisted in a database and cached locally in memory for quick, efficient access. The settings are designed so they can be updated dynamically without requiring code deployment or restarting processes.
+
+As applications grow, they tend to accumulate a lot of configuration over time. Often these end up in environment variables, hard coded in YAML files, or sprinkled through various data models as additional columns. All of these methods of configuration have their place and are completely appropriate for different purposes (i.e. for storing application secrets, configuration required during application startup, etc.).
+
+However, these methods don't work as well for runtime settings that you may want to change while your application is running.
+
+* Environment variables - These are great for environment specific configuration and they can be a good place to store sensitive data. However, they can be difficult to manage, all values must be stored as strings, and application processes need to be restarted for changes to take effect.
+
+* YAML files - These are great for more complex configurations since they support data structures and they can be shipped with your application. However, changing them usually requires a new release of the application code.
+
+* Database columns - These are great for settings tied to data models. However, they don't apply very well outside the data model, you need to build the tools for managing them into your application.
+
+SuperSettings provides a simple interface for accessing settings backed by a thread safe caching mechanism that provides in-memory performance while significantly limiting database load. You can tune how frequently the cache is refreshed and each refresh call is tuned to be highly efficient.
+
+There is also an out of the box web UI and REST API for managing settings. You can specify data types for your settings (string, integer, float, boolean, datetime, or array) and be assured that values will be valid. You can also supply documentation for each setting so that it's obvious what each one does and how it is used.
+
+## Usage
+
+* [Getting Value](#getting_values)
+  * [Hashes](#hashes)
+  * [Defaults](#defaults)
+  * [Caching](#caching)
+* [Data Model](#data_model)
+  * [Storage Engines](#storage_engines)
+  * [Encrypted Secrets](#encrypted_secrets)
+* [Web UI](#web_ui)
+  * [REST API](#rest_api)
+* [Rails Engine](#rails_engine)
+  * [Configuration](#configuration)
+
+### Getting Values
+
+This gem is in essence a key/value store. Settings are identified by unique keys and contain a typed value. You can access setting values using methods on the `SuperSettings` object.
+
+```ruby
+SuperSettings.get("key") # -> returns a string
+
+SuperSettings.integer("key") # -> returns an integer
+
+SuperSettings.float("key") # -> returns a float
+
+SuperSettings.enabled?("key") # -> returns a boolean
+
+SuperSettings.datetime("key") # -> returns a `Time` object
+
+SuperSettings.array("key") # -> returns an array of strings
+```
+
+#### Hashes
+There is also a method to get multiple settings at once structured as a Hash.
+
+```ruby
+SuperSettings.structured("parent") # -> returns an hash
+```
+
+The key provided to the `SuperSettings.structured` method indicates the key prefix and constructs the hash from settings that have keys beginning with that prefix. Keys are also broken down by a delimiter so you can create nested hashes. The delimiter defaults to `"."`, but you can specify a different one with the `delimiter` keyword argument.
+
+You can also set a maximum depth to the returned hash with the `max_depth` keyword argument.
+
+So, if you have the following settings:
+
+```
+vendors.company_1.path = "/co1"
+vendors.company_1.timeout = 5
+vendors.company_2.path = "/co2"
+page_size = 20
+```
+
+You would get these results:
+
+```ruby
+SuperSettings.structured("vendors")
+# {
+#   "company_1" => {
+#     "path" => "/co1",
+#     "timeout" => 5
+#   },
+#   "company_2" => {
+#     "path" => "/co2"
+#    }
+# }
+
+SuperSettings.structured("vendors.company_1")
+# {"path" => "/co1", "timeout" => 5}
+
+SuperSettings.structured("vendors.company_2")
+# {"path" => "/co2"}
+
+# Get all the settings by omitting the key
+SuperSettings.structured
+# {
+#   "vendors" => {
+#     "company_1" => {"path" => "/co1", "timeout" => 5},
+#     "company_2" => {"path" => "/co2"}
+#   },
+#   "page_size" => 20
+# }
+
+# Limit the depth of the returned has to one level
+SuperSettings.structured(max_depth: 1)
+# {
+#   "vendors.company_1.path => "/co1",
+#   "vendors.company_1.timeout" => 5,
+#   "vendors.company_2.path" => "/co2",
+#   "page_size" => 20
+# }
+```
+
+#### Defaults
+
+When you request a setting, you can also specify a default value to use if the setting does not have a value.
+
+```ruby
+SuperSettings.integer("key", 4)
+# return 4 if the "key" setting has not been set
+```
+
+#### Caching
+
+When you read a setting using these methods, you are actually reading from an in memory cache. All of the settings are read into this local cache and the cache is checked periodically to see if it needs to be refreshed (defaults to every five seconds, but can be customized with `SuperSettings.refresh_interval`). When the cache does need to be refreshed, only updated records are re-read from the data store by a single background thread. Thus, you don't have to worry about overloading your database by reading settings values.
+
+Cache misses are also cached so that they don't add any overhead. You should avoid querying for dynamically generated values as a setting key since this can lead to memory bloat.
+
+```ruby
+# BAD: this will create an entry in the cache for every id
+SuperSettings.enabled?("enabled_users.#{id}")
+
+# GOOD: use an array if there are a limited number of values
+SuperSettings.array("enabled_users", []).include?(id)
+
+# GOOD: use a hash if you need to scale to any number of values
+SuperSettings.structured("enabled_users", {})["id"]
+```
+
+Because all settings must be read into memory, you should avoid creating thousands of settings since this could lead to performance or memory issues loading the cache.
+
+### Data Model
+
+Each setting has a unique key, a value, a value type, and an optional description. The value type can be one of "string", "integer", "float", "boolean", "datetime", "array", or "secret". The array value type will always return an array of strings. The secret value type also returns a string and is used to indicate that the value contains sensitive data that should not be exposed. Secret values can be encrypted in the database as well (see below).
+
+The value type on a setting does not limit how it can be cast when request using one of the accessor methods on `SuperSettings`, though. For instance, you can call `SuperSettings.get("integer_key")` on an integer setting and it will return a string. The value type does ensure that the value is validated to be sure it can be cast to the specified type so you can avoid inputing invalid data.
+
+It is not possible to store an empty string in a setting; empty strings will be always cast to `nil`.
+
+A history of all settings changes is kept every time the value is changed in the `histories` association. You can use this information to see what values were in effect at what time. You can optionally alse record who made the changes.
+
+#### Storage Engines
+
+This gem abstracts out the storage engine and can support multiple storage mechanisms. It has built in support for ActiveRecord, Redis, and HTTP storage.
+
+* `SuperSettings::Storage::ActiveRecordStorage` - Stores the settings in a relational database using ActiveRecord. This is the default storage engine for Rails applications.
+* `SuperSettings::Storage::RedisStorage` - Stores the settings in a Redis database using the [redis](https://github.com/redis/redis-rb) gem.
+* `SuperSettings::Storage::HttpStorage` - Uses the SuperSettings REST API running on another server. This is useful in a micro services architecture so you can have a central settings server used by all the services.
+
+Additional storage engines can be built by creating a class that includes `SuperSettings::Storage` and implementing the unimplemented methods in that module.
+
+The storage engine is defined by setting `SuperSettings::Setting.storage` to the storage class to use. Note that each storage class may also require additional configuration. For instance the Redis storage class requires you to provide a connection to a Redis database. If you are running a Rails application, then the storage engine will be set to ActiveRecord by default. Otherwise, you will need to define it somewhere in your application's initialization.
+
+#### Encrypted Secrets
+
+You can specify that a setting is a secret by setting the value type to "secret". This will obscure the value in the UI (thoough it can still be seen when editing) as well as avoid recording the values in the setting history.
+
+You can also specify an encryption secret that is used to encrypt these settings in the database. It is highly recommended that if you store secrets in your settings that you enable this feature. The enryption secret can either be set by setting `SuperSettings.secret` or by setting the `SUPER_SETTINGS_SECRET` environment variable.
+
+If you need to roll your secret key, you can set the `SuperSettings.secret` value as an array (or as a space delmited list in the environment variable). The first secret will be the one used to encrypt values. However, all the secrets will be tried when decrypting values. This allows you to change the secret without raising decryption errors. If you do change your secret, you can run this rake task to re-encrypt all values using the new secret:
+
+```bash
+rake super_settings:encrypt_secrets
+```
+
+Encryption only changes how values are stored in the data store. Encrypted secrets are protected from someone gaining direct access to your database or a database backup and should be used if you are storing sensitive values. However, the values are not encrypted in the REST API or web UI. You must take appropriate measures to secure these if you choose to use them.
+
+### Web UI
+
+The Web UI provides all the functionality to add, update, and delete settings.
+
+![Web UI](web_ui.png)
+
+You can save multiple settings at once. If you have settings that need to be changed together, you can be assured they will all be saved in a single transaction.
+
+The Web UI is fully self contained and has no external dependencies. There are configuration settings for tweaking the layout. See the `SuperSettings::Configuration` class for
+
+You can see the Web UI in action if you clone this repository and then run:
+
+```bash
+bin/start_rails
+```
+
+Then go to http://localhost:3000/settings in your browser.
+
+You can change the layout used by the web UI. However, if you do this, you will be responsible for providing the CSS styles for the buttons, table rows and the form controls. The CSS class names used by the default layout are compatible with the class names defined in the [Bootstrap library](https://getbootstrap.com/).
+
+It is not required to use the bundled web UI. You can implement your own UI if you need to using the `SuperSettings::Setting` model.
+
+#### REST API
+
+You can mount a REST API for the exposing and managing the settings. This API is required for the web UI. The REST interface is documented in the `SuperSettings::RestAPI` class.
+
+If you are running a Rails application, you can mount the API as a controller via the bundled Rails engine. If you are not using Rails, then you can add a class that extends `SuperSettings::RackMiddleware` to your Rack middleware stack.
+
+In either case, you are responsible for implementing authentication and authorization for the HTTP requests. This allows you to seamlessly integrate with existing authentication and authorization in your application.
+
+### Rails Engine
+
+The gem ships with a Rails engine that provides easy integration with a Rails application.
+
+The default storage engine for a Rails application will be the ActiveRecord storage. You need to install the database migrations first with:
+
+```bash
+rails app:super_settings:install:migrations
+```
+
+You also need to mount the engine routes in your application's `config/routes.rb` file. The routes can be mounted under any prefix you'd like.
+
+```ruby
+mount SuperSettings::Engine => "/settings"
+```
+
+See the configuration section below for information about how to secure the controller endpoints. The engine provides no mechanism for security out of the box, but it is designed to seamlessly integrate with your application's existing authentication and authorization mechanism.
+
+#### Configuration
+
+You can configure various aspects of the Rails engine using by calling `SuperSettings.configure` in an initializer.
+
+```ruby
+# config/initializers/super_settings.rb
+
+SuperSettings.configure do |config|
+  # These options can be used to customize the header in the web UI.
+  config.controller.application_name = "My Application"
+  config.controller.application_link = "/"
+  config.controller.application_logo = "/images/app_logo.png"
+
+  # Set a custom refresh interval for the cache (default is 5 seconds)
+  config.refresh_interval = 2
+
+  # Set a secret used for encrypting settings with the "secret" value type.
+  config.secret = "ad962cc27e02657795a61b8d48a31ce4"
+
+  # Set the superclass to use for the controll. Defaults to using `ApplicationController`.
+  config.controller.superclass = Admin::BaseController
+
+  # Add additional code to the controller. In this case we are adding code to ensure only
+  # admins can access the functionality and changing the layout to use one defined by the application.
+  config.controller.enhance do
+    self.layout = "admin"
+
+    before_action do
+      require_admin
+    end
+
+    private
+
+    def require_admin
+      if current_user.nil?
+        redirect_to login_url, status: 401
+      else
+        redirect_to access_denied_url, status: 403
+      end
+    end
+  end
+
+  # Define a method that returns the value that will be stored in the settings history in
+  # the `changed_by` column.
+  config.controller.define_changed_by do
+    current_user.name
+  end
+
+  # You can define the storage engine for the model. This can be either done either with a Class
+  # object or with a symbol matching the underscored class name of a storage class defined under
+  # the SuperSettings::Storage namespace.
+  # config.model.storage = :active_record
+
+  # You can also specify a cache implementation to use to cache the last updated timestamp
+  # for model changes. By default this will use `Rails.cache`.
+  # config.model.cache = Rails.cache
+end
+```
+
+One configuration you will probably want to set is the superclass for the controller. By default, the base `ApplicationController` defined for your application will be used. However, if you want to provide Your application probably already has a
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'super_settings'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install super_settings
+```
+
+## Contributing
+
+Open a pull request on GitHub.
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -0,0 +1 @@
+0.0.0.rc1

data/app/helpers/super_settings/settings_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SuperSettings
+  module SettingsHelper
+    # Render the styles.css as an inline <style> tag.
+    def super_settings_layout_style_tag
+      application_dir = File.expand_path(File.join("..", "..", "..", "lib", "super_settings", "application"), __dir__)
+      content_tag(:style, type: "text/css") do
+        render(file: File.join(application_dir, "layout_styles.css")).html_safe
+      end
+    end
+
+    # Return the application name set by the configuration or a default value.
+    def super_settings_application_name
+      Configuration.instance.controller.application_name || "Application"
+    end
+
+    # Render the header for the web pages using values set in the configuration.
+    def super_settings_application_header
+      config = Configuration.instance.controller
+      content = "#{super_settings_application_name} Settings"
+      if config.application_logo.present?
+        content = image_tag(config.application_logo, alt: "").concat(content)
+      end
+      if config.application_link
+        link_to(content, config.application_link)
+      else
+        content
+      end
+    end
+  end
+end

data/app/views/layouts/super_settings/settings.html.erb

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <%= content_tag :title, "#{super_settings_application_name} Settings"%>
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag if defined?(csp_meta_tag) %>
+    <%= super_settings_layout_style_tag %>
+  </head>
+
+  <body class="super_settings">
+    <header>
+      <h1 class="logo">
+        <%= super_settings_application_header %>
+      </h1>
+    </header>
+    <div class="container">
+      <%= yield %>
+    </div>
+  </body>
+</html>

data/config/routes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+SuperSettings::Engine.routes.draw do
+  controller :settings do
+    get "/", action: :root, as: :root
+    get "/settings", action: :index
+    post "/settings", action: :update
+    get "/setting", action: :show
+    get "/setting/history", action: :history
+    get "/settings/last_updated_at", action: :last_updated_at
+    get "/settings/updated_since", action: :updated_since
+  end
+end

data/db/migrate/20210414004553_create_super_settings.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Needed for the super_settings gem to maintain backward compatibility with Rails 4.2
+migration_class = ActiveRecord::Migration
+if migration_class.respond_to?(:[])
+  migration_class = migration_class[4.2]
+end
+
+class CreateSuperSettings < migration_class
+  def up
+    create_table :super_settings do |t|
+      t.string :key, null: false, limit: 190, index: {unique: true}
+      t.string :value_type, limit: 30, null: false, default: "string"
+      t.string :raw_value, limit: 4096, null: true
+      t.string :description, limit: 4096, null: true
+      t.datetime :updated_at, null: false, index: true
+      t.datetime :created_at, null: false
+      t.boolean :deleted, default: false
+    end
+
+    create_table :super_settings_histories do |t|
+      t.string :key, null: false, limit: 190, index: true
+      t.string :changed_by, limit: 150, null: true, index: true
+      t.string :value, limit: 4096, null: true
+      t.boolean :deleted, default: false
+      t.datetime :created_at, null: false
+    end
+  end
+
+  def down
+    drop_table :super_settings
+    drop_table :super_settings_histories
+  end
+end

data/lib/super_settings/application/api.js

@@ -0,0 +1,88 @@
+// Functions for using the Super Settngs REST API.
+//
+// The functions are exposed through the `window.SuperSettingsAPI` object.
+//
+// You can add custom headers or query string parameters to the API requests
+// by adding key/values to the `headers` and `queryParams` hashes on this object.
+// You can use these to add authorization credentials or access tokens to the
+// requests so they will be accepted by the back end.
+(function() {
+  // Get the URL for making an API call to the specified action and id.
+  function apiURL(action, params) {
+    let url = window.location.pathname;
+    if (url.endsWith("/")) {
+      url = url.substring(0, url.length - 1);
+    }
+    if (action) {
+      url += action;
+    }
+    if (params) {
+      const queryString = Object.keys(params).map(function(key) {
+        return encodeURIComponent(key) + '=' + encodeURIComponent(params[key]);
+      }).join('&');
+      if (queryString.length > 0) {
+        url += "?" + queryString
+      }
+    }
+    return url;
+  }
+
+  function callAPI(path, options, callback) {
+    if (!options) {
+      options = {};
+    }
+    method = (options.method || "get");
+
+    params = options.params
+    let queryParams = null;
+    const fetchOptions = {credentials: "same-origin"};
+    const headers = Object.assign({"Accept": "application/json"}, SuperSettingsAPI.headers);
+    if (method === "POST") {
+      queryParams = Object.assign({}, SuperSettingsAPI.queryParams);
+      csrfParam = document.querySelector("meta[name=csrf-param]");
+      csrfToken = document.querySelector("meta[name=csrf-token]");
+      if (csrfParam && csrfToken) {
+        params = Object.assign({}, params || {});
+        params[csrfParam.content] = csrfToken.content;
+      }
+      fetchOptions["method"] = "POST";
+      fetchOptions["body"] = JSON.stringify(params);
+      headers["Content-Type"] = "application/json";
+    } else {
+      queryParams = Object.assign({}, SuperSettingsAPI.queryParams, params);
+    }
+    fetchOptions["headers"] = new Headers(headers);
+    const url = apiURL(path, queryParams);
+
+    fetch(url, fetchOptions)
+    .then(
+      function(response) {
+        if (response.ok) {
+          return response.json();
+        } else {
+          throw( response.status + response.statusText)
+        }
+      }
+    ).then(
+      callback
+    ).catch(
+      function(error) {
+        showError(error);
+      }
+    );
+  }
+
+  // Show an error message in an alert.
+  function showError(error) {
+    console.error('Error:', error)
+    alert("Sorry, an error occurred. Refresh the page and try again.")
+  }
+
+  window.SuperSettingsAPI = {
+    queryParams: {},
+    headers: {},
+    fetchSettings: function(callback) { callAPI("/settings", {}, callback) },
+    fetchHistory: function(params, callback) { callAPI("/setting/history", {params: params}, callback) },
+    updateSettings: function(params, callback) { callAPI("/settings", {method: "POST", params: params}, callback)}
+  }
+})();

data/lib/super_settings/application/helper.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module SuperSettings
+  # Helper functions used for rendering the Super Settings HTML application. These methods
+  # are mixed in to the Application class so they are accessible from the ERB templates.
+  module Helper
+    ICON_SVG = Dir.glob(File.join(__dir__, "images", "*.svg")).each_with_object({}) do |file, cache|
+      cache[File.basename(file, ".svg")] = File.read(file).chomp
+    end.freeze
+
+    ICON_BUTTON_STYLE = {
+      cursor: "pointer",
+      width: "1.5rem",
+      height: "1.5rem",
+      "min-width": "20px",
+      "min-height": "20px",
+      "margin-top": "0.25rem",
+      "margin-right": "0.5rem"
+    }.freeze
+
+    DEFAULT_ICON_STYLE = {
+      width: "1rem",
+      height: "1rem",
+      display: "inline-block",
+      "vertical-align": "middle"
+    }.freeze
+
+    # Render the scripts.js file as an inline <script> tag.
+    def javascript_tag
+      <<~HTML
+        <script>
+          #{File.read(File.join(__dir__, "scripts.js"))}
+          #{File.read(File.join(__dir__, "api.js"))}
+          #{Configuration.instance.controller.javascript}
+        </script>
+      HTML
+    end
+
+    # Render the styles.css as an inline <style> tag.
+    def style_tag
+      <<~HTML
+        <style type="text/css">
+          #{File.read(File.join(__dir__, "styles.css"))}
+        </style>
+      HTML
+    end
+
+    # Render the styles.css as an inline <style> tag.
+    def layout_style_tag
+      <<~HTML
+        <style type="text/css">
+          #{File.read(File.join(__dir__, "layout_styles.css"))}
+        </style>
+      HTML
+    end
+
+    # Render an image tag for one of the SVG images in the images directory. If the :color option
+    # is specified, it will be applied to the SVG image.
+    def icon_image(name, options = {})
+      svg = ICON_SVG[name.to_s]
+      if Coerce.present?(options[:color])
+        svg = svg.gsub("currentColor", options[:color])
+      end
+      css = DEFAULT_ICON_STYLE.merge(options[:style] || {}).map { |name, value| "#{name}:#{value}" }.join("; ")
+      options = {alt: ""}.merge(options).merge(src: "data:image/svg+xml;utf8,#{svg}", style: css)
+      tag(:img, options)
+    end
+
+    # Render an icon image as a link tag.
+    def icon_button(icon, title:, color:, js_class:, url: nil, disabled: false, style: {}, link_style: nil)
+      url = "#" if Coerce.blank?(url)
+      image = icon_image(icon, alt: title, color: color, style: ICON_BUTTON_STYLE.merge(style))
+      content_tag(:a, image, href: url, class: js_class, disabled: disabled, style: link_style)
+    end
+
+    # Return the application name set by the configuration or a default value.
+    def application_name
+      ERB::Util.html_escape(Configuration.instance.controller.application_name || "Application")
+    end
+
+    # Render the header for the web pages using values set in the configuration.
+    def application_header
+      config = Configuration.instance.controller
+      content = ERB::Util.html_escape("#{application_name} Settings")
+      if Coerce.present?(config.application_logo)
+        content = tag(:img, src: config.application_logo, alt: "") + content
+      end
+      if config.application_link
+        content_tag(:a, content, href: config.application_link)
+      else
+        content
+      end
+    end
+
+    # Render an HTML tag without any body content.
+    def tag(tag, options)
+      "<#{tag} #{html_attributes(options)}>"
+    end
+
+    # Render an HTML tag with body content.
+    def content_tag(tag, body, options)
+      "<#{tag} #{html_attributes(options)}>#{body}</#{tag}>"
+    end
+
+    # Format a hash into HTML attributes.
+    def html_attributes(options)
+      html_options = []
+      options.each do |name, value|
+        html_options << "#{name}=\"#{ERB::Util.html_escape(value.to_s)}\""
+      end
+      html_options.join(" ")
+    end
+
+    # Add additional HTML code to the <head> element on the page.
+    def add_to_head
+      @add_to_head if defined?(@add_to_head)
+    end
+  end
+end

data/lib/super_settings/application/images/edit.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-edit"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"></path><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"></path></svg>

data/lib/super_settings/application/images/info.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-info"><circle cx="12" cy="12" r="10"></circle><line x1="12" y1="16" x2="12" y2="12"></line><line x1="12" y1="8" x2="12.01" y2="8"></line></svg>