json_factory 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c49c73f5c727e2f83caad602c203bd3a4003961
-  data.tar.gz: 1b589f2f5ac1cb970f65cf741d6b5b7fa6013b16
+  metadata.gz: e4514793bfcddf9c571232e5cf6bef2f4f0e3604
+  data.tar.gz: e6370cc5a01e97d48237e9ae60b6f23f6acd6d13
 SHA512:
-  metadata.gz: 04a4f6a100f963652dd97bfc74bdfab4c7e8ddd9c414422cf43767a44f9557178a93344e94958f64c7d6a356d362f4801fb4e32bcd25cb25dc272f4eb943ddcd
-  data.tar.gz: 77002b8c955a39e6cd19635ec0e124f745bcef1cf546976b980d464af860fc1e32e04df61a0d193a86007bac76e006317ac37d6224481dc1f214c788a8c18947
+  metadata.gz: 7c49593eaacc118a094cec4ec95bd5a15c359507f870d2b7911e0445e1c2aeb5f87b065d38cfa67741368f187657dd623ba935bade271d0d7ea455e0ab3e9ce2
+  data.tar.gz: f4ed8f8663d43b36e5f5a4c23af22f6a151470655e4766c27869a12ac1594d62db271aafd67b6853c5760586248485f13e146b7b513b75dc131f9a1431cc7562

data/.rubocop.yml

@@ -12,6 +12,9 @@ Style/ClassVars:
   Exclude:
     - lib/json_factory/json_builder.rb
 
+Metrics/ClassLength:
+  Max: 150
+
 Metrics/LineLength:
   Max: 140
   Exclude:

data/README.md

@@ -22,29 +22,33 @@ Or install it yourself as:
 
 ## Usage
 
-| DSL Method    | Description                      | 
-| ------------- |:-------------------------------- |  
-| json.object!  | Create a json object             |   
-| json.array!   | Create a json array              | 
-| json.member!  | Create key value pair            |
-| json.null!    | Set object to "null"             |   
-| json.partial! | Load sub jfactory file           |
-| json.cache!   | Read and write from cache stores |
+| DSL Method | Description                                                         | 
+| ---------- |:------------------------------------------------------------------- |  
+| value      | Generates a JSON value.                                             |   
+| object     | Generates a JSON object structure.                                  |   
+| member     | Adds a key-value pair to a JSON object.                             |
+| array      | Generates a JSON array structure.                                   | 
+| element    | Adds a value to a JSON array.                                        | 
+| partial    | Loads the given partial and evaluates it using the local variables. |
+| cache      | Caches the given content under the specified key.                   |
 
 ##### Top level object  JSON structure
 
 ```ruby
 factory = <<-RUBY
-  json.object! do |json|
-    json.object!(:data) do |json|
-      json.member!(:id, object.id)
-      json.member!(:name, object.name)
-
-      json.array!(object.test_objects, :test_array) do |json, test_object|
-        json.member!(:id, test_object.id)
-        json.member!(:name, test_object.name)
+  json.object do
+    json.member :data do
+      json.object do
+        json.member :id, object.id
+        json.member :name, object.name
+        json.member :test_array do
+          json.object_array(object.test_objects) do |test_object|
+            json.member :id, test_object.id)
+            json.member :name, test_object.name
+          end
+        end
       end
-    end
+    end 
   end
 RUBY
 
@@ -53,10 +57,7 @@ test_object_1 = OpenStruct.new(id: '001', name: 'TestObject2')
 test_object_2 = OpenStruct.new(id: '002', name: 'TestObject3')
 test_object = OpenStruct.new(id: '1', name: 'TestObject1', test_objects: [test_object_1, test_object_2])
 
-# create context object
-context = JSONFactory::Context.new(object: test_object)
-
-puts JSONFactory::JSONBuilder.new(factory, context).build
+puts JSONFactory.build(factory, object: test_object)
 ```
 
 ```json
@@ -76,9 +77,9 @@ puts JSONFactory::JSONBuilder.new(factory, context).build
 
 ```ruby
 factory = <<-RUBY
-  json.array! objects do |json, test_object|
-    json.member!(:id, test_object.id)
-    json.member!(:name, test_object.name)
+  json.object_array objects  do |test_object|
+    json.member :id, test_object.id
+    json.member :name, test_object.name
   end
 RUBY
 
@@ -86,10 +87,7 @@ RUBY
 test_object_1 = OpenStruct.new(id: '001', name: 'TestObject2')
 test_object_2 = OpenStruct.new(id: '002', name: 'TestObject3')
 
