rails-settings-cached 2.2.1 → 2.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85279c41b179aa65d668a48d4d18e73b5fe886be9cd8235dc2acdb54c3beb5da
-  data.tar.gz: 516991953aa7698cf86511512d863b7903d1ec5ad648a69c386501413a75ac86
+  metadata.gz: 23b68e0d113892e9f08e29c3e70e39d79f3ce58aed36a981c55fe81593b8f3a9
+  data.tar.gz: c144240c649762ee4495fee8e2eef504244ae37746e43c294cef3512ea813a4c
 SHA512:
-  metadata.gz: 742596dc7e47c3d31ea64ecf54d96cae5885938076c2704aebe5f3e94701627631d19a8480f24ef97dc1861a8e1a1cab33c6f3aefd56ff755f88ef47c1380401
-  data.tar.gz: aa7b9a3ba2443a7ac6cb12150c196247bfd543e086b4eea1199f83eca1035ddefc1bcb32ae5d01cf9c3448dcd2f5c651dd9a73c8dab22600d28f202ef7d1f4a6
+  metadata.gz: f094b5b2485041c04885b1097715bf046e3a5525b88d800242479edaa3190fba4b3f164729840f2b11c519862387893c69ce58085d5867deab74093f75bfee1b
+  data.tar.gz: 20d36398a118661a50d45cbfbc16b416f280ef46376c96acbae2a15226ac1f2c70483adcdaacc56530169d6a96ad1e9ac4f79234766c13e2e80a5faaf5e289f6

data/README.md

@@ -30,8 +30,8 @@ You will get `app/models/setting.rb`
 ```rb
 class Setting < RailsSettings::Base
   # cache_prefix { "v1" }
-  field :app_name, default: "Rails Settings Cache Demo"
-  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
@@ -68,9 +68,11 @@ 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
@@ -124,9 +126,36 @@ irb > Setting.notification_options
 }
 ```
 
-## Readonly field
 
-Sometimes you may need to use Setting before Rails is initialized, for example `config/devise.rb`
+### 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 }
+```
+
+## Use Setting in Rails initalizing:
+
+In `version 2.3+` we allows you to use Setting before Rails is initialized.
+
+For example `config/initializers/devise.rb`
 
 ```rb
 Devise.setup do |config|
@@ -136,13 +165,45 @@ Devise.setup do |config|
 end
 ```
 
-In this case, you must define the `readonly` field:
+```rb
+class Setting < RailsSettings::Base
+  field :omniauth_google_client_id, default: ENV["OMNIAUTH_GOOGLE_CLIENT_ID"]
+  field :omniauth_google_client_secret, default: ENV["OMNIAUTH_GOOGLE_CLIENT_SECRET"]
+end
+```
+
+## Readonly field
+
+You may also want use Setting in these locations:
+
+```
+config/application.rb
+config/environments/*.rb
+```
+
+If you want do that do that, the setting field must has `readonly: true`.
+
+For example:
 
 ```rb
 class Setting < RailsSettings::Base
-  # cache_prefix { "v1" }
-  field :omniauth_google_client_id, default: ENV["OMNIAUTH_GOOGLE_CLIENT_ID"], readonly: true
-  field :omniauth_google_client_secret, default: ENV["OMNIAUTH_GOOGLE_CLIENT_SECRET"], readonly: true
+  field :mailer_provider, default: (ENV["mailer_provider"] || "smtp"), readonly: true
+  field :mailer_options, type: :hash, readonly: true, default: {
+    address: ENV["mailer_options.address"],
+    port: ENV["mailer_options.port"],
+    domain: ENV["mailer_options.domain"],
+    user_name: ENV["mailer_options.user_name"],
+    password: ENV["mailer_options.password"],
+    authentication: ENV["mailer_options.authentication"] || "login",
+    enable_starttls_auto: ENV["mailer_options.enable_starttls_auto"]
+  }
+end
+```
+
+```rb
+Rails.application.configure do
+  config.action_mailer.delivery_method = :smtp
+  config.action_mailer.smtp_settings = Setting.mailer_options.deep_symbolize_keys
 end
 ```
 

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,129 @@ 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
-          end
-        end
+            record.value = value
+            record.save!
 
-        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
           end
         end
 
-        def _value_of(var_name)
-          raise "#{self.table_name} does not exist." unless table_exists?
+        if type == :boolean
+          define_singleton_method("#{key}?") do
+            send(key)
+          end
+        end
+      end
 
-          _all_settings[var_name.to_s]
+      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
 
-        def rails_initialized?
-          Rails.application && Rails.application.initialized?
+      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 or not database connection, `#{name}.#{var_name}` 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
+        _all_settings[var_name.to_s]
+      end
+
+      def _table_exists?
+        table_exists?
+      rescue => e
+        false
+      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.1"
+      "2.3.5"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-settings-cached
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.3.5
 platform: ruby
 authors:
 - Jason Lee
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-14 00:00:00.000000000 Z
+date: 2020-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement