propensity 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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 PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL 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

@@ -0,0 +1,59 @@
+Propensity
+==========
+
+Note: This gem is still under development, but is usable, and I have used it in production systems. Ensure that you follow the instructions in their entirety.
+
+Propensity provides an easy way to manage settings within a Rails application. These settings are persisted in a database and loaded on initialization of Rails. This gem is simple, and does not contain any administrative UI.
+
+Usage
+-------
+
+To install propensity, add the following to your Gemfile
+
+```
+gem 'propensity', git: "https://github.com/entropillc/propensity.git"
+```
+
+Note that I use Ruby 1.9.x syntax above, because it rocks, and the code uses 1.9.3 conventions. Once your Gemfile is updated make sure you install your new bundle
+
+```
+bundle install
+```
+
+After bundling, you're ready to run the installation generator
+
+```
+  rails g propensity:install
+```
+
+Running the installer will copy the migrations in to your db/migrations folder and add an app_configuration.rb file to your models folder. Within app_configuration.rb you will specify your preferences.
+
+There is one piece of magic that isn't completed yet that will require you to initialize Propensity on application startup. To do this, add the following code in your application.rb file:
+
+```
+# Initializing MyApplications Application Settings
+initializer "application.environment", :before => :load_config_initializers do |app|
+  config.my_application = Propensity::Environment.new
+  MyApplication::Config = config.my_application.preferences
+end
+```
+
+Configuring Your Settings
+-------
+
+The app_configuraiton.rb file in the models folder is where you will define your preferences. An example may look something like this:
+
+```
+class AppConfiguration < Propensity::Preferences::Configuration
+
+  preference :blog_title, :string, default: "My Blog Title"
+  preference :hours_in_a_day, :integer, default: 24
+  preference :am_i_crazy, :boolean, default: true
+
+end
+```
+
+Credits
+-------
+
+I've always liked the way Spree (https://github.com/spree/spree) stored configuration settings and thought to myself "Self, you should really break that out so you can use it in other projects". So here it is, most of the code and ideas came from the Spree team. I liked their work, so I gemed it up.

data/Rakefile

@@ -0,0 +1,40 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Propensity'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/models/app_configuration.rb

@@ -0,0 +1,7 @@
+class AppConfiguration < Propensity::Preferences::Configuration
+
+  # You can define preferences for you application in this file
+  # An example preference would be the following
+  # preference :blog_title, :string, default: "My Blog Title"
+
+end

data/app/models/propensity/preference.rb

@@ -0,0 +1,5 @@
+module Propensity
+  class Preference < ActiveRecord::Base
+    attr_accessible :key, :name, :owner_id, :owner_type, :value, :value_type
+  end
+end

data/app/models/propensity/preferences/configuration.rb

@@ -0,0 +1,73 @@
+# This takes the preferrable methods and adds some
+# syntatic sugar to access the preferences
+#
+# class App < Configuration
+#   preference :color, :string
+# end
+#
+# a = App.new
+#
+# setters:
+# a.color = :blue
+# a[:color] = :blue
+# a.set :color = :blue
+# a.preferred_color = :blue
+#
+# getters:
+# a.color
+# a[:color]
+# a.get :color
+# a.preferred_color
+#
+#
+module Propensity
+  module Preferences
+    class Configuration
+      include Preferences::Preferable
+
+      def configure
+        yield(self) if block_given?
+      end
+
+      def preference_cache_key(name)
+        [self.class.name, name].join('::').underscore
+      end
+
+      def reset
+        preferences.each do |name, value|
+          set_preference name, preference_default(name)
+        end
+      end
+
+      alias :[] :get_preference
+      alias :[]= :set_preference
+
+      alias :get :get_preference
+
+      def set(*args)
+        options = args.extract_options!
+        options.each do |name, value|
+          set_preference name, value
+        end
+
+        if args.size == 2
+          set_preference args[0], args[1]
+        end
+      end
+
+      def method_missing(method, *args)
+        name = method.to_s.gsub('=', '')
+        if has_preference? name
+          if method.to_s =~ /=$/
+            set_preference(name, args.first)
+          else
+            get_preference name
+          end
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/app/models/propensity/preferences/preferable.rb

