props_template 0.13.0

data/lib/props_template/key_formatter.rb

@@ -0,0 +1,33 @@
+require 'active_support/core_ext/array'
+
+module Props
+  class KeyFormatter
+    def initialize(*args)
+      @format = {}
+      @cache = {}
+
+      options = args.extract_options!
+      args.each do |name|
+        @format[name] = []
+      end
+      options.each do |name, parameters|
+        @format[name] = parameters
+      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/props_template/layout_patch.rb

@@ -0,0 +1,55 @@
+module Props
+  module LayoutPatch
+    def render(context, options)
+      options[:locals] ||= {}
+      options[:locals][:json] = nil
+
+      @details = extract_details(options)
+      template = determine_template(options)
+
+      if template.handler == Props::Handler && options[:layout]
+        prepend_formats(template.format)
+        render_props_template(context, template, options[:layout], options[:locals])
+      else
+        super(context, options)
+      end
+    end
+
+    def render_props_template(view, template, path, locals)
+      layout_locals = locals.dup
+      layout_locals.delete(:json)
+
+      layout = resolve_props_layout(path, layout_locals, [formats.first])
+
+      body = layout.render(view, layout_locals) do |json|
+        locals[:json] = json
+        template.render(view, locals)
+      end
+
+      build_rendered_template(body, template)
+    end
+
+    def resolve_props_layout(layout, keys, formats)
+      details = @details.dup
+      details[:formats] = formats
+
+      case layout
+      when String
+        begin
+          if layout.start_with?("/")
+            ActiveSupport::Deprecation.warn "Rendering layouts from an absolute path is deprecated."
+            @lookup_context.with_fallbacks.find_template(layout, nil, false, [], details)
+          else
+            @lookup_context.find_template(layout, nil, false, [], details)
+          end
+        end
+      when Proc
+        resolve_layout(layout.call(@lookup_context, formats), keys, formats)
+      else
+        layout
+      end
+    end
+  end
+end
+
+ActionView::TemplateRenderer.prepend(Props::LayoutPatch)

data/lib/props_template/railtie.rb

@@ -0,0 +1,22 @@
+require 'rails/railtie'
+require 'props_template'
+
+module Props
+  class Railtie < ::Rails::Railtie
+    initializer :props_template do
+      ActiveSupport.on_load :action_view do
+        ActionView::Template.register_template_handler :props, Props::Handler
+        require 'props_template/dependency_tracker'
+        require 'props_template/layout_patch'
+      end
+    end
+
+    # if Rails::VERSION::MAJOR >= 4
+    #   generators do |app|
+    #     Rails::Generators.configure! app.config.generators
+    #     Rails::Generators.hidden_namespaces.uniq!
+    #     require 'generators/rails/scaffold_controller_generator'
+    #   end
+    # end
+  end
+end

data/lib/props_template/searcher.rb

