props_template 0.13.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9d1594043556583c84e0d4406165c623183b5843200c5fcdcac84f86ef7c30cc
+  data.tar.gz: 1b9cf4b6fa1accad65dee696ba8b3b998dc1f1687c1ef010980def63fceed882
+SHA512:
+  metadata.gz: 25f9e1f56cead08969fa97f7b010059bfc073e67977c20d0b71977ada79a8282b9c037d8a9f9b3f744cfe48f09ae2a91e2442e2738433a124977bd04eea6d5eb
+  data.tar.gz: 0442331012ade9ae49c2adc2a34e2c4b2ac5d809030622334fb71ad98db221be1f8c1032e4c81d2874e519ab676fa467f333457124f92df24a710c4e0b5c1663

data/lib/props_template.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'props_template/base_with_extensions'
+require 'props_template/searcher'
+require 'props_template/handler'
+
+require 'active_support'
+
+module Props
+  class Template
+    class << self
+      attr_accessor :template_lookup_options
+    end
+
+    self.template_lookup_options = { handlers: [:props] }
+
+    delegate :result!, :array!,
+      :commands_to_json!,
+      :deferred!,
+      :fragments!,
+      :set_block_content!,
+      :fragment_digest!,
+      to: :builder!
+
+    def initialize(context = nil, options = {})
+      @builder = BaseWithExtensions.new(self, context, options)
+      @context = context
+    end
+
+    def set!(key, options = {}, &block)
+      if block_given? && options[:search] && !@builder.is_a?(Searcher)
+
+        prev_builder = @builder
+        @builder = Searcher.new(self, options[:search], @context)
+        options.delete(:search)
+        @builder.set!(key, options, &block)
+        found_block, found_options = @builder.found!
+        @builder = prev_builder
+
+        if found_block
+          set!(key, found_options, &found_block)
+        end
+      else
+        @builder.set!(key, options, &block)
+      end
+    end
+
+    def builder!
+      @builder
+    end
+
+    private
+
+    def method_missing(*args, &block)
+      set!(*args, &block)
+    end
+  end
+end
+
+require 'props_template/railtie' if defined?(Rails)

data/lib/props_template/base.rb

@@ -0,0 +1,113 @@
+require 'oj'
+require 'active_support'
+
+#todo: active_support/core_ext/string/output_safety.rb
+
+module Props
+  class InvalidScopeForArrayError < StandardError; end
+  class InvalidScopeForObjError < StandardError; end
+
+  class Base
+    def initialize
+      @commands = [[:push_object]]
+      @stream = Oj::StringWriter.new(mode: :rails)
+      @scope = nil
+    end
+
+    def set_block_content!(options = {})
+      @commands.push([:push_object])
+      @scope = nil
+      yield
+      @commands.push([:pop])
+    end
+
+    def handle_set_block(key, options)
+      @commands.push([:push_key, key.to_s])
+      set_block_content!(options) do
+        yield
+      end
+    end
+
+    def set!(key, value = nil)
+      @scope ||= :object
+      if @scope == :array
+        raise InvalidScopeForObjError.new('Attempted to set! on an array! scope')
+      end
+      if block_given?
+        handle_set_block(key, value) do
+          yield
+        end
+      else
+        @commands.push([:push_key, key.to_s])
+        @commands.push([:push_value, value])
+      end
+
+      @scope = :object
+
+      nil
+    end
+
+    def refine_item_options(item, options)
+      options
+    end
+
+    def handle_collection_item(collection, item, index, options)
+      set_block_content!(options) do
+        yield
+      end
+    end
+
+    def refine_all_item_options(all_options)
+      all_options
+    end
+
+    def handle_collection(collection, options)
+      all_opts = collection.map do |item|
+        refine_item_options(item, options.clone)
+      end
+
+      all_opts = refine_all_item_options(all_opts)
+
+      collection.each_with_index do |item, index|
+        pass_opts = all_opts[index]
+        handle_collection_item(collection, item, index, pass_opts) do
+          #todo: remove index?
+          yield item, index
+        end
+      end
+    end
+    #todo, add ability to define contents of array
+    def array!(collection, options = {})
+      if @scope.nil?
+        @scope = :array
+      else
+        raise InvalidScopeForArrayError.new('array! expects exclusive use of this block')
+      end
+      @commands[-1] = [:push_array]
+
+      if !collection.empty?
+        handle_collection(collection, options) do |item, index|
+          yield item, index
+        end
+      end
+
+      @scope = :array
+
+      nil
+    end
+
+    def commands_to_json!(commands)
+      commands.each do |command|
+        @stream.send(*command)
+      end
+      json = @stream.to_s
+      @stream.reset
+      json
+    end
+
+    def result!
+      @commands.push([:pop])
+      commands_to_json!(@commands)
+    end
+  end
+end

