rails-settings-cached 2.2.0 → 2.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 765057576ddcdb19d9f394f1844950f03e8c70944abd9b104e70824f60f7e0e5
-  data.tar.gz: 0d2a2c4aa7560d96bee3a0c1a0d50f7cb89bffd5c650ae47f2bd6169c0d12b6e
+  metadata.gz: '08fedca17d5c8848f9503a0b9a2d45403fd545406ec656d899af182334d6c3ac'
+  data.tar.gz: 1b928531e53c09d4ac3c582785aad54dee23f81c00721857009c0495ee1a7f30
 SHA512:
-  metadata.gz: 908f7ae3d8e01710f9df4cb32a77b2302129107bcd34254cb5237fc5f5b98f2e4007fe315751ab3fd7e2212e14a0db133f796f994b0bd6a1cee48768717a01a9
-  data.tar.gz: fe611e7af4ac5ca72a98040c63b0475833878ac6f11b82953fd80458bb6b96311fff7fc174f890171f466f724be809cd334bc184b0cb0c8c7b3ae94f5fbee28f
+  metadata.gz: 8f742e343ecfe97413a17aafefead8f5e49a49d407e269962a90e08a3f8ad89441f0ba95f4496a80b8528f68d5edecccf930f00af39627020d75a8e947ac28a5
+  data.tar.gz: 970ef16a4a2f2c3c552f0d80d8386d5124e3821c0f9ed54d2ad3b0dd57e3c37a7cf94a6342c14d4cb585a6e188c2659ba13034607768eb2dfd29680c5c084a5f

data/README.md

@@ -1,4 +1,4 @@
-## Rails Settings Cached
+# Rails Settings Cached
 
 This a plugin that makes managing a table of
 а global key, value pairs easy. Think of it like a global Hash stored in your database,
@@ -6,39 +6,23 @@ that uses simple ActiveRecord like methods for manipulation. Keep track of any g
 setting that you don't want to hard code into your rails app. You can store any kind
 of object. Strings, numbers, arrays, or any object.
 
