metafy 1.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in metafy.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2004-2011 Caseproof, LLC
+
+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.rdoc

@@ -0,0 +1,82 @@
+= Metafy
+
+Metafy is a Gem for Rails 3 that makes it possible to easily add dynamic attributes to any ActiveRecord model. These lightweight, meta attributes work just like normal database column attributes on your ActiveRecord model and are fully searchable (i.e. you can find records by values contained in these dynamic attributes).
+
+= Installation
+
+To apply Metafy to any ActiveRecord model, follow these simple steps:
+
+1. Install
+   - Add to Gemfile: <b>gem 'metafy'</b>
+   - Install required gems: <b>bundle install</b>
+
+2. Add the 'mattrs' table to your database
+   - Create migration: <b>rails g metafy</b>
+   - Migrate your database: <b>rake db:migrate</b>
+
+3. Add metafied attributes to any of your ActiveRecord models using the <b>metafy</b> class method:
+   - Add to app/models/model.rb: <b>metafy :attribute_name</b>
+
+= Example
+
+Say you had a table named "users":
+
+  mysql> desc users;
+  +----------------+--------------+------+-----+---------+----------------+
+  | Field          | Type         | Null | Key | Default | Extra          |
+  +----------------+--------------+------+-----+---------+----------------+
+  | id             | int(11)      | NO   | PRI | NULL    | auto_increment |
+  | username       | varchar(255) | YES  | MUL | NULL    |                |
+  | email          | varchar(255) | YES  | MUL | NULL    |                |
+  | created_at     | datetime     | YES  |     | NULL    |                |
+  | updated_at     | datetime     | YES  |     | NULL    |                |
+  +----------------+--------------+------+-----+---------+----------------+
+
+And you wanted some lightweight, dynamic fields associated with the User model but didn't necessarily want them in the schema then you could add them as meta attributes using metafy like so:
+
+  # app/models/user.rb
+  class User < ActiveRecord::Base
+    metafy :first_name, :last_name,:gender, :country, :language
+  end
+
+Now you can do things like:
+  >> user = User.meta_where( :first_name => 'Bevis' ).first
+  >> user.first_name = 'Larry'
+  >> user.save
+  >> user.first_name
+    => 'Larry'
+
+OR create a new record with meta attributes:
+  >> user = User.new :first_name => 'Jerry', :last_name => 'Johnson'
+  >> user.save
+
+OR select using the meta_where scope:
+  >> num_johnsons = User.meta_where( :last_name => 'Johnson' ).count
+
+OR select & order using standard rails relations:
+  >> num_johnsons = User.where( :m_country => { :meta_value => 'Canada' } ).order( 'm_last_name.meta_value ASC' )
+
+OR chain where with meta_where:
+  >> users = User.where( 'users.email LIKE "%@gmail.com"' ).meta_where( :language => "French" )
+
+= Why would I want to use this Gem instead of just adding more database columns?
+Well, there isn't much difference functionally between a normal database colunn and a meta attribute. But there may be sometimes when you want to add a more dynamic, lightweight attribute that doesn't clutter your schema. That's when you'd use metafy.
+
+= Version history
+
+- Version 0.0.5
+  - Added more documentation
+- Version 0.0.4
+  - Fixed the metas table name issue in 3.0.7
+- Version 0.0.3
+  - Added documentation
+- Version 0.0.2
+  - Gem Fixes
+- Version 0.0.1
+  - Initial Version
+
+= Contact and copyright
+
+Bug report? Faulty/incomplete documentation? Feature request? Please post an issue on 'http://github.com/Caseproof/metafy/issues'. If its urgent, please contact me from my website at 'http://blairwilliams.com/contact'
+
+Copyright (c) 2004-2011 Caseproof, LLC, released under the MIT license

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/app/models/mattr.rb

@@ -0,0 +1,41 @@
+class Mattr < ActiveRecord::Base
+  def self.meta(target_type, target_id, meta_key)
+    Mattr.where({ :target_type => target_type, :meta_key => meta_key, :target_id => target_id }).first
+  end
+  
+  def self.meta=(args)
+    return false if args.nil? or !args.is_a?(Array) or args.length < 4
+    Mattr.metas = [ args[0], args[1], { args[2] => args[3] } ]
+  end
+
+  def self.metas=(args)
+    return if args.nil?
+    return unless args.is_a?(Array)
+    return unless args[2].is_a?(Hash)
+
+    args[2].each do |k,v|
+      unless meta = self.meta(args[0],args[1],k)
+        meta = Mattr.new
+      end
+
+      meta.target_type = args[0]
+      meta.target_id   = args[1]
+      meta.meta_key    = k
+      meta.meta_value  = v
+      meta.save
+    end
+  end
+
+  def self.value(target_type, target_id, meta_key)
+    record = self.meta(target_type, target_id, meta_key)
+    record.meta_value unless record.nil?
+  end
+  
+  def self.exists?(target_type, target_id, meta_key)
+    self.meta(target_type, target_id, meta_key) != false
+  end
+  
+  def self.metas(target_type, target_id)
+    Mattr.where({ :target_type => target_type, :target_id => target_id })
+  end
+end

