magic_meta_methods 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Nick Zalabak
+
+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,64 @@
+= magic_meta_methods
+  
+== Instructions
+
+A plugin to generate many methods or "attributes" on ActiveRecord that
+persists data into a serialized text based column as defined by :column. This
+plugin is particularly useful for storing display data or meta data that isn't intended to be queried
+directly via SQL. It reduces the number of "one-off" columns and the clutter of serialized declarations
+with getter/setters on your model.
+
+== Installation
+
+  ruby script/plugin install git://github.com/techwhizbang/magic_meta_methods.git
+
+== Usage
+
+=== Prepare database
+
+Add this migration to the desired table(s):
+
+  class MagicMetaMethods < ActiveRecord::Migration
+    def self.up
+      add_column :your_table_here, :magic_meta_methods, :mediumtext
+    end
+
+    def self.down
+      remove_column :your_table_here, :magic_meta_methods
+    end
+  end
+
+  rake db:migrate
+
+=== Meta Magic Methods in action
+
+Let's suppose your model needs to store a variety of data and types, but
+these values don't need to be queried on, many times these values are purely
+for display or front end purposes.
+
+  class YourModel < ActiveRecord::Base
+    magic_meta_methods([:abstract,
+                       [:some_hash, :hash],
+                       [:some_array, :array],
+                       [:some_indifferent_hash, :indifferent_hash]], :column => 'alternate_meta')
+  end
+  
+We can now use the magic meta methods just like a regular attribute setter
+
+  m = YourModel.new
+  m.abstract= "This is a brief synopsis of magic meta methods"
+  m.some_hash = {:a => 1, :b => 2, :c => 3}
+  m.some_array = [["Monday", "9-5"], ["Tuesday", "9-5"], ["Wed", "Closed"]]
+  m.some_indifferent_hash = {:dog => "Fido", :cat => "Garfield"}
+  m.save
+  
+You can retrieve the values
+
+  m.some_indifferent_hash['dog'] #Fido
+  m.abstract #This is a brief synopsis of magic meta methods
+  m.some_array[0] #["Monday", "9-5"]
+
+=== Other
+
+Problems, comments, and suggestions all welcome. techwhizbang [at] gmail dot com or visit my blog
+http://techwhizbang.com

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rake'
+require 'rake/testtask'
+ 
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "magic_meta_methods"
+    s.summary = "A gem that polishes ActiveRecord data serialization to make it really awesome"
+    s.description = "magic_meta_methods uses ActiveRecord data serialization and allows for several objects by key to be stored in _one_ column while still providing the same attr_accessor behavior as if there were a column for _each_ serialized object - hence the magic 'meta' methods"
+    s.email = "techwhizbang@gmail.com"
+    s.homepage = "http://github.com/techwhizbang/magic_meta_methods"
+    s.rubyforge_project = 'magic_meta_methods'
+    s.authors = ["Nick Zalabak"]
+    s.files =  FileList["[A-Za-z]*", "{lib,test}/**/*"]
+    s.test_files = FileList["test/**/*"]
+    s.add_dependency "activerecord", ">= 2.3.2"
+  end
+ 
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+ 
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+ 
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/init.rb

@@ -0,0 +1,2 @@
+require 'activerecord'
+require 'magic_meta_methods'

data/lib/magic_meta_methods.rb

