ar_doc_store 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2438ac2cf9e760f9b289db586f62688dec2eb781
+  data.tar.gz: 19817b74ce307e2e7315f93edc8d0fe40f351e6e
+SHA512:
+  metadata.gz: e760c26792d8ef0b527ad0354ed8f27ba793097131d41fa412f68c7e7f713f3394d4ae66e0a395275e0ba7cf270ba3749d72b46944a008d25fe2aa70b478216c
+  data.tar.gz: 23bc9fe56773dc79d6d70c2149c6fc39f1683b5db7efac20250569742de644c967397d8ece268119a56f09f7deceddad8c30128e935462f809bfafe9be038047

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ar_doc_store.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 David Furber
+
+MIT License
+
+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,31 @@
+# ArDocStore
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ar_doc_store'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ar_doc_store
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/ar_doc_store/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/*_test.rb"
+end

data/ar_doc_store.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ar_doc_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ar_doc_store"
+  spec.version       = ArDocStore::VERSION
+  spec.authors       = ["David Furber"]
+  spec.email         = ["dfurber@gorges.us"]
+  spec.summary       = %q{A document storage gem meant for ActiveRecord PostgresQL JSON storage.}
+  spec.description   = %q{Provides an easy way to do something that is possible in Rails but still a bit close to the metal using store_accessor: create typecasted, persistent attributes that are not columns in the database but stored in the JSON "data" column. Also supports infinite nesting of embedded models.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 4.0"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/ar_doc_store.rb

@@ -0,0 +1,29 @@
+require "ar_doc_store/version"
+require "ar_doc_store/storage"
+require "ar_doc_store/embedding/embeds_one"
+require "ar_doc_store/embedding/embeds_many"
+require "ar_doc_store/embedding/core"
+require "ar_doc_store/embedding"
+require "ar_doc_store/model"
+require "ar_doc_store/embeddable_model"
+require "ar_doc_store/attribute_types/base"
+require "ar_doc_store/attribute_types/array"
+require "ar_doc_store/attribute_types/boolean"
+require "ar_doc_store/attribute_types/enumeration"
+require "ar_doc_store/attribute_types/float"
+require "ar_doc_store/attribute_types/integer"
+require "ar_doc_store/attribute_types/string"
+
+module ArDocStore
+  @mappings = Hash.new
+  @mappings[:array]       = 'ArDocStore::AttributeTypes::ArrayAttribute'
+  @mappings[:boolean]     = 'ArDocStore::AttributeTypes::BooleanAttribute'
+  @mappings[:enumeration] = 'ArDocStore::AttributeTypes::EnumerationAttribute'
+  @mappings[:float]       = 'ArDocStore::AttributeTypes::FloatAttribute'
+  @mappings[:integer]     = 'ArDocStore::AttributeTypes::IntegerAttribute'
+  @mappings[:string]      = 'ArDocStore::AttributeTypes::StringAttribute'
+  
+  def self.mappings
+    @mappings
+  end
+end

data/lib/ar_doc_store/attribute_types/array.rb

@@ -0,0 +1,17 @@
+module ArDocStore
+  module AttributeTypes
+    
+    class ArrayAttribute < Base
+      def conversion
+        :to_a
+      end
+
+      def predicate
+        'text'
+      end
+
+    end
+
+  end
+end
+

data/lib/ar_doc_store/attribute_types/base.rb

@@ -0,0 +1,20 @@
+module ArDocStore
+  module AttributeTypes
+    class Base
+      attr_accessor :conversion, :predicate, :options, :model, :attribute
+
+      def self.build(model, attribute, options={})
+        new(model, attribute, options).build
+      end
+
+      def initialize(model, attribute, options)
+        @model, @attribute, @options = model, attribute, options
+      end
+
+      def build
+        model.store_attributes conversion, predicate, attribute
+      end
+    end
+
+  end
+end

data/lib/ar_doc_store/attribute_types/boolean.rb

@@ -0,0 +1,24 @@
+module ArDocStore
+  module AttributeTypes
+
+    class BooleanAttribute < Base
+      def build
+        key = attribute.to_sym
+        model.class_eval do
+          store_accessor :data, key
+          # define_method key, -> { item = super(); item && item == true }
+          define_method "#{key}?".to_sym, -> { !!key }
+          define_method "#{key}=".to_sym, -> (value) {
+            res = nil
+            res = true if value == 'true' || value == true || value == '1' || value == 1
+            res = false if value == 'false' || value == false || value == '0' || value == 0
+            write_store_attribute(:data, key, res)
+            data_will_change!
+          }
+          add_ransacker(key, 'bool')
+        end
+      end
+    end
+
+  end
+end

data/lib/ar_doc_store/attribute_types/enumeration.rb

@@ -0,0 +1,37 @@
+module ArDocStore
+  module AttributeTypes
+
+    class EnumerationAttribute < Base
+      
+      def build
+        key = attribute.to_sym
+        dictionary = options[:values]
+        multiple = options[:multiple]
+        strict = options[:strict]
+        model.class_eval do
+          
+          if multiple
+            attribute key, as: :array
+            if strict
+              define_method "validate_#{key}" do
+                value = public_send(key)
+                errors.add(key, :invalid) if value.is_a?(Array) && value.present? && value.reject(&:blank?).detect {|d| !dictionary.include?(d)}
+              end
+              validate "validate_#{key}".to_sym
+            end
+            # TODO should we do anything for strict option?
+          else
+            attribute key, as: :string
+            if strict
+              validates_inclusion_of key, in: dictionary, allow_blank: true
+            end
+          end
+          define_singleton_method "#{key}_choices" do
+            dictionary
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ar_doc_store/attribute_types/float.rb

@@ -0,0 +1,15 @@
+module ArDocStore
+  module AttributeTypes
+
+    class FloatAttribute < Base
+      def conversion
+        :to_f
+      end
+
+      def predicate
+        'float'
+      end
+    end
+
+  end
+end

data/lib/ar_doc_store/attribute_types/integer.rb

@@ -0,0 +1,15 @@
+module ArDocStore
+  module AttributeTypes
+
+    class IntegerAttribute < Base
+      def conversion
+        :to_i
+      end
+
+      def predicate
+        'int'
+      end
+    end
+
+  end
+end

data/lib/ar_doc_store/attribute_types/string.rb

@@ -0,0 +1,17 @@
+module ArDocStore
+  module AttributeTypes
+    
+    class StringAttribute < Base
+      def conversion
+        :to_s
+      end
+
+      def predicate
+        'text'
+      end
+
+    end
+
+  end
+end
+

data/lib/ar_doc_store/embeddable_model.rb

@@ -0,0 +1,84 @@
+module ArDocStore
+
+  module EmbeddableModel
+
+    def self.included(mod)
+
+      mod.send :include, ArDocStore::Storage
+      mod.send :include, ArDocStore::Embedding
+      mod.send :include, InstanceMethods
+      mod.send :extend, ClassMethods
+      mod.send :include, ActiveModel::AttributeMethods
+      mod.send :include, ActiveModel::Validations
+      mod.send :include, ActiveModel::Conversion
+      mod.send :extend,  ActiveModel::Naming
+      mod.send :include, ActiveModel::Dirty
+      mod.send :include, ActiveModel::Serialization
+
+      mod.class_eval do
+        attr_accessor :_destroy
+        attr_accessor :attributes
+
+        @virtual_attributes = HashWithIndifferentAccess.new
+
+        def self.virtual_attributes; @virtual_attributes; end
+        def self.virtual_attributes=(value); @virtual_attributes=value; end
+        def virtual_attributes; self.class.virtual_attributes || HashWithIndifferentAccess.new; end
+
+        delegate :as_json, to: :attributes
+
+      end
+    end
+    
+    module InstanceMethods
+      
+      def initialize(attrs={})
+        attrs ||= {}
+        @attributes = HashWithIndifferentAccess.new
+        attrs.each { |key, value|
+          key = "#{key}=".to_sym
+          self.public_send(key, value) if methods.include?(key)
+        }
+        virtual_attributes.keys.each do |attr|
+          @attributes[attr] ||= nil
+        end
+      end
+
+      def persisted?
+        false
+      end
+
+      def inspect
+        "#{self.class}: #{attributes.inspect}"
+      end
+
+      def read_store_attribute(store, key)
+        @attributes[key]
+      end
+
+      def write_store_attribute(store, key, value)
+        changed_attributes[key] = read_store_attribute(:data, key)
+        @attributes[key] = value
+      end
+
+      def data_will_change!
+        true
+      end
+      
+    end
+    
+    module ClassMethods
+      
+      def store_accessor(store, key)
+        self.virtual_attributes ||= HashWithIndifferentAccess.new
+        virtual_attributes[key] = true
+        key = key.to_sym
+        define_method key, -> { read_store_attribute(:data, key) }
+        define_method "#{key}=".to_sym, -> (value) { write_store_attribute :data, key, value }
+      end
+            
+    end
+
+  end
+end
+

data/lib/ar_doc_store/embedding.rb

@@ -0,0 +1,7 @@
+module ArDocStore
+  module Embedding
+    def self.included(base)
+      base.send :include, Core
+    end
+  end
+end

data/lib/ar_doc_store/embedding/core.rb

@@ -0,0 +1,30 @@
+module ArDocStore
+  module Embedding
+      module Core
+
+      def self.included(mod)
+        mod.send :include, EmbedsOne
+        mod.send :include, EmbedsMany
+        mod.send :include, InstanceMethods
+      end
+    
+      module InstanceMethods
+      
+        # Returns whether or not the association is valid and applies any errors to
+        # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
+        # enabled records if they're marked_for_destruction? or destroyed.
+        def embed_valid?(assn_name, record)
+          unless valid = record.valid?
+            record.errors.each do |attribute, message|
+              attribute = "#{assn_name}.#{attribute}"
+              errors[attribute] << message
+              errors[attribute].uniq!
+            end
+          end
+          valid
+        end
+
+      end
+    end
+  end
+end

data/lib/ar_doc_store/embedding/embeds_many.rb

@@ -0,0 +1,95 @@
+module ArDocStore
+  module Embedding
+      module EmbedsMany
+
+        def self.included(base)
+          base.send :extend, ClassMethods
+          base.send :include, InstanceMethods
+        end
+        
+        module InstanceMethods
+          # Validate the embedded records
+          def validate_embeds_many(assn_name)
+            if records = public_send(assn_name)
+              records.each { |record| embed_valid?(assn_name, record) }
+            end
+          end
+
+        end
+    
+        module ClassMethods
+
+          def embeds_many(assn_name, *args)
+            store_accessor :data, assn_name
+            options = args.extract_options!
+            class_name = options[:class_name] || assn_name.to_s.classify
+            create_embeds_many_accessors(assn_name, class_name)
+            create_embed_many_attributes_method(assn_name)
+            create_embeds_many_validation(assn_name)
+          end
+
+          private
+
+          def create_embeds_many_accessors(assn_name, class_name)
+            define_method assn_name.to_sym, -> {
+              ivar = "@#{assn_name}"
+              existing = instance_variable_get(ivar)
+              return existing if existing
+              my_class_name = class_name.constantize
+              items = read_store_attribute(:data, assn_name)
+              if items.present? && items.first.respond_to?(:keys)
+                items = items.map { |item| my_class_name.new(item) }
+              end
+              items ||= []
+              instance_variable_set ivar, (items)
+              items
+            }
+            define_method "#{assn_name}=".to_sym, -> (values) {
+              if values
+                items = values.map { |item|
+                  my_class_name = class_name.constantize
+                  item.is_a?(my_class_name) ? item : my_class_name.new(item)
+                }
+              else
+                items = []
+              end
+              instance_variable_set "@#{assn_name}", write_store_attribute(:data, assn_name, items)
+              # data_will_change!
+            }
+            define_method "build_#{assn_name.to_s.singularize}", -> (attributes=nil) {
+              assns = self.public_send assn_name
+              item = class_name.constantize.new attributes
+              assns << item
+              public_send "#{assn_name}=", assns
+              item
+            }
+
+            define_method "ensure_#{assn_name.to_s.singularize}", -> {
+              public_send "build_#{assn_name.to_s.singularize}" if self.public_send(assn_name).blank?
+            }
+            # TODO: alias here instead of show the same code twice?
+            define_method "ensure_#{assn_name}", -> {
+              public_send "build_#{assn_name.to_s.singularize}" if self.public_send(assn_name).blank?
+            }
+          end
+
+          def create_embed_many_attributes_method(assn_name)
+            define_method "#{assn_name}_attributes=", -> (values) {
+              data_will_change!
+              values = values.andand.values || []
+              values = values.reject { |item| item['_destroy'] == '1' }
+              public_send "#{assn_name}=", values
+            }
+          end
+
+          def create_embeds_many_validation(assn_name)
+            validate_method = "validate_embedded_record_for_#{assn_name}"
+            define_method validate_method, -> { validate_embeds_many assn_name }
+            validate validate_method
+          end
+
+        end
+    
+    end
+  end
+end

data/lib/ar_doc_store/embedding/embeds_one.rb

@@ -0,0 +1,67 @@
+module ArDocStore
+  module Embedding
+    module EmbedsOne
+      
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.send :include, InstanceMethods
+      end
+    
+      module InstanceMethods
+      
+        def validate_embeds_one(assn_name)
+          record = public_send(assn_name)
+          embed_valid?(assn_name, record) if record
+        end
+
+      end
+    
+      module ClassMethods
+
+        def embeds_one(assn_name, *args)
+          store_accessor :data, assn_name
+          options = args.extract_options!
+          class_name = options[:class_name] || assn_name.to_s.classify
+          store_attribute_from_class class_name, assn_name
+          create_embed_one_attributes_method(assn_name)
+          create_embeds_one_accessors assn_name, class_name
+          create_embeds_one_validation(assn_name)
+        end
+
+        private
+
+        def create_embeds_one_accessors(assn_name, class_name)
+          define_method "build_#{assn_name}", -> (attributes=nil) {
+            class_name = class_name.constantize if class_name.respond_to?(:constantize)
+            public_send "#{assn_name}=", class_name.new(attributes)
+            public_send assn_name
+          }
+          define_method "ensure_#{assn_name}", -> {
+            public_send "build_#{assn_name}" if public_send(assn_name).blank?
+          }
+        end
+
+        def create_embed_one_attributes_method(assn_name)
+          define_method "#{assn_name}_attributes=", -> (values) {
+            # data_will_change!
+            values ||= {}
+            values.symbolize_keys! if values.respond_to?(:symbolize_keys!)
+            if values[:_destroy] && (values[:_destroy] == '1')
+              self.public_send "#{assn_name}=", nil
+            else
+              public_send "#{assn_name}=", values
+            end              
+          }
+        end
+
+        def create_embeds_one_validation(assn_name)
+          validate_method = "validate_embedded_record_for_#{assn_name}"
+          define_method validate_method, -> { validate_embeds_one assn_name }
+          validate validate_method
+        end
+
+      end
+    
+    end
+  end
+end

data/lib/ar_doc_store/model.rb

@@ -0,0 +1,11 @@
+module ArDocStore
+  
+  module Model
+    
+    def self.included(mod)
+      mod.send :include, ArDocStore::Storage
+      mod.send :include, ArDocStore::Embedding
+    end
+    
+  end
+end

data/lib/ar_doc_store/storage.rb

@@ -0,0 +1,150 @@
+module ArDocStore
+  module Storage
+    
+    def self.included(mod)
+      mod.send :include, InstanceMethods
+      mod.send :extend, ClassMethods
+    end
+    
+    module InstanceMethods
+      
+      def write_attribute(name, value)
+        if is_stored_attribute?(name)
+          write_store_attribute :data, attribute_name_from_foreign_key(name), value
+        else
+          super
+        end
+      end
+
+      def read_attribute(name)
+        if is_stored_attribute?(name)
+          read_store_attribute :data, attribute_name_from_foreign_key(name)
+        else
+          super
+        end
+      end
+      
+      private
+      
+      def is_stored_attribute?(name)
+        name = name.to_sym
+        is_store_accessor_method?(name) || name =~ /data\-\>\>/
+      end
+
+      def is_store_accessor_method?(name)
+        name = name.to_sym
+        self.class.stored_attributes[:data] && self.class.stored_attributes[:data].include?(name)
+      end
+
+      def attribute_name_from_foreign_key(name)
+        is_store_accessor_method?(name) ? name : name.match(/\'(\w+)\'/)[0].gsub("'", '')
+      end
+      
+    end
+    
+    module ClassMethods
+      
+      def attribute(name, *args)
+        type = args.shift if args.first.is_a?(Symbol)
+        options = args.extract_options!
+        type ||= options.delete(:as) || :string
+        class_name = ArDocStore.mappings[type]
+        unless const_defined?(class_name)
+          raise "Invalid attribute type: #{name}"
+        end
+        class_name = class_name.constantize
+        class_name.build self, name, options
+      end
+
+      def add_ransacker(key, predicate = nil)
+        return unless respond_to?(:ransacker)
+        ransacker key do
+          sql = "(data->>'#{key}')"
+          if predicate
+            sql = "#{sql}::#{predicate}"
+          end
+          Arel.sql(sql)
+        end
+      end
+
+      def store_attributes(typecast_method, predicate=nil, attributes=[])
+        attributes = [attributes] unless attributes.respond_to?(:each)
+        attributes.each do |key|
+          store_accessor :data, key
+          add_ransacker(key, predicate)
+          if typecast_method.is_a?(Symbol)
+            store_attribute_from_symbol typecast_method, key
+          else
+            store_attribute_from_class typecast_method, key
+          end
+        end
+      end
+
+      def store_attribute_from_symbol(typecast_method, key)
+        define_method key.to_sym, -> { 
+          value = read_store_attribute(:data, key)
+          value.public_send(typecast_method) if value
+        }
+        define_method "#{key}=".to_sym, -> (value) {
+          # data_will_change! if @initalized
+          write_store_attribute(:data, key, value.public_send(typecast_method))
+        }
+      end
+
+      def store_attribute_from_class(class_name, key)
+        define_method key.to_sym, -> {
+          ivar = "@#{key}"
+          existing = instance_variable_get ivar
+          existing || begin
+            item = read_store_attribute(:data, key)
+            class_name = class_name.constantize if class_name.respond_to?(:constantize)
+            item = class_name.new(item) unless item.is_a?(class_name)
+            instance_variable_set ivar, item
+            item
+          end
+        }
+        define_method "#{key}=".to_sym, -> (value) {
+          ivar = "@#{key}"
+          class_name = class_name.constantize if class_name.respond_to?(:constantize)
+          value = class_name.new(value) unless value.is_a?(class_name)
+          instance_variable_set ivar, value
+          write_store_attribute :data, key, value
+          # data_will_change! if @initialized
+        }
+      end
+
+      def string_attributes(*args)
+        args.each do |arg|
+          attribute arg, as: :string
+        end
+      end
+
+      def float_attributes(*args)
+        args.each do |arg|
+          attribute arg, as: :float
+        end
+      end
+
+      def integer_attributes(*args)
+        args.each do |arg|
+          attribute arg, as: :integer
+        end
+      end
+
+      def boolean_attributes(*args)
+        args.each do |arg|
+          attribute arg, as: :boolean
+        end
+      end
+      
+      def enumerates(field, *args)
+        options = args.extract_options!
+        options[:as] = :enumeration
+        attribute field, options
+      end
+
+    
+    end
+    
+  end
+end

data/lib/ar_doc_store/version.rb

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

data/test/embedded_model_attribute_test.rb

@@ -0,0 +1,23 @@
+require_relative './test_helper'
+
+class EmbeddedModelAttributeTest < MiniTest::Test
+  
+  def test_can_set_attribute_on_embedded_model_init
+    b = Route.new route_surface: 'test'
+    assert_equal 'test', b.route_surface
+  end
+  
+  def test_can_set_attribute_on_existing_embedded_model
+    b = Route.new
+    b.route_surface = 'test'
+    assert_equal 'test', b.route_surface
+  end
+  
+  def test_can_set_enumeration_created_with_enumerates
+    door = Door.new
+    door.door_type = %w{sliding push}
+    assert_equal %w{sliding push}, door.door_type
+  end
+
+end
+

data/test/embedding_test.rb

@@ -0,0 +1,33 @@
+require_relative './test_helper'
+
+class EmbeddingTest < MiniTest::Test
+  
+  def test_can_build_embedded_model
+    restroom = Restroom.new
+    door = restroom.build_door
+    assert door.is_a?(Door)
+  end
+  
+  def test_ensure_door_returns_existing_door
+    restroom = Restroom.new
+    restroom.build_door
+    restroom.door.open_handle = %w{knob}
+    restroom.ensure_door
+    assert_equal %w{knob}, restroom.door.open_handle
+  end
+  
+  def test_attributes_equals_sets_attributes
+    restroom = Restroom.new door_attributes: { clear_distance: 5, opening_force: 13, clear_space: 43 }
+    assert_equal 5, restroom.door.clear_distance
+    restroom.door_attributes = { _destroy: '1' }
+    assert_nil restroom.door.clear_distance
+  end
+  
+  def test_attribute_validity_of_embedded_model_from_model
+    b = Building.new
+    r = Restroom.new
+    b.restrooms << r
+    assert !b.valid?
+  end
+  
+end

data/test/model_attribute_access_test.rb

@@ -0,0 +1,100 @@
+require_relative './test_helper'
+
+class ModelAttributeAccessTest < MiniTest::Test
+  def test_string_attribute_on_model_init
+    b = Building.new name: 'test'
+    assert_equal 'test', b.name
+  end
+
+  def test_string_attribute_on_existing_model
+    b = Building.new
+    b.name = 'test'
+    assert_equal 'test', b.name
+  end
+  
+  def test_boolean_attribute_on_model_init
+    b = Building.new finished: true
+    assert b.finished?
+  end
+  
+  def test_boolean_attribute_on_existing_model
+    b = Building.new
+    b.finished = true
+    assert b.finished?
+  end
+  
+  def test_float_attribute_on_init
+    b = Building.new height: 54.45
+    assert_equal 54.45, b.height
+  end
+  
+  def test_float_attribute_on_existing_model
+    b = Building.new
+    b.height = 54.45
+    assert_equal 54.45, b.height
+  end
+  
+  def test_int_attribute_on_init
+    b = Building.new stories: 5
+    assert_equal 5, b.stories
+  end
+  
+  def test_int_attribute_on_set
+    b = Building.new
+    b.stories = 5
+    assert_equal 5, b.stories
+  end
+  
+  def test_simple_enumeration_attribute
+    b = Building.new construction: 'wood'
+    assert_equal 'wood', b.construction
+  end
+  
+  def test_multiple_enumeration_attribute
+    b = Building.new multiconstruction: %w{wood plaster}
+    assert_equal %w{wood plaster}, b.multiconstruction
+  end
+
+  def test_strict_enumeration_attribute_invalid
+    b = Building.new strict_enumeration: 'wood'
+    b.valid?
+    assert b.errors[:strict_enumeration]
+  end
+  
+  def test_unstrict_enumeration_attribute_allows_assignment_of_choice_not_in_the_list
+    b = Building.new construction: 'plastic'
+    assert_equal 'plastic', b.construction
+    b.valid?
+    assert b.errors[:construction].empty?
+  end
+
+  def test_unstrict_multi_enumeration_attribute_allows_assignment_of_choice_not_in_the_list
+    b = Building.new multiconstruction: %w{plastic wood}
+    assert_equal %w{plastic wood}, b.multiconstruction
+    b.valid?
+    assert b.errors[:multiconstruction].empty?
+  end
+
+  def test_strict_multi_enumeration_attribute_invalid
+    b = Building.new strict_multi_enumeration: %w{good wood}
+    b.valid?
+    assert b.errors[:strict_multi_enumeration]
+  end
+
+  def test_strict_enumeration_attribute_valid
+    b = Building.new strict_enumeration: 'glad'
+    b.valid?
+    assert b.errors[:strict_enumeration].empty?
+  end
+
+  def test_strict_multi_enumeration_attribute_valid
+    b = Building.new strict_multi_enumeration: %w{glad bad}
+    b.valid?
+    assert b.errors[:strict_multi_enumeration].empty?
+  end
+  
+  def test_enumeration_has_choices_to_use_for_select
+    assert Building.construction_choices.present?
+  end
+    
+end

data/test/test_helper.rb

@@ -0,0 +1,127 @@
+gem 'activerecord'
+gem 'minitest'
+
+require 'minitest/autorun'
+require 'active_record'
+
+require_relative './../lib/ar_doc_store'
+
+# A building has many entrances and restrooms and some fields of its own
+# An entrance has a door, a route, and some fields of its own
+# A restroom has a door, a route, and some fields measuring the stalls
+# Route and door
+
+# This here is just to mock out enough AR behavior for a model to pretend to be an AR model without a database...
+class ARDuck
+  include ActiveModel::AttributeMethods
+  include ActiveModel::Validations
+  include ActiveModel::Conversion
+  extend  ActiveModel::Naming
+  include ActiveModel::Dirty
+  include ActiveModel::Serialization
+
+  attr_accessor :attributes
+
+  def initialize(attrs=nil)
+    @attributes = HashWithIndifferentAccess.new
+    return if attrs.nil?
+    attrs.each { |key, value|
+      key = "#{key}=".to_sym
+      self.public_send(key, value) if methods.include?(key)
+    }
+  end
+
+  def persisted?
+    false
+  end
+
+  def inspect
+    "#{self.class}: #{attributes.inspect}"
+  end
+
+  delegate :as_json, to: :attributes
+
+  def self.store_accessor(store, key)
+    key = key.to_sym
+    define_method key, -> { read_store_attribute(:data, key) }
+    define_method "#{key}=".to_sym, -> (value) { write_store_attribute :data, key, value }
+  end
+
+  def read_store_attribute(store, key)
+    @attributes[key]
+  end
+
+  def write_store_attribute(store, key, value)
+    changed_attributes[key] = read_store_attribute(:data, key)
+    @attributes[key] = value
+  end
+
+  def data_will_change!
+    true
+  end
+  
+end
+
+class Dimensions
+  include ArDocStore::EmbeddableModel
+  attribute :length, :float
+  attribute :width,  :float
+end
+
+class Route
+  include ArDocStore::EmbeddableModel
+  attribute :is_route_unobstructed, as: :boolean
+  attribute :is_route_lighted, as: :boolean
+  attribute :route_surface, as: :string
+  attribute :route_slope_percent, as: :integer
+  attribute :route_min_width, as: :integer
+end
+
+class Door
+  include ArDocStore::EmbeddableModel
+  enumerates :door_type, multiple: true, values: %w{single double french sliding push pull}
+  attribute :open_handle,  as: :enumeration, multiple: true, values: %w{push pull plate knob handle}
+  attribute :close_handle, as: :enumeration, multiple: true, values: %w{push pull plate knob handle}
+  attribute :clear_distance, as: :integer
+  attribute :opening_force, as: :integer
+  attribute :clear_space, as: :integer
+end
+
+class Entrance
+  include ArDocStore::EmbeddableModel
+  embeds_one :route
+  embeds_one :door
+end
+
+class Restroom
+  include ArDocStore::EmbeddableModel
+  embeds_one :route
+  embeds_one :door
+  
+  enumerates :restroom_type, values: %w{single double dirty nasty clean}
+
+  attribute :is_restroom_provided, as: :boolean
+  attribute :is_signage_clear, as: :boolean
+
+  embeds_one :stall_area_dimensions, class_name: 'Dimensions'
+  embeds_one :sink_area_dimensions, class_name: 'Dimensions'
+  
+  validates :restroom_type, presence: true
+  
+end
+
+class Building < ARDuck
+  include ArDocStore::Model
+  attribute :name, :string
+  attribute :comments, as: :string
+  attribute :finished, :boolean
+  attribute :stories, as: :integer
+  attribute :height, as: :float
+  attribute :construction, as: :enumeration, values: %w{concrete wood brick plaster steel}
+  attribute :multiconstruction, as: :enumeration, values: %w{concrete wood brick plaster steel}, multiple: true
+  attribute :strict_enumeration, as: :enumeration, values: %w{happy sad glad bad}, strict: true
+  attribute :strict_multi_enumeration, as: :enumeration, values: %w{happy sad glad bad}, multiple: true, strict: true
+  embeds_many :entrances
+  embeds_many :restrooms
+end
+

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: ar_doc_store
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Furber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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'
+description: 'Provides an easy way to do something that is possible in Rails but still
+  a bit close to the metal using store_accessor: create typecasted, persistent attributes
+  that are not columns in the database but stored in the JSON "data" column. Also
+  supports infinite nesting of embedded models.'
+email:
+- dfurber@gorges.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ar_doc_store.gemspec
+- lib/ar_doc_store.rb
+- lib/ar_doc_store/attribute_types/array.rb
+- lib/ar_doc_store/attribute_types/base.rb
+- lib/ar_doc_store/attribute_types/boolean.rb
+- lib/ar_doc_store/attribute_types/enumeration.rb
+- lib/ar_doc_store/attribute_types/float.rb
+- lib/ar_doc_store/attribute_types/integer.rb
+- lib/ar_doc_store/attribute_types/string.rb
+- lib/ar_doc_store/embeddable_model.rb
+- lib/ar_doc_store/embedding.rb
+- lib/ar_doc_store/embedding/core.rb
+- lib/ar_doc_store/embedding/embeds_many.rb
+- lib/ar_doc_store/embedding/embeds_one.rb
+- lib/ar_doc_store/model.rb
+- lib/ar_doc_store/storage.rb
+- lib/ar_doc_store/version.rb
+- test/embedded_model_attribute_test.rb
+- test/embedding_test.rb
+- test/model_attribute_access_test.rb
+- test/test_helper.rb
+homepage: ''
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A document storage gem meant for ActiveRecord PostgresQL JSON storage.
+test_files:
+- test/embedded_model_attribute_test.rb
+- test/embedding_test.rb
+- test/model_attribute_access_test.rb
+- test/test_helper.rb