rails-settings-cached 2.5.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f37f8d9bad4b40dd60dbf30806e1e530e1d292448ba803db06bdcca5f562c62e
-  data.tar.gz: 2900b13077db46b60b2c22cfa3a21b7af5704b86d874d485672508c8ef866475
+  metadata.gz: d45081eacc51de459cd0bc48469430474cd561386e924b40996bd5f66c1299e5
+  data.tar.gz: 485e2df525a6d3b66dfed0c0b5935aa8134b13ae0b0528d1fae536e5b19e4ae2
 SHA512:
-  metadata.gz: c696568044b97ce9a9112de42682a7e484e13a8220e0d7b1b52d5977f56358f82109e4bb1dd8b227f89089d060a49454b2bd1c86ac4cc7fbfc2c275bf0a48c55
-  data.tar.gz: c2eb40491e08ce8eefe6d96e6d987fd9a02efbad708e9a1ae0442d98b82e626300ee90eda5664be385aa81178c4be4a19b190d623a2ff8cdb0d8e0f8b53d0649
+  metadata.gz: 6651da35fec5737f76192ec01f0980ea45a85c69efb768c22edbce29b490f29dfa2498798b5af6d45a126955a3fe72bf2fa1ae76bd249237b83f408f7bba72c4
+  data.tar.gz: b96670e501b9c5aff237b02fd2da2560b654dd2835322b2e64e28679e3edf646ee940f2f2ffe69bfa7d851732ac4844bb47b01e292f4ef4b5f04e587977f8c21

data/README.md

@@ -2,11 +2,11 @@
 
 The best solution for store global settings in Rails applications.
 
-This gem will managing a table of а global key, value pairs easy. Think of it like a global Hash stored in your database, that uses simple ActiveRecord like methods for manipulation. Keep track of any global setting that you don't want to hard code into your rails app.
+This gem will make managing a table of а global key, value pairs easy. Think of it like a global Hash stored in your database, that uses simple ActiveRecord like methods for manipulation. Keep track of any global setting that you don't want to hard code into your rails app.
 
 You can store any kind of object. Strings, numbers, arrays, booleans, or any object.
 
