serializable_attributes 0.9.0

data/lib/serializable_attributes/types.rb

@@ -0,0 +1,139 @@
+module SerializableAttributes
+  class AttributeType
+    def initialize(options = {})
+      @default = options[:default]
+    end
+
+    def encode(s) s end
+
+    def type_for(key)
+      SerializableAttributes.const_get(key.to_s.classify).new
+    end
+
+    def default
+      @default && @default.duplicable? ? @default.dup : @default
+    end
+  end
+
+  class Integer < AttributeType
+    attr_reader :default
+    def parse(input)  input.blank? ? nil : input.to_i end
+  end
+
+  class Float < AttributeType
+    attr_reader :default
+    def parse(input)  input.blank? ? nil : input.to_f end
+  end
+
+  class Boolean < AttributeType
+    attr_reader :default
+    def parse(input)
+      return nil if input == ""
+      input && input.respond_to?(:to_i) ? (input.to_i > 0) : input
+    end
+
+    def encode(input)
+      return nil if input.to_s.empty?
+      return 0 if input == 'false'
+      input ? 1 : 0
+    end
+  end
+
+  class String < AttributeType
+    # converts unicode (\u003c) to the actual character
+    # http://rishida.net/tools/conversion/
+    def parse(str)
+      return nil if str.nil?
+      str.to_s.gsub(/\\u([0-9a-fA-F]{4})/) do |s|
+        int = $1.to_i(16)
+        if int.zero? && s != "0000"
+          s
+        else
+          [int].pack("U")
+        end
+      end
+    end
+  end
+
+  class Time < AttributeType
+    def parse(input)
+      return nil if input.blank?
+      case input
+        when ::Time   then input
+        when ::String then ::Time.parse(input)
+        else input.to_time
+      end
+    end
+    def encode(input) input ? input.utc.xmlschema : nil end
+  end
+
+  class Array < AttributeType
+    def initialize(options = {})
+      super
+      @item_type = type_for(options[:type] || "String")
+    end
+
+    def parse(input)
+      if input.nil?
+        nil
+      elsif input.blank?
+        []
+      else
+        input.map! { |item| @item_type.parse(item) }
+      end
+    end
+
+    def encode(input)
+      if input.nil?
+        nil
+      elsif input.blank?
+        []
+      else
+        input.map! { |item| @item_type.encode(item) }
+      end
+    end
+  end
+
+  class Hash < AttributeType
+    def initialize(options = {})
+      super
+      @key_type = String.new
+      @types    = (options[:types] || {})
+      @types.keys.each do |key|
+        value = @types.delete(key)
+        @types[key.to_s] = type_for(value)
+      end
+    end
+
+    def parse(input)
+      return nil if input.blank?
+      input.keys.each do |key|
+        value = input.delete(key)
+        key_s = @key_type.parse(key)
+        type  = @types[key_s] || @key_type
+        input[key_s] = type.parse(value)
+      end
+      input
+    end
+
+    def encode(input)
+      return nil if input.blank?
+      input.each do |key, value|
+        type = @types[key] || @key_type
+        input[key] = type.encode(value)
+      end
+    end
+  end
+
+  class << self
+    attr_accessor :types
+    def add_type(type, object = nil)
+      types[type] = object
+      Schema.send(:define_method, type) do |*names|
+        field type, *names
+      end
+    end
+  end
+  self.types = {}
+end
+

data/lib/serializable_attributes.rb

