community_engine 2.3.2 → 3.0.0

data/vendor/plugins/enumerations_mixin/README_ENUMERATIONS

@@ -1,163 +0,0 @@
-Enumerations Mixin
-Copyright (c) 2005 Trevor Squires
-Released under the MIT License.  See the LICENSE file for more details.
-
-What is this?:
-
-The enumerations mixin allows you to treat instances of your
-ActiveRecord models as though they were an enumeration of values.
-
-At it's most basic level, it allows you to say things along the lines of:
-
-booking = Booking.new(:status => BookingStatus[:provisional])
-booking.update_attribute(:status, BookingStatus[:confirmed])
-
-Booking.find :first, 
-						 :conditions => ['status_id = ?', BookingStatus[:provisional].id]
-
-BookingStatus.all.collect {|status|, [status.name, status.id]}
-
-See "How to use it" below for more information.
-
-Package Contents:
-
-This package adds two mixins and a helper to Rails' ActiveRecord:
-
-acts_as_enumerated provides capabilities to treat your model and
-its records as an enumeration. At a minimum, the database table for
-an acts_as_enumerated must contain an 'id' column and a 'name'
-column.  All instances for the acts_as_enumerated model are cached
-in memory.
-
-has_enumerated adds methods to your ActiveRecord model for setting
-and retrieving enumerated values using an associated acts_as_enumerated
-model.
-
-There is also an ActiveRecord::VirtualEnumerations helper module
-to create 'virtual' acts_as_enumerated models which helps to avoid
-cluttering up your models directory with acts_as_enumerated classes.
-
-How to use it:
-
-* acts_as_enumerated
-
-class BookingStatus < ActiveRecord::Base
-acts_as_enumerated  :conditions => 'optional_sql_conditions', 
-                    :order => 'optional_sql_orderby',
-                    :on_lookup_failure => :optional_class_method
-end
-
-With that, your BookingStatus class will have the following methods defined:
-
-* BookingStatus[arg] : lookup the BookingStatus instance for arg.
-The arg value can be a 'string' or a :symbol, in which case the
-lookup will be against the BookingStatus.name field.  Alternatively
-arg can be a Fixnum, in which case the lookup will be against the
-BookingStatus.id field.
-
-The :on_lookup_failure option specifies the name of a class method
-to invoke when the [] method is unable to locate a BookingStatus
-record for arg.  The defeault is the built-in :enforce_strict_literals
-which causes an exception to be raised when no record is found and
-the arg is a Fixnum or Symbol, otherwise it returns nil.  There are
-also built-ins for :enforce_strict (raise and exception regardless
-of the type for arg) and :enforce_none which just returns nil.
-
-The whole point of the :on_lookup_failure option is that I'm pretty
-opinionated that a) if the value can't be looked-up for a :symbol
-that I've passed, it's probably a typo so I want a *big* hint that
-something is wrong and b) it's likely that my opinion isn't shared
-by everyone so it should be configurable.
-
-* BookingStatus.all : returns an array of all BookingStatus records
-that match the :conditions specified in acts_as_enumerated, in the
-order specified by :order.
-
-NOTE: acts_as_enumerated records are considered immutable.  By
-default you cannot create/alter/destroy instances because they are
-cached in memory.  Because of Rails' process-based model it is not
-safe to allow updating acts_as_enumerated records as the caches
-will get out of sync.
-
-However, one instance where updating the models *should* be allowed
-is if you are using ActiveRecord Migrations.
-
-Using the above example you would do the following:
-
-BookingStatus.enumeration_model_updates_permitted = true
-BookingStatus.create(:name => 'newname')
-
-* has_enumerated
-
-First of all, note that you *could* specify the relationship
-to an acts_as_enumerated class using the belongs_to association.
-However, has_enumerated is preferable because you aren't really
-associated to the enumerated value, you are *aggregating* it.
-As such, the has_enumerated macro behaves more like an aggregation
-than an association.
-
-class Booking < ActiveRecord::Base
-has_enumerated  :status, :class_name => 'BookingStatus',
-                :foreign_key => 'status_id', 
-                :on_lookup_failure => :optional_instance_method
-end
-
-By default, the foreign key is interpreted to be the name of your
-has_enumerated field (in this case 'status') plus '_id'.  Additionally,
-the default value for :class_name is the camel-ized version of the
-name for your has_enumerated field.  :on_lookup_failure is explained
-below.
-
-With that, your Booking class will have the following methods defined:
-
-* status : returns the BookingStatus with an id that matches the
-value in the Booking.status_id.
-
-* status= : sets the value for Booking.status_id using the id of
-the BookingStatus instance passed as an argument.  As a short-hand,
-you can also pass it the 'name' of a BookingStatus instance, either
-as a 'string' or :symbol.
-
-I.e. mybooking.status = :confirmed or mybooking.update_attribute(:status,
-:confirmed)
-
-The :on_lookup_failure option in has_enumerated is there because
-(again) I'm opinionated about what should happen.  By default, if
-booking.status_id contains an id that isn't a valid BookingStatus.id
-I just want booking.status to return nil rather than throw an
-exception.  This ensures I can edit my Booking instances without
-having to put rescue blocks around all my booking.status calls.
-However, if I call booking.status = :bogus I want noisy hints about
-the bug.
-
-Of course, you may not agree with that in which case you can specify
-an *instance* method to be called in the case of a lookup failure.
-The method signature is as follows:
-
-your_lookup_handler(operation, name, name_foreign_key, 
-										acts_enumerated_class_name, lookup_value)
-
-The 'operation' arg will be either :read or :write.  In the case
-of :read you are expected to return something or raise an exception,
-while in the case of a :write you don't have to return anything.
-
-Note that there's enough information in the method signature that
-you can specify one method to handle all lookup failures for all
-has_enumerated fields if you happen to have more than one defined
-in your model.
-
-* ActiveRecord::VirtualEnumerations
-
-For the most part, your acts_as_enumerated classes will do nothing
-more than just act as enumerated.  
-
-In that case there isn't much point cluttering up your models
-directory with those class files.  You can use
-ActiveRecord::VirtualEnumerations to reduce that clutter.
-
-Copy virtual_enumerations_sample.rb to
-Rails.root/config/virtual_enumerations.rb and configure it accordingly.
-
-See virtual_enumerations_sample.rb in this directory for a full
-description.
-

