rails-settings-cached 0.7.2 → 2.7.0

data/Rakefile

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Rails Settings Cached"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+  t.warning = false
+end
+
+task default: :test

data/lib/generators/settings/install_generator.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 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
 
@@ -27,16 +30,19 @@ module Settings
 
     def install_setting
       template "model.rb", File.join("app/models", class_path, "#{file_name}.rb")
-      template "app.yml", File.join("config", "app.yml")
       migration_template "migration.rb", "db/migrate/create_settings.rb", migration_version: migration_version
     end
 
-    def rails5?
-      Rails.version.start_with? "5"
+    def rails_version_major
+      Rails::VERSION::MAJOR
+    end
+
+    def rails_version_minor
+      Rails::VERSION::MINOR
     end
 
     def migration_version
-      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]" if rails5?
+      "[#{rails_version_major}.#{rails_version_minor}]" if rails_version_major >= 5
     end
   end
 end

data/lib/generators/settings/templates/migration.rb

@@ -3,12 +3,10 @@ class CreateSettings < ActiveRecord::Migration<%= migration_version %>
     create_table :settings do |t|
       t.string  :var,        null: false
       t.text    :value,      null: true
-      t.integer :thing_id,   null: true
-      t.string  :thing_type, null: true, limit: 30
       t.timestamps
     end
 
-    add_index :settings, %i(thing_type thing_id var), unique: true
+    add_index :settings, %i(var), unique: true
   end
 
   def self.down

data/lib/generators/settings/templates/model.rb

@@ -1,7 +1,12 @@
 # RailsSettings Model
 class <%= class_name %> < RailsSettings::Base
-  source Rails.root.join("config/app.yml")
+  cache_prefix { "v1" }
 
-  # When config/app.yml has changed, you need change this prefix to v2, v3 ... to expires caches
-  # cache_prefix { "v1" }
+  # Define your fields
+  # field :host, type: :string, default: "http://localhost:3000"
+  # field :default_locale, default: "en", type: :string
+  # field :confirmable_enable, default: "0", type: :boolean
+  # field :admin_emails, default: "admin@rubyonrails.org", type: :array
+  # field :omniauth_google_client_id, default: (ENV["OMNIAUTH_GOOGLE_CLIENT_ID"] || ""), type: :string, readonly: true
+  # field :omniauth_google_client_secret, default: (ENV["OMNIAUTH_GOOGLE_CLIENT_SECRET"] || ""), type: :string, readonly: true
 end

data/lib/rails-settings/base.rb

@@ -1,43 +1,204 @@
+# frozen_string_literal: true
+
 module RailsSettings
-  class Base < Settings
-    def rewrite_cache
-      Rails.cache.write(cache_key, value)
+  class ProcetedKeyError < RuntimeError
+    def initialize(key)
+      super("Can't use #{key} as setting key.")
     end
+  end
 
-    def expire_cache
-      Rails.cache.delete(cache_key)
+  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
 
-    def cache_key
-      self.class.cache_key(var, thing)
+    # set the value field, YAML encoded
+    def value=(new_value)
+      self[:value] = new_value.to_yaml
+    end
+
+    def clear_cache
+      self.class.clear_cache
     end
 
     class << self
+      def clear_cache
+        RequestCache.reset
+        Rails.cache.delete(cache_key)
+      end
+
+      def field(key, **opts)
+        _define_field(key, **opts)
+      end
+
+      def scope(name)
+        @scope = name.to_sym
+        yield
+        @scope = nil
+      end
+
+      def get_field(key)
+        @defined_fields.find { |field| field[:key] == key.to_s } || {}
+      end
+
       def cache_prefix(&block)
         @cache_prefix = block
       end
 
-      def cache_key(var_name, scope_object)
-        scope = ["rails_settings_cached"]
-        scope << @cache_prefix.call if @cache_prefix
-        scope << "#{scope_object.class.name}-#{scope_object.id}" if scope_object
-        scope << var_name.to_s
-        scope.join("/")
+      def cache_key
+        key_parts = ["rails-settings-cached"]
+        key_parts << @cache_prefix.call if @cache_prefix
+        key_parts.join("/")
       end
 
-      def [](key)
-        return super(key) unless rails_initialized?
-        val = Rails.cache.fetch(cache_key(key, @object)) do
-          super(key)
+      def 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
+
+      attr_reader :defined_fields
+
+      private
+
+      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 << {
+          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)
+
+            record.value = value
+            record.save!
+
+            value
+          end
+
+          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
+          end
+        end
+
+        if type == :boolean
+          define_singleton_method("#{key}?") do
+            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)
+        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
-        val
+
+        _all_settings[var_name]
+      end
+
+      def _table_exists?
+        table_exists?
+      rescue
+        false
       end
 
-      # set a setting value by [] notation
-      def []=(var_name, value)
-        super
-        Rails.cache.write(cache_key(var_name, @object), value)
-        value
+      def rails_initialized?
+        Rails.application&.initialized?
+      end
+
+      def _all_settings
+        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
   end

data/lib/rails-settings/railtie.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module RailsSettings
   class Railtie < Rails::Railtie
     initializer "rails_settings.active_record.initialization" do
-      RailsSettings::Base.after_commit :rewrite_cache, on: %i(create update)
-      RailsSettings::Base.after_commit :expire_cache, on: %i(destroy)
+      RailsSettings::Base.after_commit :clear_cache, on: %i[create update destroy]
     end
   end
 end

data/lib/rails-settings/request_cache.rb