@@ -0,0 +1,85 @@
+module ActiveRecord
+
+  module MagicMetaMethods
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      class << base
+        attr_accessor :meta_methods_column
+        attr_accessor :meta_methods_declarations
+      end
+      base.send(:before_create, :init_meta_methods)
+    end
+
+    module ClassMethods
+      def magic_meta_methods(methods=[], options={})
+    
+        column_name = options[:column].blank? ? :magic_meta_methods : options[:column].to_sym
+        self.meta_methods_column = column_name
+        self.meta_methods_declarations = methods
+        self.meta_methods_declarations.each do |attribute|
+          if attribute.is_a?(Array)
+            name = attribute[0]
+            type = attribute[1]
+          else
+            #default to string since its the most common usage
+            name = attribute
+            type = :string
+          end
+
+          serialize column_name
+          define_method(name.to_sym) { self.get_meta_value(name, type)}
+          define_method((name.to_s + '=').to_sym) {|val| self.set_meta_value(name, val, type)}
+        end
+      end
+    end
+    
+    def init_meta_methods
+      self[self.class.meta_methods_column] = {} unless self[self.class.meta_methods_column].kind_of?(Hash)
+    end
+
+    def set_meta_value(method_name, val, type)
+      init_meta_methods #should never happen, but a failsafe
+      self[self.class.meta_methods_column][method_name] = convert_to_type(val, type)
+    end
+
+    def get_meta_value(method_name, type)
+      return nil unless self[self.class.meta_methods_column].kind_of?(Hash)
+      convert_to_type(self[self.class.meta_methods_column][method_name], type)
+    end
+
+    def convert_to_type (val, type)
+      return nil if val.nil? or (val.is_a?(String) and val.blank?)
+      converted_value = nil
+      case type
+      when :string
+        converted_value = val.to_s
+      when :integer
+        converted_value = val.to_i
+      when :float
+        converted_value = val.to_f
+      when :date
+        converted_value = val.is_a?(Date) ? val : Date.parse(val.to_s, true)
+      when :time
+        converted_value = val.is_a?(Time) ? val : Time.parse(val.to_s, true)
+      when :datetime
+        converted_value = val.is_a?(DateTime) ? val : DateTime.parse(val.to_s)
+      when :indifferent_hash
+        converted_value = val.is_a?(HashWithIndifferentAccess) ? val : (raise InvalidMetaTypeError.new("Invalid HashWithIndifferentAccess #{val}"))
+      when :hash
+        converted_value = val.is_a?(Hash) ? val : (raise InvalidMetaTypeError.new("Invalid Hash #{val}"))
+      when :array
+        converted_value = val.is_a?(Array) ? val : [val]
+      when val.is_a?(type)
+        converted_value = val
+      else
+        raise InvalidMetaTypeError.new("Invalid type #{type.name}")
+      end
+      converted_value
+    end
+  end
+end
+
+class InvalidMetaTypeError < ArgumentError; end
+
+ActiveRecord::Base.send(:include, ActiveRecord::MagicMetaMethods)

data/magic_meta_methods.gemspec

@@ -0,0 +1,51 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{magic_meta_methods}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Nick Zalabak"]
+  s.date = %q{2010-03-09}
+  s.description = %q{magic_meta_methods uses ActiveRecord data serialization and allows for several objects by key to be stored in _one_ column while still providing the same attr_accessor behavior as if there were a column for _each_ serialized object - hence the magic 'meta' methods}
+  s.email = %q{techwhizbang@gmail.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "MIT-LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/magic_meta_methods.rb",
+     "magic_meta_methods.gemspec",
+     "test/magic_meta_methods_test.rb"
+  ]
+  s.homepage = %q{http://github.com/techwhizbang/magic_meta_methods}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{magic_meta_methods}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A gem that polishes ActiveRecord data serialization to make it really awesome}
+  s.test_files = [
+    "test/magic_meta_methods_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.3.2"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 2.3.2"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 2.3.2"])
+  end
+end
+

data/test/magic_meta_methods_test.rb

