props_template 0.13.0

data/lib/props_template/extensions/cache.rb

@@ -0,0 +1,150 @@
+module Props
+  class Cache
+    delegate :controller, :safe_concat, to: :@context
+
+    def self.refine_options(options, item = nil)
+      return options if !options[:cache]
+
+      pass_opts = options.clone
+      key, rest = [*options[:cache]]
+      rest ||= {}
+
+      if item && ::Proc === key
+        key = key.call(item)
+      end
+
+      pass_opts[:cache] = [key, rest]
+      pass_opts
+    end
+
+    def initialize(context)
+      @context = context
+    end
+
+    def context
+      @context
+    end
+
+    def instrument(name, **options)
+      ActiveSupport::Notifications.instrument(name, options) do |payload|
+        yield payload
+      end
+    end
+
+    def multi_fetch(keys, options = {})
+      result = {}
+      key_to_ckey = {}
+      ckeys = []
+
+      keys.each do |k|
+        ckey = cache_key(k, options)
+        ckeys.push(ckey)
+        key_to_ckey[k] = ckey
+      end
+
+      payload = {
+        controller_name: controller.controller_name,
+        action_name: controller.action_name,
+      }
+
+      read_caches = {}
+
+      instrument('read_multi_fragments.action_view', payload) do |payload|
+        read_caches = ::Rails.cache.read_multi(*ckeys, options)
+        payload[:read_caches] = read_caches
+      end
+
+      keys.each do |k|
+        ckey = key_to_ckey[k]
+        result[k] = read_caches[ckey]
+      end
+
+      result
+    end
+
+    def multi_fetch_and_add_results(all_options)
+      first_opts = all_options[0]
+
+      if first_opts[:cache] && controller.perform_caching
+        keys = all_options.map{|i| i[:cache][0]}
+        c_opts = first_opts[:cache][1]
+        result = multi_fetch(keys, c_opts)
+
+        all_options.map do |opts|
+          key =  opts[:cache][0]
+
+          if result.key? key
+            opts[:cache][1][:result] = result[key]
+            opts
+          else
+            opts
+          end
+        end
+      else
+        all_options
+      end
+    end
+
+    #Copied from jbuilder
+    #
+
+    def cache(key=nil, options={})
+      if controller.perform_caching
+        value = cache_fragment_for(key, options) do
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    def cache_fragment_for(key, options, &block)
+      key = cache_key(key, options)
+
+      return options[:result] if options[:result]
+
+      read_fragment_cache(key, options) || write_fragment_cache(key, options, &block)
+    end
+
+    def read_fragment_cache(key, options = nil)
+      controller.instrument_fragment_cache :read_fragment, key do
+        ::Rails.cache.read(key, options)
+      end
+    end
+
+    def write_fragment_cache(key, options = nil)
+      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?(:combined_fragment_cache_key)
+        key = @context.combined_fragment_cache_key(key)
+      else
+        key = url_for(key).split('://', 2).last if ::Hash === key
+      end
+
+      ::ActiveSupport::Cache.expand_cache_key(key, :props)
+    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
+  end
+end
+

data/lib/props_template/extensions/deferment.rb

@@ -0,0 +1,56 @@
+module Props
+  class Deferment
+    attr_reader :deferred
+
+    def initialize(base, deferred = [])
+      @deferred = deferred
+      @base = base
+    end
+
+    def refine_options(options, item = nil)
+      return options if !options[:defer]
+      pass_opts = options.clone
+
+      type, rest = [*options[:defer]]
+      rest ||= {
+        placeholder: {}
+      }
+
+      if item
+        type = Proc === type ? type.call(item) : type
+      end
+
+      if type
+        pass_opts[:defer] = [type, rest]
+      else
+        pass_opts.delete(:defer)
+      end
+
+      pass_opts
+    end
+
+    def handle(options)
+      return if !options[:defer]
+
+      type, rest = options[:defer]
+      placeholder = rest[:placeholder]
+
+      request_path = @base.context.controller.request.fullpath
+      path = @base.traveled_path.join('.')
+      uri = ::URI.parse(request_path)
+      qry = ::URI.decode_www_form(uri.query || '')
+        .reject{|x| x[0] == 'bzq' }
+        .push(["bzq", path])
+
+      uri.query = ::URI.encode_www_form(qry)
+
+      @deferred.push(
+        url: uri.to_s,
+        path: path,
+        type: type.to_s
+      )
+
+      placeholder
+    end
+  end
+end