data/vendor/plugins/enumerations_mixin/Rakefile

@@ -1,14 +0,0 @@
-begin
-  require "jeweler"
-  Jeweler::Tasks.new do |gem|
-    gem.name = "enumerations_mixin"
-    gem.summary = "Allows you to treat instances of your ActiveRecord models as though they were an enumeration of values"
-    gem.description = "Allows you to treat instances of your ActiveRecord models as though they were an enumeration of values"
-    gem.email = "pivotal-opensource@googlegroups.com"
-    gem.homepage = "http://github.com/pivotal/enumerations_mixin"
-    gem.authors = ["Trevor Squires", "Pivotal Labs"]
-    gem.files = Dir["{lib}/**/*"] + Dir["{examples}/**/*"]
-  end
-rescue
-  puts "Jeweler or one of its dependencies is not installed."
-end

data/vendor/plugins/enumerations_mixin/VERSION

@@ -1 +0,0 @@
-0.2.4

data/vendor/plugins/enumerations_mixin/enumerations_mixin.gemspec

@@ -1,44 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{enumerations_mixin}
-  s.version = "0.2.4"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Trevor Squires", "Pivotal Labs"]
-  s.date = %q{2012-01-10}
-  s.description = %q{Allows you to treat instances of your ActiveRecord models as though they were an enumeration of values}
-  s.email = %q{pivotal-opensource@googlegroups.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-    "README.md"
-  ]
-  s.files = [
-    "examples/virtual_enumerations_sample.rb",
-    "lib/active_record/acts/enumerated.rb",
-    "lib/active_record/aggregations/has_enumerated.rb",
-    "lib/active_record/virtual_enumerations.rb",
-    "lib/enumerations_mixin.rb"
-  ]
-  s.homepage = %q{http://github.com/pivotal/enumerations_mixin}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Allows you to treat instances of your ActiveRecord models as though they were an enumeration of values}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rails>, [">= 3.0.0"])
-    else
-      s.add_dependency(%q<rails>, [">= 3.0.0"])
-    end
-  else
-    s.add_dependency(%q<rails>, [">= 3.0.0"])
-  end
-end
-

data/vendor/plugins/enumerations_mixin/examples/virtual_enumerations_sample.rb

@@ -1,76 +0,0 @@
-# Copyright (c) 2005 Trevor Squires
-# Released under the MIT License.  See the LICENSE file for more details.
-
-# Copy this file to Rails.root/config/initializers/virtual_enumerations.rb
-# and configure it accordingly.
-ActiveRecord::VirtualEnumerations.define do |config|
-  ###
-  # USAGE (and don't worry, it doesn't have to be as ugly as this):
-  # config.define 'ClassName', 
-  #               :table_name => 'table', :extends => 'SuperclassName',
-  #               :conditions => ['something = ?', "value"], :order => 'column ASC',
-  #               :on_lookup_failure => :enforce_strict_literals do
-  # class_evaled_functions
-  # end 
-  #
-  # 'ClassName', :table_name and :extends are used to define your virtual class.
-  # Note that 'ClassName' can be a :symbol or a 'CamelString'.  
-  #
-  # The :conditions, :order and :on_lookup_failure arguments are passed to
-  # acts_as_enumerated in your virtual class.  See README_ENUMERATIONS for info
-  # on how acts_as_enumerated works.
-  #
-  # The 'do' block will be class_eval'd by your virtual class after it has 
-  # been loaded-on-demand.
-  #
-  ###
-  # Okay, that's pretty long-winded.
-  # Everything after the initial 'class_name' is optional so for most applications, this
-  # is about as verbose as you're likely to get:
-  #
-  # config.define :booking_status, :order => 'position ASC'
-  #
-  # In the above example, ActiveRecord assumes the table will be called 'booking_statuses'
-  # and the table should have a 'position' column defined.
-  #
-  # If you've got a bunch of enumeration classes that share the same optional parameters
-  # you can pass an array of names as the first argument, saving your fingers from typing
-  # config.define over and over again:
-  #
-  # config.define [:booking_status, :card_issuer], :order => 'position ASC'
-  #
-  # You can also take advantage of ActiveRecord's STI:
-  #
-  # config.define :enum_record, :order => 'position ASC', :table_name => 'enumrecords'
-  # config.define [:booking_status, :card_issuer], :extends => 'EnumRecord'
-  #
-  # In the above example, all of the records are stored in the table called 'enumrecords'
-  # and all acts_as_enumerated parameters are automatically inherited by the
-  # subclasses (although you can override them if you want).
-  # You can also use :extends to extend a non-virtual model class (that's already in 
-  # your models directory) if that floats your boat.
-  #
-  # Finally, that strange optional 'do' block.
-  # You may be struck by the need to tamper with your virtual enumeration class after
-  # it has been loaded-on-demand.  This can be as simple as blessing it with a 
-  # certain 'act':
-  #
-  # config.define :enum_record, :order => 'position ASC' do
-  #   acts_as_list # but see README_ENUMERATIONS for rules about modifying your records 
-  # end
-  #
-  # or you may be experimenting with the dark-side... singleton methods
-  #
-  # config.define :card_issuer do
-  #   class << self[:visa]; def verify_number(arg); some_code_here; end; end
-  #   class << self[:master_card]; def verify_number(arg); some_other_code_here; end; end
-  # end
-  #
-  # For virtual enumerations, this sort of tampering *has* to be defined in the 
-  # config.define do block.  This is because in development mode, rails loads and 
-  # subsequently clobbers your model classes for each request.  The 'do' block will
-  # be evaluated each time your model class is loaded-on-demand.
-  #
-  ###
-  
-end

data/vendor/plugins/enumerations_mixin/init.rb

@@ -1,21 +0,0 @@
-# Copyright (c) 2005 Trevor Squires
-# Released under the MIT License.  See the LICENSE file for more details.
-
-require 'active_record/acts/enumerated'
-require 'active_record/aggregations/has_enumerated'
-ActiveRecord::Base.class_eval do
-  include ActiveRecord::Acts::Enumerated
-  include ActiveRecord::Aggregations::HasEnumerated
-end
-
-# Virtual enumerations are useful if you've got a ton of different
-# enumerations and don't care to litter your models directory with them.
-# It's also handy if you want to define singleton methods for your
-# enumerated values.
-# See virtual_sample.txt in this directory for more info
-if File.exist?("#{Rails.root}/config/virtual_enumerations.rb")
-  require 'active_record/virtual_enumerations'
-  silence_warnings do
-    eval(IO.read("#{Rails.root}/config/virtual_enumerations.rb"), binding)
-  end
-end

data/vendor/plugins/enumerations_mixin/lib/active_record/acts/enumerated.rb

@@ -1,180 +0,0 @@
-# Copyright (c) 2005 Trevor Squires
-# Released under the MIT License.  See the LICENSE file for more details.
-
-module ActiveRecord
-  module Acts 
-    module Enumerated 
-      def self.append_features(base)
-        super        
-        base.extend(MacroMethods)              
-      end
-      
-      module MacroMethods          
-        def acts_as_enumerated(options = {})
-          valid_keys = [:conditions, :order, :on_lookup_failure]
-          options.assert_valid_keys(*valid_keys)
-          valid_keys.each do |key|   
-          class_attribute :acts_enumerated_on_lookup_failure
-            class_attribute "acts_enumerated_#{key.to_s}"
-            if options.has_key?( key )
-              self.send "acts_enumerated_#{key.to_s}=", options[key]
-            end            
-          end
-          
-          unless self.is_a? ActiveRecord::Acts::Enumerated::ClassMethods
-            extend ActiveRecord::Acts::Enumerated::ClassMethods
-            class_eval do
-              include ActiveRecord::Acts::Enumerated::InstanceMethods
-              validates_uniqueness_of :name
-              before_save :enumeration_model_update
-              before_destroy :enumeration_model_update
-            end
-          end
-        end
-      end
-      
-      module ClassMethods  
-        attr_accessor :enumeration_model_updates_permitted
-        
-        def all
-          return @all if @all
-          conditions = self.acts_enumerated_conditions
-          order = self.acts_enumerated_order
-          @all = where(conditions).order(order).collect{|val| val.freeze}.freeze          
-        end
-
-        def [](arg)
-          case arg
-          when Symbol
-            rval = lookup_name(arg.id2name) and return rval
-          when String
-            rval = lookup_name(arg) and return rval
-          when Fixnum
-            rval = lookup_id(arg) and return rval
-          when nil
-            rval = nil 
-          else
-            raise TypeError, "#{self.name}[]: argument should be a String, Symbol or Fixnum but got a: #{arg.class.name}"            
-          end
-          self.send(:acts_enumerated_on_lookup_failure) || self.send(:enforce_strict_literals, arg)
-        end
-
-        def lookup_id(arg)
-          all_by_id[arg]
-        end
-
-        def lookup_name(arg)
-          all_by_name[arg]
-        end
-                                   
-        def include?(arg)
-          case arg
-          when Symbol
-            return !lookup_name(arg.id2name).nil?
-          when String
-            return !lookup_name(arg).nil?
-          when Fixnum
-            return !lookup_id(arg).nil?
-          when self
-            possible_match = lookup_id(arg.id) 
-            return !possible_match.nil? && possible_match == arg
-          end
-          return false
-        end
-
-        # NOTE: purging the cache is sort of pointless because
-        # of the per-process rails model.  
-        # By default this blows up noisily just in case you try to be more 
-        # clever than rails allows.  
-        # For those times (like in Migrations) when you really do want to 
-        # alter the records you can silence the carping by setting
-        # enumeration_model_updates_permitted to true.
-        def purge_enumerations_cache
-          unless self.enumeration_model_updates_permitted
-            raise "#{self.name}: cache purging disabled for your protection"
-          end
-          @all = @all_by_name = @all_by_id = nil
-        end
-
-        private 
-        
-        def all_by_id 
-          return @all_by_id if @all_by_id
-          @all_by_id = all.inject({}) { |memo, item| memo[item.id] = item; memo;}.freeze              
-        end
-        
-        def all_by_name
-          return @all_by_name if @all_by_name
-          begin
-            @all_by_name = all.inject({}) { |memo, item| memo[item.name] = item; memo;}.freeze              
-          rescue NoMethodError => err
-            if err.name == :name
-              raise TypeError, "#{self.name}: you need to define a 'name' column in the table '#{table_name}'"
-            end
-            raise
-          end            
-        end   
-        
-        def enforce_none(arg)
-          return nil
-        end
-
-        def enforce_strict(arg)
-          raise ActiveRecord::RecordNotFound, "Couldn't find a #{self.name} identified by (#{arg.inspect})"
-        end
-
-        def enforce_strict_literals(arg)
-          if Fixnum === arg || Symbol === arg
-            raise ActiveRecord::RecordNotFound, "Couldn't find a #{self.name} identified by (#{arg.inspect})"
-          end
-          return nil
-        end
-        
-      end
-
-      module InstanceMethods
-        def ===(arg)
-          case arg
-          when Symbol, String, Fixnum, nil
-            return self == self.class[arg]
-          when Array
-            return self.in?(*arg)
-          end
-          super
-        end
-        
-        alias_method :like?, :===
-        
-        def in?(*list)
-          for item in list
-            self === item and return true
-          end
-          return false
-        end
-
-        def name_sym
-          self.name.to_sym
-        end
-
-        private
-
-        # NOTE: updating the models that back an acts_as_enumerated is 
-        # rather dangerous because of rails' per-process model.
-        # The cached values could get out of synch between processes
-        # and rather than completely disallow changes I make you jump 
-        # through an extra hoop just in case you're defining your enumeration 
-        # values in Migrations.  I.e. set enumeration_model_updates_permitted = true
-        def enumeration_model_update
-          if self.class.enumeration_model_updates_permitted    
-            self.class.purge_enumerations_cache
-            return true
-          end
-          # Ugh.  This just seems hack-ish.  I wonder if there's a better way.
-          self.errors.add('name', "changes to acts_as_enumeration model instances are not permitted")   
-          return false
-        end
-      end
-    end
-  end
-end
-