pigeon_hole 0.0.1 → 0.0.2

data/lib/pigeon_hole/monster-vim-2016-07-26-10-38-28.rb

@@ -0,0 +1,53 @@
+require 'json'
+
+module PigeonHole
+  class TypedJSON
+    def self.generate(obj, *args)
+      hash_dup = each_with_parent(obj)
+      JSON.generate(hash_dup, *args)
+    end
+
+    def self.map_to_json(obj)
+      case obj
+      when Time
+        JSONTime.new(obj)
+      when DateTime
+        JSONDateTime.new(obj)
+      when Date
+        JSONDate.new(obj)
+      when Symbol
+        JSONSymbol.new(obj)
+      else
+        obj
+      end
+    end
+
+    def self.map_array_value(value)
+      case value
+      when Hash
+        each_with_parent(value)
+      when Array
+        value.map_array_value
+      else
+        map_to_json(value)
+      end
+    end
+
+    def self.each_with_parent(hash, result=nil)
+      duplicated_hash = {} || result
+
+      hash.each do |k, v|
+        case v
+        when Hash
+          duplicated_hash[k] = each_with_parent(v, duplicated_hash)
+        when Array
+          duplicated_hash[k] = v.map { |av| map_to_json(av) map_to_json(av) }.to_a
+        else
+          duplicated_hash[k] = map_to_json(v)
+        end
+      end
+
+      duplicated_hash
+    end
+  end
+end

data/lib/pigeon_hole/monster-vim-2016-07-26-10-38-29.rb

@@ -0,0 +1,53 @@
+require 'json'
+
+module PigeonHole
+  class TypedJSON
+    def self.generate(obj, *args)
+      hash_dup = each_with_parent(obj)
+      JSON.generate(hash_dup, *args)
+    end
+
+    def self.map_to_json(obj)
+      case obj
+      when Time
+        JSONTime.new(obj)
+      when DateTime
+        JSONDateTime.new(obj)
+      when Date
+        JSONDate.new(obj)
+      when Symbol
+        JSONSymbol.new(obj)
+      else
+        obj
+      end
+    end
+
+    def self.map_array_value(value)
+      case value
+      when Hash
+        each_with_parent(value)
+      when Array
+        value.mamap_array_value
+      else
+        map_to_json(value)
+      end
+    end
+
+    def self.each_with_parent(hash, result=nil)
+      duplicated_hash = {} || result
+
+      hash.each do |k, v|
+        case v
+        when Hash
+          duplicated_hash[k] = each_with_parent(v, duplicated_hash)
+        when Array
+          duplicated_hash[k] = v.map { |av| map_to_json(av) map_to_json(av) }.to_a
+        else
+          duplicated_hash[k] = map_to_json(v)
+        end
+      end
+
+      duplicated_hash
+    end
+  end
+end

data/lib/pigeon_hole/monster-vim-2016-07-26-10-39-14.rb

@@ -0,0 +1,53 @@
+require 'json'
+
+module PigeonHole
+  class TypedJSON
+    def self.generate(obj, *args)
+      hash_dup = each_with_parent(obj)
+      JSON.generate(hash_dup, *args)
+    end
+
+    def self.map_to_json(obj)
+      case obj
+      when Time
+        JSONTime.new(obj)
+      when DateTime
+        JSONDateTime.new(obj)
+      when Date
+        JSONDate.new(obj)
+      when Symbol
+        JSONSymbol.new(obj)
+      else
+        obj
+      end
+    end
+
+    def self.map_array_value(value)
+      case value
+      when Hash
+        each_with_parent(value)
+      when Array
+        value.map(&:map_array_value)
+      else
+        map_to_json(value)
+      end
+    end
+
+    def self.each_with_parent(hash, result=nil)
+      duplicated_hash = {} || result
+
+      hash.each do |k, v|
+        case v
+        when Hash
+          duplicated_hash[k] = each_with_parent(v, duplicated_hash)
+        when Array
+          duplicated_hash[k] = v.map
+        else
+          duplicated_hash[k] = map_to_json(v)
+        end
+      end
+
+      duplicated_hash
+    end
+  end
+end

data/lib/pigeon_hole/typed_json.rb

@@ -22,6 +22,17 @@ module PigeonHole
       end
     end
 
+    def self.map_array_value(value)
+      case value
+      when Hash
+        each_with_parent(value)
+      when Array
+        value.map { |av| map_array_value(av) }
+      else
+        map_to_json(value)
+      end
+    end
+
     def self.each_with_parent(hash, result=nil)
       duplicated_hash = {} || result
 
@@ -29,6 +40,8 @@ module PigeonHole
         case v
         when Hash
           duplicated_hash[k] = each_with_parent(v, duplicated_hash)
