jsoning 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2edd1def968d6f13f1ba2cc36243718163cd7dcc
-  data.tar.gz: 2e18b982c6b0269727b827d782ea72695f904d7f
+  metadata.gz: b62e31437ea7ae41f6aabc42ce7096cba6475eca
+  data.tar.gz: fdb1858c496487d96805d98a00640af0bb8e97d8
 SHA512:
-  metadata.gz: c2799fd887a3db49f97de68228f5fc4a5634f7b91466a0f119b56b7c3565e10bbb4856d5896c0422bddc5767fcd32284031873ef7dae1d97c5d68faef45b57ab
-  data.tar.gz: 5622840a2c4ddf1efa7141fa17c01793aff7bde1468113e407d676a099e08616a14a17b8f0b1f5721aaf60d219e7a283de7716582da50e374d74c6cf0f1d69e3
+  metadata.gz: 65ebaacd3211f4a650965b474bd90fc8b6a72117080fb30966a5a9015f98ffe1917b63108647e2cc3df26fef554b68b689a93713d462d714460dc48fe787a9e6
+  data.tar.gz: 7d6c24558e6fc76fbe06b52df2f91288563b83379edc68cae955a45f24f784169a7842b05128a9a8110a1601482f871c3ca7089c3d596fbd9dbdba9496f6672e

data/README.md

@@ -169,9 +169,7 @@ Jsoning the user with pretty set to true, will return:
 }
 ```
 
-## Returning Hash
-
-It is also possible to return hash as well:
+It is also possible to retrieve in form of Ruby hash rather than JSON string:
 
 ```ruby
 Jsoning[user]
