jsonity 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7837ec79aa7e71a84da9f8fda957c0217bd2691b
+  data.tar.gz: 26ad97f8e6d9b9dcd3dad8c0155eab31a80c8d6b
+SHA512:
+  metadata.gz: e7535b1ce03cb5c6cb877aaf91fa0676f93eda13bc706db8ddeb5169bc443853f0112893dcd2cc20d5a60264d2226231a9b83dca599e86815cb75f37c5e64208
+  data.tar.gz: 7b7cff2ba3ece3d3a5be9a9eb002ce8ebdc9c534537120cbc74736be1079b999621a9b90893c5c231fe5b0c999c33eb435196fa2a849bf8b9f604651059ca268

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Yuki Iwanaga
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,354 @@
+Jsonity
+=======
+
+**The most natural language for building JSON in Ruby**
+
+
+Overview
+--------
+
+```ruby
+@meta_pagination = ->(t) {
+  t.meta!(inherit: true) { |meta|
+    meta.total_pages
+    meta.current_page
+  }
+}
+
+Jsonity.build { |t|
+  t <= @users
+
+  t[].users!(inherit: true) { |user|
+    user.id
+    user.age
+    user.full_name { |u| [u.first_name, u.last_name].join ' ' }
+
+    user.avatar? { |avatar|
+      avatar.image_url
+    }
+  }
+
+  t.(&@meta_pagination)
+}
+#=> {
+#     "users": [
+#       {
+#         "id": 1,
+#         "age": 21,
+#         "full_name": "John Smith",
+#         "avatar": {
+#           "image_url": "http://example.com/john.png"
+#         }
+#       },
+#       {
+#         "id": 2,
+#         "age": 37,
+#         "full_name": "William Northington",
+#         "avatar": {
+#           "image_url": "http://example.com/william.png"
+#         }
+#       },
+#       {
+#         "id": 3,
+#         "age": 29,
+#         "full_name": "Samuel Miller",
+#         "avatar": {
+#           "image_url": "http://example.com/samuel.png"
+#         }
+#       }
+#     ],
+#     "meta": {
+#       "total_pages": 1,
+#       "current_page": 1
+#     }
+#   }
+```
+
+
+Usage
+-----
+
+Make sure to add the gem to your Gemfile.
+
+```ruby
+gem 'neo_json'
+```
+
+Start writing object:
+
+```ruby
+Jsonity.build { |t|
+  # ...
+}
+```
+
+### Object assignment
+
+To declare the data object for use:
+
+```ruby
+t <= @user
+```
+
+### Attribute nodes
+
+Basic usage of defining simple attributes:
+
+```ruby
+t.id   # @user.id
+t.age  # @user.age
+```
+ 
+Or you can use custom attributes in flexible ways:
+
+```ruby
+t.full_name { |u| [u.first_name, u.last_name].join ' ' }  # u = @user
+t.russian_roulette { rand(1..10) }                        # block parameter isn't required
+t.with_object(Time) { |t| t.now }                         # now, t = Time
+t.seventeen 17                                            # block can be omitted
+```
+
+Aliased attributes works well as you expected:
+ 
+```ruby
+# show `id` as `my_id`
+t.my_id &:id
+```
+
+### Automatic attributes inclusion
+
+If you set `attr_json` in any class, the specified attributes will automatically be included:
+
+```ruby
+class Sample < Struct.new(:id, :foo)
+  attr_json :id, :foo
+end
+
+@sample = Sample.new 123, 'foo!'
+
+Jsonity.build { |t|
+  t.sample!(@sample) { |t|
+    # leave empty inside
+  }
+}
+#=> {
+#     "sample": {
+#       "id": 123,
+#       "foo": "foo!"
+#     }
+#   }
+```
+
+### Hash nodes
+
+With name suffixed with `!`, nested object can be included:
+
+```ruby
+t.user! { |user|
+  user.name  # @user.name
+
+  user.avatar! { |avatar|
+    avatar.image_url  # @user.avatar.image_url
+    avatar.width      # @user.avatar.width
+    avatar.height     # @user.avatar.height
+  }
+}
+```
+
+If `@user.avatar = nil`, the output will be like this:
+
+```javascipt
+{
+  "user": {
+    "name": "John Smith",
+    "avatar": {
+      "image_url": null,
+      "width": null,
+      "height": null
+    }
+  }
+}
+```
+
+On the other hand, use `?` as suffix, the whole object become `null`:
+
+```ruby
+t.user! { |user|
+  user.name
+
+  user.avatar? { |avatar|
+    avatar.image_url
+    avatar.width
+    avatar.height
+  }
+}
+```
+
+and the output will be:
+
+```javascipt
+{
+  "user": {
+    "name": "John Smith",
+    "avatar": null
+  }
+}
+```
+
+Explicitly set an object to use inside a block:
+
+```ruby
+t.home?(@user.hometown_address) { |home|
+  home.street  # @user.hometown_address.street
+  home.zip
+  home.city
+  home.state
+}
+```
+
+Or blocks can inherit the parent object:
+
+```ruby
+t.user! { |user|
+  t.my!(inherit: true) { |my|
+    my.name  # @user.name
+  }
+}
+```
+
+### Array nodes
+
+Including a collection of objects, just use `t[]` and write the same syntax of hash node:
+
+```ruby
+t[].friends! { |friend|
+  friend.name
+}
+```
+
+and the output JSON will be:
+
+```javascipt
+{
+  "friends": [
+    {
+      name: "John Smith"
+    }
+  ]
+}
+```
+
+Similar to hash nodes in naming convention,  
+if `@user.friends = nil` nodes suffix with `!` will be an empty array `[]`, in contrast, some with `?` will be `null`.
+
+Also passing the object or inheritance can be done in the same way as hash nodes.
+
+
+### Mixin / Scope
+
+Since Jsonity aim to be simple and light, use plain `Proc` to fullfill functonality of mixin.
+
+```ruby
+timestamp_mixin = ->(t) {
+  t.created_at
+  t.updated_at
+}
+```
+
+and then,
+
+```ruby
+t.user! { |user|
+  user.(&timestamp_mixin)
+}
+```
+
+In case you might use different object in mixin, you can pass the object in the first argument:
+
+```ruby
+t.(@other_user, &timestamps)
+```
+
+So you take this functonality for scope:
+
+```ruby
+t.(@other_user) { |other_user|
+  other_user.name
+}
+```
+
+#### Mixining nested object and merging
+
+```ruby
+meta_pagination_mixin = ->(t) {
+  t.meta! { |meta|
+    meta.total_pages
+    meta.current_page
+  }
+}
+```
+
+and use this mixin like:
+
+```ruby
+t[].people!(@people) { |person|
+  # ...
+}
+
+t.(@people, &meta_pagination_mixin)
+
+t.meta! { |meta|
+  meta.total_count @people.count
+}
+```
+
+the output become:
+
+```javascript
+{
+  "people": [
+    // ...
+  ],
+  "meta": {
+    "total_pages": 5,
+    "current_page": 1,
+    "total_count": 123
+  }
+}
+```
+
+Notice that two objects `meta!` got merged.
+
+### Conditions
+
+Simply you can use `if` or `unless` statement inside the block:
+
+```
+t[].people! { |person|
+  unless person.private_member?
+    person.name
+    person.age
+  end
+
+  person.cv if person.looking_for_job?
+}
+```
+
+
+With Rails
+----------
+
+Helper method is available for rendering with Jsonity:
+
+```ruby
+render_json(status: :ok) { |t|
+  # ...
+}
+```
+
+
+License
+-------
+
+This project is copyright by [Creasty](http://www.creasty.com), released under the MIT lisence.  
+See `LICENSE` file for details.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+

data/jsonity.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jsonity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jsonity'
+  spec.version       = Jsonity::VERSION
+  spec.authors       = ['Yuki Iwanaga']
+  spec.email         = ['yuki@creasty.com']
+  spec.summary       = 'The most natural language for building JSON in Ruby'
+  spec.description   = 'The most natural language for building JSON in Ruby'
+  spec.homepage      = 'https://github.com/creasty/jsonity'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.3'
+end

data/lib/jsonity/attribute.rb

@@ -0,0 +1,38 @@
+module Jsonity
+  module Attribute
+    module ClassMethods
+
+      ###
+      # Automatically export attributes to json
+      #
+      # @params {[String | Symbol]} *attrs
+      ###
+      def attr_json(*attrs)
+        @json_attributes ||= Set.new
+        @json_attributes |= attrs.map(&:to_s)
+      end
+
+      ###
+      # Get json attributes
+      #
+      # @return {[String]}
+      ###
+      def json_attributes
+        @json_attributes.to_a
+      end
+    end
+
+    module InstanceMethods
+
+      ###
+      # Get json attributes
+      #
+      # @return {[String]}
+      ###
+      def json_attributes
+        self.class.json_attributes
+      end
+
+    end
+  end
+end

data/lib/jsonity/builder.rb

@@ -0,0 +1,204 @@
+require 'set'
+
+module Jsonity
+  class Builder < BasicObject
+
+    ###
+    # Build Jsonity
+    #
+    # @params {any} object - [optional]
+    # @params {Hash | nil} content - [optional]
+    # @block
+    #
+    # @return {Hash} - json object
+    ###
+    def self.build(object = nil, content = nil, &block)
+      content = {} unless content.is_a?(::Hash)
+      builder = new object, content
+
+      if object.respond_to? :json_attributes
+        object.json_attributes.each { |a| builder.__send__ :attribute, a, nil }
+      end
+
+      builder.(&block)
+      builder.__send__ :content
+    end
+
+    ###
+    # Initializer
+    #
+    # @params {any} object
+    # @params {Hash | nil} content
+    ###
+    def initialize(object, content)
+      @object, @content = object, content
+    end
+
+    ###
+    # Set `obj` for the object
+    ###
+    def <=(obj)
+      @object = obj
+    end
+
+    ###
+    # Make array context
+    #
+    # @return {Jsonity::Builder} - `self`
+    ###
+    def []
+      @array = true
+      self
+    end
+
+    ###
+    # Mixin / Scoping
+    #
+    # @params {any} obj - [optional]
+    # @block
+    ###
+    def call(obj = nil, &block)
+      if obj
+        Builder.build obj, @content, &block
+      else
+        block_call block, self, @object
+      end
+    end
+
+
+  private
+
+    ###
+    # Handle ghost methods
+    ###
+    def method_missing(name, *args, &block)
+      name = name.to_s
+      is_object = name.match OBJECT_SUFFIX
+      name = name[0..-2] if is_object
+
+      options = args.last.is_a?(::Hash) ? args.pop : {}
+      options[:_object] = args[0]
+      options[:_nullable] = ('?' == is_object)
+
+      if @array
+        @array = false
+
+        if is_object
+          array name, options, &block
+        else
+          ::Kernel.raise UnexpectedNodeOnArrayError.new("Unexpected attribute node `#{name}`")
+        end
+      else
+        if is_object
+          hash name, options, &block
+        else
+          attribute name, options, &block
+        end
+      end
+
+      self
+    end
+
+    ###
+    # Getter for `@content`
+    #
+    # @return {Hash | nil}
+    ###
+    def content
+      @content
+    end
+
+    ###
+    # Create attribute node
+    #
+    # @params {String} name
+    # @params {Hash} options
+    # @block - [optional]
+    ###
+    def attribute(name, options, &block)
+      obj = get_object_for name, options
+
+      @content[name] = block ? block_call(block, obj || @object) : obj
+    end
+
+    ###
+    # Create hash node
+    #
+    # @params {String} name
+    # @params {Hash} options
+    # @block - [optional]
+    ###
+    def hash(name, options, &block)
+      obj = get_object_for name, options
+
+      if options[:_nullable] && !obj
+        @content[name] ||= nil
+      else
+        @content[name] = {} unless @content[name].is_a?(::Hash)
+        block ||= ->(t) {}
+        Builder.build obj, @content[name], &block
+      end
+    end
+
+    ###
+    # Create array node
+    #
+    # @params {String} name
+    # @params {Hash} options
+    # @block
+    ###
+    def array(name, options, &block)
+      obj = get_object_for name, options
+
+      is_array = obj && obj.class < ::Enumerable
+
+      if !is_array && options[:_nullable]
+        @content[name] ||= nil
+        return
+      end
+
+      @content[name] = [] unless @content[name].is_a?(::Array)
+      ary = @content[name]
+
+      if is_array
+        obj.each.with_index do |a, i|
+          # TODO: deferred build so that can be merged correctly with conditional nodes
+          ary[i] = Builder.build a, ary[i], &block
+        end
+      end
+    end
+
+    ###
+    # Get object
+    #
+    # @params {String} name
+    # @params {Hash} options - [optional]
+    #
+    # @return {any}
+    ###
+    def get_object_for(name, options = nil)
+      if options && options[:_object]
+        options[:_object]
+      elsif options && options[:inherit]
+        @object
+      elsif @object.respond_to? name
+        @object.public_send name
+      end
+    end
+
+    ###
+    # Arity safe proc call
+    #
+    # @params {Proc} block
+    # @params {[any]} *args
+    #
+    # @return {any}
+    ###
+    def block_call(block, *args)
+      ::Kernel.raise RequiredBlockError.new('No block') unless block
+
+      block.call *args.first(block.arity)
+    end
+
+  end
+end

data/lib/jsonity/core_ext.rb

@@ -0,0 +1,8 @@
+require 'jsonity/attribute'
+
+class Object
+
+  extend Jsonity::Attribute::ClassMethods
+  include Jsonity::Attribute::InstanceMethods
+
+end

data/lib/jsonity/rails.rb

@@ -0,0 +1,11 @@
+module ActionController
+  class Base
+
+    def render_json(options = {}, &block)
+      json = Jsonity::Builder.build &block
+      options[:json] = json
+      render options
+    end
+
+  end
+end

data/lib/jsonity/version.rb

@@ -0,0 +1,3 @@
+module Jsonity
+  VERSION = '1.0.0'
+end

data/lib/jsonity.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+require 'jsonity/version'
+require 'jsonity/builder'
+require 'jsonity/core_ext'
+require 'jsonity/rails' if defined? Rails
+
+module Jsonity
+
+  extend Forwardable
+
+  OBJECT_SUFFIX = /[?!]$/
+
+  ## errors
+  class RequiredBlockError < StandardError; end
+  class UnexpectedNodeOnArrayError < StandardError; end
+
+  ## shortcut
+  def_delegator Builder, :build
+  module_function :build
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: jsonity
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yuki Iwanaga
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+description: The most natural language for building JSON in Ruby
+email:
+- yuki@creasty.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- jsonity.gemspec
+- lib/jsonity.rb
+- lib/jsonity/attribute.rb
+- lib/jsonity/builder.rb
+- lib/jsonity/core_ext.rb
+- lib/jsonity/rails.rb
+- lib/jsonity/version.rb
+homepage: https://github.com/creasty/jsonity
+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.2.2
+signing_key: 
+specification_version: 4
+summary: The most natural language for building JSON in Ruby
+test_files: []