data/lib/generators/metafy_generator.rb

@@ -0,0 +1,19 @@
+require 'rails/generators'
+
+class MetafyGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  source_root File.expand_path("../templates", __FILE__)
+
+   def self.next_migration_number(dirname)
+     if ActiveRecord::Base.timestamped_migrations
+       Time.now.utc.strftime("%Y%m%d%H%M%S")
+     else
+       "%.3d" % (current_migration_number(dirname) + 1)
+     end
+   end
+
+   def create_migration_file
+     migration_template 'create_mattrs.rb', 'db/migrate/create_mattrs.rb'
+   end
+end

data/lib/generators/templates/create_mattrs.rb

@@ -0,0 +1,20 @@
+class CreateMattrs < ActiveRecord::Migration
+  def self.up
+    create_table(:mattrs) do |t|
+       t.string :meta_key, :null => false
+       t.text :meta_value
+       t.references :target, :polymorphic => true, :null => false
+       
+       t.timestamps
+    end
+
+    add_index :mattrs, :meta_key
+    add_index :mattrs, :meta_value, :length => 255
+    add_index :mattrs, :target_id
+    add_index :mattrs, :target_type
+  end
+
+  def self.down
+    drop_table :mattrs
+  end
+end

data/lib/metafy.rb

@@ -0,0 +1,4 @@
+module Metafy
+  require 'metafy/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
+  require 'metafy/activerecord_methods' if defined?(Rails) && Rails::VERSION::MAJOR == 3
+end

data/lib/metafy/activerecord_methods.rb

@@ -0,0 +1,44 @@
+require 'metafy/base'
+
+# Adds the metafy method in ActiveRecord::Base, which can be used to define the metafied objects.
+class << ActiveRecord::Base
+  def metafied?
+    @metafied || false
+  end
+
+  def metafy( *options )
+    cattr_accessor :metafied_attrs
+    self.metafied_attrs = options
+
+    # Sets to determine what classes have been metafied
+    @metafied = self.metafied_attrs.count > 0
+
+    meta_joins = []
+    class_name = self.name.classify
+    table_name = self.table_name
+    meta_selects = ["#{table_name}.*"]
+    self.metafied_attrs.each do |col|
+      meta_joins.push("LEFT JOIN mattrs m_#{col.to_s} ON m_#{col.to_s}.target_id=#{table_name}.id AND m_#{col.to_s}.meta_key='#{col.to_s}' AND m_#{col.to_s}.target_type='#{class_name}'")
+      meta_selects.push("m_#{col.to_s}.meta_value AS #{col.to_s}")
+    end
+
+    default_scope :select => meta_selects, :joins => meta_joins
+
+    scope :meta_where, lambda { |options|
+      conditions = {}
+      options.each_pair do |key,val|
+        conditions["m_#{key.to_s}".to_sym] = { :meta_value => val }
+      end
+
+      where(conditions)
+    }
+    
+    has_many :mattr, :as => :target
+
+    options.each do | meta_attr |
+      attr_accessor meta_attr.to_sym
+    end
+
+    include Metafy::Base
+  end
+end

data/lib/metafy/base.rb

