has_preference 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Thomas Boerger <tboerger@tbpro.de>
+
+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

@@ -0,0 +1,15 @@
+# has_preference
+
+Add preference functionality to your ActiveRecord models.
+
+## Install
+
+    gem 'has_preference'
+
+## Usage
+
+
+
+## Credits
+
+The project <tt>has_preference</tt> have been inspired by pluginaweek. Take a look at the git [repositories](https://github.com/pluginaweek). 

data/Rakefile

@@ -0,0 +1,68 @@
+# Created by Thomas Boerger on 2011-07-01.
+# Copyright (c) 2011. All rights reserved.
+
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rubygems/specification'
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'rcov/rcovtask'
+require 'date'
+
+GEM_TITLE = 'has_preference'
+GEM_VERSION = '0.0.1'
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM_TITLE
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.extra_rdoc_files = ['README', 'LICENSE']
+  s.rdoc_options << '--line-numbers' << '--main=README'
+  s.summary = 'Has preference'
+  s.description = 'Preference for ActiveRecord models'
+  s.author = 'Thomas Boerger'
+  s.email = 'tboerger@tbpro.de'
+  s.homepage = 'http://github.com/tbpro/has_preference'
+  s.files = %w(LICENSE README Rakefile init.rb) + Dir.glob('{app,generators,lib,test}/**/*')
+  s.test_files = Dir["test/**/*_test.rb"]
+end
+
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc 'Create a gemspec'
+task :writespec do
+  File.open("#{GEM_TITLE}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+desc 'Docs for gem'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = spec.name
+  rdoc.options << '--line-numbers' << '--main=README'
+  rdoc.rdoc_files.include('README', 'LICENSE', 'lib/**/*.rb', 'app/**/*.rb')
+end
+
+#desc 'Tests for gem'
+#Rake::TestTask.new(:test) do |t|
+#  t.libs << 'lib'
+#  t.test_files = spec.test_files
+#  t.verbose = true
+#end
+
+#desc 'Rcov for gem'
+#Rcov::RcovTask.new(:rcov) do |t|
+#  t.libs << 'lib'
+#  t.test_files = spec.test_files
+#  t.rcov_opts << '--exclude="^(?!lib/|app/)"'
+#  t.verbose = true
+#end
+
+desc 'List all tasks'
+task :default do
+  puts `rake -T`.grep(/^[^(].*$/)
+end

data/app/models/preference.rb

@@ -0,0 +1,41 @@
+class Preference < ActiveRecord::Base
+  belongs_to :owner, :polymorphic => true
+  belongs_to :group, :polymorphic => true
+  
+  validates_presence_of :name, :owner_id, :owner_type
+  validates_presence_of :group_type, :if => :group_id?
+  
+  def definition
+    owner_type && (find_definition(owner_type.constantize) || find_definition(owner.class))
+  end
+  
+  def value
+    value = read_attribute(:value)
+    value = definition.type_cast(value) if definition
+    
+    value
+  end
+  
+  def group_with_optional_lookup
+    group_id ? group_without_optional_lookup : group_type
+  end
+  
+  alias_method_chain :group, :optional_lookup
+  
+  class << self
+    def split_group(group = nil)
+      if group.is_a?(ActiveRecord::Base)
+        group_id, group_type = group.id, group.class.base_class.name.to_s
+      else
+        group_id, group_type = nil, group.is_a?(Symbol) ? group.to_s : group
+      end
+      
+      [group_id, group_type]
+    end
+  end
+  
+  protected
+    def find_definition(owner_class)
+      owner_class.respond_to?(:preference_definitions) && owner_class.preference_definitions[name]
+    end
+end

data/init.rb

@@ -0,0 +1,4 @@
+# Created by Thomas Boerger on 2011-07-01.
+# Copyright (c) 2011. All rights reserved.
+
+require "has_preference"

data/lib/generators/has_attribute/migration_generator.rb

@@ -0,0 +1,11 @@
+module HasAttribute
+  module Generators
+    class MigrationGenerator < Rails::Generators::Base
+      desc "Builds the migration for preferences table"
+      
+      def create_migration_file
+        migration_template "migration.rb", "db/migrate/create_preferences.rb"
+      end
+    end
+  end
+end

data/lib/generators/has_attribute/template/migration.rb

@@ -0,0 +1,13 @@
+class CreatePreferences < ActiveRecord::Migration
+  def change
+    create_table :preferences do |t|
+      t.string :name, :null => false
+      t.references :owner, :polymorphic => true, :null => false
+      t.references :group, :polymorphic => true
+      t.string :value
+      t.timestamps
+    end
+
+    add_index :preferences, [:owner_id, :owner_type, :name, :group_id, :group_type], :unique => true, :name => 'preferences_owner_id_owner_type_name_group_id_group_type'
+  end
+end

data/lib/generators/has_preference.rb

@@ -0,0 +1,18 @@
+require 'rails/generators/named_base'
+require 'rails/generators/migration'
+require 'rails/generators/active_model'
+
+require 'generators/helpers/migration_helper'
+
+module HasPreference
+  module Generators
+    class Base < Rails::Generators::Base
+      include Rails3Generators::MigrationHelper
+      #include Rails::Generators::Migration
+
+      def self.source_root
+        @_has_preference_source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'has_preference', generator_name, 'templates'))
+      end
+    end
+  end
+end

data/lib/generators/has_preference/migration/migration_generator.rb

@@ -0,0 +1,13 @@
+require 'generators/has_preference'
+
+module HasPreference
+  module Generators
+    class MigrationGenerator < Base
+      desc "Builds the migration for preferences table"
+
+      def create_migration_file
+        migration_template "migration.rb", "db/migrate/create_preferences.rb"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+class CreatePreferences < ActiveRecord::Migration
+  def change
+    create_table :preferences do |t|
+      t.string :name, :null => false
+      t.references :owner, :polymorphic => true, :null => false
+      t.references :group, :polymorphic => true
+      t.string :value
+      t.timestamps
+    end
+
+    add_index :preferences, [:owner_id, :owner_type, :name, :group_id, :group_type], :unique => true, :name => 'preferences_owner_id_owner_type_name_group_id_group_type'
+  end
+end

data/lib/has_preference.rb

@@ -0,0 +1,361 @@
+# Created by Thomas Boerger on 2011-07-01.
+# Copyright (c) 2011. All rights reserved.
+
+module HasPreference
+  module MacroMethods
+    def has_preference(name, *args)
+      unless included_modules.include?(InstanceMethods)
+        class_inheritable_hash :preference_definitions
+        self.preference_definitions = {}
+        
+        has_many :stored_preferences, :as => :owner, :class_name => 'Preference'
+        
+        after_save :update_preferences
+        
+        named_scope :with_preferences, lambda {|preferences| build_preference_scope(preferences)}
+        named_scope :without_preferences, lambda {|preferences| build_preference_scope(preferences, true)}
+        
+        extend HasPreference::ClassMethods
+        include HasPreference::InstanceMethods
+      end
+      
+      name = name.to_s
+      
+      definition = HasPreference::Definition.new(name, *args)
+      self.preference_definitions[name] = definition
+      
+      name = name.gsub(/[^A-Za-z0-9_-]/, '').underscore
+      
+      define_method("preferred_#{name}?") do |*group|
+        preferred?(name, group.first)
+      end
+      
+      alias_method "prefers_#{name}?", "preferred_#{name}?"
+      
+      define_method("preferred_#{name}") do |*group|
+        preferred(name, group.first)
+      end
+      
+      alias_method "prefers_#{name}", "preferred_#{name}"
+      
+      define_method("preferred_#{name}=") do |*args|
+        write_preference(*args.flatten.unshift(name))
+      end
+      
+      alias_method "prefers_#{name}=", "preferred_#{name}="
+      
+      define_method("preferred_#{name}_changed?") do |*group|
+        preference_changed?(name, group.first)
+      end
+      
+      alias_method "prefers_#{name}_changed?", "preferred_#{name}_changed?"
+      
+      define_method("preferred_#{name}_was") do |*group|
+        preference_was(name, group.first)
+      end
+      
+      alias_method "prefers_#{name}_was", "preferred_#{name}_was"
+      
+      define_method("preferred_#{name}_change") do |*group|
+        preference_change(name, group.first)
+      end
+      
+      alias_method "prefers_#{name}_change", "preferred_#{name}_change"
+      
+      define_method("preferred_#{name}_will_change!") do |*group|
+        preference_will_change!(name, group.first)
+      end
+      
+      alias_method "prefers_#{name}_will_change!", "preferred_#{name}_will_change!"
+      
+      define_method("reset_preferred_#{name}!") do |*group|
+        reset_preference!(name, group.first)
+      end
+      
+      alias_method "reset_prefers_#{name}!", "reset_preferred_#{name}!"
+      
+      definition
+    end
+  end
+
+  module ClassMethods
+    def build_preference_scope(preferences, inverse = false)
+      joins = []
+      statements = []
+      values = []
+      
+      preferences = preferences.inject({}) do |result, (group, value)|
+        if value.is_a?(Hash)
+          value.each {|preference, value| result[[group, preference]] = value}
+        else
+          result[[nil, group]] = value
+        end
+        
+        result
+      end
+      
+      preferences.each do |(group, preference), value|
+        group_id, group_type = Preference.split_group(group)
+        
+        preference = preference.to_s
+        definition = preference_definitions[preference.to_s]
+        
+        value = definition.type_cast(value)
+        is_default = definition.default_value(group_type) == value
+        
+        table = "preferences_#{group_id}_#{group_type}_#{preference}"
+        
+        joins << "LEFT JOIN preferences AS #{table} ON #{table}.owner_id = #{table_name}.#{primary_key} AND " + sanitize_sql(
+          "#{table}.owner_type" => base_class.name.to_s,
+          "#{table}.group_id" => group_id,
+          "#{table}.group_type" => group_type,
+          "#{table}.name" => preference
+        )
+        
+        if inverse
+          statements << "#{table}.id IS NOT NULL AND #{table}.value " + (value.nil? ? ' IS NOT NULL' : ' != ?') + (!is_default ? " OR #{table}.id IS NULL" : '')
+        else
+          statements << "#{table}.id IS NOT NULL AND #{table}.value " + (value.nil? ? ' IS NULL' : ' = ?') + (is_default ? " OR #{table}.id IS NULL" : '')
+        end
+        
+        values << value unless value.nil?
+      end
+      
+      sql = statements.map! {|statement| "(#{statement})"} * ' AND '
+      { :joins => joins, :conditions => values.unshift(sql) }
+    end
+  end
+
+  module InstanceMethods
+    def preferences(group = nil)
+      preferences = preferences_group(group)
+      
+      unless preferences_group_loaded?(group)
+        group_id, group_type = Preference.split_group(group)
+        
+        find_preferences(:group_id => group_id, :group_type => group_type).each do |preference|
+          preferences[preference.name] = preference.value unless preferences.include?(preference.name)
+        end
+        
+        preference_definitions.each do |name, definition|
+          preferences[name] = definition.default_value(group_type) unless preferences.include?(name)
+        end
+      end
+      
+      preferences.inject({}) do |typed_preferences, (name, value)|
+        typed_preferences[name] = value.nil? ? value : preference_definitions[name].type_cast(value)
+        typed_preferences
+      end
+    end
+
+    def preferred?(name, group = nil)
+      name = name.to_s
+      assert_valid_preference(name)
+      
+      value = preferred(name, group)
+      preference_definitions[name].query(value)
+    end
+    
+    alias_method :prefers?, :preferred?
+
+    def preferred(name, group = nil)
+      name = name.to_s
+      assert_valid_preference(name)
+      
+      if preferences_group(group).include?(name)
+        value = preferences_group(group)[name]
+      else
+        group_id, group_type = Preference.split_group(group)
+        preference = find_preferences(:name => name, :group_id => group_id, :group_type => group_type).first unless preferences_group_loaded?(group)
+        
+        value = preference ? preference.value : preference_definitions[name].default_value(group_type)
+        preferences_group(group)[name] = value
+      end
+      
+      definition = preference_definitions[name]
+      value = definition.type_cast(value) unless value.nil?
+      
+      value
+    end
+    
+    alias_method :prefers, :preferred
+
+    def write_preference(name, value, group = nil)
+      name = name.to_s
+      assert_valid_preference(name)
+      
+      preferences_changed = preferences_changed_group(group)
+      
+      if preferences_changed.include?(name)
+        old = preferences_changed[name]
+        preferences_changed.delete(name) unless preference_value_changed?(name, old, value)
+      else
+        old = clone_preference_value(name, group)
+        preferences_changed[name] = old if preference_value_changed?(name, old, value)
+      end
+      
+      value = convert_number_column_value(value) if preference_definitions[name].number?
+      preferences_group(group)[name] = value
+      
+      value
+    end
+
+    def preferences_changed?(group = nil)
+      !preferences_changed_group(group).empty?
+    end
+
+    def preferences_changed(group = nil)
+      preferences_changed_group(group).keys
+    end
+
+    def preference_changes(group = nil)
+      preferences_changed(group).inject({}) do |changes, preference|
+        changes[preference] = preference_change(preference, group)
+        changes
+      end
+    end
+    
+    def reload(*args) #:nodoc:
+      result = super
+      
+      @preferences.clear if @preferences
+      @preferences_changed.clear if @preferences_changed
+      
+      result
+    end
+    
+    private
+      def assert_valid_preference(name)
+        raise(ArgumentError, "Unknown preference: #{name}") unless preference_definitions.include?(name)
+      end
+      
+      def preferences_group(group)
+        @preferences ||= {}
+        @preferences[group.is_a?(Symbol) ? group.to_s : group] ||= {}
+      end
+      
+      def preferences_group_loaded?(group)
+        preference_definitions.length == preferences_group(group).length
+      end
+      
+      def clone_preference_value(name, group)
+        value = preferred(name, group)
+        value.duplicable? ? value.clone : value
+      rescue TypeError, NoMethodError
+        value
+      end
+      
+      def preferences_changed_group(group)
+        @preferences_changed ||= {}
+        @preferences_changed[group.is_a?(Symbol) ? group.to_s : group] ||= {}
+      end
+      
+      def preference_changed?(name, group)
+        preferences_changed_group(group).include?(name)
+      end
+      
+      def preference_change(name, group)
+        [preferences_changed_group(group)[name], preferred(name, group)] if preference_changed?(name, group)
+      end
+      
+      def preference_was(name, group)
+        preference_changed?(name, group) ? preferences_changed_group(group)[name] : preferred(name, group)
+      end
+      
+      def preference_will_change!(name, group)
+        preferences_changed_group(group)[name] = clone_preference_value(name, group)
+      end
+      
+      def reset_preference!(name, group)
+        write_preference(name, preferences_changed_group(group)[name], group) if preference_changed?(name, group)
+      end
+      
+      def preference_value_changed?(name, old, value)
+        definition = preference_definitions[name]
+        
+        if definition.type == :integer && (old.nil? || old == 0)
+          value = nil if value.blank?
+        else
+          value = definition.type_cast(value)
+        end
+        
+        old != value
+      end
+      
+      def update_preferences
+        if @preferences_changed
+          @preferences_changed.each do |group, preferences|
+            group_id, group_type = Preference.split_group(group)
+            
+            preferences.keys.each do |name|
+              attributes = {:name => name, :group_id => group_id, :group_type => group_type}
+              
+              preference = find_preferences(attributes).first || stored_preferences.build(attributes)
+              preference.value = preferred(name, group)
+              
+              preference.save!
+            end
+          end
+          
+          @preferences_changed.clear
+        end
+      end
+
+      def find_preferences(attributes)
+        if stored_preferences.loaded?
+          stored_preferences.select do |preference|
+            attributes.all? {|attribute, value| preference[attribute] == value} 
+          end
+        else
+          stored_preferences.find(:all, :conditions => attributes)
+        end
+      end
+  end
+  
+  class Definition
+    attr_reader :type
+    
+    def initialize(name, *args)
+      options = args.extract_options!
+      options.assert_valid_keys(:default, :group_defaults)
+      
+      @type = args.first ? args.first.to_sym : :boolean
+      @column = ActiveRecord::ConnectionAdapters::Column.new(name.to_s, options[:default], @type == :any ? nil : @type.to_s)
+      
+      @group_defaults = (options[:group_defaults] || {}).inject({}) do |defaults, (group, default)|
+        defaults[group.is_a?(Symbol) ? group.to_s : group] = type_cast(default)
+        defaults
+      end
+    end
+
+    def name
+      @column.name
+    end
+
+    def default_value(group = nil)
+      @group_defaults.include?(group) ? @group_defaults[group] : @column.default
+    end
+
+    def number?
+      @column.number?
+    end
+
+    def type_cast(value)
+      @type == :any ? value : @column.type_cast(value)
+    end
+
+    def query(value)
+      if !(value = type_cast(value))
+        false
+      elsif number?
+        !value.zero?
+      else
+        !value.blank?
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  extend HasPreference::MacroMethods
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: has_preference
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Thomas Boerger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-01 00:00:00 Z
+dependencies: []
+
+description: Preference for ActiveRecord models
+email: tboerger@tbpro.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- init.rb
+- app/models/preference.rb
+- lib/generators/has_attribute/migration_generator.rb
+- lib/generators/has_attribute/template/migration.rb
+- lib/generators/has_preference/migration/migration_generator.rb
+- lib/generators/has_preference/migration/templates/migration.rb
+- lib/generators/has_preference.rb
+- lib/has_preference.rb
+homepage: http://github.com/tbpro/has_preference
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --main=README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Has preference
+test_files: []
+