active_settings 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWQ0NTJiMmViYWU4ZWFmNDRkMDJhYWQzZjQ1YTNmZTNmZDhjMjI3NA==
+  data.tar.gz: !binary |-
+    MjhiZTMzYTQ4NzIwYmNlYjJiNzYzOGI0YzJhODM3OWVhM2U5M2FkZQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    Njc3YTE3OTZhNmQ4NjRlN2I5ZTk0MjU3MThjYWQ3OGU4YzcyYzU0MjE3YjZk
+    OWY1NjhkMDcxMDg0YTM0ZjVhZTY0YmQwOGYzYTY2MzNiZjRmOTFkYTBhNGU5
+    Mjg4ZGU0YjEwOWVhYWJmZjVkZGExNGE4MjcxYTJlOGFiYjliNGQ=
+  data.tar.gz: !binary |-
+    N2U2MTM2OWQ4NTlhNzM1NTQwMjU0NjQzZWYzNzlmMWYzNWQxYTVmMzY5Mjkx
+    MmM4Y2UyZDkyMTc1MzNkZjFhOWRjYzgxMjkwMDk3ODllODRjODc2NmE4MmRk
+    NWExYjAxMTNjZWU4Mzg3OWYwYzRlNDM3OGVhODdlNWVhMzViZjc=

data/lib/active_settings.rb

@@ -0,0 +1,10 @@
+require 'rails'
+require 'active_settings/version'
+require 'active_settings/config'
+require 'active_settings/engine'
+
+module ActiveSettings
+  def self.detail
+    ActiveSettings::Config
+  end
+end

data/lib/active_settings/config.rb