@@ -0,0 +1,30 @@
+module RailsSettings
+  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
+      attribute :settings
+    end
+  else
+    # https://github.com/steveklabnik/request_store
+    # For Rails 5.0
+    require "request_store"
+
+    class RequestCache
+      class << self
+        def reset
+          self.settings = nil
+        end
+
+        def settings
+          RequestStore.store[:rails_settings_all_settings]
+        end
+
+        def settings=(val)
+          RequestStore.store[:rails_settings_all_settings]
+        end
+      end
+    end
+  end
+end

data/lib/rails-settings/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module RailsSettings
   class << self
     def version
-      "0.7.2"
+      "2.7.0"
     end
   end
 end

data/lib/rails-settings-cached.rb

@@ -1,8 +1,7 @@
-require_relative "rails-settings/settings"
+# frozen_string_literal: true
+
 require_relative "rails-settings/base"
-require_relative "rails-settings/scoped_settings"
-require_relative "rails-settings/default"
-require_relative "rails-settings/extend"
+require_relative "rails-settings/request_cache"
 require_relative "rails-settings/railtie"
 require_relative "rails-settings/version"
 

metadata

@@ -1,17 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-settings-cached
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 2.7.0
 platform: ruby
 authors:
 - Jason Lee
-- Squeegy
-- Georg Ledermann
-- 100hz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-08 00:00:00.000000000 Z
+date: 2021-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -19,16 +16,16 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 5.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 5.0.0
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -42,21 +39,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.46.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.46.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -70,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -84,7 +81,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: codecov
+  name: simplecov
+  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: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -97,32 +108,31 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "\n  This is improved from rails-settings, added caching.\n  Settings
-  plugin for Rails that makes managing a table of global key,\n  value pairs easy.
-  Think of it like a global Hash stored in you database,\n  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,
+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
+  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  "
 email: huacnlee@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE
 - README.md
+- Rakefile
 - lib/generators/settings/install_generator.rb
-- lib/generators/settings/templates/app.yml
 - lib/generators/settings/templates/migration.rb
 - lib/generators/settings/templates/model.rb
 - lib/rails-settings-cached.rb
 - lib/rails-settings/base.rb
-- lib/rails-settings/default.rb
-- lib/rails-settings/extend.rb
 - lib/rails-settings/railtie.rb
-- lib/rails-settings/scoped_settings.rb
-- lib/rails-settings/settings.rb
+- lib/rails-settings/request_cache.rb
 - lib/rails-settings/version.rb
 homepage: https://github.com/huacnlee/rails-settings-cached
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -132,16 +142,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
-summary: Settings plugin for Rails that makes managing a table of global keys.
+summary: The best solution for store global settings in Rails applications.
 test_files: []

data/lib/generators/settings/templates/app.yml

@@ -1,13 +0,0 @@
-# config/app.yml for rails-settings-cached
-defaults: &defaults
-  foo: "Foo"
-  bar: 123
-
-development:
-  <<: *defaults
-
-test:
-  <<: *defaults
-
-production:
-  <<: *defaults

data/lib/rails-settings/default.rb

@@ -1,40 +0,0 @@
-require "digest/md5"
-
-module RailsSettings
-  class Default < ::Hash
-    class MissingKey < StandardError; end
-
-    class << self
-      def enabled?
-        source_path && File.exist?(source_path)
-      end
-
-      def source(value = nil)
-        @source ||= value
-      end
-
-      def source_path
-        @source || Rails.root.join("config/app.yml")
-      end
-
-      def [](key)
-        # foo.bar.dar Nested fetch value
-        return instance[key] if instance.key?(key)
-        keys = key.to_s.split(".")
-        instance.dig(*keys)
-      end
-
-      def instance
-        return @instance if defined? @instance
-        @instance = new
-      end
-    end
-
-    def initialize
-      content = open(self.class.source_path).read
-      hash = content.empty? ? {} : YAML.load(ERB.new(content).result).to_hash
-      hash = hash[Rails.env] || {}
-      replace hash
-    end
-  end
-end

data/lib/rails-settings/extend.rb

@@ -1,34 +0,0 @@
-module RailsSettings
-  module Extend
-    extend ActiveSupport::Concern
-
-    included do
-      scope :with_settings, lambda {
-        joins("JOIN settings ON (settings.thing_id = #{table_name}.#{primary_key} AND
-                                 settings.thing_type = '#{base_class.name}')")
-          .select("DISTINCT #{table_name}.*")
-      }
-
-      scope :with_settings_for, lambda { |var|
-        joins("JOIN settings ON (settings.thing_id = #{table_name}.#{primary_key} AND
-                                 settings.thing_type = '#{base_class.name}') AND settings.var = '#{var}'")
-      }
-
-      scope :without_settings, lambda {
-        joins("LEFT JOIN settings ON (settings.thing_id = #{table_name}.#{primary_key} AND
-                                      settings.thing_type = '#{base_class.name}')")
-          .where("settings.id IS NULL")
-      }
-
-      scope :without_settings_for, lambda { |var|
-        where("settings.id IS NULL")
-          .joins("LEFT JOIN settings ON (settings.thing_id = #{table_name}.#{primary_key} AND
-                                       settings.thing_type = '#{base_class.name}') AND settings.var = '#{var}'")
-      }
-    end
-
-    def settings
-      ScopedSettings.for_thing(self)
-    end
-  end
-end

data/lib/rails-settings/scoped_settings.rb

@@ -1,12 +0,0 @@
-module RailsSettings
-  class ScopedSettings < Base
-    def self.for_thing(object)
-      @object = object
-      self
-    end
-
-    def self.thing_scoped
-      unscoped.where(thing_type: @object.class.base_class.to_s, thing_id: @object.id)
-    end
-  end
-end