serializable_attributes 0.9.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 rick olson
+
+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 PURPOa AND
+NONINFRINGEMENT. IN NO EVENT SaALL 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,56 @@
+# SerializedAttributes
+
+SerializedAttributes allows you to add an encoded hash to an ActiveRecord model.  
+This is similar to the built-in ActiveRecord serialization, except that the field 
+is converted to JSON, gzipped, and stored in a BLOB field.  This uses the json
+gem which is much faster than YAML serialization.  However, JSON is not nearly as
+flexible, so you're stuck with strings/integers/dates/etc.
+
+Where possible, ActiveRecord compatible methods are generated so that a migration 
+should be pretty simple.  See unit tests for examples.
+
+Some of the code and most of the ideas are taken from [Heresy][Heresy], a ruby
+implementation of [how FriendFeed uses MySQL for schema-free storage][schemafree].
+
+Supports ActiveRecord 2.2 in ruby 1.8.7, and ActiveRecord 2.3-3.1 in ruby 1.9.3.
+See [Travis CI][travis] to see if we support your version of
+ActiveRecord and ruby.
+
+[Heresy]: https://github.com/kabuki/heresy
+[schemafree]: http://bret.appspot.com/entry/how-friendfeed-uses-mysql
+[travis]: http://travis-ci.org/#!/technoweenie/serialized_attributes
+
+## Setup
+
+Install the plugin into your Rails app.
+
+## Usage
+
+```ruby
+class Profile < ActiveRecord::Base
+  # 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
+```
+

data/Rakefile

@@ -0,0 +1,132 @@
+#!/usr/bin/env rake
+
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/#{gem_file}"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+    exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/gemfiles/ar-2.2.gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gem "rake"
+gem "activerecord", "~> 2.2.3"
+
+gemspec :path=>"../"

data/gemfiles/ar-2.3.gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gem "rake"
+gem "activerecord", "~> 2.3.14"
+
+gemspec :path=>"../"

data/gemfiles/ar-3.0.gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gem "rake"
+gem "activerecord", "~> 3.0.11"
+
+gemspec :path=>"../"

data/gemfiles/ar-3.1.gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gem "rake"
+gem "activerecord", "~> 3.1.3"
+
+gemspec :path=>"../"

data/init.rb

@@ -0,0 +1,2 @@
+require File.expand_path('../rails_init', __FILE__)
+

data/lib/serializable_attributes/duplicable.rb

@@ -0,0 +1,65 @@
+# Most objects are cloneable, but not all. For example you can't dup +nil+:
+#
+#   nil.dup # => TypeError: can't dup NilClass
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+class Object
+  # Can you safely .dup this object?
+  # False for nil, false, true, symbols, numbers, class and module objects; true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Symbol #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Numeric #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Class #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Module #:nodoc:
+  def duplicable?
+    false
+  end
+end

data/lib/serializable_attributes/format/active_support_json.rb

@@ -0,0 +1,29 @@
+require 'zlib'
+require 'stringio'
+
+module SerializableAttributes
+  module Format
+    module ActiveSupportJson
+      extend self
+
+      def encode(body)
+        return nil if body.blank?
+        s = StringIO.new
+        z = Zlib::GzipWriter.new(s)
+        z.write ActiveSupport::JSON.encode(body)
+        z.close
+        s.string
+      end
+
+      def decode(body)
+        return {} if body.to_s.empty?
+        s = StringIO.new(body)
+        z = Zlib::GzipReader.new(s)
+        hash = ActiveSupport::JSON.decode(z.read)
+        z.close
+        hash
+      end
+    end
+  end
+end
+

data/lib/serializable_attributes/schema.rb

