data-attributes 0.2

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 data-attributes.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,73 @@
+= Data Attributes
+
+== Description
+
+A gem for easy access to attributes stored in a serialized data hash.
+
+== Summary
+
+ActiveRecord attributes are mapped to columns in your database; however, many attributes that needed to be persisted for an object don't need their own column because they will never be searched or filtered on.  One solution is to save these with a serialized hash into a text field in the database and provide similar access to the values as other attribute accessors.
+
+== Usage
+
+Consider a +User+ class that has a text field that is serialized, +:data+.
+
+    class User < ActiveRecord::Base
+
+      serialize :data
+
+    end
+
+We can set an accessor to an attribute to be saved in the +:data+ field with the following:
+
+    data_attributes :details
+
+This generates a read and write accessor called +details+.
+
+    u = User.new
+    u.details = "I don't need to query on this."
+    puts u.details
+    => I don't need to query on this.
+    puts u.data.inspect
+    => { "details" => "I don't need to query on this." }
+
+The default serialized attribute used is +data+. There are two ways to change the serialized attribute used for storage. The first is set a different default attribute for the class.
+
+    data_attribute_column :more_data
+
+This makes all of the accessors created with +data_attributes+ be saved in +more_data+ instead of +data+.  If a class has two (or more) serialized attributes that will share the storage responsibilities, each attribute defined with +data_attributes+ can be individually assigned to a serialized attribute by using a hash.
+
+    data_attribute :details, { :serialized_column => :more_data }
+
+This creates an accessor that saves +details+ to +more_data+.
+
+You can set a default to be returned, in the case the value hasn't be set yet.
+
+    data_attribute :details, { :default => "default value" }
+
+== Under The Hood
+
+Like column accessors that make use of +read_attribute+ and +write_attribute+, +data-attributes+ uses +read_data_attribute+ and +write_data_attribute+ to access the serialized attribute. This allows the ability to overwrite an accessor so any validation or other data manipulation needed before the value is returned or saved.
+
+== License
+
+Copyright (c) 2011 Les Fletcher
+
+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/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc "Run all tests"
+task :test do
+	sh "ruby test/data_attributes_test.rb"
+end

data/data-attributes.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "data-attributes/version"
+
+Gem::Specification.new do |s|
+  s.name        = "data-attributes"
+  s.version     = DataAttributes::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Les Fletcher"]
+  s.email       = ["les.fletcher@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A gem for easy access to attributes stored in a serialized data hash}
+  s.description = %q{A gem for easy access to attributes stored in a serialized data hash}
+
+  s.rubyforge_project = "data-attributes"
+
+  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 = ["lib"]
+
+  s.add_development_dependency('test-unit', '~> 2.2.0')
+  s.add_development_dependency('sqlite3', '~> 1.3.0')
+  s.add_dependency('activerecord', '~> 3.0.0')
+end

data/lib/data-attributes.rb

@@ -0,0 +1,2 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ), 'data-attributes', 'data_attributes' ) )
+require File.expand_path( File.join( File.dirname( __FILE__ ), 'data-attributes', 'errors' ) )

data/lib/data-attributes/data_attributes.rb

