ruby-settings-cached 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba4e9ee304a2b3dad3de28b7991da2385eb5f3e9
+  data.tar.gz: 034bf0a2d72024d4ed6762ae83a753bb27ec9c52
+SHA512:
+  metadata.gz: 5047728194298915cb178c2a93c7e1bb3d81375a905b152f8399cb87476d2458eb06e50d721850f92888b344d90dda492a508b2e6f66f211d0e4f03bd1e05194
+  data.tar.gz: 125508ee57f87528a0c3a3c49be8f0b049c1656983f62b6d2985a448a15d96c58ce02bb1dbfcb404970a9c84b2ce7919f470d0ca974f44725c167ee547d13e50

data/README.md

@@ -0,0 +1,189 @@
+# Settings Gem
+
+This is improved from [rails-settings](https://github.com/ledermann/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 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.
+
+## Status
+
+- [![Gem Version](https://badge.fury.io/rb/rails-settings-cached.png)](https://rubygems.org/gems/rails-settings-cached)
+- [![CI Status](https://travis-ci.org/RobotJiang/ruby-settings-cached.svg)](https://travis-ci.org/RobotJiang/ruby-settings-cached)
+
+## Setup
+
+Edit your Gemfile:
+
+```ruby
+# Rails 4+ project or Only ruby project
+gem "ruby-settings-cached", "0.1"
+```
+
+Generate your settings if you use Rails:
+
+```bash
+$ rails g settings <settings_name>
+```
+
+```
+
+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
+# Rails 4.1.x
+Setting.get_all
+# Rails 3.x and 4.0.x
+Setting.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` (`Settings.all` for # Rails 3.x and 4.0.x) like this:
+
+```ruby
+Setting['preferences.color'] = :blue
+Setting['preferences.size'] = :large
+Setting['license.key'] = 'ABC-DEF'
+# Rails 4.1.x
+Setting.get_all('preferences.')
+# Rails 3.x and 4.0.x
+Setting.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 default 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
+# Rails 4.1.x
+user.settings.get_all
+# Rails 3.x and 4.0.x
+user.settings.all
+# { "color" => :red }
+```
+
+If 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)
+```
+
+Settings maybe dynamically scoped. For example, if you're using [apartment gem](https://github.com/influitive/apartment) for multitenancy, you may not want tenants to share settings:
+
+```ruby
+class Settings < RailsSettings::CachedSettings
+  cache_prefix { Apartment::Tenant.current }
+  ...
+end
+```
+
+-----
+
+## 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
+```
+
+
+Also you may use [rails-settings-ui](https://github.com/accessd/rails-settings-ui) gem
+for building ready to using interface with validations.
+

data/lib/generators/settings/settings_generator.rb

@@ -0,0 +1,32 @@
+require 'rails/generators/migration'
+
+if defined?(Rails)
+  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
+        format '%.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
+end 

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

@@ -0,0 +1,17 @@
+class CreateSettings < ActiveRecord::Migration
+  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, null: true, limit: 30
+      t.timestamps
+    end
+
+    add_index :settings, %i(thing_type thing_id var), unique: true
+  end
+
+  def self.down
+    drop_table :settings
+  end
+end

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

@@ -0,0 +1,3 @@
+# RubySettings Model
+class <%= class_name %> < RubySettings::CachedSettings
+end

data/lib/ruby-settings-cached.rb

@@ -0,0 +1,7 @@
+require_relative 'ruby-settings/settings'
+require_relative 'ruby-settings/configuration'
+require_relative 'ruby-settings/cached_settings'
+require_relative 'ruby-settings/scoped_settings'
+require_relative 'ruby-settings/extend'
+
+

data/lib/ruby-settings/cached_settings.rb

@@ -0,0 +1,51 @@
+module RubySettings
+  class CachedSettings < Settings 
+    after_update :rewrite_cache    
+    after_create :rewrite_cache
+    after_destroy :expire_cache 
+
+    include RubySettings::ConfigurationHelpers
+
+    def rewrite_cache
+      cache_store.write(cache_key, value)
+    end
+
+    def expire_cache
+      cache_store.delete(cache_key)
+    end
+
+    def cache_key
+      self.class.cache_key(var, thing)
+    end
+
+    class << self
+      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}"
+      end
+
+      def [](var_name)
+        value = RubySettings.config.cache_store.fetch(cache_key(var_name, @object)) do
+          super(var_name)
+        end
+
+        if value.nil?
+          @@defaults[var_name.to_s] if value.nil?
+        else
+          value
+        end
+      end
+
+      def save_default(key, value)
+        return false unless self[key].nil?
+        self[key] = value
+      end
+    end
+  end
+end

data/lib/ruby-settings/configuration.rb

@@ -0,0 +1,30 @@
+module RubySettings
+
+  class << self
+
+    attr_accessor :configuration
+
+    def config
+      self.configuration ||= Configuration.new
+    end
+
+    def configure
+      yield config if block_given?
+    end
+
+  end
+
+  class Configuration
+    attr_accessor :cache_store
+  end
+
+  module ConfigurationHelpers
+    extend ActiveSupport::Concern
+
+    def cache_store
+      @cache_store ||= (RubySettings.config.cache_store || ActiveSupport::Cache::MemoryStore.new)
+    end
+
+  end
+end
+

data/lib/ruby-settings/extend.rb

@@ -0,0 +1,34 @@
+module RubySettings
+  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/ruby-settings/scoped_settings.rb

@@ -0,0 +1,12 @@
+module RubySettings
+  class ScopedSettings < CachedSettings
+    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/ruby-settings/settings.rb

@@ -0,0 +1,110 @@
+module RubySettings
+  class Settings < ActiveRecord::Base
+    self.table_name = table_name_prefix + 'settings'
+
+    class SettingNotFound < RuntimeError; end
+
+    cattr_accessor :defaults
+    @@defaults = {}.with_indifferent_access
+
+    belongs_to :thing, polymorphic: true
+
+    # Support old plugin
+    if defined?(SettingsDefaults::DEFAULTS)
+      @@defaults = SettingsDefaults::DEFAULTS.with_indifferent_access
+    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
+
+    class << self
+      # get or set a variable with the variable as the called method
+      def method_missing(method, *args)
+        method_name = method.to_s
+        super(method, *args)
+      rescue NoMethodError
+        # set a value for a variable
+        if method_name[-1] == '='
+          var_name = method_name.sub('=', '')
+          value = args.first
+          self[var_name] = value
+        else
+          # retrieve a value
+          self[method_name]
+        end
+      end
+
+      # destroy the specified settings record
+      def destroy(var_name)
+        var_name = var_name.to_s
+        obj = object(var_name)
+        raise SettingNotFound, "Setting variable \"#{var_name}\" not found" if obj.nil?
+
+        obj.destroy
+        true
+      end
+
+      # retrieve all settings as a hash (optionally starting with a given namespace)
+      def get_all(starting_with = nil)
+        vars = thing_scoped.select('var, value')
+        vars = vars.where("var LIKE '#{starting_with}%'") if starting_with
+
+        result = {}
+        vars.each do |record|
+          result[record.var] = record.value
+        end
+        result.merge! @@defaults.slice(*(@@defaults.keys - result.keys))
+
+        result.with_indifferent_access
+      end
+
+      def where(sql = nil)
+        vars = thing_scoped.where(sql) if sql
+        vars
+      end
+
+      # get a setting value by [] notation
+      def [](var_name)
+        object(var_name).try(:value) || @@defaults[var_name.to_s]
+      end
+
+      # set a setting value by [] notation
+      def []=(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 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 object(var_name)
+        thing_scoped.where(var: var_name.to_s).first
+      end
+
+      def thing_scoped
+        unscoped.where('thing_type is NULL and thing_id is NULL')
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: ruby-settings-cached
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Squeegy
+- Georg Ledermann
+- 100hz
+- Jason Lee
+- Raymond Jiang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.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: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.10
+description: 
+email: huacnlee@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/generators/settings/settings_generator.rb
+- lib/generators/settings/templates/migration.rb
+- lib/generators/settings/templates/model.rb
+- lib/ruby-settings-cached.rb
+- lib/ruby-settings/cached_settings.rb
+- lib/ruby-settings/configuration.rb
+- lib/ruby-settings/extend.rb
+- lib/ruby-settings/scoped_settings.rb
+- lib/ruby-settings/settings.rb
+homepage: https://github.com/RobotJiang/ruby-settings-cached
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: This is improved 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!
+test_files: []