pigeon_hole 0.0.4 → 0.1.0

data/spec/monster-vim-2016-07-26-12-05-33.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.u }
-
-  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

data/spec/monster-vim-2016-07-26-12-05-34.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.us }
-
-  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

data/spec/monster-vim-2016-07-26-12-05-35.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

data/spec/monster-vim-2016-07-26-12-06-22.rb

@@ -1,33 +0,0 @@
-require 'rake'
-require 'rspec'
-
-require "#{Rake.application.original_dir}/lib/pigeon_hole"
-
-include PigeonHole
-
-def random_integer
-  rand(9999)
-end
-
-def random_time
-  (Time.now - random_integer).to
-end
-
-def random_date
-  Date.today - random_integer
-end
-
-def random_date_time
-  DateTime.now
-end
-
-def symbolize_hash(obj)
-  if obj.is_a?(Hash)
-    obj.inject({}) do |memo, (k,v)|
-      memo[k.to_sym] = symbolize_hash(v)
-      memo
-    end
-  else
-    obj
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'rake'
-require 'rspec'
-
-require "#{Rake.application.original_dir}/lib/pigeon_hole"
-
-include PigeonHole
-
-def random_integer
-  rand(9999)
-end
-
-def random_time
-  Time.(Time.now - random_integer).to_i
-end
-
-def random_date
-  Date.today - random_integer
-end
-
-def random_date_time
-  DateTime.now
-end
-
-def symbolize_hash(obj)
-  if obj.is_a?(Hash)
-    obj.inject({}) do |memo, (k,v)|
-      memo[k.to_sym] = symbolize_hash(v)
-      memo
-    end
-  else
-    obj
-  end
-end

data/spec/monster-vim-2016-07-26-12-06-33.rb

@@ -1,33 +0,0 @@
-require 'rake'
-require 'rspec'
-
-require "#{Rake.application.original_dir}/lib/pigeon_hole"
-
-include PigeonHole
-
-def random_integer
-  rand(9999)
-end
-
-def random_time
-  Time.at(Time.now - random_integer).to_i
-end
-
-def random_date
-  Date.today - random_integer
-end
-
-def random_date_time
-  DateTime.now
-end
-
-def symbolize_hash(obj)
-  if obj.is_a?(Hash)
-    obj.inject({}) do |memo, (k,v)|
-      memo[k.to_sym] = symbolize_hash(v)
-      memo
-    end
-  else
-    obj
-  end
-end