@@ -0,0 +1,66 @@
+# create a BLOB column and setup your field types for conversion
+# and convenient attr methods
+#
+#   class Profile < ActiveRecord::Base
+#     # not needed if used as a rails plugin
+#     SerializableAttributes.setup(self)
+#
+#     # assumes #data serializes to raw_data blob field
+#     serialize_attributes do
+#       string  :title, :description
+#       integer :age
+#       float   :rank, :percentage
+#       time    :birthday
+#     end
+#
+#     # Serializes #data to assumed raw_data blob field
+#     serialize_attributes :data do
+#       string  :title, :description
+#       integer :age
+#       float   :rank, :percentage
+#       time    :birthday
+#     end
+#
+#     # set the blob field
+#     serialize_attributes :data, :blob => :serialized_field do
+#       string  :title, :description
+#       integer :age
+#       float   :rank, :percentage
+#       time    :birthday
+#     end
+#   end
+#
+module SerializableAttributes
+  VERSION = "0.9.0"
+  
+  require File.expand_path('../serializable_attributes/types', __FILE__)
+  require File.expand_path('../serializable_attributes/schema', __FILE__)
+
+  if nil.respond_to?(:duplicable?)
+    require File.expand_path('../serializable_attributes/duplicable', __FILE__)
+  end
+
+  module Format
+    autoload :ActiveSupportJson, File.expand_path('../serializable_attributes/format/active_support_json', __FILE__)
+  end
+
+  add_type :string,  String
+  add_type :integer, Integer
+  add_type :float,   Float
+  add_type :time,    Time
+  add_type :boolean, Boolean
+  add_type :array,   Array
+  add_type :hash,    Hash
+
+  module ModelMethods
+    def serialize_attributes(field = :data, options = {}, &block)
+      schema = Schema.new(self, field, options)
+      schema.instance_eval(&block)
+      schema.fields.freeze
+      schema
+    end
+  end
+end
+
+Object.const_set :SerializedAttributes, SerializableAttributes
+

data/rails_init.rb

@@ -0,0 +1,3 @@
+require File.expand_path('../lib/serializable_attributes', __FILE__)
+ActiveRecord::Base.extend SerializedAttributes::ModelMethods
+

data/script/setup

@@ -0,0 +1 @@
+bundle install --binstubs --path vendor/gems

data/serializable_attributes.gemspec

