rails-settings-cached 2.8.3 → 2.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 619f840c2f93682aec9caef59cb4a59404ce145fbb3b55e77dc259b0fc5b3abd
-  data.tar.gz: c2b49addab5c52403dbb0c3f883276b4c06a870ae4466140b876444dcbaf371f
+  metadata.gz: 212d83f192f7446ef64cdb9d2217a8dfe9324a1b8c64b2389857ca2997e5f46a
+  data.tar.gz: 4a757c45119a1c31d5ce5d4d3a02af47adcd631856c8c3f403bb5303a0ff4e6c
 SHA512:
-  metadata.gz: dcefa7f181b49c310ce6aff7bccb85e004c9048488f3a40cd24d0ed29b31d55d76cbfe6678f1c5eaf9ead4c4d84d1565ef1f0a00e04d02ed2fa58c6bfaf4c6dc
-  data.tar.gz: 585da097235e2bccd5731500a4bb862a8bdfbc9996f9aa11938b9f6d7f0c5a75f2f88b68388a87bc3898496c1562a6fbf3652ac4b0b6b6610b03a1b1b1221fad
+  metadata.gz: 29aa302129ae5ee8950137df21d529b60c90cc3b251acf9760c20b857f75be8f4407a9f4ed2ed518646c1baa411c42513bd04886c22e9d8923c36a4962bb74f4
+  data.tar.gz: 2f205f829b23ed7d3cf691b9e9c7d6f4ac236b6767bd2240b65fee039390416453bce3a99dfdfeb892e0c8aa29950ecbfa5693dd302fea1ee853e7f671bd1a23

data/README.md

