pigeon_hole 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9f679f4b70108c6d3d567f1905462749de53dd26
+  data.tar.gz: c98c767931a8f0e1799e7db0d743c484ac46abf7
+SHA512:
+  metadata.gz: 7fa933c8432ae976cc51a96f9ca01355d9ccdece601844411207752f629cb5a31fc89337827c91944426dd5b2e971d1351e44131185f09bc046eeedc00ca9e49
+  data.tar.gz: d3384729d4a8a7bdd0cf82a6099fea598fdfb62da7fea3e66dc7a4e0242c203b43e9db9539aaf721c101bebd4124a2088acc14f66d9efe8cf4d7f8969d2149f6

data/lib/pigeon_hole/json_date.rb

@@ -0,0 +1,29 @@
+module PigeonHole
+  class JSONDate < SimpleDelegator
+    # Deserializes JSON string by converting Julian year <tt>y</tt>, month
+    # <tt>m</tt>, day <tt>d</tt> and Day of Calendar Reform <tt>sg</tt> to Date.
+    def self.json_create(object)
+      Date.civil(*object.values_at('y', 'm', 'd', 'sg'))
+    end
+
+    #alias start sg unless method_defined?(:start)
+
+    # Returns a hash, that will be turned into a JSON object and represent this
+    # object.
+    def as_json(*)
+      {
+        JSON.create_id => self.class.name,
+        'y' => year,
+        'm' => month,
+        'd' => day,
+        'sg' => start,
+      }
+    end
+
+    # Stores class name (Date) with Julian year <tt>y</tt>, month <tt>m</tt>, day
+    # <tt>d</tt> and Day of Calendar Reform <tt>sg</tt> as JSON string
+    def to_json(*args)
+      as_json.to_json(*args)
+    end
+  end
+end

data/lib/pigeon_hole/json_date_time.rb

@@ -0,0 +1,41 @@
+module PigeonHole
+  class JSONDateTime < SimpleDelegator
+    # Deserializes JSON string by converting year <tt>y</tt>, month <tt>m</tt>,
+    # day <tt>d</tt>, hour <tt>H</tt>, minute <tt>M</tt>, second <tt>S</tt>,
+    # offset <tt>of</tt> and Day of Calendar Reform <tt>sg</tt> to DateTime.
+    def self.json_create(object)
+      args = object.values_at('y', 'm', 'd', 'H', 'M', 'S')
+      of_a, of_b = object['of'].split('/')
+      if of_b and of_b != '0'
+        args << DateTime.send(:Rational, of_a.to_i, of_b.to_i)
+      else
+        args << of_a
+      end
+      args << object['sg']
+      DateTime.civil(*args)
+    end
+
+    # Returns a hash, that will be turned into a JSON object and represent this
+    # object.
+    def as_json(*)
+      {
+        JSON.create_id => self.class.name,
+        'y' => year,
+        'm' => month,
+        'd' => day,
+        'H' => hour,
+        'M' => min,
+        'S' => sec,
+        'of' => offset.to_s,
+        'sg' => start,
+      }
+    end
+
+    # Stores class name (DateTime) with Julian year <tt>y</tt>, month <tt>m</tt>,
+    # day <tt>d</tt>, hour <tt>H</tt>, minute <tt>M</tt>, second <tt>S</tt>,
+    # offset <tt>of</tt> and Day of Calendar Reform <tt>sg</tt> as JSON string
+    def to_json(*args)
+      as_json.to_json(*args)
+    end
+  end
+end

data/lib/pigeon_hole/json_symbol.rb

@@ -0,0 +1,22 @@
+module PigeonHole
+  class JSONSymbol < SimpleDelegator
+    # Returns a hash, that will be turned into a JSON object and represent this
+    # object.
+    def as_json(*)
+      {
+        JSON.create_id => self.class.name,
+        's'            => to_s,
+      }
+    end
+
+    # Stores class name (Symbol) with String representation of Symbol as a JSON string.
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+
+    # Deserializes JSON string by converting the <tt>string</tt> value stored in the object to a Symbol
+    def self.json_create(o)
+      o['s'].to_sym
+    end
+  end
+end

data/lib/pigeon_hole/json_time.rb

@@ -0,0 +1,34 @@
+module PigeonHole
+  class JSONTime < SimpleDelegator
+    # Deserializes JSON string by converting time since epoch to Time
+    def self.json_create(object)
+      if usec = object.delete('u') # used to be tv_usec -> tv_nsec
+        object['n'] = usec * 1000
+      end
+      if method_defined?(:tv_nsec)
+        Time.at(object['s'], Time.Rational(object['n'], 1000))
+      else
+        Time.at(object['s'], object['n'] / 1000)
+      end
+    end
+
+    # Returns a hash, that will be turned into a JSON object and represent this
+    # object.
+    def as_json(*)
+      nanoseconds = [ tv_usec * 1000 ]
+      respond_to?(:tv_nsec) and nanoseconds << tv_nsec
+      nanoseconds = nanoseconds.max
+      {
+        JSON.create_id => self.class.name,
+        's'            => tv_sec,
+        'n'            => nanoseconds,
+      }
+    end
+
+    # Stores class name (Time) with number of seconds since epoch and number of
+    # microseconds for Time as JSON string
+    def to_json(*args)
+      as_json.to_json(*args)
+    end
+  end
+end

data/lib/pigeon_hole/typed_json.rb

@@ -0,0 +1,40 @@
+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.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)
+        else
+          duplicated_hash[k] = map_to_json(v)
+        end
+      end
+
+      duplicated_hash
+    end
+  end
+end

data/lib/pigeon_hole.rb

@@ -0,0 +1,19 @@
+module PigeonHole
+  require_relative 'pigeon_hole/typed_json'
+  require_relative 'pigeon_hole/json_date'
+  require_relative 'pigeon_hole/json_date_time'
+  require_relative 'pigeon_hole/json_symbol'
+  require_relative 'pigeon_hole/json_time'
+
+  def self.generate(obj, *args)
+    TypedJSON.generate(obj, *args)
+  end
+
+  def self.parse(string)
+    load(string)
+  end
+
+  def self.load(string)
+    JSON.load(string)
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,99 @@
+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 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/spec_helper.rb

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

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: pigeon_hole
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Stephen Binns
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-13 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pigeon_hole.rb
+- lib/pigeon_hole/json_date.rb
+- lib/pigeon_hole/json_date_time.rb
+- lib/pigeon_hole/json_symbol.rb
+- lib/pigeon_hole/json_time.rb
+- lib/pigeon_hole/typed_json.rb
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.cronofy.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.1
+signing_key: 
+specification_version: 4
+summary: Opt-in typed serialization for complex JSON types
+test_files:
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+has_rdoc: