serialbox 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.8.7@serialbox --create

data/Gemfile

@@ -0,0 +1,17 @@
+source :rubygems
+
+gem 'json'
+gem 'activesupport'
+
+group :development do
+  # SPECS
+  gem 'rspec'
+
+  # DOCS
+  gem 'yard'
+  gem 'redcarpet'
+
+  # DEVELOPMENT
+  gem 'bundler'
+  gem 'jeweler'
+end

data/Gemfile.lock

@@ -0,0 +1,41 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.10)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.6)
+    multi_json (1.5.0)
+    rake (10.0.3)
+    rdoc (3.12)
+      json (~> 1.4)
+    redcarpet (2.2.2)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.1)
+    yard (0.8.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bundler
+  jeweler
+  json
+  redcarpet
+  rspec
+  yard

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Tim Morgan
+
+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.md

@@ -0,0 +1,100 @@
+# SerialBox
+
+Provides a simple, well-defined way to specify how your objects are serialized
+and deserialized into primitive types (say, for JSON serialization). Here's an
+example object:
+
+```` ruby
+class Car
+  attr_accessor :seats, :color
+
+  include SerialBox
+  serialize_with :JSON
+  serialize_fields do |s|
+    s.serialize :seats
+    s.serialize :color
+  end
+end
+````
+
+By calling `serialize_with :JSON`, your class now gets `#to_json`, `#as_json`,
+and `.json_create` methods making it work seamlessly with the `json` gem. If you
+have more complicated data structures or accessors, this gem works with that
+too:
+
+```` ruby
+class Color
+  attr_accessor :r, :g, :b
+
+  include SerialBox
+  serialize_with :JSON
+  serialize_fields do |s|
+    s.serialize :r, :g, :b
+  end
+end
+
+class Car
+  attr_accessor :color # string
+
+  include SerialBox
+  serialize_with :JSON
+  serialize_fields do |s|
+    s.serializer 'color', :get_color
+    s.deserializer 'color', :set_color
+  end
+
+  def get_color
+    if color.r == 255 && color.g == 0 && color.b == 0
+      'red'
+    elsif color.r == 0 && color.g == 255 && color.b == 0
+      'green'
+    elsif color.r == 0 && color.g == 0 && color.b == 255
+      'blue'
+    end
+  end
+
+  def set_color(name)
+    case name
+      when 'red' then Color.new(255, 0, 0)
+      when 'green' then Color.new(0, 255, 0)
+      when 'blue' then Color.new(0, 0, 255)
+    end
+  end
+end
+````
+
+The `.serialize_fields` method lets you define serializers and deserializers
+using simple to complex syntax, depending on your needs. Here are the supported
+syntaxes:
+
+```` ruby
+serialize_fields do |s|
+  s.serialize :foo # uses #foo and #foo=, JSON field named "foo"
+  s.serialize :foo, :into => 'bar' # uses #foo and #foo=, JSON field named "bar"
+  s.serialize :@foo # reads and writes directly using @foo
+
+  s.serializer 'foo', :bar # the JSON field "foo" will have the value returned by #bar
+  s.deserializer 'foo', :bar= # the value in JSON field "foo" will be sent to #bar=
+
+  s.serializer('foo') { bar.to_s } # the JSON field "foo" will have the value returned by the block
+  s.deserializer('foo') { |value| self.bar = value.to_sym } # the block will be passed the value stored in JSON field "foo"; you must write it to your object
+end
+````
+
+**Important Note:** Right now the only serializer implemented is `:JSON`. Other
+serializers should be easy to write by following its example.
+
+## Installation
+
+To use, add this gem to your Gemfile:
+
+```` ruby
+gem 'serialbox'
+````
+
+then include the `SerialBox` module in your class, following one of the examples
+above.
+
+## Documentation
+
+Comprehensive documentation is available by running `rake doc`.

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name        = "serialbox"
+  gem.homepage    = "http://github.com/riscfuture/serialbox"
+  gem.license     = "MIT"
+  gem.summary     = %Q{Define how your object is serialized and deserialized, and this gem handles the rest.}
+  gem.description = %Q{This gem allows you to define how your object is serialized and deserialized. Then it's a simple matter of telling it which formats you want to support, and the serialization methods are automatically created for you.}
+  gem.email       = "rubygems@timothymorgan.info"
+  gem.authors     = ["Tim Morgan"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'yard'
+
+# bring sexy back (sexy == tables)
+module YARD::Templates::Helpers::HtmlHelper
+  def html_markup_markdown(text)
+    markup_class(:markdown).new(text, :gh_blockcode, :fenced_code, :autolink, :tables).to_html
+  end
+end
+
+YARD::Rake::YardocTask.new('doc') do |doc|
+  doc.options << '-m' << 'markdown' << '-M' << 'redcarpet'
+  doc.options << '--protected' << '--no-private'
+  doc.options << '-r' << 'README.md'
+  doc.options << '-o' << 'doc'
+  doc.options << '--title' << "SerialBox Documentation"
+
+  doc.files = %w( lib/**/*.rb README.md )
+end

data/VERSION

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

data/lib/serialbox.rb

@@ -0,0 +1,191 @@
+require 'active_support/concern'
+require 'active_support/core_ext/array/extract_options'
+Dir.glob(File.dirname(__FILE__) + '/serializers/*').each { |f| require f }
+
+# Mixin that adds the ability for you to define a serializable representation of
+# your object. `include` this module into your class and call
+# {ClassMethods#serialize_fields} and {ClassMethods#serialize_with} to
+# configure.
+
+module SerialBox
+  extend ActiveSupport::Concern
+
+  # Methods added to the class that this module is mixed into.
+
+  module ClassMethods
+
+    # Call this method to define how your object is serialized. This method
+    # yields an object on which you call methods to define your serialization.
+    #
+    # @yield [serializer] A block where you can define how your object is
+    #   serialized.
+    # @yieldparam [SerialBox::Serializer] serializer An object you can use to
+    #   define your serialization strategy.
+
+    def serialize_fields
+      @_serialbox_serializer = Serializer.new(self)
+      yield @_serialbox_serializer
+    end
+
+    # @overload serialize_with(serializer, ...)
+    #   Call this method to specify which serialization formats to use.
+    #
+    #   @param [Symbol, Class] serializer A serialization format adapter or the
+    #     name of such adapter under the `SerialBox::Serializers` namespace. See
+    #     the classes under {SerialBox::Serializers} for a list of possible
+    #     values.
+
+    def serialize_with(*serializers)
+      serializers.map! do |s|
+        case s
+          when Class
+            s
+          when Symbol, String
+            SerialBox::Serializers.const_get(s.to_sym)
+          else
+            raise ArgumentError, "Unknown serializer #{s.inspect}"
+        end
+      end
+
+      serializers.each { |serializer| include serializer }
+    end
+
+    # @private
+    def _serialbox_serializer() @_serialbox_serializer end
+  end
+
+
+  # An object that is used to define how a class is serialized. The methods of
+  # this object can be called within a block given to
+  # {SerialBox::ClassMethods#serialize_fields}.
+
+  class Serializer
+    # @private
+    attr_reader :serialization_operations, :deserialization_operations, :object
+
+    # @private
+    def initialize(object)
+      @serialization_operations   = Array.new
+      @deserialization_operations = Array.new
+      @object                     = object
+    end
+
+    # @overload serialize(field, ..., options={})
+    #
+    #   Specifies that one or more fields should be serialized in the most
+    #   obvious manner. This is suitable when serializing a simple getter/setter
+    #   pair or an instance variable.
+    #
+    #   @param [Symbol] field The name of a method (or instance variable with
+    #     "@" sigil) that will be serialized.
+    #   @param [Hash] options Additional options controlling how the field is
+    #     serialized.
+    #   @option options [String] :into If given, specifies that the field should
+    #     be serialized into a key with a different name. Can only be provided
+    #     if a single field is given.
+
+    def serialize(*fields)
+      options = fields.extract_options!
+      if options[:into] && fields.size > 1
+        raise ArgumentError, "Can't specify :into option with multiple fields"
+      end
+
+      fields.each do |field|
+        if field.to_s[0, 1] == '@'
+          field      = field.to_s[1..-1]
+          json_field = options[:into] || field
+          serializer(json_field) { instance_variable_get :"@#{field}" }
+          deserializer(json_field) { |value| instance_variable_set :"@#{field}", value }
+        else
+          json_field = options[:into] || field
+          serializer json_field, field
+          deserializer json_field, :"#{field}="
+        end
+      end
+    end
+
+    # Defines how a field is handled when an object is prepared for
+    # serialization.
+    #
+    # @overload serializer(json_field, object_method)
+    #   Specifies that the method `object_method` should be called and its
+    #   result should be stored in a field named `json_field` as part of
+    #   serialization.
+    #   @param [String] json_field The field to store the resulting value in.
+    #   @param [Symbol] object_method The method to call to retrieve a value.
+    #
+    # @overload serializer(json_field)
+    #   Specifies that a block should be called in the context of the instance
+    #   being serialized, and the result should be stored in a field named
+    #   `json_field`.
+    #   @param [String] json_field The field to store the resulting value in in
+    #     the JSON representation.
+    #   @yield A block that returns the value to serialize.
+    #   @yieldreturn The value to serialize into `json_field`.
+
+    def serializer(json_field, object_method=nil, &block)
+      if block_given?
+        @serialization_operations << BlockSerialization.new(json_field, block)
+      elsif object_method
+        @serialization_operations << BlockSerialization.new(json_field, lambda { send object_method })
+      else
+        raise ArgumentError, "Must provide the name of a method or a block that returns a value to serialize"
+      end
+    end
+
+    # Defines how a field is handled when an object is deserialized from its
+    # primitive representation.
+    #
+    # @overload deserializer(json_field, object_method)
+    #   Specifies that the value in `json_field` should be passed to
+    #   `object_method` during deserialization.
+    #   @param [String] json_field The field to retrieve the value from.
+    #   @param [Symbol] object_method The method to call to store the value
+    #     into the object.
+    #
+    # @overload deserializer(json_field)
+    #   Specifies that the value stored in `json_field` should be passed to the
+    #   block provided, which will store that value into the object being
+    #   deserialized.
+    #   @param [String] json_field The field to retrieve the value from in the
+    #     JSON representation.
+    #   @yield [value] A block that stores the value into the object. This block
+    #     is executed in the context of the object.
+    #   @yieldparam value The value to store.
+
+    def deserializer(json_field, object_method=nil, &block)
+      if block_given?
+        @deserialization_operations << BlockDeserialization.new(json_field, block, object)
+      elsif object_method
+        @deserialization_operations << BlockDeserialization.new(json_field, lambda { |value| send object_method, value }, object)
+      else
+        raise ArgumentError, "Must provide the name of a method or a block that sets a field from a deserialized value"
+      end
+    end
+
+    # @private
+    class BlockSerialization
+      def initialize(field, block)
+        @field = field
+        @block = block
+      end
+
+      def apply(caller, json)
+        json[@field] = caller.instance_eval(&@block)
+      end
+    end
+
+    # @private
+    class BlockDeserialization
+      def initialize(field, block, klass)
+        @field       = field
+        @method_name = "_block_deserialization_#{object_id}"
+        klass.send :define_method, @method_name, &block
+      end
+
+      def apply(caller, json)
+        caller.send @method_name, json[@field.to_s]
+      end
+    end
+  end
+end

data/lib/serializers/json.rb

@@ -0,0 +1,65 @@
+require 'json'
+
+module SerialBox
+
+  # Container module for all {SerialBox} serializers.
+
+  module Serializers
+
+    # JSON adapter for {SerialBox}. Defines the following methods when included
+    # in a class:
+    #
+    # * `#as_json`
+    # * `#to_json`
+    # * `.json_create`
+    #
+    # This gives the class total ability to work with `JSON.parse` and
+    # `#to_json`.
+
+    module JSON
+      extend ActiveSupport::Concern
+
+      # @private
+      JSON_CREATE_ID = JSON.respond_to?(:create_id) ? JSON.create_id : 'json_class'
+
+      # Converts this object into primitives suitable for JSON serialization.
+      #
+      # @return [Hash, Array] A JSON-serializable object.
+
+      def as_json(*)
+        hsh = {SerialBox::Serializers::JSON::JSON_CREATE_ID => self.class.name}
+        self.class._serialbox_serializer.serialization_operations.each do |operation|
+          operation.apply self, hsh
+        end
+        return hsh
+      end
+
+      # Serializes this object as JSON.
+      #
+      # @return [String] The JSON representation of this object.
+
+      def to_json(*args) as_json.to_json(*args) end
+
+      module ClassMethods
+
+        # Converts a primitive object (deserialized from JSON) into an instance
+        # of this class.
+        #
+        # **Note:** You should not call this method directly. You should use
+        # `JSON.parse` to ensure recursive deserialization works properly.
+        #
+        # @param [Array, Hash] object The JSON-ready primitive represnetation of
+        #   an instance of this class.
+        # @return An instance of this class derived from the JSON.
+
+        def json_create(object)
+          instance = allocate
+          _serialbox_serializer.deserialization_operations.each do |operation|
+            operation.apply instance, object
+          end
+          return instance
+        end
+      end
+    end
+  end
+end

data/serialbox.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "serialbox"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tim Morgan"]
+  s.date = "2013-01-08"
+  s.description = "This gem allows you to define how your object is serialized and deserialized. Then it's a simple matter of telling it which formats you want to support, and the serialization methods are automatically created for you."
+  s.email = "rubygems@timothymorgan.info"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".rvmrc",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/serialbox.rb",
+    "lib/serializers/json.rb",
+    "spec/json_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/riscfuture/serialbox"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Define how your object is serialized and deserialized, and this gem handles the rest."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<redcarpet>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<redcarpet>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<redcarpet>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

data/spec/json_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+generate_tester_classes 'JSON', :JSON
+
+describe SerialBox::Serializers::JSON do
+  context "[basic schema]" do
+    it "should serialize using #serialize with a method" do
+      obj = JSONSerializeMethodTester.new('value')
+      JSON.parse(obj.to_json, :create_additions => false).should eql({'json_class' => 'JSONSerializeMethodTester', 'var' => 'value'})
+
+      obj = JSON.parse('{"json_class":"JSONSerializeMethodTester","var":"value"}')
+      obj.var.should eql('value')
+    end
+
+    it "should serialize using #serialize with an instance variable" do
+      obj = JSONSerializeIvarTester.new('value')
+      JSON.parse(obj.to_json, :create_additions => false).should eql({'json_class' => 'JSONSerializeIvarTester', 'var' => 'value'})
+
+      obj = JSON.parse('{"json_class":"JSONSerializeIvarTester","var":"value"}')
+      obj.instance_variable_get(:@var).should eql('value')
+    end
+
+    it "should serialize into a custom JSON key" do
+      obj = JSONSerializeIntoTester.new('value')
+      JSON.parse(obj.to_json, :create_additions => false).should eql({'json_class' => 'JSONSerializeIntoTester', 'custom' => 'value'})
+
+      obj = JSON.parse('{"json_class":"JSONSerializeIntoTester","custom":"value"}')
+      obj.var.should eql('value')
+    end
+
+    it "should serialize using #serializer and #deserializer with object methods" do
+      obj = JSONSerializerMethodTester.new('value')
+      JSON.parse(obj.to_json, :create_additions => false).should eql({'json_class' => 'JSONSerializerMethodTester', 'var_json' => 'value'})
+
+      obj = JSON.parse('{"json_class":"JSONSerializerMethodTester","var_json":"value"}')
+      obj.var_getter.should eql('value')
+    end
+
+    it "should serialize using #serializer and #deserializer with blocks" do
+      obj = JSONSerializerBlockTester.new('value')
+      JSON.parse(obj.to_json, :create_additions => false).should eql({'json_class' => 'JSONSerializerBlockTester', 'var_json' => 'value'})
+
+      obj = JSON.parse('{"json_class":"JSONSerializerBlockTester","var_json":"value"}')
+      obj.instance_variable_get(:@var).should eql('value')
+    end
+  end
+
+  context "[sub-objects]" do
+    it "should correctly serialize and deserialize sub-objects" do
+      subobj = JSONSerializeMethodTester.new('value')
+      obj    = JSONSerializeMethodTester.new(subobj)
+      JSON.parse(obj.to_json, :create_additions => false).should eql({
+                                                                         'json_class' => 'JSONSerializeMethodTester',
+                                                                         'var'        => {'json_class' => 'JSONSerializeMethodTester',
+                                                                                          'var'        => 'value'}})
+
+      obj = JSON.parse('{"json_class":"JSONSerializeMethodTester","var":{"json_class":"JSONSerializeMethodTester","var":"value"}}')
+      obj.var.should be_kind_of(JSONSerializeMethodTester)
+      obj.var.var.should eql('value')
+    end
+
+    it "should correctly serialize and deserialize special objects in generic objects" do
+      obj    = [JSONSerializeMethodTester.new('value')]
+      JSON.parse(obj.to_json, :create_additions => false).should eql([{'json_class' => 'JSONSerializeMethodTester',
+                                                                       'var'        => 'value'}])
+
+      obj = JSON.parse('[{"json_class":"JSONSerializeMethodTester","var":"value"}]')
+      obj.should be_kind_of(Array)
+      obj.first.should be_kind_of(JSONSerializeMethodTester)
+      obj.first.var.should eql('value')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,67 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'serialbox'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end
+
+def generate_tester_classes(prefix, serialize_with)
+  eval <<-RUBY
+    class #{prefix}SerializeMethodTester
+      attr_accessor :var
+      def initialize(var) self.var = var end
+
+      include SerialBox
+      serialize_with #{serialize_with.inspect}
+      serialize_fields { |s| s.serialize :var }
+    end
+
+    class #{prefix}SerializeIvarTester
+      def initialize(var) @var = var end
+
+      include SerialBox
+      serialize_with #{serialize_with.inspect}
+      serialize_fields { |s| s.serialize :@var }
+    end
+
+    class #{prefix}SerializeIntoTester
+      attr_accessor :var
+      def initialize(var) self.var = var end
+
+      include SerialBox
+      serialize_with #{serialize_with.inspect}
+      serialize_fields { |s| s.serialize :var, :into => :custom }
+    end
+
+
+    class #{prefix}SerializerMethodTester
+      def initialize(var) @var = var end
+      def var_setter(val) @var = val end
+      def var_getter() @var end
+
+      include SerialBox
+      serialize_with #{serialize_with.inspect}
+      serialize_fields do |s|
+        s.serializer 'var_json', :var_getter
+        s.deserializer 'var_json', :var_setter
+      end
+    end
+
+    class #{prefix}SerializerBlockTester
+      def initialize(var) @var = var end
+
+      include SerialBox
+      serialize_with #{serialize_with.inspect}
+      serialize_fields do |s|
+        s.serializer('var_json') { @var }
+        s.deserializer('var_json') { |val| @var = val }
+      end
+    end
+  RUBY
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification 
+name: serialbox
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Tim Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-01-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id001
+  name: json
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id002
+  name: activesupport
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id003
+  name: rspec
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id004
+  name: yard
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id005
+  name: redcarpet
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id006
+  name: bundler
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency 
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id007
+  name: jeweler
+  prerelease: false
+  type: :development
+description: This gem allows you to define how your object is serialized and deserialized. Then it's a simple matter of telling it which formats you want to support, and the serialization methods are automatically created for you.
+email: rubygems@timothymorgan.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- .document
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/serialbox.rb
+- lib/serializers/json.rb
+- serialbox.gemspec
+- spec/json_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/riscfuture/serialbox
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Define how your object is serialized and deserialized, and this gem handles the rest.
+test_files: []
+