@@ -0,0 +1,141 @@
+# The preference_cache_key is used to determine if the preference
+# can be set. The default behavior is to return nil if there is no
+# id value. On ActiveRecords, new objects will have their preferences
+# saved to a pending hash until it is persisted.
+#
+# class_attributes are inheritied unless you reassign them in
+# the subclass, so when you inherit a Preferable class, the
+# inherited hook will assign a new hash for the subclass definitions
+# and copy all the definitions allowing the subclass to add
+# additional defintions without affecting the base
+module Propensity
+  module Preferences
+    module Preferable
+
+      def self.included(base)
+        base.class_eval do
+          extend Preferences::PreferableClassMethods
+
+          if respond_to?(:after_create)
+            after_create do |obj|
+              obj.save_pending_preferences
+            end
+          end
+
+          if respond_to?(:after_destroy)
+            after_destroy do |obj|
+              obj.clear_preferences
+            end
+          end
+
+        end
+      end
+
+      def get_preference(name)
+        has_preference! name
+        send self.class.preference_getter_method(name)
+      end
+      alias :preferred :get_preference
+      alias :prefers? :get_preference
+
+      def set_preference(name, value)
+        has_preference! name
+        send self.class.preference_setter_method(name), value
+      end
+
+      def preference_type(name)
+        has_preference! name
+        send self.class.preference_type_getter_method(name)
+      end
+
+      def preference_default(name)
+        has_preference! name
+        send self.class.preference_default_getter_method(name)
+      end
+
+      def preference_description(name)
+        has_preference! name
+        send self.class.preference_description_getter_method(name)
+      end
+
+      def has_preference!(name)
+        raise NoMethodError.new "#{name} preference not defined" unless has_preference? name
+      end
+
+      def has_preference?(name)
+        respond_to? self.class.preference_getter_method(name)
+      end
+
+      def preferences
+        prefs = {}
+        methods.grep(/^prefers_.*\?$/).each do |pref_method|
+          prefs[pref_method.to_s.gsub(/prefers_|\?/, '').to_sym] = send(pref_method)
+        end
+        prefs
+      end
+
+      def prefers?(name)
+        get_preference(name)
+      end
+
+      def preference_cache_key(name)
+        return unless id
+        [self.class.name, name, id].join('::').underscore
+      end
+
+      def save_pending_preferences
+        return unless @pending_preferences
+        @pending_preferences.each do |name, value|
+          set_preference(name, value)
+        end
+      end
+
+      def clear_preferences
+        preferences.keys.each {|pref| preference_store.delete preference_cache_key(pref)}
+      end
+
+      private
+
+      def add_pending_preference(name, value)
+        @pending_preferences ||= {}
+        @pending_preferences[name] = value
+      end
+
+      def get_pending_preference(name)
+        return unless @pending_preferences
+        @pending_preferences[name]
+      end
+
+      def convert_preference_value(value, type)
+        case type
+        when :string, :text
+          value.to_s
+        when :password
+          value.to_s
+        when :decimal
+          BigDecimal.new(value.to_s).round(2, BigDecimal::ROUND_HALF_UP)
+        when :integer
+          value.to_i
+        when :boolean
+          if value.is_a?(FalseClass) ||
+             value.nil? ||
+             value == 0 ||
+             value =~ /^(f|false|0)$/i ||
+             (value.respond_to? :empty? and value.empty?)
+             false
+          else
+             true
+          end
+        when :date
+          value.is_a?(Date) ? value : Date.parse(value)
+        else
+          value
+        end
+      end
+
+      def preference_store
+        Propensity::Preferences::Store.instance
+      end
+    end
+  end
+end

data/app/models/propensity/preferences/preferable_class_methods.rb

@@ -0,0 +1,89 @@
+module Propensity
+  module Preferences
+    module PreferableClassMethods
+
+      def preference(name, type, *args)
+        options = args.extract_options!
+        options.assert_valid_keys(:default, :description)
+        default = options[:default]
+        description = options[:description] || name
+        
+        # cache_key will be nil for new objects, then if we check if there
+        # is a pending preference before going to default
+        define_method preference_getter_method(name) do
+          if preference_cache_key(name) && preference_store.exist?(preference_cache_key(name))
+            preference_store.get preference_cache_key(name)
+          else
+            if get_pending_preference(name)
+              get_pending_preference(name)
+            else
+              send self.class.preference_default_getter_method(name)
+            end
+          end
+        end
+        alias_method prefers_getter_method(name), preference_getter_method(name)
+
+        define_method preference_setter_method(name) do |value|
+          value = convert_preference_value(value, type)
+          if preference_cache_key(name)
+            preference_store.set preference_cache_key(name), value, type
+          else
+            add_pending_preference(name, value)
+          end
+        end
+        alias_method prefers_setter_method(name), preference_setter_method(name)
+
+        define_method preference_default_getter_method(name) do
+          default
+        end
+
+        define_method preference_type_getter_method(name) do
+          type
+        end
+
+        define_method preference_description_getter_method(name) do
+          description
+        end
+      end
+
+      def remove_preference(name)
+        remove_method preference_getter_method(name) if method_defined? preference_getter_method(name)
+        remove_method preference_setter_method(name) if method_defined? preference_setter_method(name)
+        remove_method prefers_getter_method(name) if method_defined? prefers_getter_method(name)
+        remove_method prefers_setter_method(name) if method_defined? prefers_setter_method(name)
+        remove_method preference_default_getter_method(name) if method_defined? preference_default_getter_method(name)
+        remove_method preference_type_getter_method(name) if method_defined? preference_type_getter_method(name)
+        remove_method preference_description_getter_method(name) if method_defined? preference_description_getter_method(name)
+      end
+
+      def preference_getter_method(name)
+        "preferred_#{name}".to_sym
+      end
+
+      def preference_setter_method(name)
+         "preferred_#{name}=".to_sym
+      end
+
+      def prefers_getter_method(name)
+        "prefers_#{name}?".to_sym
+      end
+
+      def prefers_setter_method(name)
+         "prefers_#{name}=".to_sym
+      end
+
+      def preference_default_getter_method(name)
+        "preferred_#{name}_default".to_sym
+      end
+
+      def preference_type_getter_method(name)
+        "preferred_#{name}_type".to_sym
+      end
+
+      def preference_description_getter_method(name)
+        "preferred_#{name}_description".to_sym
+      end
+
+    end
+  end
+end