@@ -0,0 +1,287 @@
+module ActiveSettings
+
+  class << self
+    def config_definitions
+      @config_definitions ||= {}
+    end
+
+    def config_definitions=(definitions)
+      @config_definitions = definitions
+    end
+  end
+
+  class Config < ActiveRecord::Base
+    #
+    # The ActiveSettings.detail model class is stored in the database but emulates a hash
+    # with simple bracket methods that allow you to get and set values like so:
+    #
+    #   ActiveSettings.detail['setting.name'] = 'value'
+    #   ActiveSettings.detail['setting.name'] #=> "value"
+    #
+    # Config entries can be used freely as general-purpose global variables unless a definition
+    # has been given for that key, in which case restrictions and defaults may apply. The restrictions
+    # can take the form of validations, requirements, permissions or permitted options. They are
+    # declared by calling ActiveSettings::Config#define:
+    #
+    #   # setting must be either 'foo', 'bar' or 'blank'
+    #   define('admin.name', :select_from => ['foo', 'bar'])
+    #
+    #   # setting is (and must be) chosen from the names of currently available layouts
+    #   define('shop.layout', :select_from => lambda { Layout.all.map{|l| [l.name,l.id]} }, :allow_blank => false)
+    #
+    #   # setting cannot be changed at runtime
+    #   define('setting.important', :default => "something", :allow_change => false)
+    #
+    # Which almost always happens in a block like this:
+    #
+    #   ActiveSettings.detail.configure do |config|
+    #     config.namespace('user', :allow_change => true) do |user|
+    #       user.define 'allow_password_reset?', :default => true
+    #     end
+    #   end
+    #
+    # and usually in a config/active_settings.rb file in the application directory.
+    #
+    # admin.title               :: the title of the admin system
+    # admin.subtitle            :: the subtitle of the admin system
+    # defaults.page.parts       :: a comma separated list of default page parts
+    # defaults.page.status      :: a string representation of the default page status
+    # defaults.page.filter      :: the default filter to use on new page parts
+    # defaults.page.fields      :: a comma separated list of the default page fields
+    # defaults.snippet.filter   :: the default filter to use on new snippets
+    # dev.host                  :: the hostname where draft pages are viewable
+    # local.timezone            :: the timezone name (`rake -D time` for full list)
+    #                              used to correct displayed times
+    # page.edit.published_date? :: when true, shows the datetime selector
+    #                              for published date on the page edit screen
+    #
+    #
+
+    self.table_name = 'active_settings'
+    after_save :update_cache
+    attr_reader :definition
+
+    class ConfigError < RuntimeError; end
+
+    class << self
+
+      # Requesting a config item:
+      #
+      #    key = ActiveSettings.detail['key']
+      def [](key)
+        if table_exists?
+          unless ActiveSettings::Config.cache_exists?
+            ActiveSettings::Config.initialize_cache
+          end
+          Rails.cache.read('ActiveSettings::Config')[key]
+        end
+      end
+
+      # The usual way to use a config item:
+      #
+      #    ActiveSettings.detail['key'] = value
+      #
+      def []=(key, value)
+        if table_exists?
+          setting = find_or_initialize_by_key(key)
+          setting.value = value
+        end
+      end
+
+      def to_hash
+        Hash[ *find(:all).map { |pair| [pair.key, pair.value] }.flatten ]
+      end
+
+      def initialize_cache
+        Rails.cache.write('ActiveSettings::Config', ActiveSettings::Config.to_hash)
+        Rails.cache.silence!
+      end
+
+      def cache_clear!
+        initialize_cache
+      end
+
+      def cache_exists?
+        true if Rails.cache.read('ActiveSettings::Config')
+      end
+
+      def configure(&block)
+        yield self
+      end
+
+      # A convenient drying method for specifying a prefix and options common to several settings.
+      #
+      #   ActiveSettings.detail.configure do |config|
+      #     config.namespace('secret', :allow_display => false) do |secret|
+      #       secret.define('identity', :default => 'batman')      # defines 'secret.identity'
+      #       secret.define('lair', :default => 'batcave')         # defines 'secret.lair'
+      #       secret.define('longing', :default => 'vindication')  # defines 'secret.longing'
+      #     end
+      #   end
+      #
+      def namespace(prefix, options = {}, &block)
+        prefix = [options[:prefix], prefix].join('.') if options[:prefix]
+        with_options(options.merge(:prefix => prefix), &block)
+      end
+
+      # Declares a setting definition that will constrain and support the use of a particular config entry.
+      #
+      #   define('setting.key', options)
+      #
+      # Can take several options:
+      # * :default is the value that will be placed in the database if none has been set already
+      # * :type can be :string, :boolean or :integer. Note that all settings whose key ends in ? are considered boolean.
+      # * :select_from should be a list or hash suitable for passing to options_for_select, or a block that will return such a list at runtime
+      # * :validate_with should be a block that will receive a value and return true or false. Validations are also implied by type or select_from.
+      # * :allow_blank should be false if the config item must not be blank or nil
+      # * :allow_change should be false if the config item can only be set, not changed. Add a default to specify an unchanging config entry.
+      # * :allow_display should be false if the config item should not be showable in radius tags
+      #
+      # From the main ActiveSettings config/initializers/active_settings.rb:
+      #
+      #   ActiveSettings.detail.configure do |config|
+      #     config.define 'defaults.locale', :select_from => lambda {Layout.all.map{|l| [l.name, l.d]}}, :allow_blank => true
+      #     config.define 'defaults.page.parts', :default => "Body,Extended"
+      #     ...
+      #   end
+      #
+      # It's also possible to reuse a definition by passing it to define:
+      #
+      #   choose_layout = ActiveSettings::Config::Definition.new(:select_from => lambda {Layout.all.map{|l| [l.name, l.d]}})
+      #   define "my.layout", choose_layout
+      #   define "your.layout", choose_layout
+      #
+      # but at the moment that's only done in testing.
+      #
+      def define(key, options={})
+        called_from = caller.grep(/\/initializers\//).first
+        if options.is_a? ActiveSettings::Config::Definition
+          definition = options
+        else
+          key = [options[:prefix], key].join('.') if options[:prefix]
+        end
+
+        raise LoadError, %{
+Config definition error: '#{key}' is defined twice:
+1. #{called_from}
+2. #{definitions[key].definer}
+        } unless definitions[key].nil? || definitions[key].empty?
+
+        definition ||= ActiveSettings::Config::Definition.new(options.merge(:definer => called_from))
+        definitions[key] = definition
+
+        if self[key].nil? && !definition.default.nil?
+          begin
+            self[key] = definition.default
+          rescue ActiveRecord::RecordInvalid
+            raise LoadError, "Default configuration invalid: value '#{definition.default}' is not allowed for '#{key}'"
+          end
+        end
+      end
+
+      def definitions
+        ActiveSettings.config_definitions
+      end
+
+      def definition_for(key)
+        definitions[key] ||= ActiveSettings::Config::Definition.new(:empty => true)
+      end
+
+      def clear_definitions!
+        ActiveSettings.config_definitions = {}
+      end
+
+    end
+
+    # The usual way to use a config item:
+    #
+    #    ActiveSettings.detail['key'] = value
+    #
+    # is equivalent to this:
+    #
+    #   ActiveSettings::Config.find_or_create_by_key('key').value = value
+    #
+    # Calling value= also applies any validations and restrictions that are found in the associated definition.
+    # so this will raise a ConfigError if you try to change a protected config entry or a RecordInvalid if you
+    # set a value that is not among those permitted.
+    #
+    def value=(param)
+      newvalue = param.to_s
+      if newvalue != self[:value]
+        raise ConfigError, "#{self.key} cannot be changed" unless settable? || self[:value].blank?
+        if boolean?
+          self[:value] = (newvalue == '1' || newvalue == 'true') ? 'true' : 'false'
+        else
+          self[:value] = newvalue
+        end
+        self.save!
+      end
+      self[:value]
+    end
+
+    # Requesting a config item:
+    #
+    #    key = ActiveSettings.detail['key']
+    #
+    # is equivalent to this:
+    #
+    #   key = ActiveSettings::Config.find_or_create_by_key('key').value
+    #
+    # If the config item is boolean the response will be true or false. For items with :type => :integer it will be an integer,
+    # for everything else a string.
+    #
+    def value
+      if boolean?
+        checked?
+      else
+        self[:value]
+      end
+    end
+
+    # Returns the definition associated with this config item. If none has been declared this will be an empty definition
+    # that does not restrict use.
+    #
+    def definition
+      @definition ||= self.class.definition_for(self.key)
+    end
+
+    # Returns true if the item key ends with '?' or the definition specifies :type => :boolean.
+    #
+    def boolean?
+      definition.boolean? || self.key.ends_with?('?')
+    end
+
+    # Returns true if the item is boolean and true.
+    #
+    def checked?
+      return nil if self[:value].nil?
+      boolean? && self[:value] == 'true'
+    end
+
+    # Returns true if the item defintion includes a :select_from parameter that limits the range of permissible options.
+    #
+    def selector?
+      definition.selector?
+    end
+
+    # Returns a name corresponding to the current setting value, if the setting definition includes a select_from parameter.
+    #
+    def selected_value
+      definition.selected(value)
+    end
+
+    def update_cache
+      ActiveSettings::Config.initialize_cache
+    end
+
+    delegate :default, :type, :allow_blank?, :hidden?, :visible?, :settable?, :selection, :label, :notes, :units, :to => :definition
+
+    def validate
+      definition.validate(self)
+    end
+
+  end
+
+end
+
+require 'active_settings/config/definition' unless defined?(ActiveSettings::Config::Definition)

data/lib/active_settings/config/definition.rb

@@ -0,0 +1,150 @@
+module ActiveSettings
+  class Config
+    class Definition
+      
+      attr_reader :empty, :default, :type, :label, :notes, :validate_with,
+                  :select_from, :allow_blank, :allow_display,
+                  :allow_change, :units, :definer
+
+      # Configuration 'definitions' are metadata held in memory that add restriction and description to individual config entries.
+      #
+      # By default ActiveSettings' configuration machinery is open and ad-hoc: config items are just globally-accessible variables.
+      # They're created when first mentioned and then available in all parts of the application. The definition mechanism is a way 
+      # to place limits on that behavior. It allows you to protect a config entry, to specify the values it can take and to 
+      # validate it when it changes. In the next update it will also allow you to declare that
+      # a config item is global or site-specific.
+      #
+      # The actual defining is done by ActiveSettings::Config#define and usually in a block like this:
+      #
+      #   ActiveSettings::Config.configure do |config|
+      #     config.namespace('users', :allow_change => true) do |users|
+      #       users.define 'allow_password_reset?', :label => 'Allow password reset?'
+      #     end
+      #   end
+      #
+      # See the method documentation in ActiveSettings::Config for options and conventions.
+      #
+      def initialize(options={})
+        [:empty, :default, :type, :label, :notes, :validate_with, :select_from, :allow_blank,
+         :allow_change, :allow_display, :units, :definer].each do |attribute|
+          instance_variable_set "@#{attribute}".to_sym, options[attribute]
+        end
+      end
+      
+      # Returns true if the definition included an :empty flag, which should only be the case for the blank, unrestricting
+      # definitions created when an undefined config item is set or got.
+      #
+      def empty?
+        !!empty
+      end
+      
+      # Returns true if the definition included a :type => :boolean parameter. Config entries that end in '?' are automatically 
+      # considered boolean, whether a type is declared or not. config.boolean? may therefore differ from config.definition.boolean?
+      #
+      def boolean?
+        type == :boolean
+      end
+      
+      # Returns true if the definition included a :select_from parameter (either as list or proc).
+      #
+      def selector?
+        !select_from.blank?   
+      end
+      
+      # Returns true if the definition included a :type => :integer parameter
+      def integer?
+        type == :integer
+      end
+
+      # Returns true if the definition included a :type => :date parameter
+      def date?
+        type == :date
+      end
+      
+      # Returns the list of possible values for this config entry in a form suitable for passing to options_for_select.
+      # if :select_from is a proc it is called first with no arguments and its return value passed through.
+      #
+      def selection
+        if selector?
+          choices = select_from
+          choices = choices.call if choices.respond_to? :call
+          choices = normalize_selection(choices)
+          choices.unshift ['","'] if allow_blank?
+          choices
+        end
+      end
+      
+      # in definitions we accept anything that options_for_select would normally take
+      # here we standardises on an options array-of-arrays so that it's easier to validate input
+      #
+      def normalize_selection(choices)
+        choices = choices.to_a if Hash === choices
+        choices = choices.collect{|c| (c.is_a? Array) ? c : [c,c]}
+      end
+      
+      # If the config item is a selector and :select_from specifies [name, value] pairs (as hash or array), 
+      # this will return the name corresponding to the currently selected value.
+      #
+      def selected(value)
+        if value && selector? && pair = selection.find{|s| s.last == value}
+          pair.first
+        end
+      end
+      
+      # Checks the supplied value against the validation rules for this definition.
+      # There are several ways in which validations might be defined or implied:
+      # * if :validate_with specifies a block, the setting object is passed to the block
+      # * if :type is :integer, we test that the supplied string resolves to a valid integer
+      # * if the config item is a selector we test that its value is one of the permitted options
+      # * if :allow_blank has been set to false, we test that the value is not blank
+      #
+      def validate(setting)
+        if allow_blank?
+          return if setting.value.blank?
+        else
+          setting.errors.add :value, :blank if setting.value.blank?
+        end
+        if validate_with.is_a? Proc
+          validate_with.call(setting)
+        end
+        if selector?
+          setting.errors.add :value, :not_permitted unless selectable?(setting.value)
+        end
+        if integer?
+          Integer(setting.value) rescue setting.errors.add :value, :not_a_number
+        end
+      end
+      
+      # Returns true if the value is one of the permitted selections. Not case-sensitive.
+      def selectable?(value)
+        return true unless selector?
+        selection.map(&:last).map(&:downcase).include?(value.downcase)
+      end
+      
+      # Returns true unless :allow_blank has been explicitly set to false. Defaults to true.
+      # A config item that does not allow_blank must be set or it will not be valid.
+      def allow_blank?
+        true unless allow_blank == false
+      end
+      
+      # Returns true unless :allow_change has been explicitly set to false. Defaults to true. 
+      # A config item that is not settable cannot be changed in the running application.
+      def settable?
+        true unless allow_change == false
+      end
+      
+      # Returns true unless :allow_change has been explicitly set to false. Defaults to true.
+      # A config item that is not visible cannot be displayed in a view.
+      def visible?
+        true unless allow_display == false
+      end
+      
+      # Returns true if :allow_display has been explicitly set to false. Defaults to true.
+      def hidden?
+        true if allow_display == false
+      end
+      
+    end
+  end
+end
+

data/lib/active_settings/engine.rb

@@ -0,0 +1,5 @@
+module ActiveSettings
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveSettings
+  end
+end

data/lib/active_settings/version.rb

@@ -0,0 +1,3 @@
+module ActiveSettings
+  VERSION = "0.0.1"
+end

data/lib/generators/active_settings/install/install_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'rails/generators/active_record/migration'
+
+module ActiveSettings
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+      extend ActiveRecord::Generators::Migration
+      
+      source_root File.expand_path("../templates", __FILE__)
+      
+      def copy_initializer
+        template "active_settings.rb", "config/initializers/active_settings.rb"
+      end
+      
+      def create_migration_file
+        migration_template 'migration.rb', 'db/migrate/create_active_settings.rb'
+      end
+      
+    end
+  end
+end

data/lib/generators/active_settings/install/templates/active_settings.rb

@@ -0,0 +1,17 @@
+ActiveSettings.detail do |config|
+  # config.define 'admin.title', :default => "Your App"
+  # config.define 'dev.host'
+  # config.define 'local.timezone', :allow_change => true, :select_from => lambda { ActiveSupport::TimeZone::MAPPING.keys.sort }
+  # config.define 'defaults.locale', :select_from => lambda { Locales.locales }, :allow_blank => true
+  # config.define 'defaults.page.parts', :default => "Body,Extended"
+  # config.define 'defaults.page.status', :select_from => lambda { Status.selectable_values }, :allow_blank => false, :default => "Draft"
+  # config.define 'defaults.page.filter', :select_from => lambda { TextFilter.descendants.map { |s| s.filter_name }.sort }, :allow_blank => true
+  # config.define 'defaults.page.fields'
+  # config.define 'defaults.snippet.filter', :select_from => lambda { Snippets.all.map { |s| s.filter_name }.sort }, :allow_blank => true
+  # config.define 'pagination.param_name', :default => 'page'
+  # config.define 'pagination.per_page_param_name', :default => 'per_page'
+  # config.define 'admin.pagination.per_page', :type => :integer, :default => 50
+  # config.define 'site.title', :default => "Your site title", :allow_blank => false
+  # config.define 'site.host', :default => "www.example.com", :allow_blank => false
+  # config.define 'user.allow_password_reset?', :default => true
+end

data/lib/generators/active_settings/install/templates/migration.rb

@@ -0,0 +1,16 @@
+class CreateActiveSettings < ActiveRecord::Migration
+  def up
+    create_table :active_settings do |t|
+      t.string   :key, limit: 80
+      t.string   :value, limit: 120
+    end
+
+    change_table :active_settings do |t|
+      t.index  :key, unique: true
+    end
+  end
+
+  def down
+    drop_table :active_settings
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: active_settings
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Scott V. Rosenthal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+description: ActiveSettings provides an open and ad-hoc settings config for globally-accessible
+  variables via ActiveRecord in your rails 3.1+ app.
+email:
+- sr7575@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_settings/config/definition.rb
+- lib/active_settings/config.rb
+- lib/active_settings/engine.rb
+- lib/active_settings/version.rb
+- lib/active_settings.rb
+- lib/generators/active_settings/install/install_generator.rb
+- lib/generators/active_settings/install/templates/active_settings.rb
+- lib/generators/active_settings/install/templates/migration.rb
+homepage: https://github.com/scottvrosenthal/active_settings
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: ActiveSettings provides an open and ad-hoc settings config & definitions
+  for Rails cached globally-accessible variables via ActiveRecord in your rails 3.1+
+  app.
+test_files: []