arms 0.0.1.pre.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b55e292c1c3dd14a37093716198e3b6f1c727f0ec5b7936cff67737abfbdab5
+  data.tar.gz: 34431ad4cb56af7559816402c5c9a27b68f4218728a36e5d0c077ffb99691fc4
+SHA512:
+  metadata.gz: cc79ea29be6ced5ad4ed5e1a8a915f2993d898c44d4fa40510719ae2eeb9ab362b67194ea0ea595afa9a1cc52102ba2e098d4592d4718ba7e538d1af3d007cdd
+  data.tar.gz: 0e300ee399e111f75a0d1cbb144b0fe246402acfa6f64aee1c66b341c62532f28277225e890b94ca3f90c7c43fc0bc1af9010eb393f6d6385e272683f4171469

data/.simplecov

@@ -0,0 +1 @@
+SimpleCov.start

data/.yardopts

@@ -0,0 +1 @@
+--main README.md --markup=markdown {lib}/**/*.rb

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Ethan
+
+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,82 @@
+# ARMS
+
+[![Build Status](https://travis-ci.org/notEthan/arms.svg?branch=master)](https://travis-ci.org/notEthan/arms)
+[![Coverage Status](https://coveralls.io/repos/github/notEthan/arms/badge.svg)](https://coveralls.io/github/notEthan/arms)
+
+ARMS: Active Record Multiple Serialization. This is a library which extends the capabilities of ActiveRecord serialization, allowing you to chain together coders.
+
+For a very simple example, we'll do a thing you can't easily do in ActiveRecord: get a hash with indifferent string/symbol access on the model (in this case for a column named `preferences`), storing serialized JSON in the database:
+
+```ruby
+require 'arms'
+class Foo < ActiveRecord::Base
+  arms_serialize :preferences, :indifferent_hashes, JSON
+end
+```
+
+assuming you have a database set up with table `foos` and string column `preferences` (see [this script](https://gist.github.com/notEthan/84a4e583ea6e96f0f92dab43286ba301) for a full example), the database will contain JSON (seen with `#preferences_before_type_cast`) and the model attribute offers indifferent access.
+
+```ruby
+Foo.create!(preferences: {favorite_animal: 'ocelot'})
+
+foo = foo.last
+
+# JSON in the DB:
+foo.preferences_before_type_cast
+# => "{\"favorite_animal\":\"ocelot\"}"
+
+# indifferent access on the model:
+foo.preferences[:favorite_animal]
+# => 'ocelot'
+foo.preferences['favorite_animal']
+# => 'ocelot'
+```
+
+## Coder Shortcuts
+
+With stock ActiveRecord, you can call `serialize :foo, JSON` which is a sort of shortcut to the coder `ActiveRecord::Coders::JSON`. ARMS extends this a bit and offers a registry of shortcuts. In the above example, `:indifferent_hashes` is a shortcut invoking the coder `ARMS::IndifferentHashesCoder`. Most shortcut keys are symbols, but sometimes classes such as JSON or YAML are shortcut keys to coders for those serializations.
+
+Some coders take arguments when they are instantiated. Shortcuts can be expressed as an array, where the first element is the shortcut key and the remainder of the array is passed as arguments to instantiate the coder - for example, the YAML coder can take an argument hinting what class it expects to be serializing. Modifying the above, this would look like:
+
+```ruby
+class Foo < ActiveRecord::Base
+  arms_serialize :preferences, :indifferent_hashes, [YAML, Hash]
+end
+```
+
+A full example with this serialization is [at this link](https://gist.github.com/notEthan/297243912fcbd07354fc3d48093df12f).
+
+### Built-in Shortcuts
+
+The following shortcuts are built into ARMS:
+
+| Shortcut Key        | Loads                                               | Dumps                                | Arguments                       | Coder Class                      |
+| ---                 | ---                                                 | ---                                  | ---                             | ---                              |
+| JSON                | A string of JSON                                    | Ruby Arrays, Hashes, and basic types | none                            | ActiveRecord::Coders::JSON       |
+| :json               | ^                                                   | ^                                    | ^                               | ^                                |
+| YAML                | A string of YAML                                    | Any                                  | Expected loaded class           | ActiveRecord::Coders::YAMLColumn |
+| :yaml               | ^                                                   | ^                                    | ^                               | ^                                |
+| :indifferent_hashes | Indifferentiated structure of Arrays and Hashes     | Plain structure of Arrays and Hashes | none                            | ARMS::IndifferentHashesCoder     |
+| :struct             | An instance or array of instances of a Struct class | A Hash or Array of Hashes            | The Struct class to instantiate | ARMS::StructCoder                |
+
+## Provided Coders
+
+ARMS offers a few useful coders which may be used with arms_serialize, or with vanilla ActiveRecord::Base.serialize. For the most part these aim to have JSONifiable data on the #dump side, which may be stored in a JSON column or serialized to text with yaml or json.
+
+### ARMS::IndifferentHashesCoder
+
+When loading, this coder takes a JSONifiable structure of arrays and hashes, and will change Hash instances to ActiveSupport::HashWithIndifferentAccess.
+
+When dumping, it converts indifferent hashes to plain hashes.
+
+### ARMS::StructCoder
+
+Instantiated with a Struct class, this converts an instance or instances of that struct to JSONifiable types.
+
+When loading a hash (or array of hashes), the given struct class is instatiated with each member corresponding to a key of a hash.
+
+When dumping, an instance of the specified struct class (or array of instances) is dumped to a hash in which each member of the struct and its value is a key/value pair.
+
+## License
+
+ARMS is open source software available under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile.rb

@@ -0,0 +1,9 @@
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/arms.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "arms/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "arms"
+  spec.version       = ARMS::VERSION
+  spec.authors       = ["Ethan"]
+  spec.email         = ["ethan@unth.net"]
+
+  spec.summary       = 'Active Record Multiple Serialization'
+  spec.description   = 'A library which offers flexible, chained serializion for Active Record'
+  spec.homepage      = "https://github.com/notEthan/arms"
+  spec.license       = "MIT"
+
+  ignore_files = %w(.gitignore .travis.yml Gemfile test)
+  ignore_files_re = %r{\A(#{ignore_files.map { |f| Regexp.escape(f) }.join('|')})(/|\z)}
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  Dir.chdir(File.expand_path('..', __FILE__)) do
+    spec.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(ignore_files_re) }
+    spec.test_files  = `git ls-files -z test`.split("\x0") + [
+      '.simplecov',
+    ]
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "sqlite3", "~> 1.3", ">= 1.3.6" # loosen this in accordance with active_record/connection_adapters/sqlite3_adapter.rb
+end

data/lib/arms.rb

@@ -0,0 +1,96 @@
+require "arms/version"
+
+module ARMS
+  # base class for ARMS errors
+  class Error < StandardError
+  end
+
+  # a coder which is not a recognized shortcut and/or does not respond to #load and #dump
+  class InvalidCoder < Error
+    attr_accessor :coder
+  end
+
+  # an error loading column data to objects on the model
+  class LoadError < Error
+  end
+
+  # an error dumping objects from the model to column data
+  class DumpError < Error
+  end
+
+  # the object passed to a coder shortcut proc, which indicates the model and attribute name
+  # and passes optional arguments used to instantiate the coder.
+  class ShortcutInvocation
+    # the model on which an attribute is being serialized
+    attr_accessor :model
+    # the name of the attribute being serialized
+    attr_accessor :attr_name
+    # arguments passed from the shortcut invocation to the coder shortcut proc
+    attr_accessor :args
+  end
+
+  @coder_shortcuts = {}
+
+  class << self
+    # adds a shortcut which can be used with ActiveRecord::Base.arms_serialize. the key is usually
+    # a symbol, but may be anything. the given block is called by arms_serialize with an
+    # ARMS::ShortcutInvocation object, and must result in a coder.
+    #
+    # @yieldparam shortcut_invocation [ARMS::ShortcutInvocation]
+    # @yieldreturn [#load, #dump] a coder which responds to #load and #dump
+    def register_coder_shortcut(key, &coderproc)
+      raise(ArgumentError, "already registered shortcut: #{key}") if @coder_shortcuts.key?(key)
+      @coder_shortcuts[key] = coderproc
+      nil
+    end
+  end
+
+  autoload :MultiCoder, 'arms/multi_coder'
+  autoload :IndifferentHashesCoder, 'arms/indifferent_hashes_coder'
+  autoload :StructCoder, 'arms/struct_coder'
+end
+
+require 'json'
+ARMS.register_coder_shortcut(JSON) { ::ActiveRecord::Coders::JSON }
+ARMS.register_coder_shortcut(:json) { ::ActiveRecord::Coders::JSON }
+
+require 'yaml'
+ARMS.register_coder_shortcut(YAML) { |s| ::ActiveRecord::Coders::YAMLColumn.new(s.attr_name, *s.args) }
+ARMS.register_coder_shortcut(:yaml) { |s| ::ActiveRecord::Coders::YAMLColumn.new(s.attr_name, *s.args) }
+
+ARMS.register_coder_shortcut(:indifferent_hashes) { ARMS::IndifferentHashesCoder.new }
+ARMS.register_coder_shortcut(:struct) { |s| ARMS::StructCoder.new(*s.args) }
+
+module ARMS
+  module ActiveRecord
+    module AttributeMethods
+      module Serialization
+        # ActiveRecord::Base.arms_serialize takes an attribute name and any number of coders which
+        # will be chained to serialize and deserialize between the database column and the model
+        # attribute.
+        #
+        # full documentation is at {ARMS::MultiCoder#initialize}.
+        #
+        # here are a few example invocations:
+        #
+        #     # two coders: indifferent hashes, YAML with argument Hash (the object_class)
+        #     arms_serialize('preferences', :indifferent_hashes, [YAML, Hash])
+        #
+        #     # two coders: struct coder with argument Preference (the struct class), JSON coder
+        #     MultiCoder.new([[:struct, Preference], :json], attr_name: 'preferences', model: Foo)
+        def arms_serialize(attr_name, *coders)
+          multi_coder = ARMS::MultiCoder.new(coders, attr_name: attr_name, model: self)
+          serialize(attr_name, multi_coder)
+        end
+      end
+    end
+  end
+end
+
+require 'active_record'
+
+module ActiveRecord
+  class Base
+    extend ARMS::ActiveRecord::AttributeMethods::Serialization
+  end
+end

data/lib/arms/indifferent_hashes_coder.rb

@@ -0,0 +1,26 @@
+module ARMS
+  # ARMS::IndifferentHashesCoder will replace any Hashes in a structure of Arrays and Hashes with ActiveSupport::HashWithIndifferentAccess on load, and convert back to plain hashes on dump.
+  class IndifferentHashesCoder
+    # @param column_data [Array, Hash, Object] a structure in which Hashes will be replaced with ActiveSupport::HashWithIndifferentAccess
+    def load(column_data)
+      if column_data.respond_to?(:to_ary)
+        column_data.to_ary.map { |el| load(el) }
+      elsif column_data.respond_to?(:to_hash)
+        ActiveSupport::HashWithIndifferentAccess.new(column_data).transform_values { |v| load(v) }
+      else
+        column_data
+      end
+    end
+
+    # @param object [#to_ary, #to_hash, Object] a structure in which ActiveSupport::HashWithIndifferentAccess instances will be replaced with plain Hashes
+    def dump(object)
+      if object.respond_to?(:to_ary)
+        object.to_ary.map { |el| dump(el) }
+      elsif object.respond_to?(:to_hash)
+        object.to_hash.transform_values { |v| dump(v) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/arms/multi_coder.rb

@@ -0,0 +1,84 @@
+module ARMS
+  class MultiCoder
+    # loads and dumps between database column and model attribute, using any number of coders.
+    #
+    # the first coder is closest to the loaded model attribute. the last coder is closest to
+    # the dumped database column.
+    #
+    # each coder must respond to #load and #dump. such a coder can be passed directly, or as a
+    # shortcut consisting of a key registered with ARMS.register_coder_shortcut and optional
+    # arguments (using an array). each of the following is a valid coder (an element of the
+    # coders array):
+    #
+    #     # direct reference to the coder
+    #     ::ActiveRecord::Coders::YAMLColumn.new('foo')
+    #
+    #     # shortcut, equivalent to the above
+    #     :yaml
+    #
+    #     # shortcut passing optional `object_class` argument to yaml coder.
+    #     # the first element of this array is the shortcut key, and the remainder
+    #     # is arguments passed to instantiate the coder.
+    #     [:yaml, Array]
+    #
+    # here are a few example invocations that instantiate a MultiCoder:
+    #
+    #     # two coders: indifferent hashes, YAML with argument Hash (the object_class)
+    #     MultiCoder.new([:indifferent_hashes, [YAML, Hash]], attr_name: 'preferences', model: Foo)
+    #
+    #     # two coders: struct coder with argument Preference (the struct class), JSON coder
+    #     MultiCoder.new([[:struct, Preference], :json], attr_name: 'preferences', model: Foo)
+    #
+    # load goes like:
+    #
+    # database column -> coderN.load -> ... -> coder1.load -> model attribute
+    #
+    # dump goes like:
+    #
+    # model attribute -> coder1.dump -> ... -> coderN.dump -> database column
+    #
+    # @param coders [Array] an array of coders (which respond to #load and #dump) or coder shortcuts
+    # @param model [Class] the model on which the attribute is being serialized
+    # @param attr_name the attribute name being serialized on the model
+    def initialize(coders, model: nil, attr_name: nil)
+      @coders = coders.each_with_index.map do |coder, i|
+        shortcut_invocation = ShortcutInvocation.new
+        shortcut_invocation.model = model
+        shortcut_invocation.attr_name = attr_name
+
+        if coder.respond_to?(:to_ary)
+          shortcut_invocation.args = coder[1..-1]
+          coder = coder[0]
+        end
+
+        if ARMS.instance_exec { @coder_shortcuts }.key?(coder)
+          ARMS.instance_exec { @coder_shortcuts }[coder].(shortcut_invocation)
+        elsif coder.respond_to?(:load) && coder.respond_to?(:dump)
+          if shortcut_invocation.args.nil? || shortcut_invocation.args.empty?
+            coder
+          else
+            raise(InvalidCoder.new("given shortcut arguments are not passed to the coder at index #{i} which responds to #load and #dump. coder: #{coder.inspect}; shortcut args: #{shortcut_invocation.args.inspect}").tap { |e| e.coder = coder })
+          end
+        else
+          raise(InvalidCoder.new("given coder at index #{i} is not a recognized shortcut and does not respond to #load and #dump. coder: #{coder.inspect}; shortcut args: #{shortcut_invocation.args.inspect}").tap { |e| e.coder = coder })
+        end
+      end
+    end
+
+    # @param column_data [Object] data hot off the database column
+    # @return [Object] loaded (deserialized) data
+    def load(column_data)
+      @coders.reverse.inject(column_data) do |data, coder|
+        coder.load(data)
+      end
+    end
+
+    # @param object [Object] object on the model attribute
+    # @return [Object] dumped (serialized) data
+    def dump(object)
+      @coders.inject(object) do |data, coder|
+        coder.dump(data)
+      end
+    end
+  end
+end

data/lib/arms/struct_coder.rb

@@ -0,0 +1,93 @@
+module ARMS
+  # this is a ActiveRecord serialization class intended to serialize from a Struct class
+  # on the loaded ruby side to something JSON-compatible on the dumped database side.
+  #
+  # This coder relies on `loaded_class`, the Struct class which will be used to instantiate
+  # the column data. properties (members) of the loaded class will correspond
+  # to keys of the dumped json object.
+  #
+  # the data may be either a single instance of the loaded class
+  # (serialized as one hash) or an array of them (serialized as an
+  # array of hashes), indicated by the boolean keyword argument `array`.
+  #
+  # the column behind the attribute may be an actual JSON column (postgres json
+  # or jsonb - hstore should work too if you only have string attributes) or may
+  # be a string column with a string serializer after StructCoder.
+  class StructCoder
+    # @param loaded_class [Class] the Struct class to load
+    # @param array [Boolean] whether the column holds an array of Struct instances instead of just one
+    def initialize(loaded_class, array: false)
+      @loaded_class = loaded_class
+      # this notes the order of the keys as they were in the json, used by dump_object to generate
+      # json that is equivalent to the json/jsonifiable that came in, so that AR's #changed_attributes
+      # can tell whether the attribute has been changed.
+      @loaded_class.send(:attr_accessor, :arms_object_json_coder_keys_order)
+      @array = array
+    end
+
+    # @param data [Hash, Array<Hash>]
+    # @return [loaded_class, Array[loaded_class]]
+    def load(data)
+      return nil if data.nil?
+      object = if @array
+        unless data.respond_to?(:to_ary)
+          raise LoadError, "expected array-like column data; got: #{data.class}: #{data.inspect}"
+        end
+        data.map { |el| load_object(el) }
+      else
+        load_object(data)
+      end
+      object
+    end
+
+    # @param object [loaded_class, Array[loaded_class]]
+    # @return [Hash, Array<Hash>]
+    def dump(object)
+      return nil if object.nil?
+      jsonifiable = begin
+        if @array
+          unless object.respond_to?(:to_ary)
+            raise DumpError, "expected array-like attribute; got: #{object.class}: #{object.inspect}"
+          end
+          object.map do |el|
+            dump_object(el)
+          end
+        else
+          dump_object(object)
+        end
+      end
+      jsonifiable
+    end
+
+    private
+
+    # @param data [Hash]
+    # @return [loaded_class]
+    def load_object(data)
+      if data.respond_to?(:to_hash)
+        data = data.to_hash
+        good_keys = @loaded_class.members.map(&:to_s)
+        bad_keys = data.keys - good_keys
+        unless bad_keys.empty?
+          raise LoadError, "expected keys #{good_keys}; got unrecognized keys: #{bad_keys}"
+        end
+        instance = @loaded_class.new(*@loaded_class.members.map { |m| data[m.to_s] })
+        instance.arms_object_json_coder_keys_order = data.keys
+        instance
+      else
+        raise LoadError, "expected instance(s) of #{Hash}; got: #{data.class}: #{data.inspect}"
+      end
+    end
+
+    # @param object [loaded_class]
+    # @return [Hash]
+    def dump_object(object)
+      if object.is_a?(@loaded_class)
+        keys = (object.arms_object_json_coder_keys_order || []) | @loaded_class.members.map(&:to_s)
+        keys.map { |member| {member => object[member]} }.inject({}, &:update)
+      else
+        raise TypeError, "expected instance(s) of #{@loaded_class}; got: #{object.class}: #{object.inspect}"
+      end
+    end
+  end
+end

data/lib/arms/version.rb

@@ -0,0 +1,3 @@
+module ARMS
+  VERSION = "0.0.1-rc1"
+end

data/test/arms_test.rb

@@ -0,0 +1,140 @@
+require "test_helper"
+
+class ARMSTest < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::ARMS::VERSION
+  end
+end
+
+describe 'ActiveRecord::Base.arms_serialize' do
+  describe 'serializing to JSON' do
+    it 'serializes json with JSON' do
+      Blog::Foo.create!(tags_const_json: {'#BlackLivesMatter' => {rank: 1}})
+      assert_equal(%q({"#BlackLivesMatter":{"rank":1}}), Blog::UnserializedFoo.last.tags_const_json)
+    end
+    it 'serializes json with :json' do
+      Blog::Foo.create!(tags_sym_json: {'#BlackLivesMatter' => {rank: 1}})
+      assert_equal(%q({"#BlackLivesMatter":{"rank":1}}), Blog::UnserializedFoo.last.tags_sym_json)
+    end
+  end
+  describe 'serializing to YAML' do
+    it 'serializes yaml with YAML' do
+      Blog::Foo.create!(tags_const_yaml: {'#BlackLivesMatter' => {rank: 1}})
+      assert_equal(%Q(---\n"#BlackLivesMatter":\n  :rank: 1\n), Blog::UnserializedFoo.last.tags_const_yaml)
+    end
+    it 'serializes yaml with :yaml' do
+      Blog::Foo.create!(tags_sym_yaml: {'#BlackLivesMatter' => {rank: 1}})
+      assert_equal(%Q(---\n"#BlackLivesMatter":\n  :rank: 1\n), Blog::UnserializedFoo.last.tags_sym_yaml)
+    end
+  end
+  describe 'deserializing with indifferent access' do
+    it 'deserializes yaml with string keys with indifferent access shortcut' do
+      Blog::UnserializedFoo.create!(tags_indifferent_yaml: %Q(---\n"#BlackLivesMatter":\n  rank: 1\n))
+      assert_equal({'#BlackLivesMatter' => {'rank' => 1}}, Blog::Foo.last.tags_indifferent_yaml)
+      assert_instance_of(ActiveSupport::HashWithIndifferentAccess, Blog::Foo.last.tags_indifferent_yaml)
+    end
+    it 'deserializes yaml with symbol keys with indifferent access shortcut' do
+      Blog::UnserializedFoo.create!(tags_indifferent_yaml: %Q(---\n"#BlackLivesMatter":\n  :rank: 1\n))
+      assert_equal({'#BlackLivesMatter' => {'rank' => 1}}, Blog::Foo.last.tags_indifferent_yaml)
+      assert_instance_of(ActiveSupport::HashWithIndifferentAccess, Blog::Foo.last.tags_indifferent_yaml)
+    end
+    it 'deserializes json with indifferent access shortcut' do
+      Blog::UnserializedFoo.create!(tags_indifferent_json: %q({"#BlackLivesMatter":{"rank":1}}))
+      assert_equal({'#BlackLivesMatter' => {'rank' => 1}}, Blog::Foo.last.tags_indifferent_json)
+      assert_instance_of(ActiveSupport::HashWithIndifferentAccess, Blog::Foo.last.tags_indifferent_json)
+    end
+    it 'deserializes json with ARMS::IndifferentHashesCoder' do
+      Blog::UnserializedFoo.create!(tags_const_indifferent_json: %q({"#BlackLivesMatter":{"rank":1,"x":[{"y":"z"}]}}))
+      assert_equal({'#BlackLivesMatter' => {'rank' => 1, 'x' => [{'y' => 'z'}]}}, Blog::Foo.last.tags_const_indifferent_json)
+      assert_instance_of(ActiveSupport::HashWithIndifferentAccess, Blog::Foo.last.tags_const_indifferent_json)
+      assert_instance_of(ActiveSupport::HashWithIndifferentAccess, Blog::Foo.last.tags_const_indifferent_json['#BlackLivesMatter']['x'][0])
+    end
+  end
+  describe 'serializing with indifferent access' do
+    it 'serializes yaml with string keys with indifferent access shortcut' do
+      Blog::Foo.create!(tags_indifferent_yaml: {'#BlackLivesMatter' => {'rank' => 1}})
+      assert_equal(%Q(---\n"#BlackLivesMatter":\n  rank: 1\n), Blog::UnserializedFoo.last.tags_indifferent_yaml)
+    end
+    it 'serializes yaml with symbol keys with indifferent access shortcut' do
+      Blog::Foo.create!(tags_indifferent_yaml: {'#BlackLivesMatter' => {rank: 1}})
+      assert_equal(%Q(---\n"#BlackLivesMatter":\n  rank: 1\n), Blog::UnserializedFoo.last.tags_indifferent_yaml)
+    end
+    it 'serializes json with indifferent access shortcut' do
+      Blog::Foo.create!(tags_indifferent_json: {'#BlackLivesMatter' => {'rank' => 1}})
+      assert_equal(%q({"#BlackLivesMatter":{"rank":1}}), Blog::UnserializedFoo.last.tags_indifferent_json)
+    end
+    it 'serializes json with ARMS::IndifferentHashesCoder' do
+      Blog::Foo.create!(tags_const_indifferent_json: {'#BlackLivesMatter' => {rank: 1, x: [{y: 'z'}]}})
+      assert_equal(%q({"#BlackLivesMatter":{"rank":1,"x":[{"y":"z"}]}}), Blog::UnserializedFoo.last.tags_const_indifferent_json)
+    end
+  end
+  describe 'deserializing to structs' do
+    it 'deserializes json array of tags to structs' do
+      Blog::UnserializedFoo.create!(tags_ary_struct_json: %q([{"name":"#BlackLivesMatter","rank":1}]))
+      tag = Blog::Foo.last.tags_ary_struct_json.last
+      assert_equal("#BlackLivesMatter", tag.name)
+      assert_equal(1, tag.rank)
+      assert_instance_of(Blog::Tag, tag)
+    end
+    it 'deserializes yaml array of tags to structs' do
+      Blog::UnserializedFoo.create!(tags_ary_struct_yaml: %Q(---\n- name: "#BlackLivesMatter"\n  rank: 1\n))
+      tag = Blog::Foo.last.tags_ary_struct_yaml.last
+      assert_equal("#BlackLivesMatter", tag.name)
+      assert_equal(1, tag.rank)
+      assert_instance_of(Blog::Tag, tag)
+    end
+    it 'deserializes json array of tags to structs (tags_ary_struct_inst_json)' do
+      Blog::UnserializedFoo.create!(tags_ary_struct_inst_json: %q([{"name":"#BlackLivesMatter","rank":1}]))
+      tag = Blog::Foo.last.tags_ary_struct_inst_json.last
+      assert_equal("#BlackLivesMatter", tag.name)
+      assert_equal(1, tag.rank)
+      assert_instance_of(Blog::Tag, tag)
+    end
+    it 'deserializes yaml array of tags to structs (tags_ary_struct_inst_yaml)' do
+      Blog::UnserializedFoo.create!(tags_ary_struct_inst_yaml: %Q(---\n- name: "#BlackLivesMatter"\n  rank: 1\n))
+      tag = Blog::Foo.last.tags_ary_struct_inst_yaml.last
+      assert_equal("#BlackLivesMatter", tag.name)
+      assert_equal(1, tag.rank)
+      assert_instance_of(Blog::Tag, tag)
+    end
+    it 'newest_tag' do
+      Blog::UnserializedFoo.create!(newest_tag: %Q({"name":"#arms","rank":5280}))
+      foo = Blog::Foo.last
+      assert_equal("#arms", foo.newest_tag.name)
+      assert_equal(5280, foo.newest_tag.rank)
+      assert_instance_of(Blog::Tag, foo.newest_tag)
+    end
+  end
+  describe 'serializing to structs' do
+    it 'deserializes json array of tags to structs' do
+      Blog::Foo.create!(tags_ary_struct_json: [Blog::Tag.new('#BlackLivesMatter', 1)])
+      assert_equal(%q([{"name":"#BlackLivesMatter","rank":1}]), Blog::UnserializedFoo.last.tags_ary_struct_json)
+    end
+    it 'deserializes yaml array of tags to structs' do
+      Blog::Foo.create!(tags_ary_struct_yaml: [Blog::Tag.new('#BlackLivesMatter', 1)])
+      assert_equal(%Q(---\n- name: "#BlackLivesMatter"\n  rank: 1\n), Blog::UnserializedFoo.last.tags_ary_struct_yaml)
+    end
+    it 'deserializes json array of tags to structs (tags_ary_struct_inst_json)' do
+      Blog::Foo.create!(tags_ary_struct_inst_json: [Blog::Tag.new('#BlackLivesMatter', 1)])
+      assert_equal(%q([{"name":"#BlackLivesMatter","rank":1}]), Blog::UnserializedFoo.last.tags_ary_struct_inst_json)
+    end
+    it 'deserializes yaml array of tags to structs (tags_ary_struct_inst_yaml)' do
+      Blog::Foo.create!(tags_ary_struct_inst_yaml: [Blog::Tag.new('#BlackLivesMatter', 1)])
+      assert_equal(%Q(---\n- name: "#BlackLivesMatter"\n  rank: 1\n), Blog::UnserializedFoo.last.tags_ary_struct_inst_yaml)
+    end
+    it 'newest_tag' do
+      Blog::Foo.create!(newest_tag: Blog::Tag.new('#arms', 5280))
+      assert_equal(%Q({"name":"#arms","rank":5280}), Blog::UnserializedFoo.last.newest_tag)
+    end
+  end
+  describe 'incorrect invocation' do
+    it 'raises when trying to pass arguments to a coder that is not a shortcut' do
+      err = assert_raises(ARMS::InvalidCoder) { Blog::Foo.arms_serialize('x', [ARMS::IndifferentHashesCoder.new, 3]) }
+      assert_match(%r(given shortcut arguments are not passed to the coder at index 0 which responds to #load and #dump\. coder: #<ARMS::IndifferentHashesCoder.*>; shortcut args: \[3\]), err.message)
+    end
+    it 'raises when given a coder that is not a coder' do
+      err = assert_raises(ARMS::InvalidCoder) { Blog::Foo.arms_serialize('x', "jsonify this pls") }
+      assert_equal("given coder at index 0 is not a recognized shortcut and does not respond to #load and #dump. coder: \"jsonify this pls\"; shortcut args: nil", err.message)
+    end
+  end
+end

data/test/blog_models.rb

@@ -0,0 +1,56 @@
+require 'logger'
+module Blog
+  logpath = Pathname.new('log/test.log')
+  FileUtils.mkdir_p(logpath.dirname)
+  -> (logger) { define_singleton_method(:logger) { logger } }.(::Logger.new(logpath))
+  logger.level = ::Logger::INFO
+end
+
+require 'active_record'
+ActiveRecord::Base.logger = Blog.logger
+dbpath = Pathname.new('tmp/blog.sqlite3')
+FileUtils.mkdir_p(dbpath.dirname)
+dbpath.unlink if dbpath.exist?
+ActiveRecord::Base.establish_connection({
+  :adapter => "sqlite3",
+  :database  => dbpath,
+})
+
+ActiveRecord::Schema.define do
+  create_table :foos do |table|
+    table.column :tags_const_json, :string
+    table.column :tags_const_yaml, :string
+    table.column :tags_sym_json, :string
+    table.column :tags_sym_yaml, :string
+    table.column :tags_indifferent_json, :string
+    table.column :tags_indifferent_yaml, :string
+    table.column :tags_const_indifferent_json, :string
+    table.column :tags_ary_struct_json, :string
+    table.column :tags_ary_struct_yaml, :string
+    table.column :tags_ary_struct_inst_json, :string
+    table.column :tags_ary_struct_inst_yaml, :string
+    table.column :newest_tag, :string
+  end
+end
+
+module Blog
+  Tag = Struct.new(:name, :rank)
+
+  class Foo < ActiveRecord::Base
+    arms_serialize :tags_const_json, JSON
+    arms_serialize :tags_const_yaml, YAML
+    arms_serialize :tags_sym_json, :json
+    arms_serialize :tags_sym_yaml, :yaml
+    arms_serialize :tags_indifferent_json, :indifferent_hashes, :json
+    arms_serialize :tags_indifferent_yaml, :indifferent_hashes, :yaml
+    arms_serialize :tags_const_indifferent_json, ARMS::IndifferentHashesCoder.new, JSON
+    arms_serialize :tags_ary_struct_json, [:struct, Blog::Tag, array: true], :json
+    arms_serialize :tags_ary_struct_yaml, [:struct, Blog::Tag, array: true], :yaml
+    arms_serialize :tags_ary_struct_inst_json, ARMS::StructCoder.new(Blog::Tag, array: true), :json
+    arms_serialize :tags_ary_struct_inst_yaml, ARMS::StructCoder.new(Blog::Tag, array: true), :yaml
+    arms_serialize :newest_tag, [:struct, Blog::Tag], :json
+  end
+  class UnserializedFoo < ActiveRecord::Base
+    self.table_name = 'foos'
+  end
+end

data/test/struct_coder_test.rb

@@ -0,0 +1,69 @@
+require_relative 'test_helper'
+
+describe ARMS::StructCoder do
+  let(:struct) { Struct.new(:foo, :bar) }
+  let(:options) { {} }
+  let(:struct_coder) { ARMS::StructCoder.new(struct, options) }
+  describe 'json' do
+    describe 'load' do
+      it 'loads nil' do
+        assert_nil(struct_coder.load(nil))
+      end
+      it 'loads a hash' do
+        assert_equal(struct.new('bar'), struct_coder.load({"foo" => "bar"}))
+      end
+      it 'loads something else' do
+        assert_raises(ARMS::LoadError) do
+          struct_coder.load([[]])
+        end
+      end
+      it 'loads unrecognized keys' do
+        assert_raises(ARMS::LoadError) do
+          struct_coder.load({"uhoh" => "spaghettio"})
+        end
+      end
+      describe 'array' do
+        let(:options) { {array: true} }
+        it 'loads an array of hashes' do
+          data = [{"foo" => "bar"}, {"foo" => "baz"}]
+          assert_equal([struct.new('bar'), struct.new('baz')], struct_coder.load(data))
+        end
+        it 'loads an empty array' do
+          assert_equal([], struct_coder.load([]))
+        end
+        it 'does not load what is not an array of structs' do
+          assert_raises(ARMS::LoadError) { struct_coder.load({"foo" => "bar"}) }
+        end
+      end
+    end
+    describe 'dump' do
+      it 'dumps nil' do
+        assert_nil(struct_coder.dump(nil))
+      end
+      it 'dumps a struct' do
+        assert_equal({"foo" => "x", "bar" => "y"}, struct_coder.dump(struct.new('x', 'y')))
+      end
+      it 'dumps something else' do
+        assert_raises(TypeError) do
+          struct_coder.dump(Object.new)
+        end
+      end
+      it 'dumps all the keys of a struct after loading in a partial one' do
+        struct = struct_coder.load({'foo' => 'who'})
+        assert_equal({'foo' => 'who', 'bar' => nil}, struct_coder.dump(struct))
+        struct.bar = 'whar'
+        assert_equal({'foo' => 'who', 'bar' => 'whar'}, struct_coder.dump(struct))
+      end
+      describe 'array' do
+        let(:options) { {array: true} }
+        it 'dumps an array of structs' do
+          structs = [struct.new('x', 'y'), struct.new('z', 'q')]
+          assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], struct_coder.dump(structs))
+        end
+        it 'does not dump what is not an array of structs' do
+          assert_raises(ARMS::DumpError) { struct_coder.dump(struct.new('z', 'q')) }
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+proc { |p| $:.unshift(p) unless $:.any? { |lp| File.expand_path(lp) == p } }.call(File.expand_path('../lib', File.dirname(__FILE__)))
+
+require 'coveralls'
+if Coveralls.will_run?
+  Coveralls.wear!
+end
+
+require 'simplecov'
+require 'byebug'
+
+# NO EXPECTATIONS
+ENV["MT_NO_EXPECTATIONS"] = ''
+
+require 'minitest/autorun'
+require 'minitest/reporters'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+class ARMSSpec < Minitest::Spec
+end
+
+# register this to be the base class for specs instead of Minitest::Spec
+Minitest::Spec.register_spec_type(//, ARMSSpec)
+
+require 'arms'
+require_relative 'blog_models'

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: arms
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre.rc1
+platform: ruby
+authors:
+- Ethan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+description: A library which offers flexible, chained serializion for Active Record
+email:
+- ethan@unth.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".simplecov"
+- ".yardopts"
+- LICENSE.txt
+- README.md
+- Rakefile.rb
+- arms.gemspec
+- lib/arms.rb
+- lib/arms/indifferent_hashes_coder.rb
+- lib/arms/multi_coder.rb
+- lib/arms/struct_coder.rb
+- lib/arms/version.rb
+- test/arms_test.rb
+- test/blog_models.rb
+- test/struct_coder_test.rb
+- test/test_helper.rb
+homepage: https://github.com/notEthan/arms
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Active Record Multiple Serialization
+test_files:
+- test/arms_test.rb
+- test/blog_models.rb
+- test/struct_coder_test.rb
+- test/test_helper.rb
+- ".simplecov"