has_magic_columns 0.1.1

data/.gitignore

@@ -0,0 +1,6 @@
+ftags
+.rvmrc
+Gemfile.lock
+.bundle
+rdoc/
+pkg/

data/CONTRIBUTORS.md

@@ -0,0 +1,37 @@
+# Pull Requests
+
+We love pull requests. Here's a quick guide:
+
+1. Fork the repo.
+
+2. Run the tests. We only take pull requests with passing tests, and it's great
+to know that you have a clean slate: `bundle && rake`
+
+3. Add a test for your change. Only refactoring and documentation changes
+require no new tests. If you are adding functionality or fixing a bug, we need
+a test!
+
+4. Make the test pass.
+
+5. Push to your fork and submit a pull request.
+
+
+At this point you're waiting on us. We'll be in contact as soon as we are able.
+We may suggest some changes, improvements, alternatives.
+
+Some things that will increase the chance that your pull request is accepted,
+taken straight from the Ruby on Rails guide:
+
+* Use Rails idioms and helpers
+* Include tests that fail without your code, and pass with it
+* Update the documentation, the surrounding one, examples elsewhere, guides,
+  whatever is affected by your contribution
+
+# Conventions
+
+* Foremost, follow the conventions you see in the source.
+* Two spaces, no tabs.
+* No trailing whitespace. Blank lines should not have any space.
+* Prefer `&&`/`||` over `and`/`or`.
+* `MyClass.my_method(my_arg)` not `my_method( my_arg )` or `my_method my_arg`.
+* `a = b` instead of `a=b`.

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Brandon Keene <bkeene AT gmail DOT com>
+
+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,121 @@
+has_magic_columns
+===============
+
+Allows the addition of custom "magic" columns and attributes on a per-model
+or per-parent-model basis. This is useful for situations where custom fields are
+required for a specific model or for multi-user, multi-account environments where
+accounts can customize attributes for subordinate models.
+
+**NOTE**: This plugin is probably not production-ready. While all the described
+features work, not all features have been tested. It was originally a Rails 2
+plugin written by Brandon Keene and has been updated to a gem with Rails 3
+support.
+
+Installation
+============
+
+Add to your Gemfile:
+
+    gem "has_magic_columns"
+
+Create the migrations for MagicColumns and migrate:
+
+    rails g has_magic_columns:install
+    rake db:migrate
+
+Usage
+=====
+
+## Model
+
+Sprinkle a little magic into an existing model:
+
+    class User < ActiveRecord::Base
+      has_magic_columns
+    end
+
+Add magic columns to your model:
+
+    @bob = User.create(:email => "bob@example.com")
+    @bob.magic_columns.create(:name => "first_name")
+
+Supply additional options if you have more specific requirements for your columns:
+
+    @bob.magic_columns.create(:name => "last_name", :is_required => true)
+    @bob.magic_columns.create(:name => "birthday", :datatype => :date)
+    @bob.magic_columns.create(:name => "salary", :default => "40000", :pretty_name => "Yearly Salary")
+
+The :datatype option supports :check_box_boolean, :date, :datetime, or :integer.
+
+Use your new columns just like you would with any other ActiveRecord attribute:
+
+    @bob.first_name = "Bob"
+    @bob.last_name = "Magic!"
+    @bob.birthday = Date.today
+    @bob.save
+
+Find @bob and inspect him:
+
+    @bob = User.find(@bob.id)
+    @bob.first_name	#=> "Bob"
+    @bob.last_name	#=> "Magic!"
+    @bob.birthday	#=> #<Date: 4908497/2,0,2299161>
+    @bob.salary     #=> "40000", this is from :salary having a :default
+
+## Inherited Model
+
+A child can inherit magic columns from a parent. To do this, declare the parent
+as having magic columns:
+
+    class Account < ActiveRecord::Base
+      has_many :users
+      has_magic_columns
+    end
+
+And declare the child as having magic columns :through the parent.
+
+    class User < ActiveRecord::Base
+      belongs_to :account
+      has_magic_columns :through => :account
+    end
+
+To see all the magic columns available for a child from its parent:
+
+    @user.magic_columns #=> [#<MagicColumn>,...]
+    @user.account.magic_columns #=> [#<MagicColumn>,...]
+
+To add magic columns, go through the parent or child:
+
+    @user.magic_columns.create(...)
+    @user.account.magic_columns.create(...)
+
+All children for a given parent will have access to the same magic columns:
+
+    @account = Account.create(:name => "BobCorp")
+
+    @bob = User.create(:name => "bob", :account => @account)
+    @bob.magic_columns.create(:name => "salary")
+    @bob.salary = "40000"
+
+    @steve = User.create(:name => "bob", :account => @account)
+    # no need to add the column again
+    @steve.salary = "50000"
+
+To Do
+=====
+
+This gem is mostly functional. Here's a short list of things that need to be
+done to polish it up:
+
+* Test
+* Benchmark and optimize
+
+Maintainers
+===========
+
+* Drew Ulmer ([latortuga](http://github.com/latortuga))
+* Nicholas Zielinski ([zieski](http://github.com/zieski))
+
+Contribute
+==========
+See the [CONTRIBUTORS guide](https://github.com/latortuga/has_magic_columns/blob/master/CONTRIBUTORS.md).

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake'
+gem 'rdoc'
+require 'rdoc/task'
+require 'rake/testtask'
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+#desc 'Default: run unit tests.'
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation.'
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include("README.md","lib/**/*.rb")
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'HasMagicColumns'
+  rdoc.options << '--line-numbers' << '--inline-source'
+end

data/has_magic_columns.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'has_magic_columns/version'
+
+Gem::Specification.new do |s|
+  s.name = "has_magic_columns"
+  s.version = HasMagicColumns::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Drew Ulmer","Nicholas Zielinski","Brandon Keene"]
+  s.email = ["latortuga@gmail.com","zieski@gmail.com"]
+  s.homepage = %q{https://github.com/latortuga/has_magic_columns}
+  s.summary = "Custom fields for Rails 3"
+  s.description = "Allow addition of custom 'magic' columns to ActiveRecord models."
+  s.date = Date.today
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency("activesupport", ["~> 3.0"])
+  s.add_dependency("activerecord", ["~> 3.0"])
+
+  s.add_development_dependency "rails", ["~> 3.0"]
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "rspec", ["~> 2.0"]
+  s.add_development_dependency "rdoc"
+end

data/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.send :include, Has::Magic::Columns

data/lib/app/models/magic_attribute.rb

@@ -0,0 +1,29 @@
+# Always work through the interface MagicAttribute.value
+class MagicAttribute < ActiveRecord::Base
+  belongs_to :magic_column
+  belongs_to :magic_option
+
+  before_save :update_magic
+  
+  def to_s
+    (magic_option) ? magic_option.value : value
+  end
+  
+  def update_magic
+    if option = find_magic_option_for(value)
+      unless magic_option and magic_option == option
+        self.value = nil
+        self.magic_option = option
+      end
+    elsif magic_column.allow_other
+      self.magic_option = nil
+    end
+  end
+  
+private
+
+  def find_magic_option_for(value)
+    magic_column.magic_options.find(:first,
+      :conditions => ["value = ? or synonym = ?", value, value])
+  end
+end

data/lib/app/models/magic_attribute_relationship.rb

@@ -0,0 +1,4 @@
+class MagicAttributeRelationship < ActiveRecord::Base
+  belongs_to :magic_attribute
+  belongs_to :owner, :polymorphic => true
+end

data/lib/app/models/magic_column.rb

@@ -0,0 +1,33 @@
+class MagicColumn < ActiveRecord::Base
+  has_many :magic_column_relationships
+  has_many :owners, :through => :magic_column_relationships, :as => :owner
+  has_many :magic_options
+  
+  validates_presence_of :name, :datatype
+  validates_format_of :name, :with => /^[a-z][a-z0-9_]+$/
+  
+  def type_cast(value)
+    begin
+      case datatype.to_sym
+        when :check_box_boolean
+          (value.to_int == 1) ? true : false 
+        when :date
+          Date.parse(value)
+        when :datetime
+          Time.parse(value)
+        when :integer
+          value.to_int
+      else
+        value
+      end
+    rescue
+      value
+    end
+  end
+  
+  # Display a nicer (possibly user-defined) name for the column or use a fancified default.
+  def pretty_name
+    super || name.humanize
+  end
+  
+end

data/lib/app/models/magic_column_relationship.rb

@@ -0,0 +1,5 @@
+class MagicColumnRelationship < ActiveRecord::Base
+  belongs_to :magic_column
+  belongs_to :owner, :polymorphic => true
+  #belongs_to :extended_model, :polymorphic => true
+end

data/lib/app/models/magic_option.rb

@@ -0,0 +1,7 @@
+class MagicOption < ActiveRecord::Base
+  belongs_to :magic_column
+  
+  validates_presence_of :value
+  validates_uniqueness_of :value, :scope => :magic_column_id
+  validates_uniqueness_of :synonym, :scope => :magic_column_id, :if => Proc.new{|this| !this.synonym.nil? and !this.synonym.empty?}
+end

data/lib/generators/has_magic_columns/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Add a migration for has_magic_columns.
+
+Example:
+    rails generate has_magic_columns:install
+
+    This will create:
+        db/migrate/XXX_add_has_magic_columns_tables.rb

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

@@ -0,0 +1,24 @@
+require 'rails/generators/base'
+
+module HasMagicColumns
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    source_root File.expand_path('../templates',__FILE__)
+
+    desc "Add has_magic_columns migration."
+
+    def self.next_migration_number(path)
+      unless @prev_migration_nr
+        @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+      else
+        @prev_migration_nr += 1
+      end
+      @prev_migration_nr.to_s
+    end
+
+    def add_migration
+      migration_template "migration.rb", "db/migrate/add_has_magic_columns_tables.rb"
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+class AddHasMagicColumnsTables < ActiveRecord::Migration
+  def self.up
+    create_table :magic_columns do |t|
+      t.column :name,           :string
+      t.column :pretty_name,    :string
+      t.column :datatype,       :string, :default => "string"
+      t.column :default,        :string
+      t.column :is_required,    :boolean, :default => false
+      t.column :include_blank,  :boolean, :default => false
+      t.column :allow_other,    :boolean, :default => true
+      t.column :created_at,     :datetime
+      t.column :updated_at,     :datetime
+    end
+    
+    create_table :magic_attributes do |t|
+      t.column :magic_column_id, :integer
+      t.column :magic_option_id, :integer
+      t.column :value, :string
+      t.column :created_at, :datetime
+      t.column :updated_at, :datetime
+    end
+    
+    create_table :magic_options do |t|
+      t.column :magic_column_id, :integer
+      t.column :value, :string
+      t.column :synonym, :string
+      t.column :created_at, :datetime
+      t.column :updated_at, :datetime
+    end
+    
+    create_table :magic_column_relationships do |t|
+      t.column :magic_column_id, :integer
+      t.column :owner_id, :integer
+      t.column :owner_type, :string
+      t.column :created_at, :datetime
+      t.column :updated_at, :datetime
+    end
+    
+    create_table :magic_attribute_relationships do |t|
+      t.column :magic_attribute_id, :integer
+      t.column :owner_id, :integer
+      t.column :owner_type, :string
+    end   
+  end
+
+  def self.down
+    drop_table "magic_columns"
+    drop_table "magic_attributes"
+    drop_table "magic_options"
+    drop_table "magic_column_relationships"
+    drop_table "magic_attribute_relationships"
+  end
+end

data/lib/has_magic_columns/has_magic_columns.rb

@@ -0,0 +1,172 @@
+module HasMagicColumns #:nodoc:
+  def self.included(base) # :nodoc:
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def has_magic_columns(options = {})
+      unless magical?
+        # Associations
+        has_many :magic_attribute_relationships, :as => :owner, :dependent => :destroy
+        has_many :magic_attributes, :through => :magic_attribute_relationships, :dependent => :destroy
+        
+        # Eager loading - EXPERIMENTAL!
+        if options[:eager]
+          class_eval do
+            def after_initialize
+              initialize_magic_columns
+            end
+          end
+        end
+        
+        # Inheritence
+        cattr_accessor :inherited_from
+
+        # if options[:through] is supplied, treat as an inherited relationship
+        if self.inherited_from = options[:through]
+          class_eval do
+            def inherited_magic_columns
+              raise "Cannot inherit MagicColumns from a non-existant association: #{@inherited_from}" unless self.class.method_defined?(inherited_from)# and self.send(inherited_from)
+              self.send(inherited_from).magic_columns
+            end
+          end
+          alias_method :magic_columns, :inherited_magic_columns unless method_defined? :magic_columns
+
+        # otherwise the calling model has the relationships
+        else
+          has_many :magic_column_relationships, :as => :owner, :dependent => :destroy
+          has_many :magic_columns, :through => :magic_column_relationships, :dependent => :destroy
+        end
+        
+        # Hook into Base
+        class_eval do
+          alias_method :reload_without_magic, :reload
+          alias_method :create_or_update_without_magic, :create_or_update
+          alias_method :read_attribute_without_magic, :read_attribute
+        end
+      end
+      include InstanceMethods
+      
+      # Add Magic to Base
+      alias_method :reload, :reload_with_magic
+      alias_method :read_attribute, :read_attribute_with_magic
+      alias_method :create_or_update, :create_or_update_with_magic
+    end
+
+    def magical?
+      self.included_modules.include?(InstanceMethods)
+    end
+  end
+
+  module InstanceMethods #:nodoc:
+    # Reinitialize MagicColumns and MagicAttributes when Model is reloaded
+    def reload_with_magic
+      initialize_magic_columns
+      reload_without_magic
+    end
+
+    def update_attributes(new_attributes)
+      attributes = new_attributes.stringify_keys
+      magic_attrs = magic_columns.map(&:name)
+
+      super(attributes.select{ |k, v| !magic_attrs.include?(k) })
+      attributes.select{ |k, v| magic_attrs.include?(k) }.each do |k, v|
+        col = find_magic_column_by_name(k)
+        attr = find_magic_attribute_by_column(col).first
+        attr.update_attributes(:value => v)
+      end
+    end
+
+    private
+    
+    # Save MagicAttributes from @attributes
+    def create_or_update_with_magic
+      if result = create_or_update_without_magic
+        magic_columns.each do |column|
+          value = @attributes[column.name]
+          existing = find_magic_attribute_by_column(column)
+          
+          unless column.datatype == 'check_box_multiple'
+            (attr = existing.first) ? 
+              update_magic_attribute(attr, value) : 
+              create_magic_attribute(column, value)
+          else
+            #TODO - make this more efficient
+            value = [value] unless value.is_a? Array
+            existing.map(&:destroy) if existing
+            value.collect {|v| create_magic_attribute(column, v)}
+          end
+        end
+      end
+      result
+    end
+    
+    # Load (lazily) MagicAttributes or fall back
+    def method_missing(method_id, *args)
+      super(method_id, *args)
+    rescue NoMethodError
+      method_name = method_id.to_s
+      attr_names = magic_columns.map(&:name)
+      initialize_magic_columns and retry if attr_names.include?(method_name) or 
+        (md = /[\?|\=]/.match(method_name) and 
+        attr_names.include?(md.pre_match))
+      super(method_id, *args)
+    end
+    
+    # Load the MagicAttribute(s) associated with attr_name and cast them to proper type.
+    def read_attribute_with_magic(attr_name)
+      return read_attribute_without_magic(attr_name) if column_for_attribute(attr_name) # filter for regular columns
+      attr_name = attr_name.to_s
+      
+      if !(value = @attributes[attr_name]).nil?
+        if column = find_magic_column_by_name(attr_name)
+          if value.is_a? Array
+            value.map {|v| column.type_cast(v)}
+          else
+            column.type_cast(value)
+          end
+        else
+          value
+        end
+      else
+        nil
+      end
+    end
+    
+    # Lookup all MagicAttributes and setup @attributes
+    def initialize_magic_columns
+      magic_columns.each do |column| 
+        attribute = find_magic_attribute_by_column(column)
+        name = column.name
+        
+        # Validation
+        self.class.validates_presence_of(name) if column.is_required?
+        
+        # Write attribute
+        unless column.datatype == 'check_box_multiple'
+          (attr = attribute.first) ?
+            write_attribute(name, attr.to_s) :
+            write_attribute(name, column.default)
+        else
+          write_attribute(name, attribute.map(&:to_s))
+        end
+      end
+    end
+    
+    def find_magic_attribute_by_column(column)
+      magic_attributes.to_a.find_all {|attr| attr.magic_column_id == column.id}
+    end
+    
+    def find_magic_column_by_name(attr_name)
+      magic_columns.to_a.find {|column| column.name == attr_name}
+    end
+    
+    def create_magic_attribute(magic_column, value)
+      magic_attributes << MagicAttribute.create(:magic_column => magic_column, :value => value)
+    end
+    
+    def update_magic_attribute(magic_attribute, value)
+      magic_attribute.update_attributes(:value => value)
+    end
+  end
+end

data/lib/has_magic_columns/railtie.rb

@@ -0,0 +1,22 @@
+require 'has_magic_columns'
+
+module HasMagicColumns
+  class Railtie < Rails::Railtie
+    initializer "has_magic_columns" do
+
+      # I think this is probably a ghetto way of doing this
+      # based on some limited research into other plugins. Neverhtless
+      # it's the only way I know for the moment.
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.send(:include, HasMagicColumns)
+
+        %w{ models }.each do |dir|
+          path = File.join(File.dirname(__FILE__), '../app', dir)
+          $LOAD_PATH << path
+          ActiveSupport::Dependencies.autoload_paths << path
+          ActiveSupport::Dependencies.autoload_once_paths.delete(path)
+        end
+      end
+    end
+  end
+end

data/lib/has_magic_columns/version.rb

@@ -0,0 +1,3 @@
+module HasMagicColumns
+  VERSION = "0.1.1"
+end

data/lib/has_magic_columns.rb

@@ -0,0 +1,24 @@
+require 'has_magic_columns/has_magic_columns'
+require 'has_magic_columns/version'
+require 'has_magic_columns/railtie' if defined?(Rails)
+
+# Has Magic Columns
+#
+# Copyright (c) 2007 Brandon Keene <bkeene AT gmail DOT com>
+#
+# Extends @attributes on a per model basis.  Column definitions exist through
+# the built-in :magic_columns association.
+#
+# class Model < ActiveRecord::Base
+#   has_magic_columns
+# end
+#
+# @model = Model.create(...) #=> @model.id == 1
+# @model.magic_columns << MagicColumn.create(:name => "first_name")
+# @model.first_name = "Brandon"
+# @model.save
+# @model = Model.find(1)
+# @model.first_name #=> "Brandon"
+module HasMagicColumns # :nodoc:
+end
+

data/test/has_magic_columns_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+
+class HasMagicColumnsTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_this_plugin
+    flunk
+  end
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification 
+name: has_magic_columns
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Drew Ulmer
+- Nicholas Zielinski
+- Brandon Keene
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-28 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Allow addition of custom 'magic' columns to ActiveRecord models.
+email: 
+- latortuga@gmail.com
+- zieski@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- CONTRIBUTORS.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- has_magic_columns.gemspec
+- init.rb
+- lib/app/models/magic_attribute.rb
+- lib/app/models/magic_attribute_relationship.rb
+- lib/app/models/magic_column.rb
+- lib/app/models/magic_column_relationship.rb
+- lib/app/models/magic_option.rb
+- lib/generators/has_magic_columns/install/USAGE
+- lib/generators/has_magic_columns/install/install_generator.rb
+- lib/generators/has_magic_columns/install/templates/migration.rb
+- lib/has_magic_columns.rb
+- lib/has_magic_columns/has_magic_columns.rb
+- lib/has_magic_columns/railtie.rb
+- lib/has_magic_columns/version.rb
+- test/has_magic_columns_test.rb
+has_rdoc: true
+homepage: https://github.com/latortuga/has_magic_columns
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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.6.2
+signing_key: 
+specification_version: 3
+summary: Custom fields for Rails 3
+test_files: []
+