pigeon_hole 0.0.4 → 0.1.0

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

@@ -1,53 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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/spec/monster-vim-2016-07-26-10-29-02.rb

@@ -1,117 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

data/spec/monster-vim-2016-07-26-12-05-32.rb

@@ -1,117 +0,0 @@
-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(: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
-    {
-      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