@@ -0,0 +1,80 @@
+module DataAttributes
+  module DataAttributes
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      DEFAULT_DATA_COLUMN = :data
+
+      # set the default serialized attribute to use to store all the values
+      # default is :data
+      # raises +NonSerializedColumnError+ if value isn't serlialized
+      def data_attribute_column(value)
+        raise(NonSerializedColumnError) unless serialized_attributes[value.to_s]
+        write_inheritable_attribute(:attr_data_attribute_column, value.to_sym)
+      end
+
+      # set up an attribute accessor for values stored in the serialized hash
+      # takes an attribute name and a hash sets up a read and write accessor for it
+      # options:
+      #   :serialized_column => the column used to store the attribute info
+      #   :default => what to return if the attribute is not set
+      # raises +NonSerializedColumnError+ if the column specified isn't serlialized
+      def data_attribute(name, arg_opts={})
+        opts = {
+          :serialized_column => attr_data_attribute_column,
+          :default => nil
+        }
+
+        opts.merge!(arg_opts)
+
+        # make sure the serialized_column is actually serialized 
+        raise(NonSerializedColumnError) unless serialized_attributes[opts[:serialized_column].to_s]
+
+        attr_data_attributes[name.to_sym] = opts
+
+        attr_name = name.to_s
+        class_eval("def #{attr_name}; read_data_attribute('#{attr_name}'); end")
+        class_eval("def #{attr_name}= (value); write_data_attribute('#{attr_name}', value); end")
+      end
+
+      def attr_data_attributes
+        read_inheritable_attribute(:attr_data_attributes) or write_inheritable_attribute(:attr_data_attributes, {})
+      end
+
+      def attr_data_attribute_column
+        read_inheritable_attribute(:attr_data_attribute_column) or write_inheritable_attribute(:attr_data_attribute_column, DEFAULT_DATA_COLUMN)
+      end
+
+      def data_attribute_options(name)
+        attr_data_attributes.has_key?(name.to_sym) ? attr_data_attributes[name.to_sym] : raise(NonDataAttributeError)
+      end
+
+      def data_attribute_serialized_column(name)
+        data_attribute_options(name)[:serialized_column]
+      end
+
+      def data_attribute_default(name)
+        data_attribute_options(name)[:default]
+      end
+    end
+
+    def read_data_attribute(name)
+      (self.send(data_attribute_serialized_column(name)) || {}).has_key?(name) ? self.send(data_attribute_serialized_column(name))[name] : self.data_attribute_default(name)
+    end
+
+    def write_data_attribute(name, value)
+      if self.send(data_attribute_serialized_column(name)).nil?
+        self.send("#{data_attribute_serialized_column(name)}=", { name => value })
+      else
+        self.send("#{data_attribute_serialized_column(name)}=", self.send(data_attribute_serialized_column(name)).merge({ name => value }))
+      end
+    end
+
+    def data_attribute_serialized_column(name); self.class.data_attribute_serialized_column(name) end
+    def data_attribute_default(name); self.class.data_attribute_default(name) end
+  end
+end
+
+ActiveRecord::Base.send(:include, DataAttributes::DataAttributes)

data/lib/data-attributes/errors.rb

@@ -0,0 +1,10 @@
+module DataAttributes
+  class DataAttributeError < StandardError
+  end
+
+  class NonSerializedColumnError < DataAttributeError
+  end
+
+  class NonDataAttributeError < DataAttributeError
+  end
+end

data/lib/data-attributes/version.rb

@@ -0,0 +1,3 @@
+module DataAttributes
+  VERSION = "0.2"
+end

data/test/data_attributes_test.rb

@@ -0,0 +1,132 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ), 'test_helper' ) )
+
+class TestDataAttributes < Test::Unit::TestCase
+
+  def test_setup
+    assert_equal Basic.attr_data_attribute_column, :data
+    assert_equal Basic.attr_data_attributes, { :stuff => { :serialized_column => :data, :default => nil } }
+    assert_equal TwoAttribute.attr_data_attribute_column, :data
+    assert_equal TwoAttribute.attr_data_attributes, {
+      :stuff  => { :serialized_column => :data, :default => nil },
+      :things => { :serialized_column => :data, :default => nil }
+    }
+    assert_equal DifferentSerializedAttribute.attr_data_attribute_column, :more_data
+    assert_equal DifferentSerializedAttribute.attr_data_attributes, { :stuff => { :serialized_column => :more_data, :default => nil } }
+    assert_equal TwoSerializedAttribute.attr_data_attribute_column, :more_data
+    assert_equal TwoSerializedAttribute.attr_data_attributes, {
+      :stuff => { :serialized_column => :data, :default => 1 },
+      :things => { :serialized_column => :more_data, :default => "two" }
+    }
+  end
+
+  def test_basic
+    b = Basic.new
+    assert_equal b.data, nil
+    assert_equal b.stuff, nil
+
+    b.stuff = "blah"
+    assert_equal b.stuff, "blah"
+    assert_equal b.data, { "stuff" => "blah" }
+  end
+
+  def test_primitives_methods
+    b = Basic.new
+    assert_equal b.data, nil
+    assert_equal b.read_data_attribute("stuff"), nil
+
+    b.write_data_attribute("stuff", "blah")
+    assert_equal b.data, { "stuff" => "blah" }
+    assert_equal b.read_data_attribute("stuff"), "blah"
+  end
+
+  def test_two_attributes
+    b = TwoAttribute.new
+    assert_equal b.data, nil
+    assert_equal b.stuff, nil
+
+    b.stuff = "blah"
+    assert_equal b.stuff, "blah"
+    assert_equal b.data, { "stuff" => "blah" }
+
+    b.things = "boom"
+    assert_equal b.stuff, "blah"
+    assert_equal b.things, "boom"
+    assert_equal b.data, { "stuff" => "blah", "things" => "boom" }
+  end
+
+  def test_primitives_methods_two
+    b = TwoAttribute.new
+    assert_equal b.data, nil
+    assert_equal b.read_data_attribute("stuff"), nil
+
+    b.write_data_attribute("stuff", "blah")
+    assert_equal b.read_data_attribute("stuff"), "blah"
+    assert_equal b.data, { "stuff" => "blah" }
+
+    b.write_data_attribute("things", "boom")
+    assert_equal b.read_data_attribute("stuff"), "blah"
+    assert_equal b.read_data_attribute("things"), "boom"
+    assert_equal b.data, { "stuff" => "blah", "things" => "boom" }
+  end
+
+  def test_two_serialized
+    t = TwoSerializedAttribute.new
+    assert_equal t.data, nil
+    assert_equal t.more_data, nil
+    assert_equal t.stuff, 1
+    assert_equal t.things, "two"
+
+    t.stuff = "stuff val"
+    t.things = "things val"
+
+    assert_equal t.stuff, "stuff val"
+    assert_equal t.things, "things val"
+    assert_equal t.more_data, { "things" => "things val" }
+    assert_equal t.data, { "stuff" => "stuff val" }
+  end
+
+  def test_saving
+    b = Basic.create
+    id = b.id
+    assert_equal b.data, nil
+    assert_equal b.stuff, nil
+
+    b.stuff = "blah"
+    assert_equal b.stuff, "blah"
+    assert_equal b.data, { "stuff" => "blah" }
+
+    b.save
+
+    b = Basic.find(id)
+    assert_equal b.stuff, "blah"
+    assert_equal b.data, { "stuff" => "blah" }
+  end
+
+  def test_non_serialized_error
+    klass = Class.new(ActiveRecord::Base)
+    ActiveRecord::Base.const_set("NonSerializedAttribute", klass)
+
+    assert_raise(DataAttributes::NonSerializedColumnError) do
+      klass.class_eval do
+        data_attribute :stuff
+      end
+    end
+  end
+
+  def test_default_non_serialized_error
+    klass = Class.new(ActiveRecord::Base)
+    ActiveRecord::Base.const_set("DefaultNonSerializedAttribute", klass)
+
+    assert_raise(DataAttributes::NonSerializedColumnError) do
+      klass.class_eval do
+        data_attribute_column :more_data
+      end
+    end
+  end
+
+  def test_data_attribute_options
+    assert_raise(DataAttributes::NonDataAttributeError) do
+      Basic.data_attribute_options(:things)
+    end
+  end
+end