-# create context object
-context = JSONFactory::Context.new(objects: [test_object_1, test_object_2])
-
-puts JSONFactory::JSONBuilder.new(factory, context).build
+puts JSONFactory.build(factory, objects: [test_object_1, test_object_2])
 ```
 
 ```json
@@ -103,32 +101,29 @@ puts JSONFactory::JSONBuilder.new(factory, context).build
 
 ```ruby
 # tmp/test.jfactory
-json.member!(:id, test_object.id)
-json.member!(:name, test_object.name)
+json.member :id, test_object.id
+json.member :name, test_object.name
 ``` 
 
 ```ruby
 # test data
 test_object = OpenStruct.new(id: '1', name: 'TestObject1')
 
-# create context object
-context = JSONFactory::Context.new(object: test_object)
-
-puts JSONFactory::JSONBuilder.load_factory_file('tmp/test.jfactory', context).build # => { "id": 1, name: "TestObject1" }
+puts JSONFactory.build('tmp/test.jfactory', object: test_object).build # => { "id": 1, name: "TestObject1" }
 ```        
 
 ##### Load partials 
 
 ```ruby
 # tmp/_test_partial.jfactory
-json.member!(:id, test_object.id)
-json.member!(:name, test_object.name)
+json.member :id, test_object.id
+json.member :name, test_object.name
 ```  
 
 ```ruby
 # tmp/test.jfactory
-json.object! do |json|
-  json.partial!('tmp/test_partial', test_object: object)
+json.object do
+  json.partial 'tmp/test_partial', test_object: object
 end
 ``` 
 
@@ -136,21 +131,20 @@ end
 # test data
 test_object = OpenStruct.new(id: '1', name: 'TestObject1')
 
-# create context object
-context = JSONFactory::Context.new(object: test_object)
-
-puts JSONFactory::JSONBuilder.load_factory_file('tmp/test.jfactory', context).build # => { "id": 1, name: "TestObject1" }
+puts JSONFactory.build('tmp/test.jfactory', object: test_object).build # => { "id": 1, name: "TestObject1" }
 ```  
 
 ##### Use cache stores
 
 ```ruby
 factory = <<-RUBY
-  json.object! do |json|
-    json.object!(:data) do |json|
-      json.cache! 'test-cache-key' do |json|
-        json.member!(:id, object.id)
-        json.member!(:name, object.name)
+  json.object do
+    json.member :data do
+      json.object do
+        json.cache 'test-cache-key' do
+          json.member :id, object.id
+          json.member :name, object.name
+        end
       end
     end
   end
@@ -159,12 +153,9 @@ RUBY
 # test data 
 test_object = OpenStruct.new(id: '1', name: 'TestObject1')
 
-# create context object
-context = JSONFactory::Context.new(object: test_object)
+JSONFactory::Cache.instance.store = ActiveSupport::Cache::MemoryStore.new
 
