breezy_template 0.2.0 → 0.3.0

data/lib/breezy_template/active_support.rb

@@ -7,11 +7,11 @@ if Rails.version >= '4.1'
           alias_method :original_jsonify, :jsonify
 
           def jsonify(value)
-            if ::BreezyTemplate::Template::Digest === value
+            if ::BreezyTemplate::Digest === value
               value
-            elsif ::BreezyTemplate::Template::JointVar === value
+            elsif ::BreezyTemplate::JointVar === value
               value
-            elsif ::BreezyTemplate::Template::DeferVar === value
+            elsif ::BreezyTemplate::DeferVar === value
               value
             else
               original_jsonify(value)

data/lib/breezy_template/blank.rb

@@ -0,0 +1,11 @@
+class BreezyTemplate
+  class Blank
+    def ==(other)
+      super || Blank === other
+    end
+
+    def empty?
+      true
+    end
+  end
+end

data/lib/breezy_template/breezy_template.rb

@@ -0,0 +1,7 @@
+BreezyTemplate = Class.new(begin
+  require 'active_support/proxy_object'
+  ActiveSupport::ProxyObject
+rescue LoadError
+  require 'active_support/basic_object'
+  ActiveSupport::BasicObject
+end)

data/lib/breezy_template/cache_extension.rb

@@ -1,4 +1,6 @@
-module BreezyTemplate
+require 'breezy_template/breezy_template'
+
+class BreezyTemplate
   module CacheExtension
     class Digest
       def initialize(digest)
@@ -18,44 +20,73 @@ module BreezyTemplate
       end
     end
 
-    def _result(value)
-      if _cache_options?
-        _cache(*_cache_options) { super }
+    def _result(value, *args)
+      options = _cache_options(args[0])
+      if options
+        _cache(*options) { super }
       else
         super
       end
     end
 
+    def _normalize_with_cache_options(options)
+      return options unless options.key? :cache
+
+      options = options.dup
+      options[:cache] = [*options[:cache]]
+
+      if options[:cache].size == 1
+        options[:cache].push({})
+      end
+
+      options
+    end
+
     def set!(key, value = BLANK, *args)
       options = args.first || {}
-      options = _normalize_options(options)
-      if options[:partial] && _cache_options?
-        _cache_options[1] ||= {}
-        _cache_options[1][:_partial] = options[:partial]
+      options = _normalize_with_cache_options(options)
+
+      if options[:partial] && options[:cache]
+        partial_name = [*options[:partial]][0]
+        cache_options = options[:cache][1]
+        cache_options[:_partial] = partial_name
+      end
+
+      if ::Kernel.block_given?
+        super(key, value, options, ::Proc.new)
+      else
+        super(key, value, options)
       end
-        super
     end
 
     def array!(collection=[], *attributes)
-      options = attributes.first || {}
-      options = _normalize_options(options)
+      has_option = attributes.first.is_a? ::Hash
+      return super if !has_option
+
+      options = attributes.first.dup
+      options = _normalize_with_cache_options(options)
 
-      if options[:partial] && _cache_options?
-        _cache_options[1] ||= {}
-        _cache_options[1][:_partial] = options[:partial]
+      if options[:partial] && options[:cache]
+        partial_name = [*options[:partial]][0]
+        cache_options = options[:cache][1]
+        cache_options[:_partial] = partial_name
       end
 
-      super
+      if ::Kernel.block_given?
+        super(collection, options, ::Proc.new)
+      else
+        super(collection, options)
+      end
     end
 
     def _mapping_element(element, opts={})
-      if _cache_options
-        key = _cache_options.first
+      if _cache_options?(opts)
+        key, options = _cache_options(opts)
         if ::Proc === key
           key = key.call(element)
         end
 