@@ -0,0 +1,106 @@
+require 'props_template/extensions/partial_renderer'
+
+module Props
+  class Searcher
+    attr_reader :builder, :context, :fragments, :traveled_path
+
+    def initialize(builder, path=[], context = nil)
+      @search_path = path
+      @depth = 0
+      @context = context
+      @found_block = nil
+      @found_options = nil
+      @builder = builder
+      @traveled_path = []
+      @partialer = Partialer.new(self, context, builder)
+    end
+
+    def deferred!
+      []
+    end
+
+    def fragments!
+      []
+    end
+
+    def fragment_digest!
+    end
+
+    def found!
+      pass_opts = @found_options.clone || {}
+      pass_opts.delete(:defer)
+      traveled_path = @traveled_path[1..-1] || []
+      if !traveled_path.empty?
+        pass_opts[:path_suffix] = traveled_path
+      end
+
+      [@found_block, pass_opts]
+    end
+
+    def set_block_content!(*args)
+      yield
+    end
+
+    def set!(key, options={}, &block)
+      return if @found_block || !block_given?
+
+      if @search_path[@depth] == key.to_s
+        @traveled_path.push(key)
+
+        if @depth == @search_path.size - 1
+          @found_options = options
+          @found_block = block
+          return
+        end
+
+        @depth += 1
+        if options[:partial]
+          @partialer.handle(options)
+        else
+          yield
+        end
+        @depth -= 1
+      end
+
+      nil
+    end
+
+    def array!(collection, options = {}, &block)
+      return if @found_block
+
+      key_index = @search_path[@depth]
+      id_name, id_val = key_index.to_s.split('=')
+
+      if id_val
+        id_val = id_val.to_i
+        item = collection.member_by(id_name, id_val)
+      else
+        index = id_name.to_i
+        item = collection.member_at(index)
+      end
+
+      if item
+        pass_opts = @partialer.refine_options(options, item)
+        @traveled_path.push(key_index)
+
+        if @depth == @search_path.size - 1
+          @found_options = pass_opts
+          @found_block = Proc.new {
+            yield item, 0
+          }
+          return
+        end
+
+        @depth += 1
+        if pass_opts[:partial]
+          # todo: what happens when cached: true is passed?
+          # would there be any problems with not using the collection_rende?
+          @partialer.handle(pass_opts)
+        else
+          yield item, 0
+        end
+        @depth -= 1
+      end
+    end
+  end
+end

data/spec/layout_spec.rb

@@ -0,0 +1,16 @@
+require_relative './support/helper'
+require_relative './support/rails_helper'
+require 'props_template/layout_patch'
+
+RSpec.describe 'Props::Template' do
+  it 'uses a layout to render' do
+    view_path = File.join(File.dirname(__FILE__),'./fixtures')
+    controller = ActionView::TestCase::TestController.new
+    controller.prepend_view_path(view_path)
+    controller.response.headers['Content-Type']='application/json'
+    controller.request.path = '/some_url'
+
+    json = controller.render('200', layout: 'application')
+    expect(json.strip).to eql('{"data":{"success":"ok"}}')
+  end
+end

data/spec/props_template_spec.rb

