turbostreamer 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f57b4f2c7ce7f14ba08eaae9087d07e8d69ae6d
+  data.tar.gz: 7eb8046991d046191bc47378689739e971abdb80
+SHA512:
+  metadata.gz: e3abb1caae47743829462991a5d2f10798bc45c07ee5b51154424f522a08766520b9638d81bdbe84fda5b28208c5f72e7af148d28242ed63fa410cd7ff4a76f8
+  data.tar.gz: 87118ef8372d08d696d2f9e2f3e703352ce04e3c9dbe5d30510a0e2edd05c3d8ab1f76ab8f66eda74007e1cd6de98e2d550f747b355a2cf65b5052444e8cd95c

data/README.md

@@ -0,0 +1,305 @@
+# TurboStreamer [![Build Status](https://api.travis-ci.org/malomalo/turbostreamer.svg)](https://travis-ci.org/malomalo/turbostreamer)
+
+TurboStreamer gives you a simple DSL for generating JSON that beats massaging giant
+hash structures. This is particularly helpful when the generation process is
+fraught with conditionals and loops.
+
+
+[Jbuilder](https://github.com/rails/jbuilder) builds a Hash as it renders the
+template and once complete converts the Hash to JSON. TurboStreamer on the other
+hand writes directly to the output as it is rendering the template. Because of
+this some of the magic cannot be done and requires a little more verboseness.
+
+Examples
+--------
+
+``` ruby
+# app/views/message/show.json.streamer
+
+json.object! do
+  json.content format_content(@message.content)
+  json.extract! @message, :created_at, :updated_at
+
+  json.author do
+    json.object! do
+      json.name @message.creator.name.familiar
+      json.email_address @message.creator.email_address_with_name
+      json.url url_for(@message.creator, format: :json)
+    end
+  end
+
+  if current_user.admin?
+    json.visitors calculate_visitors(@message)
+  end
+  
+  json.tags do
+    json.array! do
+      @message.tags.each { |tag| json.child! tag }
+    end
+  end
+
+  json.comments @message.comments, :content, :created_at
+
+  json.attachments @message.attachments do |attachment|
+    json.object! do
+      json.filename attachment.filename
+      json.url url_for(attachment)
+    end
+  end
+end
+```
+
+This will build the following structure:
+
+``` javascript
+{
+  "content": "<p>This is <i>serious</i> monkey business</p>",
+  "created_at": "2011-10-29T20:45:28-05:00",
+  "updated_at": "2011-10-29T20:45:28-05:00",
+
+  "author": {
+    "name": "David H.",
+    "email_address": "'David Heinemeier Hansson' <david@heinemeierhansson.com>",
+    "url": "http://example.com/users/1-david.json"
+  },
+
+  "visitors": 15,
+
+  "tags": ['public'],
+  
+  "comments": [
+    { "content": "Hello everyone!", "created_at": "2011-10-29T20:45:28-05:00" },
+    { "content": "To you my good sir!", "created_at": "2011-10-29T20:47:28-05:00" }
+  ],
+
+  "attachments": [
+    { "filename": "forecast.xls", "url": "http://example.com/downloads/forecast.xls" },
+    { "filename": "presentation.pdf", "url": "http://example.com/downloads/presentation.pdf" }
+  ]
+}
+```
+
+To define attribute and structure names dynamically, use the `set!` method:
+
+``` ruby
+json.object! do
+  json.set! :author do
+    json.object! do
+      json.set! :name, 'David'
+    end
+  end
+end
+
+# => { "author": { "name": "David" } }
+```
+
+Top level arrays can be handled directly.  Useful for index and other collection
+actions.
+
+``` ruby
+json.array! @comments do |comment|
+  next if comment.marked_as_spam_by?(current_user)
+
+  json.object! do
+    json.body comment.body
+    json.author do
+      json.first_name comment.author.first_name
+      json.last_name comment.author.last_name
+    end
+  end
+end
+
+# => [ { "body": "great post...", "author": { "first_name": "Joe", "last_name": "Bloe" }} ]
+```
+
+You can also extract attributes from array directly.
+
+``` ruby
+# @people = People.all
+
+json.array! @people, :id, :name
+
+# => [ { "id": 1, "name": "David" }, { "id": 2, "name": "Jamie" } ]
+```
+
+You can either use TurboStreamer stand-alone or directly as an ActionView template
+language. When required in Rails, you can create views ala show.json.streamer
+(the json is already yielded):
+
+``` ruby
+# Any helpers available to views are available to the builder
+json.object! do
+  json.content format_content(@message.content)
+  json.extract! @message, :created_at, :updated_at
+
+  json.author do
+    json.object! do
+      json.name @message.creator.name.familiar
+      json.email_address @message.creator.email_address_with_name
+      json.url url_for(@message.creator, format: :json)
+    end
+  end
+  
+  if current_user.admin?
+    json.visitors calculate_visitors(@message)
+  end
+end
+```
+
+You can use partials as well. The following will render the file
+`views/comments/_comments.json.streamer`, and set a local variable
+`comments` with all this message's comments, which you can use inside
+the partial.
+
+```ruby
+json.partial! 'comments/comments', comments: @message.comments
+```
+
+It's also possible to render collections of partials:
+
+```ruby
+json.array! @posts, partial: 'posts/post', as: :post
+
+# or
+
+json.partial! 'posts/post', collection: @posts, as: :post
+
+# or
+
+json.partial! partial: 'posts/post', collection: @posts, as: :post
+
+# or
+
+json.comments @post.comments, partial: 'comment/comment', as: :comment
+```
+
+You can explicitly make TurboStreamer object return null if you want:
+
+``` ruby
+json.extract! @post, :id, :title, :content, :published_at
+json.author do
+  if @post.anonymous?
+    json.null! # or json.nil!
+  else
+    json.object! do
+      json.first_name @post.author_first_name
+      json.last_name @post.author_last_name
+    end
+  end
+end
+```
+
+Fragment caching is supported, it uses `Rails.cache` and works like caching in
+HTML templates:
+
+```ruby
+json.object! do
+  json.cache! ['v1', @person], expires_in: 10.minutes do
+    json.extract! @person, :name, :age
+  end
+end
+```
+
+You can also conditionally cache a block by using `cache_if!` like this:
+
+```ruby
+json.object! do
+  json.cache_if! !admin?, ['v1', @person], expires_in: 10.minutes do
+    json.extract! @person, :name, :age
+  end
+end
+```
+
+The only caveat with caching is inside and object you must cache both the key
+and the value. You cannot just cache the value. For example:
+
+```ruby
+json.boject! do
+  json.key do
+    json.cache! :key do
+    	json.value! 'Cache this.'
+    end
+  end
+end
+```
+
+Will error out, but can easily be rewritten as:
+
+```ruby
+json.boject! do
+  json.cache! :key do
+    json.key do
+      json.value! 'Cache this.'
+    end
+  end
+end
+```
+
+Keys can be auto formatted using `key_format!`, this can be used to convert
+keynames from the standard ruby_format to camelCase:
+
+``` ruby
+json.key_format! camelize: :lower
+json.object! do
+  json.first_name 'David'
+end
+
+# => { "firstName": "David" }
+```
+
+You can set this globally with the class method `key_format` (from inside your
+environment.rb for example):
+
+``` ruby
+TurboStreamer.key_format camelize: :lower
+```
+
+Syntax Differences from Jbuilder
+--------------------------------
+
+- You must open JSON object or array if you want an object or array.
+- You can directly output a value with `json.value! value`, this will
+  allow you to put a number, string, or other JSON value if you wish
+  to not have an object or array.
+- The call syntax has been removed (eg. `json.(@person, :name, :age)`)
+- Caching inside of a object must cache both the key and the value.
+
+Backends
+--------
+
+Currently TurboStreamer only uses the [Wankel JSON backend](https://github.com/malomalo/wankel),
+which supports streaming parsing and encoding.
+
+The idea was to also support [Oj](https://github.com/ohler55/oj) and
+[MessagePack](http://msgpack.org/).
+
+Oj should be relatively easily to do, you just need to figure out how to switch
+out the io so it can be captured for caching.
+
+MessagePack would require a bit more work as you would need a change in the
+protocol. We do not know how big an array or map/object will be when we
+start emitting it and MessagePack require we know it. It seems like a relatively
+small change, instead of a marker followed by number of elements there would be
+a start marker followed by the elements and then an end marker.
+
+All backends must have the following functions:
+
+- `key(string)` Output a map key
+- `value(value)` Output a value
+- `map_open` Open a object/map
+- `map_close` Close a object/map
+- `array_open` Open an Array
+- `array_close` Close an Array
+- `flush` Flush any buffers
+- `inject(string)` Inject a (usually cached) string into the output; instering any delimiters as needed.
+- `capture(&block)` Capture the output of the block (w/o any delimiters)
+
+Special Thanks & Contributors
+-----------------------------
+
+TurboStreamer is a fork of [Jbuilder](https://github.com/rails/jbuilder), built of
+what they have accopmlished and with out Jbuilder TurboStreamer would not be here today.
+Thanks to everyone who's been a part of Jbuilder!
+
+* David Heinemeier Hansson - http://david.heinemeierhansson.com/ - for writing Jbuidler!!
+* Pavel Pravosud - http://pavel.pravosud.com/ - for maintaing and pushing Jbuilder forward

data/ext/actionview/buffer.rb

@@ -0,0 +1,25 @@
+module ActionView
+  class OutputBuffer
+    alias :write :safe_concat
+  end
+  
+  class StreamingBuffer #:nodoc:
+    alias :write :safe_concat
+  end
+  
+  class JSONStreamingBuffer #:nodoc:
+    def initialize(block)
+      @block = block
+    end
+
+    def <<(value)
+      @block.call(value.to_s)
+    end
+    alias :write  :<<
+    alias :concat  :<<
+    alias :append= :<<
+    alias :safe_concat :<<
+    alias :safe_append= :<<
+  end
+  
+end

data/ext/actionview/streaming_template_renderer.rb

@@ -0,0 +1,40 @@
+module ActionView
+  class StreamingTemplateRenderer < TemplateRenderer
+    
+    def render_template(template, layout_name = nil, locals = {}) #:nodoc:
+      return [super] unless layout_name && template.supports_streaming?
+
+      locals ||= {}
+      layout   = layout_name && find_layout(layout_name, locals.keys, [formats.first])
+
+      Body.new do |buffer|
+        if template.handler == TurboStreamer::Handler
+          delayed_render_json(buffer, template, layout, @view, locals)
+        else
+          delayed_render(buffer, template, layout, @view, locals)
+        end
+      end
+    end
+
+    private
+
+      def delayed_render_json(buffer, template, layout, view, locals)
+        # Wrap the given buffer in the StreamingBuffer and pass it to the
+        # underlying template handler. Now, every time something is concatenated
+        # to the buffer, it is not appended to an array, but streamed straight
+        # to the client.
+        output  = ActionView::JSONStreamingBuffer.new(buffer)
+        yielder = lambda { |*name| view._layout_for(*name) }
+      
+        instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
+          fiber = Fiber.new do
+            template.render(view, locals, output, &yielder)
+          end
+
+          fiber.resume
+        end
+
+      end
+
+  end
+end

data/lib/turbostreamer/dependency_tracker.rb

@@ -0,0 +1,61 @@
+require 'turbostreamer'
+
+dependency_tracker = false
+
+begin
+  require 'action_view'
+  require 'action_view/dependency_tracker'
+  dependency_tracker = ::ActionView::DependencyTracker
+rescue LoadError
+  begin
+    require 'cache_digests'
+    dependency_tracker = ::CacheDigests::DependencyTracker
+  rescue LoadError
+  end
+end
+
+if dependency_tracker
+  class TurboStreamer
+    module DependencyTrackerMethods
+      # Matches:
+      #   json.partial! "messages/message"
+      #   json.partial!('messages/message')
+      #
+      DIRECT_RENDERS = /
+        \w+\.partial!     # json.partial!
+        \(?\s*            # optional parenthesis
+        (['"])([^'"]+)\1  # quoted value
+      /x
+
+      # Matches:
+      #   json.partial! partial: "comments/comment"
+      #   json.comments @post.comments, partial: "comments/comment", as: :comment
+      #   json.array! @posts, partial: "posts/post", as: :post
+      #   = render partial: "account"
+      #
+      INDIRECT_RENDERS = /
+        (?::partial\s*=>|partial:)  # partial: or :partial =>
+        \s*                         # optional whitespace
+        (['"])([^'"]+)\1            # quoted value
+      /x
+
+      def dependencies
+        direct_dependencies + indirect_dependencies + explicit_dependencies
+      end
+
+      private
+
+      def direct_dependencies
+        source.scan(DIRECT_RENDERS).map(&:second)
+      end
+
+      def indirect_dependencies
+        source.scan(INDIRECT_RENDERS).map(&:second)
+      end
+    end
+  end
+
+  ::TurboStreamer::DependencyTracker = Class.new(dependency_tracker::ERBTracker)
+  ::TurboStreamer::DependencyTracker.send :include, ::TurboStreamer::DependencyTrackerMethods
+  dependency_tracker.register_tracker :streamer, ::TurboStreamer::DependencyTracker
+end

data/lib/turbostreamer/encoders/wankel.rb

@@ -0,0 +1,82 @@
+require 'wankel'
+
+class TurboStreamer
+  class WankelEncoder < ::Wankel::StreamEncoder
+  
+    def initialize(io, options={})
+      @stack = []
+      @indexes = []
+      
+      super(io, {mode: :as_json}.merge(options))
+    end
+  
+    def key(k)
+      string(k)
+    end
+    
+    def value(v)
+      if @stack.last == :array || @stack.last == :map
+        @indexes[-1] += 1
+      end
+      super
+    end
+    
+    def map_open
+      @stack << :map
+      @indexes << 0
+      super
+    end
+    
+    def map_close
+      @indexes.pop
+      @stack.pop
+      super
+    end
+    
+    def array_open
+      @stack << :array
+      @indexes << 0
+      super
+    end
+    
+    def array_close
+      @indexes.pop
+      @stack.pop
+      super
+    end
+    
+    def inject(string)
+      flush
+
+      if @stack.last == :array
+        self.output.write(',') if @indexes.last > 0
+        @indexes[-1] += 1
+      elsif @stack.last == :map
+        self.output.write(',') if @indexes.last > 0
+        capture do
+          string("")
+          string("")
+        end
+        @indexes[-1] += 1
+      end
+    
+      self.output.write(string)
+    end
+    
+    def capture(to=nil)
+      flush
+      old, to = self.output, to || ::StringIO.new
+      @indexes << 0
+      self.output = to
+    
+      yield
+    
+      flush
+      to.string.gsub(/\A,|,\Z/, '')
+    ensure
+      @indexes.pop
+      self.output = old
+    end
+  
+  end
+end

data/lib/turbostreamer/handler.rb

@@ -0,0 +1,22 @@
+require "turbostreamer"
+require "active_support/core_ext"
+# This module makes TurboStreamer work with Rails using the template handler API.
+
+class TurboStreamer
+  class Handler
+    
+    class_attribute :default_format
+    self.default_format = :json
+    
+    def self.supports_streaming?
+      true
+    end
+    
+    def self.call(template)
+      # this juggling is required to keep line numbers right in the error
+      %{__already_defined = defined?(json); json||=TurboStreamer::Template.new(self, output_buffer: output_buffer || ActionView::OutputBuffer.new); #{template.source}
+        json.target! unless (__already_defined && __already_defined != "method")}
+    end
+    
+  end
+end

data/lib/turbostreamer/key_formatter.rb

@@ -0,0 +1,33 @@
+require 'active_support/core_ext/array'
+
+class TurboStreamer
+  class KeyFormatter
+    def initialize(*args)
+      @format = {}
+      @cache = {}
+
+      options = args.extract_options!
+      args.each do |name|
+        @format[name] = []
+      end
+      options.each do |name, paramaters|
+        @format[name] = paramaters
+      end
+    end
+
+    def initialize_copy(original)
+      @cache = {}
+    end
+
+    def format(key)
+      @cache[key] ||= @format.inject(key.to_s) do |result, args|
+        func, args = args
+        if ::Proc === func
+          func.call result, *args
+        else
+          result.send func, *args
+        end
+      end
+    end
+  end
+end

data/lib/turbostreamer/railtie.rb

@@ -0,0 +1,17 @@
+require 'rails/railtie'
+require 'turbostreamer/handler'
+require 'turbostreamer/template'
+
+require File.expand_path('../../../ext/actionview/buffer', __FILE__)
+require File.expand_path('../../../ext/actionview/streaming_template_renderer', __FILE__)
+
+class TurboStreamer
+  class Railtie < ::Rails::Railtie
+    initializer :turbostreamer do
+      ActiveSupport.on_load :action_view do
+        ActionView::Template.register_template_handler :streamer, TurboStreamer::Handler
+        require 'turbostreamer/dependency_tracker'
+      end
+    end
+  end
+end

data/lib/turbostreamer/template.rb

@@ -0,0 +1,225 @@
+require 'turbostreamer'
+
+class TurboStreamer::Template < TurboStreamer
+  
+  class << self
+    attr_accessor :template_lookup_options
+  end
+
+  self.template_lookup_options = { handlers: [:streamer] }
+
+  def initialize(context, *args, &block)
+    @context = context
+    super(*args, &block)
+  end
+  
+  def partial!(name_or_options, locals = {})
+    if name_or_options.class.respond_to?(:model_name) && name_or_options.respond_to?(:to_partial_path)
+      @context.render(name_or_options, json: self)
+    else
+      if name_or_options.is_a?(Hash)
+        options = name_or_options
+      else
+        if locals.one? && (locals.keys.first == :locals)
+          options = locals.merge(partial: name_or_options)
+        else
+          options = { partial: name_or_options, locals: locals }
+        end
+        # partial! 'name', foo: 'bar'
+        as = locals.delete(:as)
+        options[:as] = as if as.present?
+        options[:collection] = locals[:collection] if locals.key?(:collection)
+      end
+      
+      _render_partial_with_options options
+    end
+  end
+
+  def array!(collection = BLANK, *attributes, &block)
+    options = attributes.extract_options!
+
+    if options.key?(:partial)
+      partial! options.merge(collection: collection)
+    else
+      super
+    end
+  end
+
+  # Caches the json constructed within the block passed. Has the same signature
+  # as the `cache` helper method in `ActionView::Helpers::CacheHelper` and so
+  # can be used in the same way.
+  #
+  # Example:
+  #
+  #   json.cache! ['v1', @person], expires_in: 10.minutes do
+  #     json.extract! @person, :name, :age
+  #   end
+  def cache!(key=nil, options={})
+    if @context.controller.perform_caching
+      value = _cache_fragment_for(key, options) do
+        _capture { _scope { yield self }; }
+      end
+
+      inject!(value)
+    else
+      yield
+    end
+  end
+  
+  # Caches a collection of objects using fetch_multi, if supported.
+  # Requires a block for each item in the array. Accepts optional 'key' attribute
+  # in options (e.g. key: 'v1').
+  #
+  # Example:
+  #
+  # json.cache_collection! @people, expires_in: 10.minutes do |person|
+  #   json.partial! 'person', :person => person
+  # end
+  def cache_collection!(collection, options = {}, &block)
+    if @context.controller.perform_caching
+      keys_to_collection_map = _keys_to_collection_map(collection, options)
+      results = _read_multi_fragment_cache(keys_to_collection_map.keys, options)
+      
+      array! do
+        keys_to_collection_map.each_key do |key|
+          if results[key]
+            inject!(results[key])
+          else
+            value = _write_fragment_cache(key, options) do
+              _capture { _scope { yield keys_to_collection_map[key] } }
+            end
+            inject!(value)
+          end
+        end
+      end
+    else
+      array! collection, options, &block
+    end
+  end
+
+  # Conditionally catches the json depending in the condition given as first
+  # parameter. Has the same signature as the `cache` helper method in
+  # `ActionView::Helpers::CacheHelper` and so can be used in the same way.
+  #
+  # Example:
+  #
+  #   json.cache_if! !admin?, @person, expires_in: 10.minutes do
+  #     json.extract! @person, :name, :age
+  #   end
+  def cache_if!(condition, *args)
+    condition ? cache!(*args, &::Proc.new) : yield
+  end
+
+  private
+
+  def _render_partial_with_options(options)
+    options.reverse_merge! locals: {}
+    options.reverse_merge! ::TurboStreamer::Template.template_lookup_options
+    as = options[:as]
+
+    if as && options.key?(:collection)
+      as = as.to_sym
+      collection = options.delete(:collection)
+      locals = options.delete(:locals)
+      array! collection do |member|
+        member_locals = locals.clone
+        member_locals.merge! collection: collection
+        member_locals.merge! as => member
+        _render_partial options.merge(locals: member_locals)
+      end
+    else
+      _render_partial options
+    end
+  end
+
+  def _render_partial(options)
+    options[:locals].merge! json: self
+    @context.render options
+  end
+  
+  def _keys_to_collection_map(collection, options)
+    key = options.delete(:key)
+    
+    collection.inject({}) do |result, item|
+      key = key.respond_to?(:call) ? key.call(item) : key
+      cache_key = key ? [key, item] : item
+      result[_cache_key(cache_key, options)] = item
+      result
+    end
+  end
+
+  def _cache_fragment_for(key, options, &block)
+    key = _cache_key(key, options)
+    _read_fragment_cache(key, options) || _write_fragment_cache(key, options, &block)
+  end
+
+  def _read_multi_fragment_cache(keys, options = nil)
+    @context.controller.instrument_fragment_cache :read_multi_fragment, keys do
+      ::Rails.cache.read_multi(*keys, options)
+    end
+  end
+
+  def _read_fragment_cache(key, options = nil)
+    @context.controller.instrument_fragment_cache :read_fragment, key do
+      ::Rails.cache.read(key, options)
+    end
+  end
+
+  def _write_fragment_cache(key, options = nil)
+    @context.controller.instrument_fragment_cache :write_fragment, key do
+      yield.tap do |value|
+        ::Rails.cache.write(key, value, options)
+      end
+    end
+  end
+
+  def _cache_key(key, options)
+    name_options = options.slice(:skip_digest, :virtual_path)
+    key = _fragment_name_with_digest(key, name_options)
+
+    if @context.respond_to?(:fragment_cache_key)
+      key = @context.fragment_cache_key(key)
+    elsif ::Hash === key
+      key = url_for(key).split('://', 2).last
+    end
+
+    ::ActiveSupport::Cache.expand_cache_key(key, :streamer)
+  end
+
+  def _fragment_name_with_digest(key, options)
+    if @context.respond_to?(:cache_fragment_name)
+      # Current compatibility, fragment_name_with_digest is private again and cache_fragment_name
+      # should be used instead.
+      @context.cache_fragment_name(key, options)
+    elsif @context.respond_to?(:fragment_name_with_digest)
+      # Backwards compatibility for period of time when fragment_name_with_digest was made public.
+      @context.fragment_name_with_digest(key)
+    else
+      key
+    end
+  end
+
+  def _fragment_name_with_digest(key, options)
+    if @context.respond_to?(:cache_fragment_name)
+      # Current compatibility, fragment_name_with_digest is private again and cache_fragment_name
+      # should be used instead.
+      @context.cache_fragment_name(key, options)
+    else
+      key
+    end
+  end
+
+  def _partial_options?(options)
+    ::Hash === options && options.key?(:as) && options.key?(:partial)
+  end
+
+  def _is_active_model?(object)
+    object.class.respond_to?(:model_name) && object.respond_to?(:to_partial_path)
+  end
+
+  def _eachable_arguments?(value, *args)
+    return true if super
+    options = args.last
+    ::Hash === options && options.key?(:as)
+  end
+end

data/lib/turbostreamer/version.rb

@@ -0,0 +1,3 @@
+class TurboStreamer
+  VERSION = '1.0'
+end

data/lib/turbostreamer.rb

@@ -0,0 +1,335 @@
+require 'stringio'
+require 'turbostreamer/key_formatter'
+
+class TurboStreamer
+  
+  BLANK = ::Object.new
+  
+  
+  ENCODERS = {
+    json: {oj: 'Oj', wankel: 'Wankel'},
+    msgpack: {msgpack: 'MessagePack'}
+  }
+  
+  @@default_encoders = {}
+  @@key_formatter = nil
+
+  undef_method :==
+  undef_method :equal?
+  
+  def self.encode(options = {}, &block)
+    new(options, &block).target!
+  end
+  
+  def initialize(options = {})
+    @output_buffer = options[:output_buffer] || ::StringIO.new
+    @encoder = options[:encoder] || TurboStreamer.default_encoder_for(options[:mime] || :json).new(@output_buffer)
+
+    @key_formatter = options.fetch(:key_formatter){ @@key_formatter ? @@key_formatter.clone : nil }
+
+    yield self if ::Kernel.block_given?
+  end
+  
+  def key!(key)
+    @encoder.key(_key(key))
+  end
+    
+  def value!(value)
+    @encoder.value(value)
+  end
+  
+  def object!(&block)
+    @encoder.map_open
+    _scope { block.call } if block
+    @encoder.map_close
+  end
+  
+  # Extracts the mentioned attributes or hash elements from the passed object 
+  # and turns them into a JSON object.
+  #
+  # Example:
+  #
+  #   @person = Struct.new(:name, :age).new('David', 32)
+  #
+  #   or you can utilize a Hash
+  #
+  #   @person = { name: 'David', age: 32 }
+  #
+  #   json.pluck! @person, :name, :age
+  #
+  #   { "name": David", "age": 32 }
+  def pluck!(object, *attributes)
+    object! do
+      extract!(object, *attributes)
+    end
+  end
+  
+  # Extracts the mentioned attributes or hash elements from the passed object 
+  # and turns them into attributes of the JSON.
+  #
+  # Example:
+  #
+  #   @person = Struct.new(:name, :age).new('David', 32)
+  #
+  #   or you can utilize a Hash
+  #
+  #   @person = { name: 'David', age: 32 }
+  #
+  #   json.extract! @person, :name, :age
+  #
+  #   { "name": David", "age": 32 }, { "name": Jamie", "age": 31 }
+  def extract!(object, *attributes)
+    if ::Hash === object
+      attributes.each{ |key| _set_value key, object.fetch(key) }
+    else
+      attributes.each{ |key| _set_value key, object.public_send(key) }
+    end
+  end
+  
+  # Turns the current element into an array and iterates over the passed
+  # collection, adding each iteration as an element of the resulting array.
+  #
+  # Example:
+  #
+  #   json.array!(@people) do |person|
+  #     json.name person.name
+  #     json.age calculate_age(person.birthday)
+  #   end
+  #
+  #   [ { "name": David", "age": 32 }, { "name": Jamie", "age": 31 } ]
+  #
+  # It's generally only needed to use this method for top-level arrays. If you 
+  # have named arrays, you can do:
+  #
+  #   json.people(@people) do |person|
+  #     json.name person.name
+  #     json.age calculate_age(person.birthday)
+  #   end
+  #
+  #   { "people": [ { "name": David", "age": 32 }, { "name": Jamie", "age": 31 } ] }
+  #
+  # If you omit the block then you can set the top level array directly:
+  #
+  #   json.array! [1, 2, 3]
+  #
+  #   [1,2,3]
+  def array!(collection = BLANK, *attributes, &block)
+    @encoder.array_open
+    
+    if _blank?(collection)
+      _scope(&block) if block
+    else
+      _extract_collection(collection, *attributes, &block)
+    end
+
+    @encoder.array_close
+  end
+  
+  def set!(key, value = BLANK, *args, &block)
+    key!(key)
+    
+    if block
+      if !_blank?(value)
+        # json.comments @post.comments { |comment| ... }
+        # { "comments": [ { ... }, { ... } ] }
+        _scope { array!(value, &block) }
+      else
+        # json.comments { ... }
+        # { "comments": ... }
+        _scope(&block)
+      end
+    elsif args.empty?
+      # json.age 32
+      # { "age": 32 }
+      value!(value)
+    elsif _eachable_arguments?(value, *args)
+      # json.comments @post.comments, :content, :created_at
+      # { "comments": [ { "content": "hello", "created_at": "..." }, { "content": "world", "created_at": "..." } ] }
+      _scope{ array!(value, *args) }
+    else
+      # json.author @post.creator, :name, :email_address
+      # { "author": { "name": "David", "email_address": "david@thinking.com" } }
+      object!{ extract!(value, *args) }
+    end
+  end
+
+  alias_method :method_missing, :set!
+  private :method_missing
+
+  # Specifies formatting to be applied to the key. Passing in a name of a
+  # function  will cause that function to be called on the key.  So :upcase
+  # will upper case the key.  You can also pass in lambdas for more complex
+  # transformations.
+  #
+  # Example:
+  #
+  #   json.key_format! :upcase
+  #   json.author do
+  #     json.name "David"
+  #     json.age 32
+  #   end
+  #
+  #   { "AUTHOR": { "NAME": "David", "AGE": 32 } }
+  #
+  # You can pass parameters to the method using a hash pair.
+  #
+  #   json.key_format! camelize: :lower
+  #   json.first_name "David"
+  #
+  #   { "firstName": "David" }
+  #
+  # Lambdas can also be used.
+  #
+  #   json.key_format! ->(key){ "_" + key }
+  #   json.first_name "David"
+  #
+  #   { "_first_name": "David" }
+  #
+  def key_format!(*args)
+    @key_formatter = KeyFormatter.new(*args)
+  end
+
+  # Same as the instance method key_format! except sets the default.
+  def self.key_format(*args)
+    @@key_formatter = KeyFormatter.new(*args)
+  end
+
+  def self.key_formatter=(formatter)
+    @@key_formatter = formatter
+  end
+  
+  def self.set_default_encoder(mime, encoder)
+    @@default_encoders[mime] = encoder
+  end
+  
+  def self.get_encoder(mime, key)
+    require "turbostreamer/encoders/#{key}"
+    Object.const_get("TurboStreamer::#{ENCODERS[mime][key]}Encoder")
+  end
+  
+  def self.default_encoder_for(mime)
+    if @@default_encoders[mime]
+      @@default_encoders[mime]
+    else
+      ENCODERS[mime].to_a.find do |key, class_name|
+        next if !const_defined?(class_name)
+        return get_encoder(mime, key)
+      end
+    
+      ENCODERS[mime].to_a.find do |key, class_name|
+        begin
+          return get_encoder(mime, key)
+        rescue ::LoadError
+          next
+        end
+      end
+      
+      raise ArgumentError, "Could not find an adapter to use"
+    end
+  end
+
+  def _extract_collection(collection, *attributes, &block)
+    if collection.nil?
+      # noop
+    elsif block
+      collection.each do |element|
+        _scope{ yield element }
+      end
+    elsif attributes.any?
+      collection.each { |element| pluck!(element, *attributes) }
+    else
+      collection.each { |element| value!(element) }
+    end
+  end
+
+  # Inject a valid JSON string into the current
+  def inject!(json_text)
+    @encoder.inject(json_text)
+  end
+
+  # Turns the current element into an array and yields a builder to add a hash.
+  #
+  # Example:
+  #
+  #   json.comments do
+  #     json.child! { json.content "hello" }
+  #     json.child! { json.content "world" }
+  #   end
+  #
+  #   { "comments": [ { "content": "hello" }, { "content": "world" } ]}
+  #
+  # More commonly, you'd use the combined iterator, though:
+  #
+  #   json.comments(@post.comments) do |comment|
+  #     json.content comment.formatted_content
+  #   end
+  def child!(value = BLANK, *args, &block)
+    if block
+      if _eachable_arguments?(value, *args)
+        # json.child! comments { |c| ... }
+        _scope { array!(value, &block) }
+      else
+        # json.child! { ... }
+        # [...]
+        _scope(&block)
+      end
+    elsif args.empty?
+      value!(value)
+    elsif _eachable_arguments?(value, *args)
+      _scope{ array!(value, *args) }
+    else
+      object!{ extract!(value, *args) }
+    end
+    
+  end
+  
+  # Encodes the current builder as JSON.
+  def target!
+    @encoder.flush
+    
+    if @encoder.output.is_a?(::StringIO)
+      @encoder.output.string
+    else
+      @encoder.output
+    end
+  end
+  
+  private
+  
+  def _write(key, value)
+    @encoder.key(_key(key))
+    @encoder.value(value)
+  end
+
+  def _key(key)
+    @key_formatter ? @key_formatter.format(key) : key.to_s
+  end
+
+  def _set_value(key, value)
+    return if _blank?(value)
+    _write key, value
+  end
+
+  def _capture(to=nil, &block)
+    @encoder.capture(to, &block)
+  end
+    
+  def _scope
+    parent_formatter = @key_formatter
+    yield
+  ensure
+    @key_formatter = parent_formatter
+  end
+
+  def _eachable_arguments?(value, *args)
+    value.respond_to?(:each) && !value.is_a?(Hash)
+  end
+
+  def _blank?(value=@attributes)
+    BLANK == value
+  end
+  
+end
+
+
+require 'turbostreamer/railtie' if defined?(Rails)

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: turbostreamer
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Jon Bracy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: wankel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.2
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- jonbracy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- ext/actionview/buffer.rb
+- ext/actionview/streaming_template_renderer.rb
+- lib/turbostreamer.rb
+- lib/turbostreamer/dependency_tracker.rb
+- lib/turbostreamer/encoders/wankel.rb
+- lib/turbostreamer/handler.rb
+- lib/turbostreamer/key_formatter.rb
+- lib/turbostreamer/railtie.rb
+- lib/turbostreamer/template.rb
+- lib/turbostreamer/version.rb
+homepage: https://github.com/malomalo/turbostreamer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+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.11
+signing_key: 
+specification_version: 4
+summary: Stream JSON via a Builder-style DSL
+test_files: []