data/test/models.rb

@@ -0,0 +1,26 @@
+class Basic < ActiveRecord::Base
+  serialize :data
+  data_attribute :stuff
+end
+
+class TwoAttribute < ActiveRecord::Base
+  serialize :data
+  data_attribute :stuff
+  data_attribute :things
+end
+
+class DifferentSerializedAttribute < ActiveRecord::Base
+  serialize :more_data
+
+  data_attribute_column :more_data
+  data_attribute :stuff
+end
+
+class TwoSerializedAttribute < ActiveRecord::Base
+  serialize :data
+  serialize :more_data
+
+  data_attribute_column :more_data
+  data_attribute :stuff, { :serialized_column => :data, :default => 1 }
+  data_attribute :things, { :default => "two" }
+end

data/test/schema.rb

@@ -0,0 +1,30 @@
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+  
+  ActiveRecord::Schema.define do
+    create_table "basics" do |t|
+      t.text :data
+    end
+
+    create_table "two_attributes" do |t|
+      t.text :data
+    end
+
+    create_table "different_serialized_attribute" do |t|
+      t.text :more_data
+    end
+
+    create_table "two_serialized_attributes" do |t|
+      t.text :data
+      t.text :more_data
+    end
+
+    create_table "non_serialized_attributes" do |t|
+      t.text :data
+    end
+
+    create_table "default_non_serialized_attributes" do |t|
+      t.text :more_data
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+require 'active_record'
+
+require File.expand_path( File.join( File.dirname( __FILE__ ), '..', 'lib', 'data-attributes' ) )
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+require File.expand_path( File.join( File.dirname( __FILE__ ), 'schema' ) )
+require File.expand_path( File.join( File.dirname( __FILE__ ), 'models' ) )

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: data-attributes
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: "0.2"
+platform: ruby
+authors: 
+- Les Fletcher
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-10 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.2.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id003
+description: A gem for easy access to attributes stored in a serialized data hash
+email: 
+- les.fletcher@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- data-attributes.gemspec
+- lib/data-attributes.rb
+- lib/data-attributes/data_attributes.rb
+- lib/data-attributes/errors.rb
+- lib/data-attributes/version.rb
+- test/data_attributes_test.rb
+- test/models.rb
+- test/schema.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+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: data-attributes
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: A gem for easy access to attributes stored in a serialized data hash
+test_files: 
+- test/data_attributes_test.rb
+- test/models.rb
+- test/schema.rb
+- test/test_helper.rb