data/lib/props_template/extensions/fragment.rb

@@ -0,0 +1,50 @@
+require 'digest'
+
+module Props
+  class Fragment
+    attr_reader :fragments
+    attr_accessor :name
+
+    def initialize(base, fragments={})
+      @base = base
+      @fragments = fragments
+      @digest = Digest::SHA2.new(256)
+    end
+
+    def handle(options)
+      return if !options[:partial]
+      partial_name, partial_opts = options[:partial]
+      fragment = partial_opts[:fragment]
+
+      if String === fragment || Symbol === fragment
+        fragment_name = fragment.to_s
+        path = @base.traveled_path.join('.')
+        @name = fragment_name
+        @fragments[fragment_name] ||= []
+        @fragments[fragment_name].push(path)
+      end
+
+      if fragment == true
+        locals = partial_opts[:locals]
+
+        identity = {}
+        locals
+          .clone
+          .tap{|h| h.delete(:json)}
+          .each do |key, value|
+            if value.respond_to?(:to_global_id)
+              identity[key] = value.to_global_id.to_s
+            else
+              identity[key] = value
+            end
+          end
+
+        path = @base.traveled_path.join('.')
+        fragment_name = @digest.hexdigest("#{partial_name}#{identity.to_json}")
+        @name = fragment_name
+        @fragments[fragment_name] ||= []
+        @fragments[fragment_name].push(path)
+      end
+    end
+  end
+end

data/lib/props_template/extensions/partial_renderer.rb