@@ -0,0 +1,102 @@
+module Metafy
+  module Base
+    def initialize(attributes = nil)
+      unless attributes.nil?
+        super(attributes.except(*self.metafied_attrs))
+        define_accessors_for_attributes
+        attributes.each do |n,v|
+          set_metafied_attribute(n,v) if has_metafied_attribute?(n)
+        end
+      else
+        super(nil)
+      end
+    end
+
+    def has_metafied_attribute?(attribute)
+      return self.metafied_attrs.include?(attribute.to_sym)
+    end
+
+    def read_metafied_attribute(attribute)
+      has_metafied_attribute?(attribute.to_sym) ? Mattr.value(self.class.name, self.id, attribute.to_s) : nil
+    end
+
+    def write_metafied_attributes
+      self.metafied_attrs.each do | meta_attr |
+        write_metafied_attribute( meta_attr )
+      end
+    end
+
+    def write_metafied_attribute( meta_attr )
+      meta_attr = meta_attr.to_sym
+
+      old_meta = read_metafied_attribute( meta_attr )
+      new_meta = get_metafied_attribute( meta_attr )
+      
+      if( old_meta != new_meta )
+        Mattr.meta = [ self.class.name, self.id, meta_attr.to_s, get_metafied_attribute( meta_attr ) ]
+      end
+    end
+
+    def populate_metafied_attributes
+      define_accessors_for_attributes
+
+      attributes = Mattr.metas(self.class.name, self.id)
+      attributes.each do | meta_attr |
+        set_metafied_attribute( meta_attr.meta_key.to_sym, meta_attr.meta_value.to_s )
+      end
+    end
+
+    def singleton_class
+      class << self
+        self
+      end
+    end
+
+    def define_accessor_for_attribute(att)
+      singleton_class.send(:attr_accessor, att.to_sym)
+    end
+    
+    def define_accessors_for_attributes
+      self.metafied_attrs.each do | meta_attr |
+        unless respond_to?(meta_attr.to_s)
+          define_accessor_for_attribute(meta_attr)
+        end
+      end
+    end
+
+    def self.included object
+      super
+      object.after_initialize :populate_metafied_attributes
+      object.after_find :populate_metafied_attributes
+      object.after_save :write_metafied_attributes
+    end
+
+    def set_metafied_attribute(att, value = nil)
+      unless respond_to?(att.to_s + '=')
+        define_accessor_for_attribute(att)           
+      end
+
+      send(att.to_s + '=', value)
+    end
+
+    def get_metafied_attribute(att)
+      unless respond_to?(att.to_s)
+        define_accessor_for_attribute(att)
+      end
+
+      send(att.to_s)
+    end
+
+    # overrides update_attributes to take meta attributes into account
+    def update_attributes(attributes)
+      attributes.each do |n,v|
+        if has_metafied_attribute?(n.to_sym)
+          set_metafied_attribute( n.to_sym, v )
+          write_metafied_attribute( n.to_sym )
+        end
+      end
+
+      attributes.nil? ? super(nil) : super(attributes.except(*self.metafied_attrs))
+    end
+  end
+end

data/lib/metafy/engine.rb

@@ -0,0 +1,9 @@
+require 'rails'
+require 'active_record/base'
+require 'metafy'
+
+module Metafy
+  class Engine < Rails::Engine
+    config.autoload_paths += %W(#{config.root})
+  end
+end

data/metafy.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "metafy"
+  s.version     = "1.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["supercleanse","btoone"]
+  s.email       = ["support@caseproof.com"]
+  s.homepage    = "http://blairwilliams.com/rails/metafy"
+  s.summary     = %q{Dynamic Attributes Engine for Rails 3}
+  s.description = %q{Metafy is a Gem for Rails 3 that makes it possible to easily add dynamic attributes to any ActiveRecord model. These lightweight, meta attributes work just like normal database column attributes on your ActiveRecord model and are fully searchable (i.e. you can find records by values contained in these dynamic attributes).}
+
+  s.add_dependency('rails','>= 3.0.3')
+  s.license = 'MIT'
+
+  s.rubyforge_project = "metafy"
+
+  s.files         = `git ls-files`.split("\n")
+  #s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  #s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  #s.require_paths = ["app","config","lib"]
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/test/unit/mattr_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class MattrTest < ActiveSupport::TestCase
+  test "test meta attributes" do
+    assert true
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: metafy
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.1
+platform: ruby
+authors: 
+- supercleanse
+- btoone
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-10 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.3
+  type: :runtime
+  version_requirements: *id001
+description: Metafy is a Gem for Rails 3 that makes it possible to easily add dynamic attributes to any ActiveRecord model. These lightweight, meta attributes work just like normal database column attributes on your ActiveRecord model and are fully searchable (i.e. you can find records by values contained in these dynamic attributes).
+email: 
+- support@caseproof.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- app/models/mattr.rb
+- lib/generators/metafy_generator.rb
+- lib/generators/templates/create_mattrs.rb
+- lib/metafy.rb
+- lib/metafy/activerecord_methods.rb
+- lib/metafy/base.rb
+- lib/metafy/engine.rb
+- metafy.gemspec
+- test/test_helper.rb
+- test/unit/mattr_test.rb
+homepage: http://blairwilliams.com/rails/metafy
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: metafy
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Dynamic Attributes Engine for Rails 3
+test_files: []
+