Hashie::Extensions::Persistable

lib/hashie.rb

@@ -13,6 +13,7 @@ module Extensions
     autoload :DeepMerge,         'hashie/extensions/deep_merge'
     autoload :IgnoreUndeclared,  'hashie/extensions/ignore_undeclared'
     autoload :IndifferentAccess, 'hashie/extensions/indifferent_access'
+    autoload :HashInitializer,  'hashie/extensions/hash_initializer'
     autoload :MergeInitializer,  'hashie/extensions/merge_initializer'
     autoload :MethodAccess,      'hashie/extensions/method_access'
     autoload :MethodQuery,       'hashie/extensions/method_access'
@@ -25,6 +26,7 @@ module Extensions
     autoload :PrettyInspect,     'hashie/extensions/pretty_inspect'
     autoload :KeyConversion,     'hashie/extensions/key_conversion'
     autoload :MethodAccessWithOverride, 'hashie/extensions/method_access'
+    autoload :Persistable,       'hashie/extensions/persistable'
 
     module Parsers
       autoload :YamlErbParser, 'hashie/extensions/parsers/yaml_erb_parser'

lib/hashie/extensions/hash_initializer.rb

@@ -0,0 +1,24 @@
+module Hashie
+  module Extensions
+    # Marker module to indicate has a single-argument hash constructor.
+    module HashInitializer
+    end
+
+    # Doesn't work...
+    # module MergeInitializer
+    # include HashInitializer
+    # end
+  end
+
+  class Hash
+    # Not unless MergeInititalizer is included
+  end
+
+  class Mash
+    include Extensions::HashInitializer
+  end
+
+  class Dash
+    include Extensions::HashInitializer
+  end
+end

lib/hashie/extensions/persistable.rb

@@ -0,0 +1,38 @@
+  module Hashie
+    module Extensions
+      module Persistable
+        CANNOT_INCLUDE = 'Peristable can only be used on classes with Hashie::Extensions::HashInitializer'
+        CANNOT_SAVE = 'Cannot save unless persistable_file is set or the target file is passed as a parameter'
+
+        module ClassMethods
+          def load(file)
+            new(YAML.load(File.read(file))).tap do |h|
+              h.persistable_file = file
+            end
+          end
+        end
+
+        def self.included(base)
+          # Can only include into classes with a hash initializer
+          fail ArgumentError, CANNOT_INCLUDE unless
+            base.include?(Hashie::Extensions::HashInitializer) ||
+            base.include?(Hashie::Extensions::MergeInitializer)
+          base.extend ClassMethods
+          super
+        end
+
+        def save(file = nil)
+          self.persistable_file = file unless file.nil?
+          fail ArgumentError, CANNOT_SAVE if persistable_file.nil?
+          File.write(persistable_file, YAML.dump(self))
+          persistable_file
+        end
+
+        def persistable_file=(file)
+          @persistable_file = Pathname(file)
+        end
+
+        attr_reader :persistable_file
+      end
+    end
+  end

spec/fixtures/persistable/hello_world.yaml

@@ -0,0 +1,3 @@
+---
+foo: bar
+msg: Hello, world!

spec/hashie/extensions/persistable_spec.rb

@@ -0,0 +1,101 @@
+require 'tempfile'
+
+module Hashie
+  module Extensions
+    RSpec.describe Persistable do
+      shared_examples 'loads YAML' do | test_class |
+        describe '.load' do
+          subject(:hash) { test_class.load('spec/fixtures/persistable/hello_world.yaml') }
+          it 'instantiates a instance from a YAML file' do
+            expect(hash).to be_a_kind_of ::Hash
+            expect(hash).to eq(
+              'foo' => 'bar',
+              'msg' => 'Hello, world!'
+            )
+          end
+
+          it 'remembers the filename' do
+            expect(hash.persistable_file).to eq(Pathname('spec/fixtures/persistable/hello_world.yaml'))
+          end
+        end
+      end
+
+      shared_examples 'saves YAML' do | test_class |
+        describe '#save' do
+          let(:obj) do
+            test_class.new(
+              'foo' => 'bar!',
+              'msg' => 'saved!'
+            )
+          end
+
+          it 'raises an error if persistable_file is not set' do
+            expect { obj.save }.to raise_error(ArgumentError, /cannot save unless persistable_file is set/i)
+          end
+
+          it 'saves to persistable_file' do
+            tmpfile = Tempfile.new(['hash', '.yaml'])
+            obj.persistable_file = tmpfile
+            expect(obj.save).to eq(Pathname(tmpfile))
+            expect(test_class.load(tmpfile)).to eq(obj)
+          end
+
+          it 'changes and saves to persistable_file (passed as an argument)' do
+            tmpfile = Tempfile.new(['hash', '.yaml'])
+            expect(obj.save(tmpfile)).to eq(Pathname(tmpfile))
+            expect(obj.persistable_file).to eq(Pathname(tmpfile))
+            expect(test_class.load(tmpfile)).to eq(obj)
+          end
+        end
+
+        describe '#[]=' do
+          context 'with autosave enabled'
+          pending 'autosaves'
+          context 'without autosave enabled' do
+            pending 'does not autosave'
+          end
+        end
+      end
+
+      context 'with Hash' do
+        class MyHash < ::Hash
+          include Hashie::Extensions::MergeInitializer
+          include Hashie::Extensions::Persistable
+        end
+
+        include_examples 'loads YAML', MyHash
+        include_examples 'saves YAML', MyHash
+      end
+
+      context 'with Hashie::Hash' do
+        class MyHashieHash < Hashie::Hash
+          include Hashie::Extensions::MergeInitializer
+          include Hashie::Extensions::Persistable
+        end
+
+        include_examples 'loads YAML', MyHashieHash
+        include_examples 'saves YAML', MyHashieHash
+      end
+
+      context 'with Hashie::Mash' do
+        class MyHashieMash < Hashie::Mash
+          include Hashie::Extensions::Persistable
+        end
+
+        include_examples 'loads YAML', MyHashieMash
+        include_examples 'saves YAML', MyHashieMash
+      end
+
+      context 'with Hashie::Dash' do
+        class MyHashieDash < Hashie::Dash
+          include Hashie::Extensions::Persistable
+          property 'foo'
+          property 'msg'
+        end
+
+        include_examples 'loads YAML', MyHashieDash
+        include_examples 'saves YAML', MyHashieDash
+      end
+    end
+  end
+end