Jump To …

json-hash.rb

Make Peace wih JSON and Hash

 

      		
    

    

      
        

          
        

        
Why do I care?

      		
      
        

      		
    

    

      
        

          
        

        
If you’ve ever needed to build an AJAX route handler, you may have noticed
the prevalence of the design pattern where you return a JSON response.



post “/comments.json” do
  comment = Comment.create(params[:comment])
  comment.to_json
end




Ohm helps you here by providing sensible defaults. It’s not very popular,
but Ohm actually has a to_hash method.

      		
      
        

      		
    

    

      
        

          
        

        
Let’s start by requiring ohm and json. In ruby 1.9, json is
actually part of the standard library, so you don’t have to install a gem
for it. For ruby 1.8.x, a simple [sudo] gem install json will do it.

      		
      
        
require "ohm"
require "json"

      		
    

    

      
        

          
        

        
Here we define our Post model with just a single attribute called
title.



We also define a validation, asserting the presence of the title.

      		
      
        
class Post < Ohm::Model
  attribute :title

  def validate
    assert_present :title
  end
end

      		
    

    

      
        

          
        

        
Now let’s load the test framework cutest to verify our code. We
also call Ohm.flush for each test run.

      		
      
        
require "cutest"

prepare { Ohm.flush }

      		
    

    

      
        

          
        

        
When we successfully create a Post, we can see that it returns
only the id and its value in the hash.

      		
      
        
test "hash representation when created" do
  post = Post.create(:title => "my post")

  assert({ :id => "1" } == post.to_hash)
end

      		
    

    

      
        

          
        

        
The JSON representation is actually just post.to_hash.to_json, so the
same result, only in JSON, is returned.

      		
      
        
test "json representation when created" do
  post = Post.create(:title => "my post")

  assert("{\"id\":\"1\"}" == post.to_json)
end

      		
    

    

      
        

          
        

        
Let’s try and do the opposite now — that is, purposely try and create
an invalid Post. We can see that it returns the errors of the
Post, because we added an assert_present :title in our code above.

      		
      
        
test "hash representation when validation failed" do
  post = Post.create

  assert({ :errors => [[:title, :not_present]]} == post.to_hash)
end

      		
    

    

      
        

          
        

        
As is the case for a valid record, the JSON representation is
still equivalent to post.to_hash.to_json.

      		
      
        
test "json representation when validation failed" do
  post = Post.create

  assert("{\"errors\":[[\"title\",\"not_present\"]]}" == post.to_json)
end

      		
    

    

      
        

          
        

        
Whitelisted approach

      		
      
        

      		
    

    

      
        

          
        

        
Unlike in other frameworks which dumps out all attributes by default,
Ohm favors a whitelisted approach where you have to explicitly
declare which attributes you want.



By default, only :id and :errors will be available, depending if
it was successfully saved or if there were validation errors.

      		
      
        

      		
    

    

      
        

          
        

        
Let’s re-open our Post class, and add a to_hash method.

      		
      
        
class Post
  def to_hash
    super.merge(:title => title)
  end
end

      		
    

    

      
        

          
        

        
Now, let’s test that the title is in fact part of to_hash.

      		
      
        
test "customized to_hash" do
  post = Post.create(:title => "Override FTW?")
  assert({ :id => "1", :title => "Override FTW?" } == post.to_hash)
end

      		
    

    

      
        

          
        

        
Conclusion

      		
      
        

      		
    

    

      
        

          
        

        
Ohm has a lot of neat intricacies like this. Some of the things to keep
in mind from this tutorial would be:



    

  1. Ohm doesn’t assume too much about your needs.
    2. 

  2. If you need a customized version, you can always define it yourself.
    3. 

  3. Customization is easy using basic OOP principles.
    4.