-> 🚨 BREAK CHANGES WARNING:
-> rails-settings-cached 2.x has redesigned the API, the new version will compatible with the stored setting values by an older version.
-> When you want to upgrade 2.x, you must read the README again, and follow guides to change your Setting model.
-> 0.x stable branch: https://github.com/huacnlee/rails-settings-cached/tree/0.x
-
-## Status
+[![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) [![CI Status](https://travis-ci.org/huacnlee/rails-settings-cached.svg)](http://travis-ci.org/huacnlee/rails-settings-cached) [![Code Climate](https://codeclimate.com/github/huacnlee/rails-settings-cached/badges/gpa.svg)](https://codeclimate.com/github/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)
-
-## Setup
+## Installation
 
 Edit your Gemfile:
 
-```ruby
-gem "rails-settings-cached", "~> 2.0"
-```
-
-Generate your settings:
-
 ```bash
-$ rails g settings:install
+$ bundle add rails-settings-cached
 ```
 
-If you want custom model name:
+Generate your settings:
 
 ```bash
 $ rails g settings:install
-```
 
-Or use a custom name:
-
-```bash
-$ rails g settings:install SiteConfig
+# Or use a custom name:
+$ rails g settings:install AppConfig
 ```
 
 You will get `app/models/setting.rb`
@@ -46,20 +30,26 @@ You will get `app/models/setting.rb`
 ```rb
 class Setting < RailsSettings::Base
   # cache_prefix { "v1" }
-
-  field :host, default: "http://example.com"
+  field :app_name, default: "Rails Settings"
+  field :host, default: "http://example.com", readonly: true
+  field :default_locale, default: "zh-CN"
   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]+/
-  field :captcha_enable, type: :boolean, default: 1
+
   field :notification_options, type: :hash, default: {
     send_all: true,
     logging: true,
     sender_email: "foo@bar.com"
   }
+
+  # lambda default value
+  field :welcome_message, type: :string, default: -> { "welcome to #{self.app_name}" }
 end
 ```
 
@@ -68,19 +58,21 @@ You must use `field` method to statement the setting keys, otherwise you can't u
 Now just put that migration in the database with:
 
 ```bash
-rake db:migrate
+$ rails db:migrate
 ```
 
 ## Usage
 
-The syntax is easy.  First, let's create some settings to keep track of:
+The syntax is easy. First, let's create some settings to keep track of:
 
 ```ruby
 irb > Setting.host
 "http://example.com"
-irb > Setting.host = "https://your-host.com"
-irb > Setting.host
-"https://your-host.com"
+irb > Setting.app_name
+"Rails Settings"
+irb > Setting.app_name = "Rails Settings Cached"
+irb > Setting.app_name
+"Rails Settings Cached"
 
 irb > Setting.user_limits
 20
@@ -134,6 +126,31 @@ irb > Setting.notification_options
 }
 ```
 
+
+### Get defined fields
+
+> version 2.3+
+
+```rb
+# Get all keys
+Setting.keys
+=> ["app_name", "host", "default_locale", "readonly_item"]
+
+# Get editable keys
+Settng.editable_keys
+=> ["app_name", "default_locale"]
+
+# Get readonly keys
+Setting.readonly_keys
+=> ["host", "readonly_item"]
+
+# Get options of field
+Setting.get_field("host")
+=> { 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 }
+```
+
 ## Readonly field
 
 Sometimes you may need to use Setting before Rails is initialized, for example `config/devise.rb`
@@ -156,6 +173,26 @@ class Setting < RailsSettings::Base
 end
 ```
 
+## Use Setting in Rails initalizing:
+
+You can't use Setting in these locations:
+
+```
+config/application.rb
+config/environments/*.rb
+```
+
+If you wants do that, put the setting into `config/initializers/*.rb`
+
+For example:
+
+```rb
+# config/initializers/devise.rb
+Devise.setup do |config|
+  config.omniauth :twitter, Setting.twitter_api_key, Setting.twitter_api_secret
+end
+```
+
 ### Caching flow:
 
 ```
@@ -201,7 +238,7 @@ config/routes.rb
 
 ```rb
 namespace :admin do
-  resources :settings
+  resource :settings
 end
 ```
 
@@ -257,78 +294,50 @@ app/views/admin/settings/show.html.erb
       Use YAML format to config the SMTP_html
     </div>
   </div>
-<% end %>
-```
-
-##  Backward compatible to support 0.x scoped settings
-
-You may used the scoped setting feature in 0.x version. Before you upgrade rails-settings-cached 2.x, you must follow this guide to backward compatible it.
-
-For example:
 
-```rb
-class User < ApplicationRecord
-  include RailsSettings::Extend
-end
-
-@user.settings.color = "red"
-@user.settings.foo = 123
+  <div>
+    <%= f.submit 'Update Settings' %>
+  </div>
+<% end %>
 ```
 
-create `app/models/concerns/scoped_setting.rb`
+## Scoped Settings
 
-```rb
-module ScopedSetting
-  extend ActiveSupport::Concern
+> 🚨 BREAK CHANGES WARNING:
+> rails-settings-cached 2.x has redesigned the API, the new version will compatible with the stored setting values by an older version.
+> When you want to upgrade 2.x, you must read the README again, and follow guides to change your Setting model.
+> 0.x stable branch: https://github.com/huacnlee/rails-settings-cached/tree/0.x
 
-  included do
-    has_many :settings, as: :thing
-  end
+- [Backward compatible to support 0.x scoped settings](docs/backward-compatible-to-scoped-settings.md)
 
-  class_methods do
-    def scoped_field(name, default: nil)
-      define_method(name) do
-        obj = settings.where(var: name).take || settings.new(var: name, value: default)
-        obj.value
-      end
+For new project / new user of rails-settings-cached. The [ActiveRecord::AttributeMethods::Serialization](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html#method-i-serialize) is best choice.
 
-      define_method("#{name}=") do |val|
-        record = settings.where(var: name).take || settings.new(var: name)
-        record.value = val
-        record.save!
+> This is reason of why rails-settings-cached 2.x removed **Scoped Settings** feature.
 
-        val
-      end
-    end
-  end
-end
-```
+For example:
 
-Now include it for your model:
+We wants a preferences setting for user.
 
 ```rb
-class User < ApplicationRecord
-  include ScopedSetting
-
-  scoped_field :color, default: ""
-  scoped_field :foo, default: 0
+class User < ActiveRecord::Base
+  serialize :preferences
 end
-```
-
-Now you must to find project with ".setting." for replace with:
 
-Same values will fetch from the `settings` table.
-
-```rb
-@user.color = "red"
-@user.color # => "red"
-@user.foo = 123
-@user.foo # =>
+@user = User.new
+@user.preferences[:receive_emails] = true
+@user.preferences[:public_email] = true
+@user.save
 ```
 
 ## Use cases:
 
-- [ruby-china/homeland](https://github.com/ruby-china/homeland)
-- [thebluedoc/bluedoc](https://github.com/thebluedoc/bluedoc/blob/master/app/models/setting.rb)
-- [tootsuite/mastodon](https://github.com/tootsuite/mastodon)
-- [helpyio/helpy](https://github.com/helpyio/helpy)
+- [ruby-china/homeland](https://github.com/ruby-china/homeland) - master
+- [forem/forem](https://github.com/forem/forem) - 2.x
+- [siwapp/siwapp](https://github.com/siwapp/siwapp) - 2.x
+- [aidewoode/black_candy](https://github.com/aidewoode/black_candy) - 2.x
+- [thebluedoc/bluedoc](https://github.com/thebluedoc/bluedoc/blob/master/app/models/setting.rb) - 2.x
+- [tootsuite/mastodon](https://github.com/tootsuite/mastodon) - 0.6.x
+- [helpyio/helpy](https://github.com/helpyio/helpy) - 0.5.x
+
+
+And more than [1K repositories](https://github.com/huacnlee/rails-settings-cached/network/dependents) used.

data/lib/generators/settings/install_generator.rb

@@ -3,14 +3,15 @@
 require "rails/generators"
 require "rails/generators/migration"
 
-module Settings
+module RailsSettings
   class InstallGenerator < Rails::Generators::NamedBase
+    namespace "settings:install"
     desc "Generate RailsSettings files."
     include Rails::Generators::Migration
 
     argument :name, type: :string, default: "setting"
 
-    source_root File.expand_path("../templates", __FILE__)
+    source_root File.expand_path("templates", __dir__)
 
     @@migrations = false
 

data/lib/rails-settings/base.rb

@@ -6,7 +6,7 @@ module RailsSettings
   class Base < ActiveRecord::Base
     class SettingNotFound < RuntimeError; end
 
-    SEPARATOR_REGEXP = /[\n,;]+/
+    SEPARATOR_REGEXP = /[\n,;]+/.freeze
     self.table_name = table_name_prefix + "settings"
 
     # get the value field, YAML decoded
@@ -26,15 +26,17 @@ module RailsSettings
     class << self
       def clear_cache
         RequestStore.store[:rails_settings_all_settings] = nil
-        Rails.cache.delete(self.cache_key)
+        Rails.cache.delete(cache_key)
       end
 
       def field(key, **opts)
-        @keys ||= []
-        @keys << key.to_s
         _define_field(key, default: opts[:default], type: opts[:type], readonly: opts[:readonly], separator: opts[:separator])
       end
 
+      def get_field(key)
+        @defined_fields.find { |field| field[:key] == key.to_s } || {}
+      end
+
       def cache_prefix(&block)
         @cache_prefix = block
       end
@@ -46,96 +48,130 @@ module RailsSettings
       end
 
       def keys
-        @keys
+        @defined_fields.map { |field| field[:key] }
+      end
+
+      def editable_keys
+        @defined_fields.reject { |field| field[:readonly] }.map { |field| field[:key] }
+      end
+
+      def readonly_keys
+        @defined_fields.select { |field| field[:readonly] }.map { |field| field[:key] }
       end
 
       private
 
-        def _define_field(key, default: nil, type: :string, readonly: false, separator: nil)
-          if readonly
-            define_singleton_method(key) do
-              self.send(:_convert_string_to_typeof_value, type, default, separator: separator)
-            end
-          else
-            define_singleton_method(key) do
-              val = self.send(:_value_of, key)
-              result = nil
-              if !val.nil?
-                result = val
-              else
-                result = default
-                result = default.call if default.is_a?(Proc)
-              end
-
-              result = self.send(:_convert_string_to_typeof_value, type, result, separator: separator)
-
-              result
+      def _define_field(key, default: nil, type: :string, readonly: false, separator: nil)
+        @defined_fields ||= []
+        @defined_fields << {
+          key: key.to_s,
+          default: default,
+          type: type || :string,
+          readonly: readonly.nil? ? false : readonly
+        }
+
+        if readonly
+          define_singleton_method(key) do
+            send(:_convert_string_to_typeof_value, type, default, separator: separator)
+          end
+        else
+          define_singleton_method(key) do
+            val = send(:_value_of, key)
+            result = nil
+            if !val.nil?
+              result = val
+            else
+              result = default
+              result = default.call if default.is_a?(Proc)
             end
 
-            define_singleton_method("#{key}=") do |value|
-              var_name = key.to_s
+            result = send(:_convert_string_to_typeof_value, type, result, separator: separator)
 
-              record = find_by(var: var_name) || new(var: var_name)
-              value = self.send(:_convert_string_to_typeof_value, type, value, separator: separator)
+            result
+          end
 
-              record.value = value
-              record.save!
+          define_singleton_method("#{key}=") do |value|
+            var_name = key.to_s
 
-              value
-            end
-          end
+            record = find_by(var: var_name) || new(var: var_name)
+            value = send(:_convert_string_to_typeof_value, type, value, separator: separator)
 
-          if type == :boolean
-            define_singleton_method("#{key}?") do
-              self.send(key)
-            end
+            record.value = value
+            record.save!
+
+            value
           end
         end
 
-        def _convert_string_to_typeof_value(type, value, separator: nil)
-          return value unless [String, Integer, Float, BigDecimal].include?(value.class)
-
-          case type
-          when :boolean
-            value == "true" || value == "1" || value == 1 || value == true
-          when :array
-            value.split(separator || SEPARATOR_REGEXP).reject { |str| str.empty? }.map(&:strip)
-          when :hash
-            value = YAML.load(value).to_h rescue eval(value).to_h rescue {}
-            value.deep_stringify_keys!
-            value
-          when :integer
-            value.to_i
-          when :float
-            value.to_f
-          when :big_decimal
-            value.to_d
-          else
-            value
+        if type == :boolean
+          define_singleton_method("#{key}?") do
+            send(key)
           end
         end
+      end
 
-        def _value_of(var_name)
-          raise "#{self.table_name} does not exist." unless table_exists?
+      def _convert_string_to_typeof_value(type, value, separator: nil)
+        return value unless [String, Integer, Float, BigDecimal].include?(value.class)
+
+        case type
+        when :boolean
+          value == "true" || value == "1" || value == 1 || value == true
+        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
+          value.deep_stringify_keys!
+          ActiveSupport::HashWithIndifferentAccess.new(value)
+        when :integer
+          value.to_i
+        when :float
+          value.to_f
+        when :big_decimal
+          value.to_d
+        else
+          value
+        end
+      end
 
-          _all_settings[var_name.to_s]
+      def _value_of(var_name)
+        unless table_exists?
+          # Fallback to default value if table was not ready (before migrate)
+          puts "WARNING: table: \"#{table_name}\" does not exist, `#{name}.#{var_name}` fallback to returns the default value."
+          return nil
         end
 
-        def rails_initialized?
-          Rails.application && Rails.application.initialized?
+        _all_settings[var_name.to_s]
+      rescue => e
+        if e.message.include?("connect")
+          puts "WARNING: `#{name}.#{var_name}` called but no connection, fallback to returns the default value."
+          return nil
         end
 
-        def _all_settings
-          raise "You cannot use settings before Rails initialize." unless rails_initialized?
-          RequestStore.store[:rails_settings_all_settings] ||= begin
-            Rails.cache.fetch(self.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
+        raise e
+      end
+
+      def rails_initialized?
+        Rails.application&.initialized?
+      end
+
+      def _all_settings
+        RequestStore.store[:rails_settings_all_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
         end
+      end
     end
   end
 end

data/lib/rails-settings/version.rb

@@ -3,7 +3,7 @@
 module RailsSettings
   class << self
     def version
-      "2.2.0"
+      "2.3.4"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-settings-cached
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.4
 platform: ruby
 authors:
 - Jason Lee
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2020-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -130,9 +130,10 @@ files:
 - lib/rails-settings/railtie.rb
 - lib/rails-settings/version.rb
 homepage: https://github.com/huacnlee/rails-settings-cached
-licenses: []
+licenses:
+- MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -148,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Settings plugin for Rails that makes managing a table of global keys.
 test_files: []