data/app/models/propensity/preferences/store.rb

@@ -0,0 +1,74 @@
+# StoreInstance has a persistence flag that is on by default,
+# but we disable database persistence in testing to speed up tests
+#
+
+require 'singleton'
+
+module Propensity
+  module Preferences
+
+    class StoreInstance
+      attr_accessor :persistence
+
+      def initialize
+        @cache = Rails.cache
+        @persistence = true
+        load_preferences
+      end
+
+      def set(key, value, type)
+        @cache.write(key, value)
+        persist(key, value, type)
+      end
+
+      def exist?(key)
+        @cache.exist? key
+      end
+
+      def get(key)
+        @cache.read(key)
+      end
+
+      def delete(key)
+        @cache.delete(key)
+        destroy(key)
+      end
+
+      private
+
+      def persist(cache_key, value, type)
+        return unless should_persist?
+
+        preference = Propensity::Preference.find_or_initialize_by_key(cache_key)
+        preference.value = value
+        preference.value_type = type
+        preference.save
+      end
+
+      def destroy(cache_key)
+        return unless should_persist?
+
+        preference = Propensity::Preference.find_by_key(cache_key)
+        preference.destroy if preference
+      end
+
+      def load_preferences
+        return unless should_persist?
+
+        Propensity::Preference.all.each do |p|
+          @cache.write(p.key, p.value)
+        end
+      end
+
+      def should_persist?
+        @persistence
+      end
+
+    end
+
+    class Store < StoreInstance
+      include Singleton
+    end
+
+  end
+end

data/db/migrate/20120910124552_create_propensity_preferences.rb

@@ -0,0 +1,15 @@
+class CreatePropensityPreferences < ActiveRecord::Migration
+  def change
+    create_table :propensity_preferences do |t|
+      t.string :name
+      t.integer :owner_id
+      t.string :owner_type
+      t.text :value
+      t.string :key
+      t.string :value_type
+      t.timestamps
+    end
+
+    add_index :propensity_preferences, :key, :unique => true
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'rails/generators/base'
+
+module Propensity
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      def self.source_root
+        @source ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      end
+
+      desc "This generator Propensity in to a Rails application"
+      
+      def add_configuration_and_initializers
+        copy_file "app_configuration.rb", "app/models/app_configuration.rb"
+      end
+      
+    end
+  end
+end

data/lib/generators/propensity/install/templates/app_configuration.rb

@@ -0,0 +1,7 @@
+class AppConfiguration < Propensity::Preferences::Configuration
+
+  # You can define preferences for you application in this file
+  # An example preference would be the following
+  # preference :blog_title, :string, default: "My Blog Title"
+
+end

data/lib/propensity/engine.rb

@@ -0,0 +1,9 @@
+module Propensity
+  class Engine < ::Rails::Engine
+    isolate_namespace Propensity
+
+    initializer "propensity.load_preferences", :before => "application.environment" do
+      ::ActiveRecord::Base.send :include, Propensity::Preferences::Preferable
+    end
+  end
+end

data/lib/propensity/environment.rb

@@ -0,0 +1,11 @@
+module Propensity
+  class Environment
+    include EnvironmentExtension
+
+    attr_accessor :preferences
+
+    def initialize(configuration=nil)
+      @preferences = configuration ? configuration.new : AppConfiguration.new
+    end
+  end
+end

data/lib/propensity/environment_extension.rb

@@ -0,0 +1,23 @@
+module Propensity
+  module EnvironmentExtension
+    extend ActiveSupport::Concern
+
+    def add_class(name)
+      self.instance_variable_set "@#{name}", Set.new
+
+      create_method( "#{name}=".to_sym ) { |val|
+        instance_variable_set( "@" + name, val)
+      }
+
+      create_method(name.to_sym) do
+        instance_variable_get( "@" + name )
+      end
+    end
+
+    private
+
+      def create_method(name, &block)
+        self.class.send(:define_method, name, &block)
+      end
+  end
+end

data/lib/propensity/version.rb

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

data/lib/propensity.rb

@@ -0,0 +1,3 @@
+require "propensity/environment_extension"
+require "propensity/environment"
+require "propensity/engine"

data/lib/tasks/propensity_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :propensity do
+#   # Task goes here
+# end