-builder = JSONFactory::JSONBuilder.new(factory, context)
-builder.cache.store = ActiveSupport::Cache::MemoryStore.new
-puts builder.build # => { "data": { "id": "1", "name": "TestObject1" } }
+puts JSONFactory.build(factory, object: test_object) # => { "data": { "id": "1", "name": "TestObject1" } }
 ```
 
 ## Development

data/examples/benchmark.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require 'bundler'
+Bundler.setup
+
 require 'jbuilder'
 require 'benchmark'
 require 'forgery'
 
-require_relative '../lib/json_factory'
+require 'json_factory'
 
 objects = []
 sub_array = []
@@ -28,9 +31,8 @@ end
 end
 
 # CURRENT RUNTIME WITH 1000 and 10 = 0.133410
-Benchmark.bmbm(15) do |x|
+Benchmark.bmbm(10) do |x|
   x.report(:json_factory) do
-    builder = JSONFactory::JSONBuilder.load_factory_file('fixtures/test.jfactory')
-    builder.build(JSONFactory::Context.new(objects: objects))
+    JSONFactory.build('fixtures/test.jfactory', objects: objects)
   end
 end

data/examples/fixtures/_test_partial.jfactory

@@ -1 +1 @@
-json.member!(:id, context.id)
+json.member :id, id

data/examples/fixtures/test.jfactory

@@ -1,8 +1,10 @@
-json.array! objects do |json, test_object|
-  json.member!(:id, test_object.id)
-  json.member!(:name, test_object.name)
-  json.member!(:description, test_object.description)
-  json.array!(test_object.test_array, :test_array) do |json, test_sub_object|
-    json.partial! 'fixtures/test_partial', id: test_sub_object.id
+json.object_array(objects) do |test_object|
+  json.member :id, test_object.id
+  json.member :name, test_object.name
+  json.member :description, test_object.description
+  json.member :test_array do
+    json.object_array(test_object.test_array) do |test_sub_object|
+      json.partial 'fixtures/test_partial', id: test_sub_object.id
+    end
   end
 end

data/examples/readme_examples.rb

@@ -1,19 +1,22 @@
+# frozen_string_literal: true
+
 require_relative '../lib/json_factory'
 
 # test data
-test_object_1 = OpenStruct.new(id: '001', name: 'TestObject2')
-test_object_2 = OpenStruct.new(id: '002', name: 'TestObject3')
-test_object = OpenStruct.new(id: '1', name: 'TestObject1', description: 'Test2', test_objects: [test_object_1, test_object_2])
+test_object1 = OpenStruct.new(id: '001', name: 'TestObject2')
+test_object2 = OpenStruct.new(id: '002', name: 'TestObject3')
+test_object = OpenStruct.new(id: '1', name: 'TestObject1', description: 'Test2', test_objects: [test_object1, test_object2])
 
 factory = <<-RUBY
-  json.object! do |json|
-    json.object!(:data) do |json|
-      json.member!(:id, object.id)
-      json.member!(:name, object.name)
-
-      json.array!(object.test_objects, :test_array) do |json, test_object|
-        json.member!(:id, test_object.id)
-        json.member!(:name, test_object.name)
+  object! do
+    object!(:data) do
+      member!(:id, object.id)
+      member!(:name, object.name)
+      member!(:test_array) do
+        array!(object.test_objects) do |test_object|
+          member!(:id, test_object.id)
+          member!(:name, test_object.name)
+        end
       end
     end
   end
@@ -24,15 +27,13 @@ context = JSONFactory::Context.new(object: test_object)
 
 puts JSONFactory::JSONBuilder.new(factory, context).build
 
-
-
 factory = <<-RUBY
-  json.array! objects do |json, test_object|
-    json.member!(:id, test_object.id)
-    json.member!(:name, test_object.name)
+  array! objects do |test_object|
+    member!(:id, test_object.id)
+    member!(:name, test_object.name)
   end
 RUBY
 # create context object
-context = JSONFactory::Context.new(objects: [test_object_1, test_object_2])
+context = JSONFactory::Context.new(objects: [test_object1, test_object2])
 
 puts JSONFactory::JSONBuilder.new(factory, context).build

data/json_factory.gemspec

@@ -7,11 +7,9 @@ require 'json_factory/version'
 Gem::Specification.new do |spec|
   spec.name          = 'json_factory'
   spec.version       = JSONFactory::VERSION
-  spec.authors       = ['Alexander Klaiber']
-  spec.email         = ['alex.klaiber@gmail.com']
+  spec.author        = 'Alexander Klaiber'
 
-  spec.summary       = 'JsonFactory is a Easy DSL to create JSON structures with the development focus on performance.'
-  spec.description   = 'JsonFactory is a Easy DSL to create JSON structures with the development focus on performance.'
+  spec.summary       = 'JsonFactory is a easy DSL to create JSON structures with a development focus on performance.'
   spec.homepage      = 'https://github.com/aklaiber/json_factory'
   spec.license       = 'MIT'
 
@@ -19,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'activesupport', '>= 5.1.0'
-  spec.add_runtime_dependency 'oj'
+  spec.add_runtime_dependency 'json'
   spec.add_runtime_dependency 'redis-activesupport', '>= 5.0.0'
 
   spec.add_development_dependency 'bundler'

data/lib/json_factory.rb

@@ -1,21 +1,34 @@
 # frozen_string_literal: true
 
-require 'oj'
-
 require 'active_support'
 require 'active_support/cache/redis_store'
 
+require 'json_factory/railtie' if defined?(Rails)
+
 require_relative 'json_factory/version'
-require_relative 'json_factory/context'
+require_relative 'json_factory/configuration'
+require_relative 'json_factory/errors'
+require_relative 'json_factory/state'
+require_relative 'json_factory/converter'
+require_relative 'json_factory/dsl'
+require_relative 'json_factory/dsl/object_array'
+require_relative 'json_factory/template_store'
 require_relative 'json_factory/json_builder'
-require_relative 'json_factory/json_object'
+require_relative 'json_factory/builder'
 
 module JSONFactory
-  autoload :Cache,            'json_factory/cache.rb'
-  autoload :CacheError,       'json_factory/cache_error.rb'
-  autoload :CacheStoreProxy,  'json_factory/cache_store_proxy.rb'
-  autoload :BaseStoreProxy,   'json_factory/cache_store_proxy/base_store_proxy.rb'
-  autoload :RedisStoreProxy,  'json_factory/cache_store_proxy/redis_store_proxy.rb'
-  autoload :MemoryStoreProxy, 'json_factory/cache_store_proxy/memory_store_proxy.rb'
-  autoload :FileStoreProxy,   'json_factory/cache_store_proxy/file_store_proxy.rb'
+  autoload :Cache, 'json_factory/cache'
+  autoload :TemplateStore, 'json_factory/template_store.rb'
+
+  def self.build(template, local_variables = {})
+    Builder.new(template, local_variables).build
+  end
+
+  def self.configure
+    if block_given?
+      yield Configuration.instance
+    else
+      Configuration.instance
+    end
+  end
 end

data/lib/json_factory/builder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module JSONFactory
+  class Builder
+    def initialize(template, local_variables = {})
+      @io = StringIO.new
+      @template = template
+      @local_variables = local_variables
+    end
+
+    def context
+      @local_variables
+    end
+
+    def build
+      json_builder = JSONBuilder.new(@io)
+      if File.exist?(@template)
+        json_builder.render_template(@template, @local_variables)
+      else
+        json_builder.render_string(@template, @local_variables)
+      end
+      @io.string
+    end
+  end
+end

data/lib/json_factory/cache.rb

@@ -3,24 +3,18 @@
 module JSONFactory
   class Cache
     include Singleton
-
-    attr_accessor :prefix
+    attr_accessor :store, :prefix
 
     def initialize
       @prefix = 'json_factory'
-
-      self.store = ::Rails.cache if defined?(::Rails.cache)
     end
 
-    attr_reader :store
-    alias store_proxy store
-
-    def store=(store)
-      @store = CacheStoreProxy.build(store)
+    def transform_key(key)
+      [prefix, key].compact.join(':')
     end
 
-    delegate :read, to: :store
-    delegate :write, to: :store
-    delegate :delete, to: :store
+    def fetch(key, options = nil, &block)
+      store.fetch(transform_key(key), options, &block)
+    end
   end
 end

data/lib/json_factory/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module JSONFactory
+  class Configuration
+    include Singleton
+
+    attr_reader :helpers
+
+    def initialize
+      @helpers = []
+    end
+
+    def include_helper(mod)
+      @helpers.push(mod)
+    end
+  end
+end

data/lib/json_factory/converter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module JSONFactory
+  module Converter
+    def self.json_key(object)
+      json_value(object.to_s)
+    end
+
+    def self.json_value(object)
+      raise "don't know how to convert #{object.inspect} (#{object.class})" unless object.respond_to?(:to_json)
+      object.to_json
+    end
+  end
+end

data/lib/json_factory/dsl.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module JSONFactory
+  class DSL
+    def self.check_arity(argc, expected)
+      return if expected === argc # rubocop:disable Style/CaseEquality
+      raise ArgumentError, "wrong number of arguments (given #{argc}, expected #{expected})"
+    end
+
+    def initialize(builder)
+      @builder = builder
+    end
+
+    # :call-seq:
+    #   json.value(value) -> nil
+    #
+    # Generates a JSON value.
+    #
+    #    json.value 1     # generates: 1
+    #    json.value nil   # generates: null
+    #    json.value :foo  # generates: "foo"
+    def value(value)
+      warn 'given block not used' if block_given?
+      @builder.value(value)
+    end
+
+    # :call-seq:
+    #   json.array           -> nil
+    #   json.array { block } -> nil
+    #
+    # Generates a JSON array structure.
+    #
+    # The block is evaluated in order to add element to the array.
+    #
+    # If no block is given, an empty array is generated.
+    #
+    #    json.array
+    #    # generates: []
+    #
+    #    json.array do
+    #      json.element 1
+    #      json.element 2
+    #    end
+    #    # generates: [1,2]
+    def array(&block)
+      @builder.array(&block)
+    end
+
+    # :call-seq:
+    #   json.element(value)    -> nil
+    #   json.element { block } -> nil
+    #
+    # Adds a value to a JSON array. Results in an exception if called outside an
+    # array.
+    #
+    # If an argument is given, it is used as the element's value.
+    #
+    # If a block is given, it is evaluated in order to add nested structures.
+    #
+    #    json.array do
+    #      json.element 1
+    #      json.element 2
+    #      json.element do
+    #        json.array do
+    #          json.element 3
+    #          json.element 4
+    #        end
+    #      end
+    #    end
+    #    # generates: [1,2,[3,4]]
+    def element(*args)
+      if block_given?
+        DSL.check_arity(args.length, 0..1)
+        warn 'block supersedes value argument' if args.length == 1 && block_given?
+        @builder.element { yield }
+      else
+        DSL.check_arity(args.length, 1)
+        @builder.element(*args)
+      end
+    end
+
+    # :call-seq:
+    #   json.object           -> nil
+    #   json.object { block } -> nil
+    #
+    # Generates a JSON object structure.
+    #
+    # The block is evaluated in order to add key-value pairs to the object.
+    #
+    # If no block is given, an empty object is generated.
+    #
+    #    json.object
+    #    # generates: {}
+    #
+    #    json.object do
+    #      json.member :foo, 1
+    #      json.member :bar, 2
+    #    end
+    #    # generates: {"foo":1,"bar":2}
+    def object
+      if block_given?
+        @builder.object { yield }
+      else
+        @builder.object
+      end
+    end
+
+    # :call-seq:
+    #   json.member(key, value)    -> nil
+    #   json.member(key) { block } -> nil
+    #
+    # Adds a key-value pair to a JSON object. Results in an exception if called
+    # outside an object.
+    #
+    # The first argument is used as the key. If a second argument is given, it
+    # is used as the member's value.
+    #
+    # If a block is given, it is evaluated in order to add nested structures.
+    #
+    #    json.object do
+    #      json.member :foo, 1
+    #      json.member :bar, 2
+    #      json.member :baz do
+    #        json.array do
+    #          json.element 3
+    #          json.element 4
+    #        end
+    #      end
+    #    end
+    #    # generates: {"foo":1,"bar":2,"baz":[3,4]}
+    def member(*args)
+      if block_given?
+        DSL.check_arity(args.length, 1..2)
+        warn 'block supersedes value argument' if args.length == 2 && block_given?
+        @builder.member(*args) { yield }
+      else
+        DSL.check_arity(args.length, 2)
+        @builder.member(*args)
+      end
+    end
+
+    # :call-seq:
+    #   json.cache(key) { block } -> nil
+    #
+    # Caches the given content under the specified key.
+    #
+    # If a cache entry is found, it is added to the output. Otherwise, the given
+    # block is evaluated and the result is stored in the cache.
+    #
+    #    json.object do
+    #      json.member :foo, 1
+    #      cache 'test-key' do
+    #        json.member :bar, 2   # will be stored in the cache
+    #      end
+    #      cache 'test-key' do
+    #        json.member :baz, 3   # will be ignored
+    #      end
+    #    end
+    #    # generates: {"foo":1,"bar":2,"bar":2}
+    #
+    # When caching object members or array elements, commas are inserted as
+    # needed. However, no further checks are performed, so improper use may
+    # result in invalid JSON, for example by adding cached object members to an
+    # array.
+    def cache(key)
+      @builder.cache(key) { yield }
+    end
+
+    # :call-seq:
+    #   json.partial(file, local_variables = {})
+    #
+    # Loads the given partial and evaluates it using the local variables.
+    #
+    #    # simple.jfactory
+    #    json.object do
+    #      json.member :name, name
+    #    end
+    #
+    #    json.array do
+    #      json.element do
+    #        json.partial 'simple.jfactory', name: 'foo'
+    #      end
+    #      json.element do
+    #        json.partial 'simple.jfactory', name: 'bar'
+    #      end
+    #    end
+    #    # generates: [{"name":"foo"},{"name":"bar"}]
+    #
+    # Partial files are loaded only once to minimize file access.
+    def partial(file, local_variables = {})
+      path = Pathname.new(File.expand_path(file))
+      path = "#{path.dirname}/_#{path.basename}.jfactory" if path.extname.empty?
+      @builder.partial(path.to_s, local_variables)
+    end
+  end
+end

data/lib/json_factory/dsl/object_array.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSONFactory
+  class DSL
+    # Helper method to generate an array of objects.
+    #
+    #   json.object_array([1,2,3]) do |id|
+    #     json.member :id, id
+    #   end
+    #   # generates: [{"id":1},{"id":2},{"id":2}]
+    #
+    # The above is equivalent to:
+    #
+    #   json.array do
+    #     [1,2,3].each do |id|
+    #       json.object do
+    #         json.member :id, id
+    #       end
+    #     end
+    #   end
+    #   # generates: [{"id":1},{"id":2},{"id":2}]
+    def object_array(collection)
+      array do
+        collection.each do |*values|
+          element do
+            object do
+              yield(*values)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_factory/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module JSONFactory
+  class BuilderError < StandardError
+  end
+
+  class TypeNotAllowedError < BuilderError
+  end
+
+  class EmptyValueError < BuilderError
+  end
+end

data/lib/json_factory/json_builder.rb

@@ -2,30 +2,161 @@
 
 module JSONFactory
   class JSONBuilder
-    attr_accessor :output
-    attr_reader :stream, :factory, :cache
+    BUILDER_VARIABLE_NAME = :json
 
-    def self.load_factory_file(path, context = nil)
-      raise "file format is invalid. #{path}" unless File.extname(path).eql?('.jfactory')
-      raise "jfactory file #{path} not found" unless File.exist?(path)
-      new(File.open(path).read, context)
-    end
+    TOKEN_LEFT_SQUARE_BRACKET = '['
+    TOKEN_RIGHT_SQUARE_BRACKET = ']'
+    TOKEN_LEFT_CURLY_BRACKET = '{'
+    TOKEN_RIGHT_CURLY_BRACKET = '}'
+    TOKEN_COLON = ':'
+    TOKEN_COMMA = ','
 
-    def initialize(factory, context = nil)
-      @factory = factory
+    def initialize(io, type = :value)
+      @stack = [State.new(io, type)]
       @cache = Cache.instance
-      @context = context
+      @template_store = TemplateStore.instance
+    end
+
+    def value(value = nil)
+      raise TypeNotAllowedError, 'Can only add value as a value' unless type == :value
+      raise TypeNotAllowedError, 'Cannot add multiple values' unless count.zero?
+      add_value(value)
+      increment_count
+    end
+
+    def array
+      raise TypeNotAllowedError, 'Can only add array as a value' unless type == :value
+      raise TypeNotAllowedError, 'Cannot add multiple values' unless count.zero?
+
+      io << TOKEN_LEFT_SQUARE_BRACKET
+      push_type(:array) { yield } if block_given?
+      io << TOKEN_RIGHT_SQUARE_BRACKET
+      increment_count
+    end
+
+    def element(value = nil)
+      raise TypeNotAllowedError, 'Can only add an element within an array' unless type == :array
+
+      add_separator
+      if block_given?
+        push_type(:value) { yield }
+      else
+        add_value(value)
+      end
+      increment_count
+    end
+
+    def object
+      raise TypeNotAllowedError, 'Can only add object as a value' unless type == :value
+      raise TypeNotAllowedError, 'Cannot add multiple values' unless count.zero?
+
+      io << TOKEN_LEFT_CURLY_BRACKET
+      push_type(:object) { yield } if block_given?
+      io << TOKEN_RIGHT_CURLY_BRACKET
+      increment_count
+    end
+
+    def member(key, value = nil)
+      raise TypeNotAllowedError, 'Can only add a member within an object' unless type == :object
+
+      add_separator
+      io << Converter.json_key(key)
+      io << TOKEN_COLON
+      if block_given?
+        push_type(:value) { yield }
+      else
+        add_value(value)
+      end
+      increment_count
+    end
+
+    def cache(key)
+      value = @cache.fetch(key) do
+        cache_io = StringIO.new
+        push_io(cache_io) { yield }
+        cache_io.string
+      end
+      raise EmptyValueError if value.empty?
+
+      add_separator
+      io << value
+      increment_count
+    end
+
+    def evaluate(string, local_variables, filename)
+      binding = jfactory
+      local_variables.each_pair do |key, value|
+        binding.local_variable_set(key, value)
+      end
+      binding.local_variable_set(BUILDER_VARIABLE_NAME, DSL.new(self))
+      eval(string, binding, filename.to_s) # rubocop:disable Security/Eval
+    end
+
+    def render_template(filename, local_variables)
+      template = @template_store.get(filename)
+      evaluate(template, local_variables, filename)
+    end
+    alias partial render_template
+
+    def render_string(string, local_variables)
+      evaluate(string, local_variables, '(inline)')
+    end
+
+    private
+
+    def add_value(value)
+      io << Converter.json_value(value)
     end
 
-    def build
-      @output  =  StringIO.new
-      @stream  = Oj::StreamWriter.new(@output, indent: 0)
+    def add_separator
+      io << TOKEN_COMMA unless count.zero?
+    end
+
+    def io
+      @stack.last.io
+    end
+
+    def type
+      @stack.last.type
+    end
+
+    def count
+      @stack.last.count
+    end
+
+    def increment_count
+      @stack.last.count += 1
+    end
+
+    def push_io(io)
+      @stack.push(State.new(io, type))
+      yield
+      @stack.pop
+    end
+
+    def push_type(type)
+      @stack.push(State.new(io, type))
+      yield
+      raise EmptyValueError if type == :value && count.zero?
+      @stack.pop
+    end
+  end
+end
 
-      JSONObject.new(self, @context).schema! { |json|
-        json.instance_eval(@factory)
-      }
+JSONFactory::JSONBuilder.class_eval do
+  # Returns an empty evaluation context, similar to Ruby's main object.
+  def jfactory
+    Object.allocate.instance_eval do
+      class << self
+        JSONFactory.configure.helpers.each { |mod| include mod }
 
-      @output.string.delete("\n").gsub('null}', 'null') if @output
+        def to_s
+          'jfactory'
+        end
+        alias inspect to_s
+      end
+      return binding
     end
   end
+  private :jfactory
 end

data/lib/json_factory/railtie.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JSONFactory
+  class Railtie < Rails::Railtie
+    initializer 'json_factory.cache' do
+      Cache.instance.store = Rails.cache
+    end
+
+    initializer 'json_factory.jfactory_watcher' do |app|
+      jfactory_reloader = app.config.file_watcher.new(Dir.glob(::Rails.root.join('app/views/**/*.jfactory'))) do
+        TemplateStore.instance.clear
+      end
+
+      app.reloaders << jfactory_reloader
+
+      config.to_prepare do
+        jfactory_reloader.execute_if_updated
+      end
+    end
+  end
+end

data/lib/json_factory/state.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module JSONFactory
+  class State
+    attr_accessor :io, :type, :count
+
+    def initialize(io, type, count = 0)
+      @io = io
+      @type = type
+      @count = count
+    end
+  end
+end

data/lib/json_factory/template_store.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JSONFactory
+  class TemplateStore
+    include Singleton
+
+    def initialize
+      @templates = {}
+    end
+
+    def get(path)
+      if @templates.key? path
+        @templates.fetch(path)
+      else
+        @templates.store(path, read_template(path))
+      end
+    end
+
+    def clear
+      @templates.clear
+    end
+
+    private
+
+    def read_template(path)
+      raise "file format is invalid. #{path}" unless File.extname(path).eql?('.jfactory')
+      raise "jfactory file #{path} not found" unless File.exist?(path)
+      File.read(path)
+    end
+  end
+end

data/lib/json_factory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONFactory
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_factory
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Alexander Klaiber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-08 00:00:00.000000000 Z
+date: 2018-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 5.1.0
 - !ruby/object:Gem::Dependency
-  name: oj
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -150,10 +150,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: JsonFactory is a Easy DSL to create JSON structures with the development
-  focus on performance.
-email:
-- alex.klaiber@gmail.com
+description: 
+email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -176,16 +174,17 @@ files:
 - examples/readme_examples.rb
 - json_factory.gemspec
 - lib/json_factory.rb
+- lib/json_factory/builder.rb
 - lib/json_factory/cache.rb
-- lib/json_factory/cache_error.rb
-- lib/json_factory/cache_store_proxy.rb
-- lib/json_factory/cache_store_proxy/base_store_proxy.rb
-- lib/json_factory/cache_store_proxy/file_store_proxy.rb
-- lib/json_factory/cache_store_proxy/memory_store_proxy.rb
-- lib/json_factory/cache_store_proxy/redis_store_proxy.rb
-- lib/json_factory/context.rb
+- lib/json_factory/configuration.rb
+- lib/json_factory/converter.rb
+- lib/json_factory/dsl.rb
+- lib/json_factory/dsl/object_array.rb
+- lib/json_factory/errors.rb
 - lib/json_factory/json_builder.rb
-- lib/json_factory/json_object.rb
+- lib/json_factory/railtie.rb
+- lib/json_factory/state.rb
+- lib/json_factory/template_store.rb
 - lib/json_factory/version.rb
 homepage: https://github.com/aklaiber/json_factory
 licenses:
@@ -210,6 +209,6 @@ rubyforge_project:
 rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: JsonFactory is a Easy DSL to create JSON structures with the development
-  focus on performance.
+summary: JsonFactory is a easy DSL to create JSON structures with a development focus
+  on performance.
 test_files: []

data/lib/json_factory/cache_error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module JSONFactory
-  class CacheError < StandardError
-  end
-end

data/lib/json_factory/cache_store_proxy.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module JSONFactory
-  module CacheStoreProxy
-    PROXIES = [RedisStoreProxy, MemoryStoreProxy, FileStoreProxy].freeze
-
-    def self.build(store)
-      store_proxy = PROXIES.find { |proxy| proxy.handle?(store) }
-      fail CacheError, "#{store.class} is a not supported cache" if store_proxy.nil?
-      store_proxy.new(store)
-    end
-  end
-end

data/lib/json_factory/cache_store_proxy/base_store_proxy.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module JSONFactory
-  module CacheStoreProxy
-    class BaseStoreProxy
-      attr_reader :store
-
-      def self.handle?(store)
-        defined?(self::STORE_CLASS) && store.is_a?(self::STORE_CLASS)
-      end
-
-      def initialize(store, prefix = 'json_factory')
-        @store = store
-        @prefix = prefix
-      end
-
-      def read(key, options = nil)
-        store.read("#{@prefix}:#{key}", options)
-      end
-
-      def write(key, value, options = nil)
-        store.write("#{@prefix}:#{key}", value, options)
-      end
-
-      def delete(key, options = nil)
-        store.delete("#{@prefix}:#{key}", options)
-      end
-    end
-  end
-end

data/lib/json_factory/cache_store_proxy/file_store_proxy.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module JSONFactory
-  module CacheStoreProxy
-    class FileStoreProxy < BaseStoreProxy
-      STORE_CLASS = ActiveSupport::Cache::FileStore.freeze
-    end
-  end
-end

data/lib/json_factory/cache_store_proxy/memory_store_proxy.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module JSONFactory
-  module CacheStoreProxy
-    class MemoryStoreProxy < BaseStoreProxy
-      STORE_CLASS = ActiveSupport::Cache::MemoryStore.freeze
-    end
-  end
-end

data/lib/json_factory/cache_store_proxy/redis_store_proxy.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module JSONFactory
-  module CacheStoreProxy
-    class RedisStoreProxy < BaseStoreProxy
-      STORE_CLASS = ActiveSupport::Cache::RedisStore.freeze
-    end
-  end
-end

data/lib/json_factory/context.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module JSONFactory
-  class Context
-    def initialize(data = nil)
-      @data = data
-    end
-
-    def add(key, value)
-      @data[key] = value
-    end
-
-    def method_missing(method_name, *arguments, &block)
-      return @data[method_name] if @data.is_a?(Hash) && @data.key?(method_name)
-      super
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      (@data.is_a?(Hash) && @data.key?(method_name)) || super
-    end
-  end
-end

data/lib/json_factory/json_object.rb

@@ -1,86 +0,0 @@
-module JSONFactory
-  class JSONObject
-    attr_reader :json_builder
-    attr_accessor :context
-
-    @@partials = {}
-
-    def initialize(json_builder, context = nil)
-      @json_builder = json_builder
-      @context = context
-    end
-
-    def open_object
-      json_builder.stream.push_object
-    end
-
-    def close_object
-      json_builder.stream.pop
-    end
-
-    def schema!(object = nil)
-      yield self, object
-      self
-    end
-
-    def object!(key = nil, &block)
-      json_object = JSONObject.new(json_builder)
-
-      json_builder.stream.push_key(key.to_s) if key
-
-      json_object.open_object
-      json_object.schema!(&block)
-      json_object.close_object
-    end
-
-    def array!(array, key = nil, &block)
-      json_builder.stream.push_array(key ? key.to_s : nil)
-      array.each do |object|
-        builder = JSONObject.new(json_builder)
-        builder.open_object
-        builder.schema!(object, &block)
-        builder.close_object
-      end
-      json_builder.stream.pop
-    end
-
-    def member!(key, value = nil)
-      json_builder.stream.push_value(value, key.to_s)
-    end
-
-    def null!
-      json_builder.output.seek(json_builder.output.pos - 1)
-      json_builder.output.puts('null')
-    end
-
-    def cache!(cache_key, &block)
-      json = json_builder.cache.read(cache_key) if cache_key && json_builder.cache
-      return json_builder.output.puts(json) unless json.blank?
-
-      start_cache_pos = json_builder.output.pos
-      self.schema!(&block)
-      end_cache_pos = json_builder.output.pos
-
-      json_builder.cache.write(cache_key, json_builder.output.string[start_cache_pos..end_cache_pos])
-    end
-
-    def partial!(path, data = {})
-      path = Pathname.new(path)
-
-      if path.extname.eql?('.jfactory')
-        @@partials[path] ||= File.open(path).read
-      else
-        @@partials[path] ||= File.open("#{path.dirname}/_#{path.basename}.jfactory").read
-      end
-
-      JSONObject.new(json_builder, JSONFactory::Context.new(data)).schema! do |json|
-        json.instance_eval(@@partials[path])
-      end
-    end
-
-    def method_missing(method_name, *arguments, &block)
-      return context.send(method_name) if context.respond_to?(method_name)
-      super
-    end
-  end
-end