@@ -161,6 +161,55 @@ Setting.get_field("default_locale")[:options]
 => { option_values: %w[en zh-CN jp], help_text: "Bla bla ..." }
 ```
 
+### Custom type for setting
+
+> Since: 2.9.0
+
+You can write your custom field type by under `RailsSettings::Fields` module.
+
+#### For example
+
+```rb
+module RailsSettings
+  module Fields
+    class YesNo < ::RailsSettings::Fields::Base
+      def serialize(value)
+        case value
+        when true then "YES"
+        when false then "NO"
+        else raise StandardError, 'invalid value'
+        end
+      end
+
+      def deserialize(value)
+        case value
+        when "YES" then true
+        when "NO" then false
+        else nil
+        end
+      end
+    end
+  end
+end
+```
+
+Now you can use `yes_no` type in you setting:
+
+```rb
+class Setting
+  field :custom_item, type: :yes_no, default: 'YES'
+end
+```
+
+```rb
+irb> Setting.custom_item = 'YES'
+irb> Setting.custom_item
+true
+irb> Setting.custom_item = 'NO'
+irb> Setting.custom_item
+false
+```
+
 #### Get All defined fields
 
 > version 2.7.0+

data/lib/rails-settings/base.rb

@@ -8,7 +8,6 @@ module RailsSettings
   end
 
   class Base < ActiveRecord::Base
-    SEPARATOR_REGEXP = /[\n,;]+/
     PROTECTED_KEYS = %w[var value]
     self.table_name = table_name_prefix + "settings"
 
@@ -55,7 +54,7 @@ module RailsSettings
       end
 
       def get_field(key)
-        @defined_fields.find { |field| field[:key] == key.to_s } || {}
+        @defined_fields.find { |field| field.key == key.to_s }.to_h || {}
       end
 
       def cache_prefix(&block)
@@ -69,15 +68,15 @@ module RailsSettings
       end
 
       def keys
-        @defined_fields.map { |field| field[:key] }
+        @defined_fields.map(&:key)
       end
 
       def editable_keys
-        @defined_fields.reject { |field| field[:readonly] }.map { |field| field[:key] }
+        @defined_fields.reject(&:readonly).map(&:key)
       end
 
       def readonly_keys
-        @defined_fields.select { |field| field[:readonly] }.map { |field| field[:key] }
+        @defined_fields.select(&:readonly).map(&:key)
       end
 
       attr_reader :defined_fields
@@ -89,56 +88,23 @@ module RailsSettings
 
         raise ProtectedKeyError.new(key) if PROTECTED_KEYS.include?(key)
 
+        field = ::RailsSettings::Fields::Base.generate(
+          scope: @scope, key: key, default: default,
+          type: type, readonly: readonly, options: opts,
+          separator: separator, parent: self
+        )
         @defined_fields ||= []
-        @defined_fields << {
-          scope: @scope,
-          key: key,
-          default: default,
-          type: type || :string,
-          readonly: readonly.nil? ? false : readonly,
-          options: opts
-        }
-
-        if readonly
-          define_singleton_method(key) do
-            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
-            val = send(:_value_of, key)
-            result = nil
-            if !val.nil?
-              result = val
-            else
-              result = default
-              result = default.call if default.is_a?(Proc)
-            end
-
-            result = send(:_convert_string_to_typeof_value, type, result, separator: separator)
-
-            result
-          end
-
-          define_singleton_method("#{key}=") do |value|
-            var_name = key
-
-            record = find_by(var: var_name) || new(var: var_name)
-            value = send(:_convert_string_to_typeof_value, type, value, separator: separator)
+        @defined_fields << field
 
-            record.value = value
-            record.save!
+        define_singleton_method(key) { field.read }
 
-            value
-          end
+        unless readonly
+          define_singleton_method("#{key}=") { |value| field.save!(value: value) }
 
           if validates
             validates[:if] = proc { |item| item.var.to_s == key }
             send(:validates, key, **validates)
-
-            define_method(:read_attribute_for_validation) do |_key|
-              self.value
-            end
+            define_method(:read_attribute_for_validation) { |_key| self.value }
           end
         end
 
@@ -156,49 +122,6 @@ module RailsSettings
         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
-          ["true", "1", 1, true].include?(value)
-        when :array
-          value.split(separator || SEPARATOR_REGEXP).reject { |str| str.empty? }.map(&:strip)
-        when :hash
-          value = begin
-            YAML.safe_load(value).to_h
-          rescue
-            {}
-          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 _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
-
-        _all_settings[var_name]
-      end
-
-      def _table_exists?
-        table_exists?
-      rescue
-        false
-      end
-
       def rails_initialized?
         Rails.application&.initialized?
       end

data/lib/rails-settings/fields/array.rb

@@ -0,0 +1,17 @@
+module RailsSettings
+  module Fields
+    class Array < ::RailsSettings::Fields::Base
+      def deserialize(value)
+        return nil if value.nil?
+
+        return value unless value.is_a?(::String)
+
+        value.split(separator).reject(&:empty?).map(&:strip)
+      end
+
+      def serialize(value)
+        deserialize(value)
+      end
+    end
+  end
+end

data/lib/rails-settings/fields/base.rb

@@ -0,0 +1,77 @@
+module RailsSettings
+  module Fields
+    class Base < Struct.new(:scope, :key, :default, :parent, :readonly, :separator, :type, :options, keyword_init: true)
+      SEPARATOR_REGEXP = /[\n,;]+/
+
+      def initialize(scope:, key:, default:, parent:, readonly:, separator:, type:, options:)
+        super
+        self.readonly = !!readonly
+        self.type ||= :string
+        self.separator ||= SEPARATOR_REGEXP
+      end
+
+      def save!(value:)
+        serialized_value = serialize(value)
+        parent_record = parent.find_by(var: key) || parent.new(var: key)
+        parent_record.value = serialized_value
+        parent_record.save!
+        parent_record.value
+      end
+
+      def saved_value
+        return parent.send(:_all_settings)[key] if table_exists?
+
+        # Fallback to default value if table was not ready (before migrate)
+        puts(
+          "WARNING: table: \"#{parent.table_name}\" does not exist or not database connection, `#{parent.name}.#{key}` fallback to returns the default value."
+        )
+        nil
+      end
+
+      def default_value
+        default.is_a?(Proc) ? default.call : default
+      end
+
+      def read
+        return deserialize(default_value) if readonly || saved_value.nil?
+
+        deserialize(saved_value)
+      end
+
+      def deserialize(value)
+        raise NotImplementedError
+      end
+
+      def serialize(value)
+        raise NotImplementedError
+      end
+
+      def to_h
+        super.slice(:scope, :key, :default, :type, :readonly, :options)
+      end
+
+      def table_exists?
+        parent.table_exists?
+      rescue StandardError
+        false
+      end
+
+      class << self
+        def generate(**args)
+          fetch_field_class(args[:type]).new(**args)
+        end
+
+        private
+
+        def fetch_field_class(type)
+          field_class_name = type.to_s.split("_").map(&:capitalize).join("")
+          begin
+            const_get("::RailsSettings::Fields::#{field_class_name}")
+          rescue StandardError
+            ::RailsSettings::Fields::String
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-settings/fields/big_decimal.rb

