json_array_serializer 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f73b57b7f55339462a957b6c76ab971c88e7dff4
-  data.tar.gz: 847e31692753ec27162889aa6b6d291b1271e0ce
+  metadata.gz: 759b6374e0d2f2f6b141dc720a08e358445a31ca
+  data.tar.gz: e129f2d357544ff607187baf39b43855665b6dd9
 SHA512:
-  metadata.gz: 086df0f1ea603ff6ceb99427091e00833a44677fac610fb334c60c24749c9619c9ae9bc81a1cd0758a8a082b1bf13d4703133fd4740d102f9282640ace9b57b8
-  data.tar.gz: 3a03198c64f3c6d2b243fe1bb056f0a30295485025bd88463515e588839496f8f92b2facb2f20f553b2d4a9628d203a16107c4305aac73de24a5cd502e780a72
+  metadata.gz: b521b7344f0f00622f628a3f293640daffbf3fae68508aabe7cc7be34cf3c26ceaf2a23422cb6ad71ef4fce5a18a6811e5af7908fca6473b571f24be90b80033
+  data.tar.gz: ece9d5e2a0c7905cb41a32f0931518d10ef9db77bbc023918b352dd989d6f04eda4afda9cc3a5c7abbb8716c4c1d462b980c4a7283e7d1c266ec6e2e419325be

data/README.md

@@ -26,22 +26,9 @@ class Foo < ActiveRecord::Base
 end
 ```
 
-Or if you want to save object with more complexity, and custom functionality, simply extend `JSONArraySerizalizer`.
+### Specifying Element Class
 
-```ruby
-# A class to hold a collection of commands.
-#
-class CommandArray < JSONArraySerizalizer
-  def perform
-    each do |command|
-      result = system(command.program)
-      raise "Error" if !result && command.raise_exception
-    end
-  end
-end
-```
-
-You can also pass in a class to load the individual JSON objects as when extending the base `JSONArraySerizalizer`.
+You can pass a class to specify the type of the arrays elements.
 
 ```ruby
 class Developer < OpenStruct
@@ -51,13 +38,68 @@ class Developer < OpenStruct
 end
 
 class Company < ActiveRecord::Base