-        _cache(key, opts) {
+        _cache(key, options) {
           _scope { yield element }
         }
       else
@@ -63,16 +94,20 @@ module BreezyTemplate
       end
     end
 
-    def _cache_options?
-      !!@extensions[:cache]
+    def _cache_options?(options)
+      !!options[:cache]
     end
 
-    def _cache_options
-      @extensions[:cache]
+    def _cache_options(options)
+      return nil if !options
+      options = [*options[:cache]]
+      key, options = options
+
+      return [key, options]
     end
 
     def _extended_options?(value)
-      _cache_options? || super
+      _cache_options?(value) || super
     end
 
     def _breezy_set_cache(key, value)
@@ -90,7 +125,11 @@ module BreezyTemplate
     end
 
     def _cache(key=nil, options={})
-      return yield self if !@context.controller.perform_caching || key.nil?
+      perform_caching = @context.respond_to?(:controller) && @context.controller.perform_caching
+
+      if !perform_caching || key.nil?
+        return yield self
+      end
 
       parent_js = @js
       key = _cache_key(key, options)
@@ -120,11 +159,20 @@ module BreezyTemplate
     end
 
     def _fragment_name_with_digest(key, options)
-      if _cache_options? && _cache_options[1] && _cache_options[1][:_partial] && !options[:skip_digest]
-        partial = _cache_options[1][:_partial]
+      if options && options[:_partial]
+        partial = options[:_partial]
         [key, _partial_digest(partial)]
       else
-        super
+        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
     end
   end

data/lib/breezy_template/configuration.rb

@@ -1,4 +1,6 @@
-module BreezyTemplate
+require 'breezy_template/breezy_template'
+
+class BreezyTemplate
   class Configuration
     attr_accessor :track_assets
 

data/lib/breezy_template/deferment_extension.rb

@@ -1,10 +1,13 @@
-module BreezyTemplate
+require 'breezy_template/breezy_template'
+
+class BreezyTemplate
   module DefermentExtension
     ACTIVE_MODES = [:auto, :manual].freeze
 
     def set!(key, value = BLANK, *args)
-      if ::Kernel.block_given? && _deferment_options?
-        if _deferment_auto?
+      options = args[0]
+      if ::Kernel.block_given? && _deferment_options?(options)
+        if _deferment_auto?(options)
           @js.push(_breezy_visit_current(@path))
         end
         return _set_value key, nil
@@ -20,17 +23,16 @@ module BreezyTemplate
       "defers.push({url:'#{uri}'});"
     end
 
-    def _deferment_options?
-      !!@extensions[:defer] && (@search_path.nil? || @search_path.size == 0)
-
+    def _deferment_options?(options)
+      options && !!options[:defer] && (@search_path.nil? || @search_path.size == 0)
     end
 
-    def _deferment_options
-      @extensions[:defer]
+    def _deferment_options(options)
+      options[:defer]
     end
 
-    def _deferment_auto?
-      _deferment_options[0] == :auto
+    def _deferment_auto?(options)
+      _deferment_options(options) == :auto
     end
 
     def _set_request_url(request_path)
@@ -38,11 +40,11 @@ module BreezyTemplate
     end
 
     def _extended_options?(value)
-      _deferment_options? || super
+      _deferment_options?(value) || super
     end
 
     def _mapping_element(element, options)
-      if _deferment_options?
+      if _deferment_options?(options)
         if options.has_key? :key
           id_name = options[:key]
           id_val = element[id_name]

data/lib/breezy_template/dependency_tracker.rb

@@ -1,4 +1,5 @@
 # This was taken from jbuilder
+require 'breezy_template/breezy_template'
 
 dependency_tracker = false
 
@@ -15,7 +16,7 @@ rescue LoadError
 end
 
 if dependency_tracker
-  class BreezyTemplate::Template
+  class BreezyTemplate
     module DependencyTrackerMethods
       # Matches:
       #   json.partial! partial: "comments/comment"
@@ -26,6 +27,8 @@ if dependency_tracker
       INDIRECT_RENDERS = /
         (?::partial\s*=>|partial:)  # partial: or :partial =>
         \s*                         # optional whitespace
+        \[*                         # optional Bracket
+        \s*                         # optional whitespace
         (['"])([^'"]+)\1            # quoted value
       /x
 
@@ -42,6 +45,6 @@ if dependency_tracker
   end
 
   ::BreezyTemplate::DependencyTracker = Class.new(dependency_tracker::ERBTracker)
-  ::BreezyTemplate::DependencyTracker.send :include, ::BreezyTemplate::Template::DependencyTrackerMethods
+  ::BreezyTemplate::DependencyTracker.send :include, ::BreezyTemplate::DependencyTrackerMethods
   dependency_tracker.register_tracker :breezy, ::BreezyTemplate::DependencyTracker
 end

data/lib/breezy_template/digestor.rb

@@ -1,7 +1,8 @@
+require 'breezy_template/breezy_template'
 require 'action_view'
 require 'action_view/digestor'
 
-module BreezyTemplate
+class BreezyTemplate
   module PartialDigestor
     if ::Rails.version >= '5.0'
       def _partial_digestor(options)

data/lib/breezy_template/errors.rb

@@ -0,0 +1,24 @@
+require 'breezy_template/breezy_template'
+
+class BreezyTemplate
+  class NullError < ::NoMethodError
+    def self.build(key)
+      message = "Failed to add #{key.to_s.inspect} property to null object"
+      new(message)
+    end
+  end
+
+  class ArrayError < ::StandardError
+    def self.build(key)
+      message = "Failed to add #{key.to_s.inspect} property to an array"
+      new(message)
+    end
+  end
+
+  class MergeError < ::StandardError
+    def self.build(current_value, updates)
+      message = "Can't merge #{updates.inspect} into #{current_value.inspect}"
+      new(message)
+    end
+  end
+end

data/lib/breezy_template/handler.rb

@@ -1,11 +1,13 @@
-module BreezyTemplate
+require 'breezy_template/breezy_template'
+
+class BreezyTemplate
   class Handler
     cattr_accessor :default_format
     self.default_format = Mime[:js]
 
     def self.call(template)
       # this juggling is required to keep line numbers right in the error
-      %{__already_defined = defined?(json); json||=::BreezyTemplate::Template.new(self);json._filter_by_path(breezy_filter) if defined?(breezy_filter); json._set_request_url(request.path);#{template.source}
+      %{__already_defined = defined?(json); json||=::BreezyTemplate.new(self);json._filter_by_path(breezy_filter) if defined?(breezy_filter); json._set_request_url(request.path);#{template.source}
         if !(__already_defined && __already_defined != "method")
           json.merge!({data: json.found! || json.empty! })
           json.key_format! :downcase

data/lib/breezy_template/key_formatter.rb

@@ -0,0 +1,34 @@
+require 'breezy_template/breezy_template'
+require 'active_support/core_ext/array'
+
+class BreezyTemplate
+  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/breezy_template/partial_extension.rb

@@ -1,4 +1,6 @@
-module BreezyTemplate
+require 'breezy_template/breezy_template'
+
+class BreezyTemplate
   module PartialExtension
     class DeferVar
       def initialize
@@ -37,8 +39,8 @@ module BreezyTemplate
     end
 
     def set!(key, value = BLANK, *args)
-      options = args.first || {}
-      options = _normalize_options(options)
+      options = args.last || {}
+
       if args.one? && _partial_options?(options)
         _set_inline_partial key, value, options
       else
@@ -47,11 +49,13 @@ module BreezyTemplate
     end
 
     def array!(collection = [], *attributes)
-      options = attributes.first || {}
-      options = _normalize_options(options)
+      options = attributes.last || {}
+      options = _normalize_options_for_partial(options)
 
       if attributes.one? && _partial_options?(options)
-        _render_partial_with_options(options.merge(collection: collection))
+        _, opts = options[:partial]
+        opts.reverse_merge!(collection: collection)
+        _render_partial_with_options(options)
       else
         super
       end
@@ -65,6 +69,20 @@ module BreezyTemplate
       ::Hash === options && options.key?(:partial)
     end
 
+    def _normalize_options_for_partial(options)
+      if !_partial_options?(options)
+        return options
+      end
+
+      partial_options = [*options[:partial]]
+      partial, rest = partial_options
+      if partial && !rest
+        options.dup.merge(partial: [partial, rest || {}])
+      else
+        options
+      end
+    end
+
     def _partial_digest(partial)
       lookup_context = @context.lookup_context
       name = lookup_context.find(partial, lookup_context.prefixes, true).virtual_path
@@ -72,20 +90,31 @@ module BreezyTemplate
     end
 
     def _set_inline_partial(name, object, options)
-      value = if object.nil? && options.empty?
+      options = _normalize_options_for_partial(options)
+
+      partial, partial_opts = options[:partial]
+      if partial_opts[:joint] == true
+        partial_opts[:joint] = name
+      end
+
+      value = if object.nil? && partial.empty?
         []
       else
         locals = {}
-        locals[options[:as]] = object if !_blank?(object) && options.key?(:as)
-        locals.merge!(options[:locals]) if options.key? :locals
+        locals[partial_opts[:as]] = object if !_blank?(partial_opts) && partial_opts.key?(:as)
+        locals.merge!(partial_opts[:locals]) if partial_opts.key? :locals
+        partial_opts.merge!(locals: locals)
 
-        _scope{ _render_partial options.merge(locals: locals) }
+        _scope{ _render_partial(options) }
       end
 
-      set! name, value
+      options = options.dup
+      options.delete(:partial)
+      set! name, value, options
     end
 
     def _render_partial(options)
+      partial, options = options[:partial]
       joint = options[:joint]
       if joint
         joint = joint.to_sym
@@ -95,25 +124,34 @@ module BreezyTemplate
       end
 
       options[:locals].merge! json: self
-      @context.render options
+      @context.render options.merge(partial: partial)
     end
 
     def _render_partial_with_options(options)
+      options = _normalize_options_for_partial(options)
+      partial, partial_opts = options[:partial]
       ary_opts = options.dup
-      options.reverse_merge! locals: {}
-      options.reverse_merge! ::BreezyTemplate::Template.template_lookup_options
-      as = options[:as]
 
-      if options.key?(:collection)
-        collection = options.delete(:collection)
-        locals = options.delete(:locals)
+      partial_opts.reverse_merge! locals: {}
+      partial_opts.reverse_merge! ::BreezyTemplate.template_lookup_options
+      as = partial_opts[:as]
+
+      if partial_opts.key?(:collection)
+        collection = partial_opts.delete(:collection)
+        extract_joint_name = partial_opts.delete(:joint)
+        locals = partial_opts.delete(:locals)
 
         ary_opts.delete(:partial)
         array! collection, ary_opts do |member|
+
           member_locals = locals.clone
           member_locals.merge! collection: collection
           member_locals.merge! as.to_sym => member if as
-          _render_partial options.merge(locals: member_locals)
+          partial_opts.merge!(locals: member_locals)
+          if extract_joint_name.respond_to?(:call)
+            partial_opts.merge!(joint: extract_joint_name.call(member))
+          end
+          _render_partial options
         end
       else
         _render_partial options