data/lib/props_template/base_with_extensions.rb

@@ -0,0 +1,117 @@
+require 'props_template/base'
+require 'props_template/extensions/partial_renderer'
+require 'props_template/extensions/cache'
+require 'props_template/extensions/deferment'
+require 'props_template/extension_manager'
+require 'props_template/key_formatter'
+
+require 'active_support/core_ext/string/output_safety'
+
+module Props
+  class BaseWithExtensions < Base
+    attr_reader :builder, :context, :fragments, :traveled_path, :deferred, :commands
+
+    def initialize(builder, context = nil, options = {})
+      @context = context
+      @builder = builder
+      #todo: refactor so deferred can be its own class
+      @em = ExtensionManager.new(self)
+      @traveled_path = []
+      @key_formatter = KeyFormatter.new(camelize: :lower)
+      super()
+    end
+
+    def deferred!
+      @em.deferred
+    end
+
+    def fragments!
+      @em.fragments
+    end
+
+    def fragment_digest!
+      @em.fragment_digest
+    end
+
+    def set_block_content!(options = {})
+      return super if !@em.has_extensions(options)
+
+      @em.handle(@commands, options) do
+        yield
+      end
+    end
+
+    def scoped_state
+      prev_state = [@commands, @em.deferred, @em.fragments]
+      @commands = []
+      @em  = ExtensionManager.new(self)
+      yield
+      next_state = [@commands, @em.deferred, @em.fragments]
+      @commands = prev_state[0]
+      @em = ExtensionManager.new(self, prev_state[1], prev_state[2])
+
+      next_state
+    end
+
+    def set!(key, options = {}, &block)
+      key = @key_formatter.format(key)
+
+      if block_given?
+        options = @em.refine_options(options)
+      end
+
+      super(key, options, &block)
+    end
+
+    def handle_set_block(key, options)
+      @traveled_path.push(key)
+      n = 1
+      if suffix = options[:path_suffix]
+        n += suffix.length
+        @traveled_path.push(suffix)
+      end
+
+      super
+
+      @traveled_path.pop(n)
+      return
+    end
+
+    def handle_collection_item(collection, item, index, options)
+      if collection.respond_to? :member_key
+        member_key = collection.member_key
+      end
+
+      if !member_key
+        @traveled_path.push(index)
+      else
+        id = if item.respond_to? member_key
+          item.send(member_key)
+        elsif item.is_a? Hash
+          item[member_key] || item[member_key.to_sym]
+        end
+
+        if id.nil?
+          @traveled_path.push(index)
+        else
+          @traveled_path.push("#{member_key.to_s}=#{id}")
+        end
+      end
+
+      super
+
+      @traveled_path.pop
+      return
+    end
+
+    def refine_all_item_options(all_options)
+      @em.refine_all_item_options(all_options)
+    end
+
+
+    def refine_item_options(item, options)
+      @em.refine_options(options, item)
+    end
+  end
+end
+

data/lib/props_template/core_ext.rb

@@ -0,0 +1,19 @@
+module Props
+  module Extensions
+    module Array
+      module Member
+        def member_at(index)
+          at(index)
+        end
+
+        def member_by(attribute, value)
+          raise NotImplementedError, 'Implement member_by(attr, value) in your own delegate'
+        end
+      end
+    end
+  end
+end
+
+class Array
+  include Props::Extensions::Array::Member
+end