-  serialize :developers, JSONArraySerializer.new(Developer)
+  serialize :developers, JSONArraySerializer.new(element_class: Developer)
 end
 ```
 
-The class you pass to `JSONArraySerializer.new` __must__ have the following two methods.
+The `element_class` you pass to `JSONArraySerializer.new` __must__ have the following two methods.
 
 ```
 # A.new : Hash -> A
 # a.to_h : -> Hash (where a is an instance of A)
 ```
+
+### Specifying Array Class
+
+You can pass a class to specify the type of the loaded array itself. This allows for serializing classes that act like arrays.
+
+```ruby
+class SongArray < Array
+  def play_all
+    each do |song|
+      queue song['name']
+    end
+  end
+end
+
+class Playlist < ActiveRecord::Base
+  serialize :songs, JSONArraySerializer.new(array_class: SongArray)
+end
+```
+
+The `array_class` you pass to `JSONArraySerializer.new` __must__ have the following two methods.
+
+```
+# A.new : Array -> A
+# a.to_a : -> Array (where a is an instance of A) ?????
+```
+
+### Specifying the Database Type
+
+This gem allows you to save arrays on either Text/String columns or Array columns. The default is `:text`.
+
+```ruby
+  serialize :foo, JSONArraySerializer.new                       # Will save to :text.
+  serialize :foo, JSONArraySerializer.new(column_type: :text)   # Same as above.
+  serialize :foo, JSONArraySerializer.new(column_type: :array)  # Saves to array column.
+```
+
+## Example
+
+```ruby
+class Developer < OpenStruct
+  def develop(name)
+    # Write code.
+  end
+end
+
+class DeveloperArray < Array
+  def develop
+    each { |d| d.develop }
+  end
+end
+
+class Company < ActiveRecord::Base
+  serialize :developers, JSONArraySerializer.new(array_class: DeveloperArray, element_class: Developer)
+end
+```

data/lib/json_array_serializer/version.rb

@@ -1,3 +1,3 @@
 class JSONArraySerializer < Array
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/json_array_serializer.rb

@@ -1,8 +1,8 @@
 require 'json'
 require 'json_array_serializer/version'
 
-class JSONArraySerializer < Array
-  attr_accessor :element_class
+class JSONArraySerializer
+  attr_accessor :element_class, :array_class
 
   # Class -> void (hook)
   # Sets up the new JSONArraySerializer with it's elements
@@ -14,44 +14,46 @@ class JSONArraySerializer < Array
   # A.new : Hash -> A
   # a.to_h : -> Hash (where a is an instance of A)
   #
-  def initialize(element_class = Hash, column_type = :text)
+  def initialize(array_class: Array, element_class: Hash, column_type: :text)
+    @array_class   = array_class
     @element_class = element_class
     @column_type   = column_type
   end
 
-  # [JSON String] || JSON String -> [element_class]
+  # [JSON String] || JSON String -> array_class<element_class>
   # Takes an array of JSON strings and loads them
   # into an array of element_classes.
   #
   def load(data)
+    return data if data.nil?
+
     array = case @column_type
     when :array
-      data
+      data.map do |json|
+        hash = JSON.load(json)
+        (element_class == Hash) ? hash : element_class.new(hash)
+      end
     when :string, :text
-      JSON.load(data)
+      JSON.load(data).map do |hash|
+        (element_class == Hash) ? hash : element_class.new(hash)
+      end
     end
 
-    array.map do |json|
-      hash = JSON.load(json)
-      (element_class == Hash) ? hash : element_class.new(hash)
-    end
+    (array_class == Array) ? array : array_class.new(array)
   end
 
-  # [element_class] -> [JSON String] || JSON String
+  # array_class<element_class> -> [JSON String] || JSON String
   # Takes an array of element_classes and dumps them
   # into JSON Strings, and returns the array of them.
   #
-  def dump(array)
-    serialized_array = array.map do |e|
-      hash = (element_class == Hash) ? e : e.to_h
-      JSON.dump(hash)
-    end
+  def dump(data)
+    return data if data.nil?
 
     case @column_type
     when :array
-      serialized_array
+      data.to_a.map { |e| JSON.dump(e.to_h) }
     when :string, :text
-      JSON.dump(serialized_array)
+      JSON.dump(data.to_a.map { |e| e.to_h })
     end
   end
 end

data/spec/json_array_serializer_spec.rb

@@ -1,296 +1,218 @@
 require 'spec_helper'
 
 describe JSONArraySerializer do
+  let(:array) { Array.new(5, foo: 'bar', baz: 1337) }
+  let(:array_string) { JSON.dump(array) }
+  let(:serializer) { JSONArraySerializer.new }
 
-  it 'is an array' do
-    serializer = JSONArraySerializer.new
-    expect(serializer).to be_an(Array)
+  describe '#load' do
+    it 'returns nil given nil' do
+      expect(serializer.load(nil)).to eq(nil)
+    end
+
+    it 'returns an empty array given an empty array' do
+      expect(serializer.load('[]')).to eq([])
+    end
+
+    it 'returns an array of the same length as it\'s given' do
+      expect(serializer.load(array_string).length).to eq(array.length)
+    end
+  end
+
+  describe '#dump' do
+    it 'returns nil given nil' do
+      expect(serializer.dump(nil)).to eq(nil)
+    end
+
+    it 'returns a string given an array' do
+      expect(serializer.dump(array)).to be_a(String)
+    end
+  end
+
+  it 'converts symbols to strings' do
+    symbol_array = [
+      { foo: 'bar' },
+      { name: 'nate', age: 21 },
+      { ramble: 'rara', float: 21.13 },
+      { symbol: :very_symbol },
+      { hash: { 'foo' => 'bar' } },
+      { symbol_hash: { foo: 'bar' } }
+    ]
+    expected = symbol_array.map(&:stringify)
+    expect(serializer.load(serializer.dump(symbol_array))).to eq(expected)
   end
 
-  context 'text backed serialization' do
-    context 'default class (Hash)' do
-      let(:serializer) { JSONArraySerializer.new }
+  context 'with default array_class (Array)' do
+    let(:serializer) { JSONArraySerializer.new }
 
-      describe '.new' do
-        it 'sets it\'s element class to a Hash' do
-          expect(serializer.element_class).to eq(Hash)
-        end
+    describe '.new' do
+      it 'sets it\'s array class to Array' do
+        expect(serializer.array_class).to eq(Array)
       end
+    end
 
-      describe '#load' do
-        it 'returns an empty array given an empty array' do
-          expect(serializer.load("[]")).to eq([])
-        end
-
-        it 'returns an array of the same length as it\'s given' do
-          array = Array.new(5, "{}")
-          expect(serializer.load(JSON.dump(array)).length).to eq(array.length)
-        end
-
-        it 'has elements that are in fact Hashs' do
-          array = Array.new(5, "{}")
-          expect(serializer.load(JSON.dump(array)).reject { |e| e.is_a? Hash }).to be_empty
-        end
-
-        it 'loads arrays of JSON with data' do
-          array = Array.new(5, "{\"foo\":\"bar\",\"baz\":1337}")
-          expect(serializer.load(JSON.dump(array)).first).to eq({'foo' => 'bar', 'baz' => 1337})
-        end
+    describe '#load' do
+      it 'returns an instance of Array' do
+        expect(serializer.load(array_string)).to be_a(Array)
       end
+    end
 
-      describe '#dump' do
-        it 'returns a string given an array' do
-          array = Array.new(5, {})
-          expect(serializer.dump(array)).to be_a(String)
-        end
+    describe '#dump' do
+      it 'returns a string given an Array' do
+        expect(serializer.dump(array)).to be_a(String)
+      end
 
-        it 'JSON can load it' do
-          array = Array.new(5, {foo: 'bar'})
-          expect { JSON.load(serializer.dump(array)) }.not_to raise_error
-        end
+      it 'JSON can load it' do
+        expect { JSON.load(serializer.dump(array)) }.not_to raise_error
       end
+    end
+  end
 
-      it 'dumps and loads equivalent arrays' do
-        array = [
-          { 'foo' => 'bar' },
-          { 'name' => 'nate', 'age' => 21 },
-          { 'ramble' => 'rara', 'float' => 21.13 }
-        ]
-        expect(serializer.load(serializer.dump(array))).to eq(array)
+  context 'with CustomArray array_class' do
+    class CustomArray
+      def initialize(array)
+        @arr = array
       end
 
-      it 'converts symbols to strings' do
-        array = [
-          { foo: 'bar' },
-          { name: 'nate', age: 21 },
-          { ramble: 'rara', float: 21.13 },
-          { symbol: :very_symbol },
-          { hash: { 'foo' => 'bar' } },
-          { symbol_hash: { foo: 'bar' } }
-        ]
-        expected = array.map(&:stringify)
-        expect(serializer.load(serializer.dump(array))).to eq(expected)
+      def to_a
+        @arr
       end
     end
 
-    context 'with OpenStruct class' do
-      let(:serializer) { JSONArraySerializer.new(OpenStruct) }
+    let(:serializer) { JSONArraySerializer.new(array_class: CustomArray) }
 
-      describe '.new' do
-        it 'sets it\'s element class to a OpenStruct' do
-          expect(serializer.element_class).to eq(OpenStruct)
-        end
+    describe '.new' do
+      it 'sets it\'s array class to CustomArray' do
+        expect(serializer.array_class).to eq(CustomArray)
       end
+    end
 
-      describe '#load' do
-        it 'returns an empty array given an empty array' do
-          expect(serializer.load(JSON.dump([]))).to eq([])
-        end
-
-        it 'returns an array of the same length as it\'s given' do
-          array = Array.new(5, "{}")
-          expect(serializer.load(JSON.dump(array)).length).to eq(array.length)
-        end
-
-        it 'has elements that are in fact OpenStructs' do
-          array = Array.new(5, "{}")
-          expect(serializer.load(JSON.dump(array)).reject { |e| e.is_a? OpenStruct }).to be_empty
-        end
-
-        it 'loads arrays of JSON with data' do
-          array = Array.new(5, "{\"foo\":\"bar\",\"baz\":1337}")
-          expect(serializer.load(JSON.dump(array)).first).to eq(OpenStruct.new(foo: 'bar', baz: 1337))
-        end
+    describe '#load' do
+      it 'returns an instance of CustomArray' do
+        expect(serializer.load(array_string)).to be_a(CustomArray)
       end
+    end
 
-      describe '#dump' do
-        it 'returns a string given an array' do
-          array = Array.new(5, {})
-          expect(serializer.dump(array)).to be_a(String)
-        end
+    describe '#dump' do
+      let(:custom_array) { CustomArray.new([{foo: 'bar'}, {}]) }
+      it 'returns a string given an CustomArray' do
+        expect(serializer.dump(custom_array)).to be_a(String)
+      end
 
-        it 'JSON can load it' do
-          array = Array.new(5, {foo: 'bar'})
-          expect { JSON.load(serializer.dump(array)) }.not_to raise_error
-        end
+      it 'JSON can load it' do
+        expect { JSON.load(serializer.dump(custom_array)) }.not_to raise_error
       end
+    end
+  end
 
-      it 'dumps and loads equivalent arrays' do
-        array = [
-          OpenStruct.new('foo' => 'bar'),
-          OpenStruct.new('name' => 'nate', 'age' => 21),
-          OpenStruct.new('ramble' => 'rara', 'float' => 21.13)
-        ]
-        expect(serializer.load(serializer.dump(array))).to eq(array)
+  context 'with default element_class (Hash)' do
+    let(:serializer) { JSONArraySerializer.new }
+
+    describe '.new' do
+      it 'sets it\'s element class to a Hash' do
+        expect(serializer.element_class).to eq(Hash)
       end
+    end
 
-      it 'converts symbols to strings' do
-        array = [
-          OpenStruct.new(foo: 'bar'),
-          OpenStruct.new(name: 'nate', age: 21),
-          OpenStruct.new(ramble: 'rara', float: 21.13),
-          OpenStruct.new(symbol: :very_symbol),
-          OpenStruct.new(hash: { 'foo' => 'bar' }),
-          OpenStruct.new(symbol_hash: { foo: 'bar' })
-        ]
-        expected = array.map(&:stringify_values)
-        expect(serializer.load(serializer.dump(array))).to eq(expected)
+    describe '#load' do
+      it 'has elements that are in fact Hashs' do
+        expect(serializer.load(array_string).reject { |e| e.is_a? Hash }).to be_empty
       end
     end
-  end
 
-  context 'array backed serialization' do
-    context 'default class (Hash)' do
-      let(:serializer) { JSONArraySerializer.new(Hash, :array) }
+    describe '#dump' do
+      it 'returns a string given an array of hashes' do
+        expect(serializer.dump(array)).to be_a(String)
+      end
 
-      describe '.new' do
-        it 'sets it\'s element class to a Hash' do
-          expect(serializer.element_class).to eq(Hash)
-        end
+      it 'JSON can load it' do
+        expect { JSON.load(serializer.dump(array)) }.not_to raise_error
       end
+    end
 
-      describe '#load' do
-        it 'returns an empty array given an empty array' do
-          expect(serializer.load([])).to eq([])
-        end
-
-        it 'returns an array of the same length as it\'s given' do
-          array = Array.new(5, "{}")
-          expect(serializer.load(array).length).to eq(array.length)
-        end
-
-        it 'has elements that are in fact Hashs' do
-          array = Array.new(5, "{}")
-          expect(serializer.load(array).reject { |e| e.is_a? Hash }).to be_empty
-        end
-
-        it 'loads arrays of JSON with data' do
-          array = Array.new(5, "{\"foo\":\"bar\",\"baz\":1337}")
-          expect(serializer.load(array).first).to eq({'foo' => 'bar', 'baz' => 1337})
-        end
+    it 'dumps and loads equivalent arrays' do
+      hash_array = [
+        { 'foo' => 'bar' },
+        { 'name' => 'nate', 'age' => 21 },
+        { 'ramble' => 'rara', 'float' => 21.13 }
+      ]
+      expect(serializer.load(serializer.dump(hash_array))).to eq(hash_array)
+    end
+  end
+
+  context 'with OpenStruct element_class' do
+    let(:serializer) { JSONArraySerializer.new(element_class: OpenStruct) }
+
+    describe '.new' do
+      it 'sets it\'s element class to a OpenStruct' do
+        expect(serializer.element_class).to eq(OpenStruct)
       end
+    end
 
-      describe '#dump' do
-        it 'returns an empty array given an empty array' do
-          expect(serializer.dump([])).to eq([])
-        end
-
-        it 'returns an array of the same length as it\'s given' do
-          array = Array.new(5, {})
-          expect(serializer.dump(array).length).to eq(array.length)
-        end
-
-        it 'has elements that are JSON strings' do
-          array = Array.new(5, {foo: 'bar'})
-          expect {
-            serializer.dump(array).map { |e| JSON.load(e) }
-          }.not_to raise_error
-        end
-
-        it 'dumps hashes with data' do
-          array = Array.new(5, {foo: 'bar', baz: 1337})
-          expect(serializer.dump(array).first).to eq("{\"foo\":\"bar\",\"baz\":1337}")
-        end
+    describe '#load' do
+      it 'has elements that are in fact OpenStructs' do
+        expect(serializer.load(array_string).reject { |e| e.is_a? OpenStruct }).to be_empty
       end
+    end
 
-      it 'dumps and loads equivalent arrays' do
-        array = [
-          { 'foo' => 'bar' },
-          { 'name' => 'nate', 'age' => 21 },
-          { 'ramble' => 'rara', 'float' => 21.13 }
-        ]
-        expect(serializer.load(serializer.dump(array))).to eq(array)
+    describe '#dump' do
+      it 'returns a string given an array of OpenStructs' do
+        expect(serializer.dump(array)).to be_a(String)
       end
 
-      it 'converts symbols to strings' do
-        array = [
-          { foo: 'bar' },
-          { name: 'nate', age: 21 },
-          { ramble: 'rara', float: 21.13 },
-          { symbol: :very_symbol },
-          { hash: { 'foo' => 'bar' } },
-          { symbol_hash: { foo: 'bar' } }
-        ]
-        expected = array.map(&:stringify)
-        expect(serializer.load(serializer.dump(array))).to eq(expected)
+      it 'JSON can load it' do
+        expect { JSON.load(serializer.dump(array)) }.not_to raise_error
       end
     end
 
-    context 'with OpenStruct class' do
-      let(:serializer) { JSONArraySerializer.new(OpenStruct, :array) }
+    it 'dumps and loads equivalent arrays' do
+      open_struct_array = [
+        OpenStruct.new('foo' => 'bar'),
+        OpenStruct.new('name' => 'nate', 'age' => 21),
+        OpenStruct.new('ramble' => 'rara', 'float' => 21.13)
+      ]
+      expect(serializer.load(serializer.dump(open_struct_array))).to eq(open_struct_array)
+    end
+  end
+
+  context 'with string/text column_type' do
+    let(:serializer) { JSONArraySerializer.new(column_type: :text) }
+
+    describe '#load' do
+      it 'loads arrays of JSON with data' do
+        expect(serializer.load(array_string).first).to eq({'foo' => 'bar', 'baz' => 1337})
+      end
+    end
 
-      describe '.new' do
-        it 'sets it\'s element class to a OpenStruct' do
-          expect(serializer.element_class).to eq(OpenStruct)
-        end
+    describe '#dump' do
+      it 'returns a string given an array' do
+        expect(serializer.dump(array)).to be_a(String)
       end
 
-      describe '#load' do
-        it 'returns an empty array given an empty array' do
-          expect(serializer.load([])).to eq([])
-        end
-
-        it 'returns an array of the same length as it\'s given' do
-          array = Array.new(5, "{}")
-          expect(serializer.load(array).length).to eq(array.length)
-        end
-
-        it 'has elements that are in fact OpenStructs' do
-          array = Array.new(5, "{}")
-          expect(serializer.load(array).reject { |e| e.is_a? OpenStruct }).to be_empty
-        end
-
-        it 'loads arrays of JSON with data' do
-          array = Array.new(5, "{\"foo\":\"bar\",\"baz\":1337}")
-          expect(serializer.load(array).first).to eq(OpenStruct.new(foo: 'bar', baz: 1337))
-        end
+      it 'JSON can load it' do
+        expect { JSON.load(serializer.dump(array)) }.not_to raise_error
       end
+    end
+  end
 
-      describe '#dump' do
-        it 'returns an empty array given an empty array' do
-          expect(serializer.dump([])).to eq([])
-        end
-
-        it 'returns an array of the same length as it\'s given' do
-          array = Array.new(5, OpenStruct.new)
-          expect(serializer.dump(array).length).to eq(array.length)
-        end
-
-        it 'has elements that are JSON strings' do
-          array = Array.new(5, OpenStruct.new({foo: 'bar'}))
-          expect {
-            serializer.dump(array).map { |e| JSON.load(e) }
-          }.not_to raise_error
-        end
-
-        it 'dumps OpenStructs with data' do
-          array = Array.new(5, OpenStruct.new(foo: 'bar', baz: 1337))
-          expect(serializer.dump(array).first).to eq("{\"foo\":\"bar\",\"baz\":1337}")
-        end
+  context 'with array column_type' do
+    let(:serializer) { JSONArraySerializer.new(column_type: :array) }
+    let(:array_of_json) { Array.new(5, JSON.dump(foo: 'bar', baz: 1337)) }
+
+    describe '#load' do
+      it 'loads arrays of JSON with data' do
+        expect(serializer.load(array_of_json).first).to eq({'foo' => 'bar', 'baz' => 1337})
       end
+    end
 
-      it 'dumps and loads equivalent arrays' do
-        array = [
-          OpenStruct.new('foo' => 'bar'),
-          OpenStruct.new('name' => 'nate', 'age' => 21),
-          OpenStruct.new('ramble' => 'rara', 'float' => 21.13),
-          OpenStruct.new(symbol: 'rara', 'float' => 21.13)
-        ]
-        expect(serializer.load(serializer.dump(array))).to eq(array)
+    describe '#dump' do
+      it 'returns an array given an array' do
+        expect(serializer.dump(array)).to be_a(Array)
       end
 
-      it 'converts symbols to strings' do
-        array = [
-          OpenStruct.new(foo: 'bar'),
-          OpenStruct.new(name: 'nate', age: 21),
-          OpenStruct.new(ramble: 'rara', float: 21.13),
-          OpenStruct.new(symbol: :very_symbol),
-          OpenStruct.new(hash: { 'foo' => 'bar' }),
-          OpenStruct.new(symbol_hash: { foo: 'bar' })
-        ]
-        expected = array.map(&:stringify_values)
-        expect(serializer.load(serializer.dump(array))).to eq(expected)
+      it 'JSON can load it\'s elements' do
+        expect { serializer.dump(array).each { |s| JSON.load(s) } }.not_to raise_error
       end
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json_array_serializer
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Nathan Lilienthal