rails-settings-cached 0.4.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6bd842dbc504791a77630162468aa6e478a995c2
-  data.tar.gz: 5dcfb862ea79ee47eec0dd6316dfad8b3d1ff811
+SHA256:
+  metadata.gz: e89d0b87824703140e5d9182ade7936b22045bde791ba86d805dfbde9614f7b7
+  data.tar.gz: 2a3643dd2c6b3b837c3a4b1361651ca0a5b468336e038a38d1aaaa3bc659e151
 SHA512:
-  metadata.gz: cd476936667b371251f5fb6b66a3a1dabdf5e99b6808171ecfdd0baa38bca03df6e6ed9475ed7a488626795952076a87d42923b174a13da57e4e1d24bb7c5e95
-  data.tar.gz: 8f093f58bf66a5939d57c6d412a7b9ce742b95f0de4d2f34ea1c0db53fc720df7aa23761964162b0a6d9ff1344630afa405ad9c348bc266a18c0a8ef4008d560
+  metadata.gz: e6b9209c170d1b5d34b62496533936c4e8598bc963fb5bd1fbb3a8c5b86424e6c7986fb300eb4aebc89ce7e13f86d083588bef06e93c5c6927b18ccf2465e5e6
+  data.tar.gz: 7b7b05d0794663008292b3630c99c160f8fc54cc0b9e8b958d46052cb63ce94f9eff4d012d06b2676551cfc805502d890e5313a887d3611bfb6fdbd0ffb2d3d9

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006 Alex Wayne
+Some additional features added 2009 by Georg Ledermann
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOa AND
+NONINFRINGEMENT. IN NO EVENT SaALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,179 +1,233 @@
-# Settings Gem
-
-This is improved from rails-settings, added caching for all settings.
-Settings is a plugin that makes managing a table of global key, value pairs easy.
-Think of it like a global Hash stored in you database, that uses simple ActiveRecord
-like methods for manipulation.  Keep track of any global setting that you dont want
-to hard code into your rails app.  You can store any kind of object.  Strings, numbers,
-arrays, or any object. Ported to Rails 3!
-
-## Status
-
-- [![Gem Version](https://badge.fury.io/rb/rails-settings-cached.png)](https://rubygems.org/gems/rails-settings-cached)
-- [![CI Status](https://api.travis-ci.org/huacnlee/rails-settings-cached.png)](http://travis-ci.org/huacnlee/rails-settings-cached)
-
-## Setup
-
-Edit your Gemfile:
-
-```ruby
-# Rails 4.1.x
-gem "rails-settings-cached", "0.4.1"
-# Rails 4+
-gem "rails-settings-cached", "0.3.1"
-# Rails 3.x
-gem "rails-settings-cached", "0.2.4"
-```
-
-Generate your settings:
-
-```bash
-$ rails g settings <settings_name>
-```
-
-Note: If you migrating from gem `rails-settings` then make sure you have it in your model
-
-```ruby
-class Settings < RailsSettings::CachedSettings
-  ...
-end
-```
-
-Now just put that migration in the database with:
-
-```bash
-rake db:migrate
-```
-
-## Usage
-
-The syntax is easy.  First, lets create some settings to keep track of:
-
-```ruby
-Setting.admin_password = 'supersecret'
-Setting.date_format    = '%m %d, %Y'
-Setting.cocktails      = ['Martini', 'Screwdriver', 'White Russian']
-Setting.foo            = 123
-Setting.credentials    = { :username => 'tom', :password => 'secret' }
-```
-
-Now lets read them back:
-
-```ruby
-Setting.foo            # returns 123
-```
-
-Changing an existing setting is the same as creating a new setting:
-
-```ruby
-Setting.foo = 'super duper bar'
-```
-
-For changing an existing setting which is a Hash, you can merge new values with existing ones:
-
-```ruby
-Setting.merge!(:credentials, :password => 'topsecret')
-Setting.credentials    # returns { :username => 'tom', :password => 'topsecret' }
-```
-
-Decide you dont want to track a particular setting anymore?
-
-```ruby
-Setting.destroy :foo
-Setting.foo            # returns nil
-```
-
-Want a list of all the settings?
-
-```ruby
-Setting.get_all
-# returns {'admin_password' => 'super_secret', 'date_format' => '%m %d, %Y'}
-```
-
-You need name spaces and want a list of settings for a give name space? Just choose your prefered named space delimiter and use Setting.get_all like this:
-
-```ruby
-Setting['preferences.color'] = :blue
-Setting['preferences.size'] = :large
-Setting['license.key'] = 'ABC-DEF'
-Setting.get_all('preferences.')
-# returns { 'preferences.color' => :blue, 'preferences.size' => :large }
-```
-
-Set defaults for certain settings of your app.  This will cause the defined settings to return with the
-Specified value even if they are **not in the database**.  Make a new file in `config/initializers/default_settings.rb`
-with the following:
-
-```ruby
-Setting.defaults[:some_setting] = 'footastic'
-Setting.where(:var => "some_setting").count
-=> 0
-Setting.some_setting
-=> "footastic"
-```
-
-Init defualt value in database, this has indifferent with `Setting.defaults[:some_setting]`, this will **save the value into database**:
-
-```ruby
-Setting.save_default(:some_key, "123")
-Setting.where(:var => "some_key").count
-=> 1
-Setting.some_key
-=> "123"
-```
-
-Settings may be bound to any existing ActiveRecord object. Define this association like this:
-Notice! is not do caching in this version.
-
-```ruby
-class User < ActiveRecord::Base
-  include RailsSettings::Extend
-end
-```
-
-Then you can set/get a setting for a given user instance just by doing this:
-
-```ruby
-user = User.find(123)
-user.settings.color = :red
-user.settings.color # returns :red
-user.settings.get_all # { "color" => :red }
-```
-
-I you want to find users having or not having some settings, there are named scopes for this:
-
-```ruby
-User.with_settings
-# => returns a scope of users having any setting
-
-User.with_settings_for('color')
-# => returns a scope of users having a 'color' setting
-
-User.without_settings
-# returns a scope of users having no setting at all (means user.settings.get_all == {})
-
-User.without_settings('color')
-# returns a scope of users having no 'color' setting (means user.settings.color == nil)
-```
-
------
-
-## How to create a list, form to manage Settings?
-
-If you want create an admin interface to editing the Settings, you can try methods in follow:
-
-```ruby
-class SettingsController < ApplicationController
-  def index
-    # to get all items for render list
-    @settings = Setting.unscoped
-  end
-  
-  def edit
-    @setting = Setting.unscoped.find(params[:id])
-  end
-end
-```
-
-
-That's all there is to it! Enjoy!
+# 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,
+that uses simple ActiveRecord like methods for manipulation. Keep track of any global
+setting that you dont 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 redesign the API, the new version will compatible with the stored setting values by older version.
+> When you wants to upgrade 2.x, you must read the README again, and follow guides to change your Setting model.
+
+## 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) [![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
+
+Edit your Gemfile:
+
+```ruby
+gem "rails-settings-cached"
+```
+
+Generate your settings:
+
+```bash
+$ rails g settings:install
+```
+
+If you want custom model name:
+
+```bash
+$ rails g settings:install
+```
+
+Or use a custom name:
+
+```bash
+$ rails g settings:install SiteConfig
+```
+
+You will get `app/models/setting.rb`
+
+```rb
+class Setting < RailsSettings::Base
+  # cache_prefix { "v1" }
+
+  field :host, default: "http://example.com"
+  field :readonly_item, type: :integer, default: 100, readonly: true
+  field :user_limits, type: :integer, default: 20
+  field :admin_emails, type: :array, default: %w[admin@rubyonrails.org]
+  field :captcha_enable, type: :boolean, default: 1
+  field :notification_options, type: :hash, default: {
+    send_all: true,
+    logging: true,
+    sender_email: "foo@bar.com"
+  }
+end
+```
+
+You must use `field` method to statement the setting keys, otherwice you can't use it.
+
+Now just put that migration in the database with:
+
+```bash
+rake db:migrate
+```
+
+## Usage
+
+The syntax is easy.  First, lets 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.user_limits
+20
+irb > Setting.user_limits = "30"
+irb > Setting.user_limits
+30
+irb > Setting.user_limits = 45
+irb > Setting.user_limits
+45
+
+irb > Setting.captcha_enable
+1
+irb > Setting.captcha_enable?
+true
+irb > Setting.captcha_enable = "0"
+irb > Setting.captcha_enable
+false
+irb > Setting.captcha_enable = "1"
+irb > Setting.captcha_enable
+true
+irb > Setting.captcha_enable = "false"
+irb > Setting.captcha_enable
+false
+irb > Setting.captcha_enable = "true"
+irb > Setting.captcha_enable
+true
+irb > Setting.captcha_enable?
+true
+
+irb > Setting.admin_emails
+["admin@rubyonrails.org"]
+irb > Setting.admin_emails = %w[foo@bar.com bar@dar.com]
+irb > Setting.admin_emails
+["foo@bar.com", "bar@dar.com"]
+irb > Setting.admin_emails = "huacnlee@gmail.com,admin@admin.com\nadmin@rubyonrails.org"
+irb > Setting.admin_emails
+["huacnlee@gmail.com", "admin@admin.com", "admin@rubyonrails.org"]
+
+irb > Setting.notification_options
+{
+  send_all: true,
+  logging: true,
+  sender_email: "foo@bar.com"
+}
+irb > Setting.notification_options = {
+  sender_email: "notice@rubyonrails.org"
+}
+irb > Setting.notification_options
+{
+  sender_email: "notice@rubyonrails.org"
+}
+```
+
+### Caching flow:
+
+```
+Setting.host -> Check Cache -> Exist - Get value of key for cache -> Return
+                   |
+                Fetch all key and values from DB -> Write Cache -> Get value of key for cache -> return
+                   |
+                Return default value or nil
+```
+
+In each Setting keys call, we will load the cache/db and save in Thread.current for avoid hit cache/db.
+
+Each key update will expires the cache, so do not add some frequent update key.
+
+## Change cache key
+
+Some times you may need to force update cache, now you can use `cache_prefix`
+
+```ruby
+class Setting < RailsSettings::Base
+  cache_prefix { "you-prefix" }
+  ...
+end
+```
+
+-----
+
+## How to manage Settings in admin interface?
+
+If you want create an admin interface to editing the Settings, you can try methods in follow:
+
+config/routes.rb
+
+```rb
+namespace :admin do
+  resources :settings
+end
+```
+
+
+app/controllers/admin/settings_controller.rb
+
+```rb
+module Admin
+  class SettingsController < ApplicationController
+    before_action :get_setting, only: [:edit, :update]
+
+    def show
+    end
+
+    def create
+      setting_params.keys.each do |key|
+        next if key.to_s == "site_logo"
+        Setting.send("#{key}=", setting_params[key].strip) unless setting_params[key].nil?
+      end
+      redirect_to admin_settings_path(notice: "Setting was successfully updated.")
+    end
+
+
+    private
+      def setting_params
+        params.require(:setting).permit(:host, :user_limits, :admin_emails,
+          :captcha_enable, :notification_options)
+      end
+  end
+end
+```
+
+app/views/admin/settings/show.html.erb
+
+```erb
+<%= form_for(Setting.new, url: admin_settings_path) do |f| %>
+  <div class="form-group">
+    <label class="control-label">Host</label>
+    <%= f.text_field :host, value: Setting.host, class: "form-control", placeholder: "http://localhost"  %>
+  </div>
+
+  <div class="form-group form-checkbox">
+    <label>
+      <%= f.check_box :captcha_enable, checked: Setting.captcha_enable? %>
+      Enable/Disable Captcha
+    </label>
+  </div>
+
+  <div class="form-group">
+    <label class="control-label">Admin Emails</label>
+    <%= f.text_area :admin_emails, value: Setting.admin_emails.join("\n"), class: "form-control" %>
+  </div>
+
+  <div class="form-group">
+    <label class="control-label">Notification options</label>
+    <%= f.text_area :notification_options, value: YAML.dump(Setting.notification_options), class: "form-control", style: "height: 180px;"  %>
+    <div class="form-text">
+      Use YAML format to config the SMTP_html
+    </details>
+<% end %>
+```
+
+## Use case:
+
+- [ruby-china/ruby-china](https://github.com/ruby-china/ruby-china)

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/migration"
+
+module Settings
+  class InstallGenerator < Rails::Generators::NamedBase
+    desc "Generate RailsSettings files."
+    include Rails::Generators::Migration
+
+    argument :name, type: :string, default: "setting"
+
+    source_root File.expand_path("../templates", __FILE__)
+
+    @@migrations = false
+
+    def self.next_migration_number(dirname) #:nodoc:
+      if ActiveRecord::Base.timestamped_migrations
+        if @@migrations
+          (current_migration_number(dirname) + 1)
+        else
+          @@migrations = true
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        end
+      else
+        format "%.3d", current_migration_number(dirname) + 1
+      end
+    end
+
+    def install_setting
+      template "model.rb", File.join("app/models", class_path, "#{file_name}.rb")
+      migration_template "migration.rb", "db/migrate/create_settings.rb", migration_version: migration_version
+    end
+
+    def rails5?
+      Rails.version.start_with? "5"
+    end
+
+    def migration_version
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]" if rails5?
+    end
+  end
+end

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

@@ -1,14 +1,12 @@
-class CreateSettings < ActiveRecord::Migration
+class CreateSettings < ActiveRecord::Migration<%= migration_version %>
   def self.up
     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, :limit => 30, :null => true
+      t.string  :var,        null: false
+      t.text    :value,      null: true
       t.timestamps
     end
-    
-    add_index :settings, [ :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,2 +1,10 @@
-class <%= class_name %> < RailsSettings::CachedSettings
+# RailsSettings Model
+class <%= class_name %> < RailsSettings::Base
+  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
 end

data/lib/rails-settings/base.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RailsSettings
+  class Base < ActiveRecord::Base
+    class SettingNotFound < RuntimeError; end
+
+    SEPARATOR_REGEXP = /[\s,]/
+    self.table_name = table_name_prefix + "settings"
+
+    # get the value field, YAML decoded
+    def value
+      YAML.load(self[:value]) if self[:value].present?
+    end
+
+    # set the value field, YAML encoded
+    def value=(new_value)
+      self[:value] = new_value.to_yaml
+    end
+
+    def expire_cache
+      Thread.current[:rails_settings_all_settings] = nil
+      Rails.cache.delete(self.class.cache_key)
+    end
+
+    class << self
+      def field(key, **opts)
+        _define_field(key, default: opts[:default], type: opts[:type], readonly: opts[:readonly])
+      end
+
+      def cache_prefix(&block)
+        @cache_prefix = block
+      end
+
+      def cache_key
+        scope = ["rails-settings-cached"]
+        scope << @cache_prefix.call if @cache_prefix
+        scope.join("/")
+      end
+
+      private
+        def _define_field(key, default: nil, type: :string, readonly: false)
+          self.class.define_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(:_covert_string_to_typeof_value, type, result)
+
+            result
+          end
+
+          unless readonly
+            self.class.define_method("#{key}=") do |value|
+              var_name = key.to_s
+
+              record = find_by(var: var_name) || new(var: var_name)
+              value = self.send(:_covert_string_to_typeof_value, type, value)
+
+              record.value = value
+              record.save!
+
+              value
+            end
+          end
+
+          if type == :boolean
+            self.class.define_method("#{key}?") do
+              val = self.send(:_value_of, key)
+              val == "true" || val == "1"
+            end
+          end
+        end
+
+        def _covert_string_to_typeof_value(type, value)
+          return value unless value.is_a?(String) || value.is_a?(Integer)
+
+          case type
+          when :boolean
+            return value == "true" || value == "1" || value == 1 || value == true
+          when :array
+            return value.split(SEPARATOR_REGEXP).reject { |str| str.empty? }
+          when :hash
+            value = YAML.load(value).to_hash rescue {}
+            value.deep_stringify_keys!
+            return value
+          when :integer
+            return value.to_i
+          else
+            value
+          end
+        end
+
+        def _value_of(var_name)
+          raise "#{self.table_name} does not exist." unless table_exists?
+
+          _all_settings[var_name.to_s]
+        end
+
+        def rails_initialized?
+          Rails.application && Rails.application.initialized?
+        end
+
+        def _all_settings
+          raise "You can use settings before Rails initialize." unless rails_initialized?
+          Thread.current[: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
+          end
+        end
+    end
+  end
+end

data/lib/rails-settings/railtie.rb

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

data/lib/rails-settings/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RailsSettings
+  class << self
+    def version
+      "2.0.0"
+    end
+  end
+end

data/lib/rails-settings-cached.rb

@@ -1,4 +1,8 @@
-require "rails-settings/settings"
-require "rails-settings/scoped_settings"
-require "rails-settings/cached_settings"
-require "rails-settings/extend"
+# frozen_string_literal: true
+
+require_relative "rails-settings/base"
+require_relative "rails-settings/railtie"
+require_relative "rails-settings/version"
+
+module RailsSettings
+end

metadata

@@ -1,17 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-settings-cached
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 2.0.0
 platform: ruby
 authors:
-- Squeegy
-- Georg Ledermann
-- 100hz
 - Jason Lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-12 00:00:00.000000000 Z
+date: 2019-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -19,29 +16,105 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 4.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
-description: 
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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
+    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: 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: minitest
+  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: codecov
+  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'
+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,
+  numbers, arrays, or any object.\n  "
 email: huacnlee@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE
 - README.md
-- lib/generators/settings/settings_generator.rb
+- Rakefile
+- lib/generators/settings/install_generator.rb
 - lib/generators/settings/templates/migration.rb
 - lib/generators/settings/templates/model.rb
 - lib/rails-settings-cached.rb
-- lib/rails-settings/cached_settings.rb
-- lib/rails-settings/extend.rb
-- lib/rails-settings/scoped_settings.rb
-- lib/rails-settings/settings.rb
+- lib/rails-settings/base.rb
+- lib/rails-settings/railtie.rb
+- lib/rails-settings/version.rb
 homepage: https://github.com/huacnlee/rails-settings-cached
 licenses: []
 metadata: {}
@@ -53,21 +126,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
-summary: This is imporved from rails-settings, added caching. Settings is a plugin
-  that makes managing a table of global key, value pairs easy. Think of it like a
-  global Hash stored in you database, that uses simple ActiveRecord like methods for
-  manipulation.  Keep track of any global setting that you dont want to hard code
-  into your rails app.  You can store any kind of object.  Strings, numbers, arrays,
-  or any object. Ported to Rails 3!
+summary: Settings plugin for Rails that makes managing a table of global keys.
 test_files: []

data/lib/generators/settings/settings_generator.rb

@@ -1,30 +0,0 @@
-require 'rails/generators/migration'
-
-    class SettingsGenerator < Rails::Generators::NamedBase
-      include Rails::Generators::Migration
-  
-      argument :name, :type => :string, :default => "my_settings"
-  
-      source_root File.expand_path('../templates', __FILE__)  
-  
-      @@migrations = false
-      
-      def self.next_migration_number(dirname) #:nodoc:
-        if ActiveRecord::Base.timestamped_migrations
-          if @@migrations          
-            (current_migration_number(dirname) + 1)
-          else
-            @@migrations = true
-            Time.now.utc.strftime("%Y%m%d%H%M%S")
-          end
-        else
-          "%.3d" % (current_migration_number(dirname) + 1)
-        end
-      end  
-
-      def settings      
-        #generate(:model, name, "--skip-migration")
-        template "model.rb", File.join("app/models",class_path,"#{file_name}.rb"), :force => true
-        migration_template "migration.rb", "db/migrate/create_settings.rb"
-      end
-    end

data/lib/rails-settings/cached_settings.rb

@@ -1,25 +0,0 @@
-module RailsSettings
-  class CachedSettings < Settings
-    after_update :rewrite_cache    
-    after_create :rewrite_cache
-    def rewrite_cache
-      Rails.cache.write("settings:#{self.var}", self.value)
-    end
-    
-    after_destroy { |record| Rails.cache.delete("settings:#{record.var}") }
-    
-    def self.[](var_name)
-      cache_key = "settings:#{var_name}"
-      obj = Rails.cache.fetch(cache_key) {
-        super(var_name)
-      }
-      obj == nil ? @@defaults[var_name.to_s] : obj
-    end    
-    
-    def self.save_default(key,value)
-      if self.send(key) == nil
-        self.send("#{key}=",value)
-      end
-    end
-  end
-end

data/lib/rails-settings/extend.rb

@@ -1,37 +0,0 @@
-module RailsSettings
-  module Extend
-    extend ActiveSupport::Concern
-    
-    included do 
-      scope :with_settings, -> {
-        joins("JOIN settings ON (settings.thing_id = #{self.table_name}.#{self.primary_key} AND
-                                               settings.thing_type = '#{self.base_class.name}')")
-        .select("DISTINCT #{self.table_name}.*")
-      } 
-                             
-
-      scope :with_settings_for, ->(var) {
-        joins("JOIN settings ON (settings.thing_id = #{self.table_name}.#{self.primary_key} AND
-              settings.thing_type = '#{self.base_class.name}') AND settings.var = '#{var}'") 
-      }
-                                                               
-      scope :without_settings, -> {
-        joins("LEFT JOIN settings ON (settings.thing_id = #{self.table_name}.#{self.primary_key} AND settings.thing_type = '#{self.base_class.name}')")
-        .where("settings.id IS NULL")    
-      } 
-                                     
-      scope :without_settings_for, ->(var) {
-        where('settings.id IS NULL')
-        .joins("LEFT JOIN settings ON (settings.thing_id = #{self.table_name}.#{self.primary_key} AND
-               settings.thing_type = '#{self.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,13 +0,0 @@
-module RailsSettings
-  class ScopedSettings < Settings
-    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

data/lib/rails-settings/settings.rb

@@ -1,118 +0,0 @@
-module RailsSettings
-  class Settings < ActiveRecord::Base
-
-    self.table_name = table_name_prefix + 'settings'
-
-    class SettingNotFound < RuntimeError; end
-
-    cattr_accessor :defaults
-    @@defaults = {}.with_indifferent_access
-
-    # Support old plugin
-    if defined?(SettingsDefaults::DEFAULTS)
-      @@defaults = SettingsDefaults::DEFAULTS.with_indifferent_access
-    end
-
-    #get or set a variable with the variable as the called method
-    def self.method_missing(method, *args)
-      method_name = method.to_s
-      super(method, *args)
-    rescue NoMethodError
-      #set a value for a variable
-      if method_name =~ /=$/
-        var_name = method_name.gsub('=', '')
-        value = args.first
-        self[var_name] = value
-      #retrieve a value
-      else
-        self[method_name]
-      end
-    end
-
-    #destroy the specified settings record
-    def self.destroy(var_name)
-      var_name = var_name.to_s
-      obj = object(var_name)
-      unless obj.nil?
-        obj.destroy
-        true
-      else
-        raise SettingNotFound, "Setting variable \"#{var_name}\" not found"
-      end
-    end
-
-    #retrieve all settings as a hash (optionally starting with a given namespace)
-    def self.get_all(starting_with = nil)
-      vars = thing_scoped.select("var,value")
-      if starting_with
-        vars = vars.where("var LIKE '#{starting_with}%'")
-      end
-
-      result = {}
-      vars.each do |record|
-        result[record.var] = record.value
-      end
-      result.with_indifferent_access
-    end
-    
-    def self.where(sql = nil)
-      if sql
-        vars = thing_scoped.where(sql)
-      end
-      vars
-    end
-    
-    #get a setting value by [] notation
-    def self.[](var_name)
-      if var = object(var_name)
-        var.value
-      elsif @@defaults[var_name.to_s]
-        @@defaults[var_name.to_s]
-      else
-        nil
-      end
-    end
-
-    #set a setting value by [] notation
-    def self.[]=(var_name, value)
-      var_name = var_name.to_s
-
-      record = object(var_name) || thing_scoped.new(:var => var_name)
-      record.value = value
-      record.save!
-
-      value
-    end
-
-    def self.merge!(var_name, hash_value)
-      raise ArgumentError unless hash_value.is_a?(Hash)
-
-      old_value = self[var_name] || {}
-      raise TypeError, "Existing value is not a hash, can't merge!" unless old_value.is_a?(Hash)
-
-      new_value = old_value.merge(hash_value)
-      self[var_name] = new_value if new_value != old_value
-
-      new_value
-    end
-
-    def self.object(var_name)
-      thing_scoped.where(:var => var_name.to_s).first
-    end
-
-    #get the value field, YAML decoded
-    def value
-      YAML::load(self[:value])
-    end
-
-    #set the value field, YAML encoded
-    def value=(new_value)
-      self[:value] = new_value.to_yaml
-    end
-
-    def self.thing_scoped
-      unscoped.where("thing_type is NULL and thing_id is NULL")
-    end
-
-  end
-end