@@ -0,0 +1,187 @@
+require "concurrent/map"
+require 'action_view'
+
+module Props
+  class Partialer
+    def initialize(base, context, builder)
+      @context = context
+      @builder = builder
+      @base = base
+    end
+
+    def find_and_add_template(all_options)
+      first_opts = all_options[0]
+
+      if first_opts[:partial]
+        partial_opts = block_opts_to_render_opts(@builder, first_opts)
+        renderer = PartialRenderer.new(@context, partial_opts)
+
+        all_options.map do |opts|
+          opts[:_template] = renderer.template
+          opts
+        end
+      else
+        all_options
+      end
+    end
+
+    def block_opts_to_render_opts(builder, options)
+      partial, pass_opts = [*options[:partial]]
+      pass_opts ||= {}
+      pass_opts[:locals] ||= {}
+      pass_opts[:locals][:json] = @builder
+      pass_opts[:partial] = partial
+
+      pass_opts
+    end
+
+    def refine_options(options, item = nil)
+      PartialRenderer.refine_options(options, item)
+    end
+
+    def handle(options)
+      pass_opts = block_opts_to_render_opts(@builder, options)
+      renderer = PartialRenderer.new(@context, pass_opts)
+      template = options[:_template] || renderer.template
+
+      renderer.render(template, pass_opts)
+    end
+  end
+
+  class PartialRenderer < ActionView::AbstractRenderer
+    OPTION_AS_ERROR_MESSAGE  = "The value (%s) of the option `as` is not a valid Ruby identifier; " \
+                               "make sure it starts with lowercase letter, " \
+                               "and is followed by any combination of letters, numbers and underscores."
+    IDENTIFIER_ERROR_MESSAGE = "The partial name (%s) is not a valid Ruby identifier; " \
+                               "make sure your partial name starts with underscore."
+
+    INVALID_PARTIAL_MESSAGE = "The partial name must be a string, but received (%s)."
+
+    def self.find_and_add_template(builder, context, all_options)
+      first_opts = all_options[0]
+
+      if first_opts[:partial]
+        partial_opts = block_opts_to_render_opts(builder, first_opts)
+        renderer = new(context, partial_opts)
+
+        all_options.map do |opts|
+          opts[:_template] = renderer.template
+          opts
+        end
+      else
+        all_options
+      end
+    end
+
+    def self.raise_invalid_option_as(as)
+      raise ArgumentError.new(OPTION_AS_ERROR_MESSAGE % (as))
+    end
+
+    def self.raise_invalid_identifier(path)
+      raise ArgumentError.new(IDENTIFIER_ERROR_MESSAGE % (path))
+    end
+
+
+    def self.retrieve_variable(path)
+      base = path[-1] == "/" ? "" : File.basename(path)
+      raise_invalid_identifier(path) unless base =~ /\A_?(.*?)(?:\.\w+)*\z/
+      $1.to_sym
+    end
+
+    def self.refine_options(options, item = nil)
+      return options if !options[:partial]
+
+      partial, rest = [*options[:partial]]
+      rest = (rest || {}).clone
+      locals = rest[:locals] || {}
+      rest[:locals] = locals
+
+      if item
+        as = if !rest[:as]
+          retrieve_variable(partial)
+        else
+          rest[:as].to_sym
+        end
+
+        raise_invalid_option_as(as) unless /\A[a-z_]\w*\z/.match?(as.to_s)
+
+        locals[as] = item
+
+        if fragment_name = rest[:fragment]
+          fragment_name = Proc === fragment_name ? fragment_name.call(item) : fragment_name.to_s
+          rest[:fragment] = fragment_name
+        end
+      end
+
+      pass_opts = options.clone
+      pass_opts[:partial] = [partial, rest]
+
+      pass_opts
+    end
+
+    attr_reader :template
+
+    def initialize(context, options)
+      @context = context
+      super(@context.lookup_context)
+      @options = options.merge(formats: [:json])
+      @options.delete(:handlers)
+      @details = extract_details(@options)
+
+      partial = @options[:partial]
+
+      if !(String === partial)
+        raise_invalid_partial(partial.inspect)
+      end
+
+      @path = partial
+      @context_prefix = @lookup_context.prefixes.first
+      template_keys = retrieve_template_keys(@options)
+      @template = find_template(@path, template_keys)
+    end
+
+    def render(template, options)
+      #remove this later
+
+      render_partial(template, @context, @options)
+    end
+
+    private
+
+      def render_partial(template, view, options)
+        template ||= @template
+        # @variable ||= template.variable
+
+        instrument(:partial, identifier: @template.identifier) do |payload|
+          locals = options[:locals]
+          content = template.render(view, locals)
+
+          payload[:cache_hit] = view.view_renderer.cache_hits[template.virtual_path]
+          build_rendered_template(content, template)
+        end
+      end
+
+      # Sets up instance variables needed for rendering a partial. This method
+      # finds the options and details and extracts them. The method also contains
+      # logic that handles the type of object passed in as the partial.
+      #
+      # If +options[:partial]+ is a string, then the <tt>@path</tt> instance variable is
+      # set to that string. Otherwise, the +options[:partial]+ object must
+      # respond to +to_partial_path+ in order to setup the path.
+
+      def find_template(path, locals)
+        prefixes = path.include?(?/) ? [] : @lookup_context.prefixes
+        @lookup_context.find_template(path, prefixes, true, locals, @details)
+      end
+
+      def retrieve_template_keys(options)
+        template_keys = options[:locals].keys
+        template_keys << options[:as] if options[:as]
+        template_keys
+      end
+
+      def raise_invalid_partial(path)
+        raise ArgumentError.new(INVALID_PARTIAL_MESSAGE % (path))
+      end
+  end
+end

data/lib/props_template/handler.rb

@@ -0,0 +1,16 @@
+require 'active_support'
+
+module Props
+  class Handler
+    cattr_accessor :default_format
+    self.default_format = :json
+
+    def self.call(template, source = nil)
+      source ||= template.source
+      # this juggling is required to keep line numbers right in the error
+      %{__already_defined = defined?(json); json||=Props::Template.new(self); #{source};
+        json.result! unless (__already_defined && __already_defined != "method")
+      }
+    end
+  end
+end