@@ -199,6 +197,57 @@ Jsoning.add_type MyFancyString, processor: { |fancy_string| fancy_string.get_str
 Internally, it is how Jsoning convert date-like data type (`Date`, `DateTime`, `Time`, `ActiveSupport::TimeWithZone`) to
 ISO8601 which can be parsed by compliant JavaScript interpreter in the browser (or somewhere else).
 
+## Parsing JSON back to Hash
+
+The `JSON` library that is part of Ruby Standard Library already support parsing from JSON string to Hash.
+However, if you feel that you need to assign default value, for example, when a value is missing, or when you want to 
+enforce the schema, Ruby's own `JSON` library cannot do that yet. Jsoning, on the other hand, can.
+
+The schema must have been defined by using `Jsoning.for` as have been demonstrated earlier.
+
+Until then, to convert from JSON string to Hash, one can call:
+
+```ruby
+Jsoning.parse(the_json_string, Class)
+```
+
+For example, given:
+
+```ruby
+Jsoning.for(My::User) do
+  key :name, null: false
+  key :years_old, from: :age
+  key :gender, default: "male"
+  key :books, default: proc {
+    default_college_books = []
+    default_college_books << My::Book.new("Mathematics 6A")
+    default_college_books << My::Book.new("Physics A2")
+    default_college_books
+  }
+  key :degree_detail, from: :taken_degree
+end
+
+the_json_string = %Q{
+  {"name":"Adam Baihaqi",
+   "years_old":21,
+   "gender":"male",
+   "books":[{"name":"Mathematics 6A"},{"name":"Physics A2"}],
+   "degree_detail":null,
+   "registered_at":"2015-11-01T14:41:09+00:00"}
+} 
+```
+
+Calling: `Jsoning.parse(the_json_string, My::User)` will yield a Hash as follow:
+
+```ruby
+{"name"=>"Adam Baihaqi", 
+ "years_old"=>21, 
+ "gender"=>"male", 
+ "books"=>[{"name"=>"Mathematics 6A"}, {"name"=>"Physics A2"}], 
+ "degree_detail"=>nil, 
+ "registered_at"=>"2015-11-01T14:41:09+00:00"}
+```
+
 ## Changelog
 
 == Version 0.1.0
@@ -214,6 +263,11 @@ ISO8601 which can be parsed by compliant JavaScript interpreter in the browser (
 1. Allow user to specify how Jsoning would extract value from a custom data type
 2. Date, DateTime, Time, ActiveSupport::TimeWithZone now is by default parsed to ISO8601 format.
 
+== Version 0.4.0
+
+1. When passing a proc as default value, it will be executed to assign default value when value is nil.
+2. Parsing JSON string as hash by using `Jsoning.parse`
+
 ## License
 
 The gem is proudly available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/jsoning/dsl/for_dsl.rb

@@ -34,7 +34,7 @@ class Jsoning::ForDsl
     mapper.name = mapped_to
     mapper.default_value = options.delete(:default) || options.delete("default")
     mapper.nullable = options.delete(:null)
-    mapper.nullable = options.delete("null") if mapper.nullable.nil?
+    mapper.nullable = options.delete("null") if mapper.nullable?.nil?
 
     options.keys { |key| raise Jsoning::Error, "Undefined option: #{key}" }
 

data/lib/jsoning/foundations/mapper.rb

@@ -1,9 +1,9 @@
-# takes care of translating/fetching values from the object
+# responsible of mapping from object to representable values, one field at a time
 class Jsoning::Mapper
   # when mapped, what will be the mapped name
   attr_writer :name
 
-  attr_accessor :default_value
+  attr_writer :default_value
   attr_writer :nullable
   # what variable in the object will be used to obtain the value
   attr_accessor :parallel_variable
@@ -11,11 +11,11 @@ class Jsoning::Mapper
 
   def initialize
     self.parallel_variable = nil
-    self.default_value = nil
+    @default_value = nil
     self.nullable = true
   end
 
-  def nullable
+  def nullable?
     if @nullable.is_a?(TrueClass) || @nullable.is_a?(FalseClass)
       return @nullable
     else
@@ -31,18 +31,31 @@ class Jsoning::Mapper
 
   # map this very specific object's field to target_hash
   def extract(object, target_hash)
+    target_value = nil
+
     if object.respond_to?(parallel_variable)
       parallel_val = object.send(parallel_variable)
-      parallel_val = default_value if parallel_val.nil?
-      target_hash[name] = deep_parse(parallel_val)
-    else
-      if default_value
-        target_hash[name] = deep_parse(default_value)
+      target_value = deep_parse(parallel_val)
+    end
+
+    if target_value.nil?
+      target_value = self.default_value
+      if target_value.nil? && !self.nullable?
+        raise Jsoning::Error, "Null value given for '#{name}' when serializing #{object}"
+      end
+    end
+    target_hash[name] = deep_parse(target_value)
+  end
+
+  def default_value
+    if @default_value
+      if @default_value.is_a?(Proc)
+        return deep_parse(@default_value.())
       else
-        unless nullable
-          raise Jsoning::Error, "Null value given for '#{name}' when serializing #{object}"
-        end
+        return deep_parse(@default_value)
       end
+    else
+      nil
     end
   end
 
@@ -69,11 +82,10 @@ class Jsoning::Mapper
           parsed_data = object
         else
           protocol = Jsoning.protocol_for!(object.class)
-          parsed_data = protocol.parse(object)
+          parsed_data = protocol.retrieve_values_from(object)
         end
       end
 
-
       parsed_data
     end
 end

data/lib/jsoning/foundations/protocol.rb

@@ -31,7 +31,7 @@ class Jsoning::Protocol
     pretty = options["pretty"] if pretty.nil?
     pretty = false if pretty.nil?
 
-    data = parse(object)
+    data = retrieve_values_from(object)
 
     if pretty
       JSON.pretty_generate(data)
@@ -40,7 +40,8 @@ class Jsoning::Protocol
     end
   end
 
-  def parse(object)
+  # construct the JSON from given object
+  def retrieve_values_from(object)
     # hold data here
     data = {}
 
@@ -52,6 +53,33 @@ class Jsoning::Protocol
     data
   end
 
+  # construct hash from given JSON
+  def construct_hash_from(json_string)
+    data = {}
+
+    # make all json obj keys to downcase, symbol
+    json_obj = JSON.parse(json_string)
+    json_obj = Hash[json_obj.map { |k, v| [k.to_s.downcase, v]}]
+
+    mappers_order.each do |mapper_sym|
+      mapper = mapper_for(mapper_sym)
+      mapper_key_name = mapper.name.to_s.downcase
+      
+      mapper_default_value = mapper.default_value
+      mapper_key_value = json_obj[mapper_key_name]
+      # retrieve value from key, if not available, from default
+      value = mapper_key_value || mapper_default_value
+
+      if value.nil? && !mapper.nullable?
+        raise Jsoning::Error, "Constructing hash failed due to #{mapper_key_name} being nil when it is not allowed to" 
+      end
+
+      data[mapper_key_name] = value
+    end
+
+    data
+  end
+
   private
   def canonical_name(key_name)
     key_name.to_s.downcase.to_sym

data/lib/jsoning/version.rb

@@ -1,3 +1,3 @@
 module Jsoning
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/jsoning.rb

@@ -24,20 +24,24 @@ module Jsoning
     protocol
   end
 
+  # retrieve the protocol or raise an error when the protocol is not defined yet
   def protocol_for!(klass)
     protocol = PROTOCOLS[klass.to_s]
     raise Jsoning::Error, "Undefined Jsoning protocol for #{klass.to_s}" if protocol.nil?
     protocol
   end
 
+  # clearing the protocols
   def clear
     PROTOCOLS.clear
   end
 
+  # define the protocol
   def for(klass, &block)
     Jsoning::ForDsl.new(protocol_for(klass)).instance_eval(&block)
   end
 
+  # generate the json document
   def generate(object, options = {})
     initialize_type_extensions 
     protocol = protocol_for!(object.class)
@@ -80,19 +84,16 @@ module Jsoning
     end
   end
 
-  class << self
-    def add_type(klass, options = {})
-      processor = options[:processor]
-      raise Jsoning::Error, "Pass in processor that is a proc explaining how to extract the value" unless processor.is_a?(Proc)
-
-      TYPE_EXTENSIONS[klass.to_s] = processor
-      nil
-    end
-  end
-  
-  def self.[](object) 
+  def [](object) 
     protocol = protocol_for!(object.class)
-    protocol.parse(object)
+    protocol.retrieve_values_from(object)
+  end
+
+  def add_type(klass, options = {})
+    processor = options[:processor]
+    raise Jsoning::Error, "Pass in processor that is a proc explaining how to extract the value" unless processor.is_a?(Proc)
+    TYPE_EXTENSIONS[klass.to_s] = processor
+    nil
   end
 
   # monkey patch Kernel
@@ -103,4 +104,10 @@ module Jsoning
       Jsoning.generate(object, options)
     end
   end
+
+  # parse the JSON String to Hash
+  def parse(json_string, klass)
+    protocol = protocol_for!(klass)
+    protocol.construct_hash_from(json_string)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsoning
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Adam Pahlevi