@@ -0,0 +1,282 @@
+require_relative './support/helper'
+
+RSpec.describe 'Props::Base' do
+  it 'initializes' do
+    expect {
+      Props::Base.new
+    }.to_not raise_error
+  end
+
+  context 'result!' do
+    it 'returns {} when empty' do
+      json = Props::Base.new
+      expect(json.result!.strip).to eql('{}')
+    end
+  end
+
+  context 'set!' do
+    it 'sets a value' do
+      json = Props::Base.new
+      json.set! :foo, 'bar'
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json({
+        foo: 'bar'
+      })
+    end
+
+    it 'sets a empty obj when block is empty' do
+      json = Props::Base.new
+      json.set! :foo do
+      end
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json({
+        foo: {}
+      })
+    end
+
+    it 'sets a empty obj when nested block is empty' do
+      json = Props::Base.new
+      json.set! :foo do
+        json.set! :bar do
+        end
+      end
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json({
+        foo: {
+          bar: {}
+        }
+      })
+    end
+
+    it 'sets a null value' do
+      json = Props::Base.new
+      json.set! :foo, nil
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json({
+        foo: nil
+      })
+    end
+
+    it 'sets multiple values' do
+      json = Props::Base.new
+      json.set! :foo, 'bar'
+      json.set! :steve, 'cool'
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json({
+        foo: 'bar',
+        steve: 'cool'
+      })
+    end
+
+    it 'sets multiple values with the same key, the last one wins' do
+      json = Props::Base.new
+      json.set! :foo, 'bar'
+      json.set! :foo, 'cool'
+
+      attrs = JSON.parse(json.result!)
+
+      expect(attrs).to eql({
+        'foo' => 'cool'
+      })
+    end
+
+    it 'throws InvalidScopeForObjError when the current scope is an array' do
+      json = Props::Base.new
+      json.array! [1, 2] do |item|
+        json.set! :foo, item
+      end
+      expect {
+        json.set! :bar, 'world'
+      }.to raise_error(Props::InvalidScopeForObjError)
+    end
+  end
+
+  context 'set! with a block' do
+    it 'creates a new nested object' do
+      json = Props::Base.new
+      json.set! :outer do
+        json.set! :inner, 'baz'
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json({
+        outer: {
+          inner: 'baz'
+        }
+      })
+    end
+
+    it 'creates a nested object' do
+      json = Props::Base.new
+      json.set! :outer do
+        json.set! :inner, 'baz'
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json({
+        outer: {
+          inner: 'baz'
+        }
+      })
+    end
+
+    it 'creates a nested array of objects' do
+      json = Props::Base.new
+      json.set! :outer do
+        json.array! [1, 2] do |item|
+          json.set! :foo, item
+        end
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json({
+        outer: [
+          {foo: 1},
+          {foo: 2}
+        ]
+      })
+    end
+
+    it 'treats the second argument as an options arg' do
+      json = Props::Base.new
+      json.set! :outer, {some: 'setting'} do
+        json.set! :inner, 'baz'
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json({
+        outer: {
+          inner: 'baz'
+        }
+      })
+    end
+  end
+
+  context 'array!' do
+    it 'creates an array of 1 object' do
+      json = Props::Base.new
+      json.array! [1] do |num|
+        json.set! :foo, num
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json([
+        {foo: 1}
+      ])
+    end
+
+    it 'passes the index as the second argument of yield' do
+      json = Props::Base.new
+      json.array! ['a', 'b'] do |item, index|
+        json.set! :foo, [item, index]
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json([
+        {foo: ['a', 0]},
+        {foo: ['b', 1]}
+      ])
+    end
+
+    it 'creates an empty array when passed an empty collection' do
+      json = Props::Base.new
+      json.array! [] do |num|
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json([
+      ])
+    end
+
+    it 'creates an array of empty arrays when passed an empty collection' do
+      json = Props::Base.new
+      json.array! [1] do |num|
+        json.array! [] do
+        end
+      end
+
+      attrs = json.result!.strip
+      expect(attrs).to eql_json([[]])
+    end
+
+    it 'creates an array of empties if set did not get called in array' do
+      json = Props::Base.new
+      json.array! [1, 2, 3] do |num|
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json([
+        {},
+        {},
+        {}
+      ])
+    end
+
+    it 'throws InvalidScopeForArray error when array is used twice' do
+      json = Props::Base.new
+      json.array! [1] do
+        json.set! :foo, 'first'
+      end
+
+      expect {
+        json.array! [2] do |num|
+          json.set! :foo, 'second'
+        end
+      }.to raise_error(Props::InvalidScopeForArrayError)
+    end
+
+    it 'creates an array of multiple objects' do
+      json = Props::Base.new
+      json.array! [1, 2] do |num|
+        json.set! :foo, num
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json([
+        {foo: 1},
+        {foo: 2}
+      ])
+    end
+
+    it 'creates an array of arrays' do
+      json = Props::Base.new
+      json.array! [[1, 2], [3, 4]] do |part|
+        json.array! part do |num|
+          json.set! :foo, num
+        end
+      end
+
+      attrs = json.result!.strip
+
+      expect(attrs).to eql_json([
+        [{foo: 1}, {foo: 2}],
+        [{foo: 3}, {foo: 4}]
+      ])
+    end
+
+    it 'throws InvalidScopeForArrayError when the current scope is already an object' do
+      json = Props::Base.new
+      json.set! :foo, 'bar'
+      expect {
+        json.array! [1, 2] do |num|
+          json.set! :foo, 'noop'
+        end
+      }.to raise_error(Props::InvalidScopeForArrayError)
+    end
+  end
+end