-[![Gem Version](https://badge.fury.io/rb/rails-settings-cached.svg)](https://rubygems.org/gems/rails-settings-cached) [![CI Status](https://travis-ci.org/huacnlee/rails-settings-cached.svg)](http://travis-ci.org/huacnlee/rails-settings-cached) [![codecov.io](https://codecov.io/github/huacnlee/rails-settings-cached/coverage.svg?branch=master)](https://codecov.io/github/huacnlee/rails-settings-cached?branch=master)
+[![Gem Version](https://badge.fury.io/rb/rails-settings-cached.svg)](https://rubygems.org/gems/rails-settings-cached) [![build](https://github.com/huacnlee/rails-settings-cached/workflows/build/badge.svg)](https://github.com/huacnlee/rails-settings-cached/actions?query=workflow%3Abuild) [![codecov.io](https://codecov.io/github/huacnlee/rails-settings-cached/coverage.svg?branch=master)](https://codecov.io/github/huacnlee/rails-settings-cached?branch=master)
 
 ## Installation
 
@@ -30,26 +30,32 @@ You will get `app/models/setting.rb`
 ```rb
 class Setting < RailsSettings::Base
   # cache_prefix { "v1" }
-  field :app_name, default: "Rails Settings", validates: { presence: true, length: { in: 2..20 } }
-  field :host, default: "http://example.com", readonly: true
-  field :default_locale, default: "zh-CN", validates: { presence: true, inclusion: { in: %w[zh-CN en jp] } }
-  field :readonly_item, type: :integer, default: 100, readonly: true
-  field :user_limits, type: :integer, default: 20
-  field :exchange_rate, type: :float, default: 0.123
-  field :admin_emails, type: :array, default: %w[admin@rubyonrails.org]
-  field :captcha_enable, type: :boolean, default: true
 
-  # Override array separator, default: /[\n,]/ split with \n or comma.
-  field :tips, type: :array, separator: /[\n]+/
+  scope :application do
+    field :app_name, default: "Rails Settings", validates: { presence: true, length: { in: 2..20 } }
+    field :host, default: "http://example.com", readonly: true
+    field :default_locale, default: "zh-CN", validates: { presence: true, inclusion: { in: %w[zh-CN en jp] } }, option_values: %w[en zh-CN]
+    field :admin_emails, type: :array, default: %w[admin@rubyonrails.org]
+
+    # lambda default value
+    field :welcome_message, type: :string, default: -> { "welcome to #{self.app_name}" }, validates: { length: { maximum: 255 } }
+    # Override array separator, default: /[\n,]/ split with \n or comma.
+    field :tips, type: :array, separator: /[\n]+/
+  end
+
+  scope :limits do
+    field :user_limits, type: :integer, default: 20
+    field :exchange_rate, type: :float, default: 0.123
+    field :captcha_enable, type: :boolean, default: true, group: :limits
+  end
 
   field :notification_options, type: :hash, default: {
     send_all: true,
     logging: true,
     sender_email: "foo@bar.com"
-  }
+  }, group: :advanced
 
-  # lambda default value
-  field :welcome_message, type: :string, default: -> { "welcome to #{self.app_name}" }, validates: { length: { maximum: 255 } }
+  field :readonly_item, type: :integer, default: 100, readonly: true
 end
 ```
 
@@ -145,9 +151,24 @@ Setting.readonly_keys
 
 # Get options of field
 Setting.get_field("host")
-=> { key: "host", type: :string, default: "http://example.com", readonly: true }
+=> { scope: :application, key: "host", type: :string, default: "http://example.com", readonly: true }
 Setting.get_field("app_name")
-=> { key: "app_name", type: :string, default: "Rails Settings", readonly: false }
+=> { scope: :application, key: "app_name", type: :string, default: "Rails Settings", readonly: false }
+Setting.get_field(:user_limits)
+=> { scope: :limits, key: "user_limits", type: :integer, default: 20, readonly: false }
+```
+
+#### Get All defined fields
+
+> version 2.7.0+
+
+You can use `defined_fields` method to get all defined fields in Setting.
+
+```rb
+# Get editable fields and group by scope
+editable_fields = Setting.defined_fields
+  .select { |field| !field[:readonly] }
+  .group_by { |field| field[:scope] }
 ```
 
 ## Validations
@@ -162,9 +183,23 @@ class Setting < RailsSettings::Base
 end
 ```
 
-Now validate will work on record save.
+Now validate will work on record save:
+
+```rb
+irb> Setting.app_name = ""
+ActiveRecord::RecordInvalid: (Validation failed: App name can't be blank)
+irb> Setting.app_name = "Rails Settings"
+"Rails Settings"
+irb> Setting.default_locale = "zh-TW"
+ActiveRecord::RecordInvalid: (Validation failed: Default locale is not included in [zh-CN, en, jp])
+irb> Setting.default_locale = "en"
+"en"
+```
+
+Validate by `save` / `valid?` method:
 
 ```rb
+
 setting = Setting.find_or_initialize_by(var: :app_name)
 setting.value = ""
 setting.valid?
@@ -411,6 +446,7 @@ end
 - [huacnlee/bluedoc](https://github.com/huacnlee/bluedoc) - 2.x
 - [getzealot/zealot](https://github.com/getzealot/zealot) - 2.x
 - [kaishuu0123/rebacklogs](https://github.com/kaishuu0123/rebacklogs) - 2.x
+- [texterify/texterify](https://github.com/texterify/texterify) - 2.x
 - [tootsuite/mastodon](https://github.com/tootsuite/mastodon) - 0.6.x
 - [helpyio/helpy](https://github.com/helpyio/helpy) - 0.5.x
 - [daqing/rabel](https://github.com/daqing/rabel) - 0.4.x

data/lib/rails-settings/base.rb

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
 
 module RailsSettings
-  class Base < ActiveRecord::Base
-    class SettingNotFound < RuntimeError; end
+  class ProcetedKeyError < RuntimeError
+    def initialize(key)
+      super("Can't use #{key} as setting key.")
+    end
+  end
 
-    SEPARATOR_REGEXP = /[\n,;]+/.freeze
+  class Base < ActiveRecord::Base
+    SEPARATOR_REGEXP = /[\n,;]+/
+    PROTECTED_KEYS = %w[var value]
     self.table_name = table_name_prefix + "settings"
 
     # get the value field, YAML decoded
     def value
+      # rubocop:disable Security/YAMLLoad
       YAML.load(self[:value]) if self[:value].present?
     end
 
@@ -28,7 +34,13 @@ module RailsSettings
       end
 
       def field(key, **opts)
-        _define_field(key, default: opts[:default], type: opts[:type], readonly: opts[:readonly], separator: opts[:separator], validates: opts[:validates])
+        _define_field(key, **opts)
+      end
+
+      def scope(name)
+        @scope = name.to_sym
+        yield
+        @scope = nil
       end
 
       def get_field(key)
@@ -40,9 +52,9 @@ module RailsSettings
       end
 
       def cache_key
-        scope = ["rails-settings-cached"]
-        scope << @cache_prefix.call if @cache_prefix
-        scope.join("/")
+        key_parts = ["rails-settings-cached"]
+        key_parts << @cache_prefix.call if @cache_prefix
+        key_parts.join("/")
       end
 
       def keys
@@ -57,20 +69,29 @@ module RailsSettings
         @defined_fields.select { |field| field[:readonly] }.map { |field| field[:key] }
       end
 
+      attr_reader :defined_fields
+
       private
 
-      def _define_field(key, default: nil, type: :string, readonly: false, separator: nil, validates: nil)
+      def _define_field(key, default: nil, type: :string, readonly: false, separator: nil, validates: nil, **opts)
+        key = key.to_s
+
+        raise ProcetedKeyError.new(key) if PROTECTED_KEYS.include?(key)
+
         @defined_fields ||= []
         @defined_fields << {
-          key: key.to_s,
+          scope: @scope,
+          key: key,
           default: default,
           type: type || :string,
-          readonly: readonly.nil? ? false : readonly
+          readonly: readonly.nil? ? false : readonly,
+          options: opts
         }
 
         if readonly
           define_singleton_method(key) do
-            send(:_convert_string_to_typeof_value, type, default, separator: separator)
+            result = default.is_a?(Proc) ? default.call : default
+            send(:_convert_string_to_typeof_value, type, result, separator: separator)
           end
         else
           define_singleton_method(key) do
@@ -89,19 +110,19 @@ module RailsSettings
           end
 
           define_singleton_method("#{key}=") do |value|
-            var_name = key.to_s
+            var_name = key
 
             record = find_by(var: var_name) || new(var: var_name)
             value = send(:_convert_string_to_typeof_value, type, value, separator: separator)
 
             record.value = value
-            record.save(validate: false)
+            record.save!
 
             value
           end
 
           if validates
-            validates[:if] = Proc.new { |item| item.var.to_s == key.to_s }
+            validates[:if] = proc { |item| item.var.to_s == key }
             send(:validates, key, **validates)
 
             define_method(:read_attribute_for_validation) do |_key|
@@ -115,6 +136,13 @@ module RailsSettings
             send(key)
           end
         end
+
+        # delegate instance get method to class for support:
+        # setting = Setting.new
+        # setting.admin_emails
+        define_method(key) do
+          self.class.public_send(key)
+        end
       end
 
       def _convert_string_to_typeof_value(type, value, separator: nil)
@@ -122,19 +150,15 @@ module RailsSettings
 
         case type
         when :boolean
-          value == "true" || value == "1" || value == 1 || value == true
+          ["true", "1", 1, true].include?(value)
         when :array
           value.split(separator || SEPARATOR_REGEXP).reject { |str| str.empty? }.map(&:strip)
         when :hash
           value = begin
-                    begin
-                      YAML.load(value).to_h
-                    rescue StandardError
-                      eval(value).to_h
-                    end
-                  rescue StandardError
-                    {}
-                  end
+            YAML.safe_load(value).to_h
+          rescue
+            {}
+          end
           value.deep_stringify_keys!
           ActiveSupport::HashWithIndifferentAccess.new(value)
         when :integer
@@ -155,12 +179,12 @@ module RailsSettings
           return nil
         end
 
-        _all_settings[var_name.to_s]
+        _all_settings[var_name]
       end
 
       def _table_exists?
         table_exists?
-      rescue => e
+      rescue
         false
       end
 
@@ -169,13 +193,11 @@ module RailsSettings
       end
 
       def _all_settings
-        RequestCache.settings ||= begin
-          Rails.cache.fetch(cache_key, expires_in: 1.week) do
-            vars = unscoped.select("var, value")
-            result = {}
-            vars.each { |record| result[record.var] = record.value }
-            result.with_indifferent_access
-          end
+        RequestCache.settings ||= Rails.cache.fetch(cache_key, expires_in: 1.week) do
+          vars = unscoped.select("var, value")
+          result = {}
+          vars.each { |record| result[record.var] = record.value }
+          result.with_indifferent_access
         end
       end
     end

data/lib/rails-settings/railtie.rb

@@ -3,7 +3,7 @@
 module RailsSettings
   class Railtie < Rails::Railtie
     initializer "rails_settings.active_record.initialization" do
-      RailsSettings::Base.after_commit :clear_cache, on: %i(create update destroy)
+      RailsSettings::Base.after_commit :clear_cache, on: %i[create update destroy]
     end
   end
 end

data/lib/rails-settings/request_cache.rb

@@ -1,9 +1,9 @@
 module RailsSettings
-  if defined? ActiveSupport::CurrentAttributes 
+  if defined? ActiveSupport::CurrentAttributes
     # For storage all settings in Current, it will reset after per request completed.
     # Base on ActiveSupport::CurrentAttributes
     # https://api.rubyonrails.org/classes/ActiveSupport/CurrentAttributes.html
-    class RequestCache < ActiveSupport::CurrentAttributes 
+    class RequestCache < ActiveSupport::CurrentAttributes
       attribute :settings
     end
   else
@@ -27,4 +27,4 @@ module RailsSettings
       end
     end
   end
-end
+end

data/lib/rails-settings/version.rb

@@ -3,7 +3,7 @@
 module RailsSettings
   class << self
     def version
-      "2.5.0"
+      "2.7.0"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-settings-cached
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Jason Lee
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-08 00:00:00.000000000 Z
+date: 2021-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -110,7 +110,7 @@ dependencies:
         version: '0'
 description: "\n  The best solution for store global settings in Rails applications.\n\n
   \ This gem will managing a table of а global key, value pairs easy. Think of it
-  like a \n  global Hash stored in your database, that uses simple ActiveRecord like
+  like a\n  global Hash stored in your database, that uses simple ActiveRecord like
   methods for manipulation.\n\n  Keep track of any global setting that you dont want
   to hard code into your rails app.\n  You can store any kind of object.  Strings,
   numbers, arrays, or any object.\n  "
@@ -134,7 +134,7 @@ homepage: https://github.com/huacnlee/rails-settings-cached
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -149,8 +149,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key:
+rubygems_version: 3.2.3
+signing_key: 
 specification_version: 4
 summary: The best solution for store global settings in Rails applications.
 test_files: []