+        when Array
+          duplicated_hash[k] = v.map { |av| map_array_value(av) }
         else
           duplicated_hash[k] = map_to_json(v)
         end

data/spec/integration_spec.rb

@@ -73,6 +73,24 @@ describe "serializing symbols" do
   end
 end
 
+describe "serializing arrays" do
+  let(:array) { [:a_symbol, { "test" => :foo } ] }
+
+  subject { PigeonHole.generate(array: array) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a array" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash).to eq({ "array" => array })
+    expect(hash["array"]).to be_a(Array)
+  end
+end
+
 describe "serializing nested hashes" do
   let(:expected) do
     {

data/spec/monster-vim-2016-07-26-10-29-02.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe "serializing dates" do
+  let(:date) { random_date }
+
+  subject { PigeonHole.generate(date: date) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a date time" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash).to eq({ "date" => date })
+    expect(hash["date"]).to be_a(Date)
+  end
+end
+
+describe "serializing times" do
+  let(:time) { random_time }
+
+  subject { PigeonHole.generate(time: time) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a time" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash).to eq({ "time" => time })
+    expect(hash["time"]).to be_a(Time)
+  end
+end
+
+describe "serializing datetimes" do
+  let(:date_time) { random_date_time }
+
+  subject { PigeonHole.generate(date_time: date_time) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a date_time" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash["date_time"]).to be_a(DateTime)
+    expect(hash["date_time"].to_date).to eq(date_time.to_date)
+    expect(hash["date_time"].to_time.to_i).to eq(date_time.to_time.to_i)
+  end
+end
+
+describe "serializing symbols" do
+  let(:symbol) { :a_symbol }
+
+  subject { PigeonHole.generate(symbol: symbol) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a symbol" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash).to eq({ "symbol" => symbol })
+    expect(hash["symbol"]).to be_a(Symbol)
+  end
+end
+
+describe "serializing arrays" do
+  let(:symbol) { [:a_symbol] }
+
+  subject { PigeonHole.generate(symbol: symbol) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a symbol" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash).to eq({ "symbol" => symbol })
+    expect(hash["symbol"].first).to be_a(Symbol)
+  end
+end
+
+describe "serializing nested hashes" do
+  let(:expected) do
+    {
+      foo: {
+        bar: random_time,
+        baz: :temp
+      }
+    }
+  end
+
+  subject { PigeonHole.generate(expected) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a symbol" do
+    result = subject
+    hash = PigeonHole.parse(result)
+
+    expect(symbolize_hash(hash)).to eq(expected)
+  end
+end

data/spec/monster-vim-2016-07-26-10-29-53.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe "serializing dates" do
+  let(:date) { random_date }
+
+  subject { PigeonHole.generate(date: date) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a date time" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash).to eq({ "date" => date })
+    expect(hash["date"]).to be_a(Date)
+  end
+end
+
+describe "serializing times" do
+  let(:time) { random_time }
+
+  subject { PigeonHole.generate(time: time) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a time" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash).to eq({ "time" => time })
+    expect(hash["time"]).to be_a(Time)
+  end
+end
+
+describe "serializing datetimes" do
+  let(:date_time) { random_date_time }
+
+  subject { PigeonHole.generate(date_time: date_time) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a date_time" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash["date_time"]).to be_a(DateTime)
+    expect(hash["date_time"].to_date).to eq(date_time.to_date)
+    expect(hash["date_time"].to_time.to_i).to eq(date_time.to_time.to_i)
+  end
+end
+
+describe "serializing symbols" do
+  let(:symbol) { :a_symbol }
+
+  subject { PigeonHole.generate(symbol: symbol) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a symbol" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash).to eq({ "symbol" => symbol })
+    expect(hash["symbol"]).to be_a(Symbol)
+  end
+end
+
+describe "serializing arrays" do
+  let(:symbol) { [:a_symbol] }
+
+  subject { PigeonHole.generate(symbol: symbol) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a symbol" do
+    result = subject
+    hash = PigeonHole.parse(result)
+    expect(hash).to eq({ [ "symbol" => symbol ] })
+    expect(hash["symbol"]).to
+    expect(hash["symbol"].first).to be_a(Symbol)
+  end
+end
+
+describe "serializing nested hashes" do
+  let(:expected) do
+    {
+      foo: {
+        bar: random_time,
+        baz: :temp
+      }
+    }
+  end
+
+  subject { PigeonHole.generate(expected) }
+
+  it "serializes hash into a string" do
+    result = subject
+    expect(result).to_not be_empty
+  end
+
+  it "can be deserialized to a symbol" do
+    result = subject
+    hash = PigeonHole.parse(result)
+
+    expect(symbolize_hash(hash)).to eq(expected)
+  end
+end