@@ -0,0 +1,174 @@
+require 'test/unit'
+
+require 'rubygems'
+gem 'activerecord'
+require 'active_record'
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/magic_meta_methods")
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :base_meta_models do |t|
+      t.column :magic_meta_methods, :text
+      t.column :type, :string
+      t.column :alternate_meta, :text
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class BaseMetaModel < ActiveRecord::Base
+  magic_meta_methods([
+    :a_string,
+    [:a_hash, :hash],
+    [:hours, :array],
+    [:cats, :indifferent_hash]]
+  )
+end
+
+class MetaModel < BaseMetaModel
+  magic_meta_methods([
+    :a_string,
+    [:a_hash, :hash],
+    [:hours, :array],
+    [:cats, :indifferent_hash]]
+  )
+end
+
+class MetaModelChild < MetaModel
+  magic_meta_methods(
+  [:a_string]
+  )
+end
+
+class EmptyMetaModel < MetaModel
+  magic_meta_methods
+end
+
+class AlternateColumnMetaModel < BaseMetaModel
+  magic_meta_methods([:a_string,
+                     [:a_hash, :hash],
+                     [:hours, :array],
+                     [:cats, :indifferent_hash]], :column => 'alternate_meta')
+end
+
+class MagicMetaMethodsTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    (1..4).each do  |counter|
+      m = MetaModel.create!
+      m.a_string = "yes"
+      m.a_hash = {:a => 1}
+      m.hours = ["1", "2", "3"]
+      m.cats = HashWithIndifferentAccess.new(:cat => "cat", :cat2 => "cat2", "cat3" => "cat3")
+      m.save!
+    end
+    MetaModelChild.create!
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_alternate_column_name
+    assert_equal AlternateColumnMetaModel.meta_methods_column, :alternate_meta
+  end
+
+  def test_meta_method_persistance
+    assert_equal "yes", MetaModel.first.a_string
+  end
+
+  def test_alternate_column_create_with_meta_data
+    a = AlternateColumnMetaModel.create!(:a_string => 'hello', :a_hash => {:a => 1, :b => 2})
+    a = AlternateColumnMetaModel.first
+    assert_equal('hello', a.a_string)
+    assert_equal({:a => 1, :b => 2}, a.a_hash)
+    assert_not_nil(a.alternate_meta)
+  end
+
+  def test_meta_method_hashes
+    assert_equal({:a => 1}, MetaModel.first.a_hash)
+  end
+
+  def test_meta_method_indifferent_hashes
+    assert_equal({"cat"=>"cat", "cat2"=>"cat2", "cat3"=>"cat3"}, MetaModel.first.cats)
+  end
+
+
+  def test_update_meta_method_value
+    m = MetaModel.first
+    m.a_string = "changed"
+    m.save!
+    assert_equal "changed", MetaModel.first.a_string
+  end
+
+  def test_empty_meta_method_should_return_nil
+    assert_equal nil, MetaModelChild.first.a_string
+  end
+
+  def test_blank_declaration_of_meta_methods_class
+    assert_nothing_raised do
+      EmptyMetaModel.create!
+    end
+  end
+
+  def test_init_meta_methods_should_return_hash_if_nil
+    assert_equal({}, MetaModel.new.send(:init_meta_methods))
+  end
+
+  def test_should_convert_string_type
+    assert_equal("String", MetaModel.new.send(:convert_to_type, "String", :string))
+  end
+
+  def test_should_convert_hash_type
+    assert_equal({:a => 1, :b => 2}, MetaModel.new.send(:convert_to_type, {:a => 1, :b => 2}, :hash))
+  end
+
+  def test_should_convert_date_type
+    d = Date.parse("12/5/1982")
+    assert_equal(d, MetaModel.new.send(:convert_to_type, d, :date))
+  end
+
+  def test_should_raise_an_error_if_an_invalid_hash
+    d = Date.parse("2/5/1998")
+    assert_raise(InvalidMetaTypeError) do
+      MetaModel.new.send(:convert_to_type, d, :hash)
+    end
+  end
+
+  def test_should_convert_time_type
+    t = Time.now
+    assert_equal(t, MetaModel.new.send(:convert_to_type, t, :time))
+  end
+
+  def test_should_convert_datetime_type
+    t = DateTime.now
+    assert_equal(t, MetaModel.new.send(:convert_to_type, t, :datetime))
+  end
+
+  def test_should_convert_array_type
+    a = [1, 2, "3"]
+    assert_equal(a, MetaModel.new.send(:convert_to_type, a, :array))
+  end
+
+  def test_should_convert_integer_type
+    assert_equal(1, MetaModel.new.send(:convert_to_type, 1, :integer))
+  end
+
+  def test_should_convert_float_type
+    assert_equal(1.123456789, MetaModel.new.send(:convert_to_type, 1.123456789, :float) )
+  end
+
+  def test_should_convert_hash_with_indifferent_access
+    hida = HashWithIndifferentAccess.new(:a => 1, :b => 2)
+    assert_equal(hida, MetaModel.new.send(:convert_to_type, hida, :indifferent_hash))
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: magic_meta_methods
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Nick Zalabak
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-09 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.2
+    version: 
+description: magic_meta_methods uses ActiveRecord data serialization and allows for several objects by key to be stored in _one_ column while still providing the same attr_accessor behavior as if there were a column for _each_ serialized object - hence the magic 'meta' methods
+email: techwhizbang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION
+- init.rb
+- lib/magic_meta_methods.rb
+- magic_meta_methods.gemspec
+- test/magic_meta_methods_test.rb
+has_rdoc: true
+homepage: http://github.com/techwhizbang/magic_meta_methods
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: magic_meta_methods
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A gem that polishes ActiveRecord data serialization to make it really awesome
+test_files: 
+- test/magic_meta_methods_test.rb