@@ -0,0 +1,67 @@
+## This is the rakegem gemspec template. Make sure you read and understand
+## all of the comments. Some sections require modification, and others can
+## be deleted if you don't need them. Once you understand the contents of
+## this file, feel free to delete any comments that begin with two hash marks.
+## You can find comprehensive Gem::Specification documentation, at
+## http://docs.rubygems.org/read/chapter/20
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.3.5") if s.respond_to? :required_rubygems_version=
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'serializable_attributes'
+  s.version           = '0.9.0'
+  s.date              = '2011-12-05'
+  s.rubyforge_project = 'serializable_attributes'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "Store a serialized hash of attributes in a single ActiveRecord column."
+  s.description = "A bridge between using AR and a full blown schema-free db."
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["Rick Olson"]
+  s.email    = 'technoweenie@gmail.com'
+  s.homepage = 'http://github.com/technoweenie/serialized_attributes'
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  s.add_dependency "activerecord", [">= 2.2.0", "< 3.2.0"]
+
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    LICENSE
+    README.md
+    Rakefile
+    gemfiles/ar-2.2.gemfile
+    gemfiles/ar-2.3.gemfile
+    gemfiles/ar-3.0.gemfile
+    gemfiles/ar-3.1.gemfile
+    init.rb
+    lib/serializable_attributes.rb
+    lib/serializable_attributes/duplicable.rb
+    lib/serializable_attributes/format/active_support_json.rb
+    lib/serializable_attributes/schema.rb
+    lib/serializable_attributes/types.rb
+    rails_init.rb
+    script/setup
+    serializable_attributes.gemspec
+    test/serialized_attributes_test.rb
+    test/test_helper.rb
+    test/types_test.rb
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ %r{^test/*/.+\.rb} }
+end

data/test/serialized_attributes_test.rb

@@ -0,0 +1,382 @@
+# -*- coding: utf-8 -*-
+require File.expand_path("../test_helper", __FILE__)
+
+formatters = [SerializedAttributes::Format::ActiveSupportJson]
+formatters.each do |fmt|
+  Object.const_set("SerializedAttributeWithSerializedDataTestWith#{fmt.name.demodulize}", Class.new(ActiveSupport::TestCase)).class_eval do
+    class << self
+      attr_accessor :format, :current_time, :raw_hash, :raw_data
+    end
+    self.format       = fmt
+    self.current_time = Time.now.utc.midnight
+    self.raw_hash     = {:title => 'abc', :age => 5, :average => 5.1, :birthday => current_time.xmlschema, :active => true, :names => %w(d e f), :lottery_picks => [1, 8, 7], :extras => {'b' => 'two'}}
+    self.raw_data     = format.encode(raw_hash)
+
+    def setup
+      SerializedRecordWithDefaults.data_schema.formatter = SerializedRecord.data_schema.formatter = self.class.format
+      @newbie  = SerializedRecordWithDefaults.new
+      @record  = SerializedRecord.new
+      @changed = SerializedRecord.new
+      @record.raw_data  = self.class.raw_data
+      @changed.raw_data = self.class.raw_data
+      @changed.title    = 'def'
+      @changed.age      = 6
+    end
+
+    test "schema lists attribute names" do
+      %w(title body age average birthday active default_in_my_favor names
+         lottery_picks extras).each do |attr|
+        assert SerializedRecord.data_schema.all_column_names.include?(attr),
+          "#{attr} attribute not found"
+        assert SerializedRecord.attribute_names.include?(attr),
+          "#{attr} attribute not found"
+      end
+      assert !SerializedRecord.data_schema.all_column_names.include?('raw_data'),
+        "raw_data attribute found"
+    end
+
+    test "existing model respects defaults from missing key" do
+      assert !@record.data.key?('default_in_my_favor')
+      assert @record.default_in_my_favor?
+      assert_equal true, @record.data['default_in_my_favor']
+      @record.default_in_my_favor = false
+      assert !@record.default_in_my_favor?
+      @record.default_in_my_favor = nil
+      assert @record.default_in_my_favor?
+    end
+
+    test "new model respects array defaults" do
+      assert_equal %w(a b c), @newbie.names
+    end
+
+    test "new model respects hash defaults" do
+      assert_equal({:a => 1}, @newbie.extras)
+    end
+
+    test "new model respects integer defaults" do
+      assert_equal 18, @newbie.age
+    end
+
+    test "new model respects string defaults" do
+      assert_equal 'blank', @newbie.title
+      assert_equal 'blank', @newbie.body
+    end
+
+    test "new model respects float defaults" do
+      assert_equal 5.2, @newbie.average
+    end
+
+    test "new model respects boolean defaults" do
+      assert  @newbie.active?
+    end
+
+    test "new model respects date defaults" do
+      assert_equal Time.utc(2009, 1, 1), @newbie.birthday
+    end
+
+    test "reloads serialized data" do
+      @changed.id = 481516
+      assert_equal @record.title, @changed.reload(2342).title
+      assert_equal @record.age,   @changed.age
+    end
+
+    test "initialized model is not changed" do
+      @record.data
+      assert !@record.data_changed?
+    end
+
+    test "#attribute_names contains serialized fields" do
+      assert_equal %w(active age average birthday extras lottery_picks names title), @record.attribute_names
+      @record.body = 'a'
+      assert_equal %w(active age average birthday body extras lottery_picks names title), @record.attribute_names
+    end
+
+    test "initialization does not call writers" do
+      def @record.title=(v)
+        raise ArgumentError
+      end
+      assert_not_nil @record.data
+    end
+
+    test "ignores data with extra keys" do
+      @record.raw_data = self.class.format.encode(self.class.raw_hash.merge(:foo => :bar))
+      assert_not_nil @record.title     # no undefined foo= error
+      assert_equal false, @record.save # extra before_save cancels the operation
+      assert_equal self.class.raw_hash.merge(:active => 1).stringify_keys.keys.sort, self.class.format.decode(@record.raw_data).keys.sort
+    end
+
+    test "reads strings" do
+      assert_equal self.class.raw_hash[:title], @record.title
+    end
+
+    test "parses strings with unicode characters" do
+      @record.title = "Encöded ɐ \\u003c \\Upload \\upload" # test unicode char, \u**** code, and legit \U... string
+      assert_equal "Encöded ɐ < \\Upload \\upload", @record.title
+    end
+
+    test "clears strings with nil" do
+      assert @record.data.key?('title')
+      @record.title = nil
+      assert !@record.data.key?('title')
+    end
+
+    test "reads arrays" do
+      assert_equal self.class.raw_hash[:names], @record.names
+    end
+
+    test "reads arrays with custom type" do
+      assert_equal self.class.raw_hash[:lottery_picks], @record.lottery_picks
+    end
+
+    test "clears arrays with nil" do
+      assert @record.data.key?('names')
+      @record.names = nil
+      assert !@record.data.key?('names')
+    end
+
+    test "reads hashes" do
+      assert_equal self.class.raw_hash[:extras].stringify_keys, @record.extras
+    end
+
+    test "reads hashes with custom types" do
+      now = Time.utc(Time.now.year, 1, 1)
+      @record.raw_data = self.class.format.encode('extras' => {:num => "7", :foo => :bar, :started_at => now})
+      assert_equal({'num' => 7, 'started_at' => now, 'foo' => 'bar'}, @record.extras)
+    end
+
+    test "clears hashes with nil" do
+      assert @record.data.key?('extras')
+      @record.extras = nil
+      assert !@record.data.key?('extras')
+    end
+
+    test "reads integers" do
+      assert_equal self.class.raw_hash[:age], @record.age
+    end
+
+    test "parses integers from strings" do
+      @record.age = '5.5'
+      assert_equal 5, @record.age
+    end
+
+    test "clears integers with nil" do
+      assert @record.data.key?('age')
+      @record.age = nil
+      assert !@record.data.key?('age')
+    end
+
+    test "clears integers with blank" do
+      assert @record.data.key?('age')
+      @record.age = ''
+      assert !@record.data.key?('age')
+    end
+
+    test "reads floats" do
+      assert_equal self.class.raw_hash[:average], @record.average
+    end
+
+    test "parses floats from strings" do
+      @record.average = '5.5'
+      assert_equal 5.5, @record.average
+    end
+
+    test "clears floats with nil" do
+      assert @record.data.key?('average')
+      @record.average = nil
+      assert !@record.data.key?('average')
+    end
+
+    test "clears floats with blank" do
+      assert @record.data.key?('average')
+      @record.average = ''
+      assert !@record.data.key?('average')
+    end
+
+    test "reads times" do
+      assert_equal self.class.current_time, @record.birthday
+    end
+
+    test "parses times from strings" do
+      t = 5.years.ago.utc.midnight
+      @record.birthday = t.xmlschema
+      assert_equal t, @record.birthday
+    end
+
+    test "clears times with nil" do
+      assert @record.data.key?('birthday')
+      @record.birthday = nil
+      assert !@record.data.key?('birthday')
+    end
+
+    test "clears times with blank" do
+      assert @record.data.key?('birthday')
+      @record.birthday = ''
+      assert !@record.data.key?('birthday')
+    end
+
+    test "reads booleans" do
+      assert_equal true, @record.active
+    end
+
+    test "parses booleans from strings" do
+      @record.active = '1'
+      assert_equal true, @record.active
+      @record.active = '0'
+      assert_equal false, @record.active
+    end
+
+    test "parses booleans from integers" do
+      @record.active = 1
+      assert_equal true, @record.active
+      @record.active = 0
+      assert_equal false, @record.active
+    end
+
+    test "converts booleans to false with nil" do
+      assert @record.data.key?('active')
+      @record.active = nil
+      assert !@record.data.key?('active')
+    end
+
+    test "ignores empty strings for booleans" do
+      @newbie.clearance = ""
+      assert_nil @newbie.clearance
+    end
+
+     test "attempts to re-encode data when saving" do
+       assert_not_nil @record.title
+       @record.raw_data = nil
+       assert_equal false, @record.save # extra before_save cancels the operation
+       expected = self.class.raw_hash.merge \
+         :active   => true,
+         :birthday => Time.parse(self.class.raw_hash[:birthday])
+       assert_equal expected.stringify_keys, @record.class.data_schema.decode(@record.raw_data)
+     end
+
+    test "knows untouched record is not changed" do
+      assert !@record.data_changed?
+      assert_equal [], @record.data_changed
+    end
+
+    test "knows updated record is changed" do
+      assert @changed.data_changed?
+      assert_equal %w(age title), @changed.data_changed.sort
+    end
+
+    test "tracks if field has changed" do
+      assert !@record.title_changed?
+      assert  @changed.title_changed?
+    end
+
+    test "tracks field changes" do
+      assert_nil @record.title_change
+      assert_equal %w(abc def), @changed.title_change
+    end
+  end
+
+  Object.const_set("SerializedAttributeTest#{fmt.name.demodulize}", Class.new(ActiveSupport::TestCase)).class_eval do
+    class << self
+      attr_accessor :format
+    end
+    self.format = fmt
+
+    def setup
+      SerializedRecord.data_schema.formatter = self.class.format
+      @record = SerializedRecord.new
+    end
+
+    test "encodes and decodes data successfully" do
+      hash = {'a' => 1, 'b' => 2}
+      encoded = self.class.format.encode(hash)
+      assert_equal self.class.format.decode(encoded), hash
+    end
+
+    test "defines #data method on the model" do
+      assert @record.respond_to?(:data)
+      assert_equal @record.data, {'default_in_my_favor' => true}
+    end
+
+    attributes = {:string => [:title, :body], :integer => [:age], :float => [:average], :time => [:birthday], :boolean => [:active], :array => [:names, :lottery_picks], :hash => [:extras]}
+    attributes.values.flatten.each do |attr|
+      test "defines ##{attr} method on the model" do
+        assert @record.respond_to?(attr)
+        assert_nil @record.send(attr)
+      end
+
+      next if attr == :active
+      test "defines ##{attr}_before_type_cast method on the model" do
+        assert @record.respond_to?("#{attr}_before_type_cast")
+        assert_equal "", @record.send("#{attr}_before_type_cast")
+      end
+    end
+
+    test "defines #active_before_type_cast method on the model" do
+      assert @record.respond_to?(:active_before_type_cast)
+      assert_equal "", @record.active_before_type_cast
+    end
+
+    attributes[:string].each do |attr|
+      test "defines ##{attr}= method for string fields" do
+        assert @record.respond_to?("#{attr}=")
+        assert_equal 'abc', @record.send("#{attr}=", "abc")
+        assert_equal 'abc', @record.data[attr.to_s]
+      end
+
+      test "does not define ##{attr}? method for string fields" do
+        assert !@record.respond_to?("#{attr}?")
+      end
+    end
+
+    attributes[:integer].each do |attr|
+      test "defines ##{attr}= method for integer fields" do
+        assert @record.respond_to?("#{attr}=")
+        assert_equal 0, @record.send("#{attr}=", "abc")
+        assert_equal 1, @record.send("#{attr}=", "1.2")
+        assert_equal 1, @record.data[attr.to_s]
+      end
+
+      test "does not define ##{attr}? method for integer fields" do
+        assert !@record.respond_to?("#{attr}?")
+      end
+    end
+
+    attributes[:float].each do |attr|
+      test "defines ##{attr}= method for float fields" do
+        assert @record.respond_to?("#{attr}=")
+        assert_equal 0.0, @record.send("#{attr}=", "abc")
+        assert_equal 1.2, @record.send("#{attr}=", "1.2")
+        assert_equal 1.2, @record.data[attr.to_s]
+      end
+
+      test "does not define ##{attr}? method for float fields" do
+        assert !@record.respond_to?("#{attr}?")
+      end
+    end
+
+    attributes[:time].each do |attr|
+      test "defines ##{attr}= method for time fields" do
+        assert @record.respond_to?("#{attr}=")
+        t = Time.now.utc.midnight
+        assert_equal t, @record.send("#{attr}=", t.xmlschema)
+        assert_equal t, @record.data[attr.to_s]
+      end
+
+      test "does not define ##{attr}? method for boolean fields" do
+        assert !@record.respond_to?("#{attr}?")
+      end
+    end
+
+    attributes[:boolean].each do |attr|
+      test "defines ##{attr}= method for boolean fields" do
+        assert @record.respond_to?("#{attr}=")
+        assert_equal false, @record.send("#{attr}=", 0)
+        assert_equal true,  @record.send("#{attr}=", "1.2")
+        assert_equal true,  @record.data[attr.to_s]
+      end
+
+      test "defines ##{attr}? method for float fields" do
+        assert @record.respond_to?("#{attr}?")
+      end
+    end
+  end
+end