@@ -0,0 +1,188 @@
+module SerializableAttributes
+  class Schema
+    class << self
+      attr_writer :default_formatter
+      def default_formatter
+        @default_formatter ||= SerializableAttributes::Format::ActiveSupportJson
+      end
+    end
+
+    attr_accessor :formatter
+    attr_reader :model, :field, :fields
+
+    def all_column_names
+      fields ? fields.keys : []
+    end
+
+    def encode(body)
+      body = body.dup
+      body.each do |key, value|
+        if field = fields[key]
+          body[key] = field.encode(value)
+        end
+      end
+      formatter.encode(body)
+    end
+
+    def decode(data, is_new_record = false)
+      decoded = formatter.decode(data)
+      hash = ::Hash.new do |h, key|
+        if type = fields[key]
+          h[key] = type ? type.default : nil
+        end
+      end
+
+      decoded.each do |k, v|
+        next unless include?(k)
+        type = fields[k]
+        hash[k] = type ? type.parse(v) : v
+      end
+
+      if decoded.blank? && is_new_record
+        fields.each do |key, type|
+          hash[key] = type.default if type.default
+        end
+      end
+      hash
+    end
+
+    def include?(key)
+      @fields.include?(key.to_s)
+    end
+
+    # Initializes a new Schema.  See `ModelMethods#serialize_attributes`.
+    #
+    # model   - The ActiveRecord class.
+    # field   - The String name of the ActiveRecord attribute that holds
+    #           data.
+    # options - Optional Hash:
+    #           :blob      - The String name of the actual DB field.  Defaults to
+    #                        "raw_#{field}"
+    #           :formatter - The module that handles encoding and decoding the
+    #                        data.  The default is set in
+    #                        `Schema#default_formatter`.
+    def initialize(model, field, options)
+      @model, @field, @fields = model, field, {}
+      @blob_field = options.delete(:blob) || "raw_#{@field}"
+      @formatter  = options.delete(:formatter) || self.class.default_formatter
+      blob_field  = @blob_field
+      data_field  = @field
+
+      meta_model = class << @model; self; end
+      changed_ivar = "#{data_field}_changed"
+      meta_model.send(:attr_accessor, "#{data_field}_schema")
+      @model.send("#{data_field}_schema=", self)
+
+      @model.class_eval do
+        def reload(options = nil)
+          reset_serialized_data
+          super
+        end
+      end
+
+      meta_model.send(:define_method, :attribute_names) do
+        column_names + send("#{data_field}_schema").all_column_names
+      end
+
+      @model.send(:define_method, :reset_serialized_data) do
+        instance_variable_set("@#{data_field}", nil)
+      end
+
+      @model.send(:define_method, :attribute_names) do
+        (super() + send(data_field).keys - [blob_field]).
+          map! { |s| s.to_s }.sort!
+      end
+
+      @model.send(:define_method, data_field) do
+        instance_variable_get("@#{data_field}") || begin
+          instance_variable_get("@#{changed_ivar}").clear if send("#{changed_ivar}?")
+          schema   = self.class.send("#{data_field}_schema")
+          hash     = schema.decode(send(blob_field), new_record?)
+          instance_variable_set("@#{data_field}", hash)
+          hash
+        end
+      end
+
+      @model.send(:define_method, :write_serialized_field) do |name, value|
+        raw_data = send(data_field) # load fields if needed
+        name_str = name.to_s
+        schema   = self.class.send("#{data_field}_schema")
+        type     = schema.fields[name_str]
+        changed_fields = send(changed_ivar)
+        instance_variable_get("@#{changed_ivar}")[name_str] = raw_data[name_str] unless changed_fields.include?(name_str)
+        parsed_value = type ? type.parse(value) : value
+        if parsed_value.nil?
+          raw_data.delete(name_str)
+        else
+          raw_data[name_str] = parsed_value
+        end
+        parsed_value
+      end
+
+      @model.send(:define_method, changed_ivar) do
+        hash = instance_variable_get("@#{changed_ivar}") || instance_variable_set("@#{changed_ivar}", {})
+        hash.keys
+      end
+
+      @model.send(:define_method, "#{changed_ivar}?") do
+        !send(changed_ivar).empty?
+      end
+
+      @model.before_save do |r|
+        schema = r.class.send("#{data_field}_schema")
+        r.send("#{blob_field}=", schema.encode(r.send(data_field)))
+      end
+    end
+
+    # Adds the accessors for a serialized field on this model.  Also sets up
+    # the encoders and decoders.
+    #
+    # type_name - The Symbol matching a valid type.
+    # *names    - One or more Symbol field names.
+    # options   - Optional Hash to be sent to the initialized Type.
+    #             :default - Sets the default value.
+    #
+    # Returns nothing.
+    def field(type_name, *names)
+      options      = names.extract_options!
+      data_field   = @field
+      changed_ivar = "#{data_field}_changed"
+      type         = SerializableAttributes.types[type_name].new(options)
+      names.each do |name|
+        name_str = name.to_s
+        @fields[name_str] = type
+
+        @model.send(:define_method, name) do
+          send(data_field)[name_str]
+        end
+
+        if type.is_a? Boolean
+          @model.send :alias_method, "#{name}?", name
+        end
+
+        @model.send(:define_method, "#{name}=") do |value|
+          write_serialized_field name_str, value
+        end
+
+        @model.send(:define_method, "#{name}_changed?") do
+          send(changed_ivar).include?(name_str)
+        end
+
+        @model.send(:define_method, "#{name}_before_type_cast") do
+          value = send(name)
+          value = type.encode(value) if type
+          value.to_s
+        end
+
+        @model.send(:define_method, "#{name}_change") do
+          if send("#{name}_changed?")
+            [instance_variable_get("@#{changed_ivar}")[name_str], send(data_field)[name_str]]
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+