data/lib/props_template/dependency_tracker.rb

@@ -0,0 +1,50 @@
+# This was taken from jbuilder
+require 'props_template'
+
+
+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
+  module Props
+    module DependencyTrackerMethods
+      # Matches:
+      #   json.comments @post.comments, partial: "comments/comment", as: :comment
+      #   json.array! @posts, partial: "posts/post", as: :post
+      #
+      INDIRECT_RENDERS = /
+        (?::partial\s*=>|partial:)  # partial: or :partial =>
+        \s*                         # optional whitespace
+        \[*                         # optional Bracket
+        \s*                         # optional whitespace
+        (['"])([^'"]+)\1            # quoted value
+      /x
+
+      def dependencies
+        indirect_dependencies + explicit_dependencies
+      end
+
+      private
+
+      def indirect_dependencies
+        source.scan(INDIRECT_RENDERS).map(&:second)
+      end
+    end
+  end
+
+  Props::DependencyTracker = Class.new(dependency_tracker::ERBTracker)
+  Props::DependencyTracker.send :include, Props::DependencyTrackerMethods
+
+  ActionView::DependencyTracker.register_tracker :props, Props::DependencyTracker
+end

data/lib/props_template/extension_manager.rb

@@ -0,0 +1,107 @@
+require 'props_template/extensions/partial_renderer'
+require 'props_template/extensions/cache'
+require 'props_template/extensions/deferment'
+require 'props_template/extensions/fragment'
+
+module Props
+  class ExtensionManager
+    attr_reader :base, :builder, :context
+
+    def initialize(base, defered=[], fragments={})
+      @base = base
+      @context = base.context
+      @builder = base.builder
+      @fragment = Fragment.new(base, fragments)
+      @deferment = Deferment.new(base, defered)
+      @partialer = Partialer.new(base, context, builder)
+      @cache = Cache.new(@context)
+    end
+
+    def refine_options(options, item = nil)
+      options = @partialer.refine_options(options, item)
+      options = @deferment.refine_options(options, item)
+      options = Cache.refine_options(options, item)
+      options
+    end
+
+    def refine_all_item_options(all_options)
+      all_options = @partialer.find_and_add_template(all_options)
+      all_options = @cache.multi_fetch_and_add_results(all_options)
+      all_options
+    end
+
+    def deferred
+      @deferment.deferred
+    end
+
+    def fragment_digest
+      @fragment.name
+    end
+
+    def fragments
+      @fragment.fragments
+    end
+
+    def has_extensions(options)
+      options[:defer] || options[:cache] || options[:partial]
+    end
+
+    def handle(commands, options)
+      return yield if !has_extensions(options)
+
+      if options[:defer]
+        placeholder = @deferment.handle(options)
+        commands.push([:push_value, placeholder])
+        @fragment.handle(options)
+      else
+        handle_cache(options) do
+          base.set_block_content! do
+            if options[:partial]
+              current_digest = @fragment.name
+              @fragment.handle(options)
+              @partialer.handle(options)
+              @fragment.name = current_digest
+            else
+              yield
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def content_for_cache(commands, deferred_paths, fragment_paths)
+      suffix = [
+        [:push_value, deferred_paths],
+        [:push_value, fragment_paths],
+        [:pop]
+      ]
+
+      [[:push_array]] + commands + suffix
+    end
+
+    def handle_cache(options)
+      if options[:cache]
+        state = @cache.cache(*options[:cache]) do
+          commands = content_for_cache(*base.scoped_state {yield})
+          base.commands_to_json!(commands).strip
+        end
+
+        value, next_deferred, next_fragments = Oj.load(state)
+        base.commands.push([:push_value, value])
+        deferred.push(*next_deferred)
+
+        next_fragments.each do |k, v|
+          if fragments[k]
+            fragments[k].push(*v)
+          else
+            fragments[k] = v
+          end
+        end
+      else
+        yield
+      end
+    end
+  end
+end