@@ -0,0 +1,15 @@
+module RailsSettings
+  module Fields
+    class BigDecimal < ::RailsSettings::Fields::Base
+      def deserialize(value)
+        return nil if value.nil?
+
+        value.to_d
+      end
+
+      def serialize(value)
+        deserialize(value)
+      end
+    end
+  end
+end

data/lib/rails-settings/fields/boolean.rb

@@ -0,0 +1,15 @@
+module RailsSettings
+  module Fields
+    class Boolean < ::RailsSettings::Fields::Base
+      def deserialize(value)
+        return nil if value.nil?
+
+        ["true", "1", 1, true].include?(value)
+      end
+
+      def serialize(value)
+        deserialize(value)
+      end
+    end
+  end
+end

data/lib/rails-settings/fields/float.rb

@@ -0,0 +1,15 @@
+module RailsSettings
+  module Fields
+    class Float < ::RailsSettings::Fields::Base
+      def deserialize(value)
+        return nil if value.nil?
+
+        value.to_f
+      end
+
+      def serialize(value)
+        deserialize(value)
+      end
+    end
+  end
+end

data/lib/rails-settings/fields/hash.rb

@@ -0,0 +1,23 @@
+module RailsSettings
+  module Fields
+    class Hash < ::RailsSettings::Fields::Base
+      def deserialize(value)
+        return nil if value.nil?
+
+        return value unless value.is_a?(::String)
+
+        load_value(value).deep_stringify_keys.with_indifferent_access
+      end
+
+      def serialize(value)
+        deserialize(value)
+      end
+
+      def load_value(value)
+        YAML.safe_load(value).to_h
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end

data/lib/rails-settings/fields/integer.rb

@@ -0,0 +1,15 @@
+module RailsSettings
+  module Fields
+    class Integer < ::RailsSettings::Fields::Base
+      def deserialize(value)
+        return nil if value.nil?
+
+        value.to_i
+      end
+
+      def serialize(value)
+        deserialize(value)
+      end
+    end
+  end
+end

data/lib/rails-settings/fields/string.rb

@@ -0,0 +1,15 @@
+module RailsSettings
+  module Fields
+    class String < ::RailsSettings::Fields::Base
+      def deserialize(value)
+        return nil if value.nil?
+
+        value
+      end
+
+      def serialize(value)
+        deserialize(value)
+      end
+    end
+  end
+end

data/lib/rails-settings/version.rb

@@ -3,7 +3,7 @@
 module RailsSettings
   class << self
     def version
-      "2.8.3"
+      "2.9.2"
     end
   end
 end

data/lib/rails-settings-cached.rb

@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "rails-settings/fields/base"
+require_relative "rails-settings/fields/array"
+require_relative "rails-settings/fields/big_decimal"
+require_relative "rails-settings/fields/boolean"
+require_relative "rails-settings/fields/float"
+require_relative "rails-settings/fields/hash"
+require_relative "rails-settings/fields/integer"
+require_relative "rails-settings/fields/string"
+
 require_relative "rails-settings/base"
 require_relative "rails-settings/request_cache"
 require_relative "rails-settings/middleware"
@@ -7,4 +16,6 @@ require_relative "rails-settings/railtie"
 require_relative "rails-settings/version"
 
 module RailsSettings
+  module Fields
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-settings-cached
 version: !ruby/object:Gem::Version
-  version: 2.8.3
+  version: 2.9.2
 platform: ruby
 authors:
 - Jason Lee
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-19 00:00:00.000000000 Z
+date: 2023-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -127,6 +127,14 @@ files:
 - lib/generators/settings/templates/model.rb
 - lib/rails-settings-cached.rb
 - lib/rails-settings/base.rb
+- lib/rails-settings/fields/array.rb
+- lib/rails-settings/fields/base.rb
+- lib/rails-settings/fields/big_decimal.rb
+- lib/rails-settings/fields/boolean.rb
+- lib/rails-settings/fields/float.rb
+- lib/rails-settings/fields/hash.rb
+- lib/rails-settings/fields/integer.rb
+- lib/rails-settings/fields/string.rb
 - lib/rails-settings/middleware.rb
 - lib/rails-settings/railtie.rb
 - lib/rails-settings/request_cache.rb
@@ -150,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.25
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: The best solution for store global settings in Rails applications.