breezy_template 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1034948b51df6045cd4ebed1fec5278d578b6232
+  data.tar.gz: 37f2073cb2c299d22fa2d12b0b022d34d531ed7e
+SHA512:
+  metadata.gz: ceab85197a0d71c53c3b4ac25263bc392fcf700b1a23e88f5dcb8a79f6634b7bc6d6e93e10d3ff0f2222a3c5d8b3345e02b66978d44e452463ae53aa05c567a4
+  data.tar.gz: 7fc963e83b28dfdbb7a2216815e7e3319089c7bb6745ffe92f3e37d583490d492adc8607cc097b21c905052d5077ba5a6994474f60c28773315be42c0659fc64

data/lib/breezy_template.rb

@@ -0,0 +1,268 @@
+require 'jbuilder'
+require 'digest/md5'
+require 'action_view'
+require 'active_support'
+require 'breezy_template/active_support'
+require 'breezy_template/digestor'
+require 'breezy_template/configuration'
+require 'breezy_template/handler'
+require 'breezy_template/partial_extension'
+require 'breezy_template/cache_extension'
+require 'breezy_template/deferment_extension'
+require 'breezy_template/search_extension'
+
+module BreezyTemplate
+  class Engine < ::Rails::Engine
+    initializer :breezy_template do |app|
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Template.register_template_handler :breezy, BreezyTemplate::Handler
+        ActionView::Template.register_template_handler :props, BreezyTemplate::Handler
+        require 'breezy_template/dependency_tracker'
+      end
+    end
+  end
+
+  class Template < ::Jbuilder
+    include PartialDigestor
+    prepend PartialExtension
+
+    prepend CacheExtension
+    prepend SearchExtension
+    prepend DefermentExtension
+
+    class << self
+      attr_accessor :template_lookup_options
+    end
+
+    self.template_lookup_options = { handlers: [:breezy] }
+
+    def initialize(context, *args)
+      @context = context
+      @js = []
+      @path = []
+      @joints = {}
+      @extensions = {}
+      super(*args)
+    end
+
+    def empty!
+      attributes = @attributes
+      @attributes = {}
+      attributes
+    end
+
+    def wrap!(name, *args)
+      @extensions[name.to_sym] = args
+    end
+
+    def _blank
+      BLANK
+    end
+
+    def method_missing(*args)
+      key = args[0]
+      @path.push(key)
+      if ::Kernel.block_given?
+        args = _args_for_set_with_block(*args)
+        set!(*args, &::Proc.new)
+      else
+        args = _args_for_set(*args)
+        set!(*args)
+      end
+    ensure
+      # ::Byebug.byebug
+      @extensions = {}
+      @path.pop
+    end
+
+    def _scope
+      parent_extensions = @extensions
+      @extensions = {}
+      parent_attributes, parent_formatter = @attributes, @key_formatter
+      @attributes = BLANK
+      yield
+      @attributes
+    ensure
+      # ::Byebug.byebug
+      @extensions = parent_extensions
+      @attributes, @key_formatter = parent_attributes, parent_formatter
+    end
+
+    def set!(key, value = BLANK, *args)
+      _ensure_valid_key(key)
+      result = if ::Kernel.block_given?
+        _result(value, &::Proc.new)
+      else
+        _result(value)
+      end
+
+      _set_value key, result
+    end
+
+    def _ensure_valid_key(key)
+      current_value = _blank? ? _blank : @attributes.fetch(_key(key), _blank)
+      raise NullError.build(key) if current_value.nil?
+    end
+
+    def _result(value)
+      if ::Kernel.block_given?
+        _scope { yield self }
+      elsif ::Jbuilder === value
+        # json.age 32
+        # json.person another_jbuilder
+        # { "age": 32, "person": { ...  }
+        value.attributes!
+      else
+        # json.age 32
+        # { "age": 32 }
+        value
+      end
+    end
+
+    def _set_value(key, result)
+      super
+    end
+
+    def array!(collection = [], *attributes)
+      options = attributes.first || {}
+      options = _normalize_options(options)
+
+      collection = [] if collection.nil?
+      collection = _prepare_collection_for_map(collection)
+
+      array = if ::Kernel.block_given?
+        _map_collection(collection, options, &::Proc.new)
+      elsif attributes.any?
+        _map_collection(collection, options) { |element| extract! element, *attributes }
+      else
+        collection.to_a
+      end
+
+      @extensions = {}
+      merge! array #remove this depednacy
+    end
+
+    def target!
+      js = _breezy_return(@attributes)
+
+      @js.push(js)
+      "(function(){var joints={};var cache={};var defers=[];#{@js.join}})()"
+    end
+
+    private
+      def _merge_values(current_value, updates)
+        # Always use the new values. This is because cached values
+        # are no longer a Ruby object. They are JS values and can't
+        # be merged.
+
+        updates
+      end
+
+      def _prepare_collection_for_map(collection)
+        collection
+      end
+
+      def _args_for_set_with_block(*args)
+        key = args[0]
+        #todo: check this
+        if ::Hash === args[1] && _extended_options?(args[1])
+          options = args[1]
+          [key, BLANK, options]
+        else
+          [key, BLANK]
+        end
+      end
+
+      def _args_for_set(*args)
+        if args.length == 3
+          key, value, options = args
+
+          [key, value, options]
+        else
+          key, value = args
+
+          [key, value]
+        end
+      end
+
+      def _extended_options?(value)
+        false
+      end
+
+      def _mapping_element(element, options)
+        _scope { yield element }
+      end
+
+      def _map_collection(collection, options)
+        @path.push(nil)
+        collection.map.with_index do |element, i|
+          if options.has_key? :key
+            id_name = options[:key]
+            id_val = element[id_name]
+            @path[-1] = "#{id_name}=#{id_val}"
+          else
+            @path[-1] = i
+          end
+
+          _mapping_element(element, options, &::Proc.new)
+
+        end - [BLANK]
+      ensure
+        @path.pop
+      end
+
+
+      def _breezy_return(results)
+        "return (#{_dump(results)});"
+      end
+
+      def _dump(value)
+        ::MultiJson.dump(value)
+      end
+
+      def _normalize_options(options)
+        options = options.dup
+        key = options[:cache]
+        opts = {}
+        return options if !key
+
+        if ::Array === key && key.length == 2 && ::Hash === key.last
+          return options
+        end
+
+        if options[:partial]
+          opts[:partial] = options[:partial]
+        end
+
+        key = case key
+        when ::Array
+          key
+        when ::Proc
+          key
+        else
+          [key]
+        end
+
+        options[:cache] = [key, opts]
+        options
+      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 _logger
+        ::ActionView::Base.logger
+      end
+  end
+end

data/lib/breezy_template/active_support.rb

@@ -0,0 +1,24 @@
+# https://github.com/rails/jbuilder/issues/204
+if Rails.version >= '4.1'
+  module ActiveSupport
+    module JSON
+      module Encoding
+        class JSONGemEncoder
+          alias_method :original_jsonify, :jsonify
+
+          def jsonify(value)
+            if ::BreezyTemplate::Template::Digest === value
+              value
+            elsif ::BreezyTemplate::Template::JointVar === value
+              value
+            elsif ::BreezyTemplate::Template::DeferVar === value
+              value
+            else
+              original_jsonify(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/breezy_template/cache_extension.rb

@@ -0,0 +1,131 @@
+module BreezyTemplate
+  module CacheExtension
+    class Digest
+      def initialize(digest)
+        @digest = "cache[\"#{digest}\"]"
+      end
+
+      def to_json(*)
+        @digest
+      end
+
+      def as_json(*)
+        self
+      end
+
+      def encode_json(*)
+        @digest
+      end
+    end
+
+    def _result(value)
+      if _cache_options?
+        _cache(*_cache_options) { super }
+      else
+        super
+      end
+    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]
+      end
+        super
+    end
+
+    def array!(collection=[], *attributes)
+      options = attributes.first || {}
+      options = _normalize_options(options)
+
+      if options[:partial] && _cache_options?
+        _cache_options[1] ||= {}
+        _cache_options[1][:_partial] = options[:partial]
+      end
+
+      super
+    end
+
+    def _mapping_element(element, opts={})
+      if _cache_options
+        key = _cache_options.first
+        if ::Proc === key
+          key = key.call(element)
+        end
+
+        _cache(key, opts) {
+          _scope { yield element }
+        }
+      else
+        super
+      end
+    end
+
+    def _cache_options?
+      !!@extensions[:cache]
+    end
+
+    def _cache_options
+      @extensions[:cache]
+    end
+
+    def _extended_options?(value)
+      _cache_options? || super
+    end
+
+    def _breezy_set_cache(key, value)
+      "cache[\"#{key}\"]=#{_dump(value)};"
+    end
+
+    def _cache_key(key, options={})
+      key = _fragment_name_with_digest(key, options)
+      key = url_for(key).split('://', 2).last if ::Hash === key
+      key = ::ActiveSupport::Cache.expand_cache_key(key, :jbuilder)
+
+      ::Digest::MD5.hexdigest(key.to_s).tap do |digest|
+        _logger.try :debug, "Cache key :#{key} was digested to #{digest}"
+      end
+    end
+
+    def _cache(key=nil, options={})
+      return yield self if !@context.controller.perform_caching || key.nil?
+
+      parent_js = @js
+      key = _cache_key(key, options)
+      @js = []
+
+      blank_or_value = begin
+        ::Rails.cache.fetch(key, options) do
+          result = yield self
+          if result != _blank
+            @js << _breezy_set_cache(key, result)
+            @js.join
+          else
+            _blank
+          end
+        end
+      ensure
+        @js = parent_js
+      end
+
+      if blank_or_value == _blank
+        _blank
+      else
+        v = blank_or_value
+        @js.push(v)
+        Digest.new(key)
+      end
+    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]
+        [key, _partial_digest(partial)]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/breezy_template/configuration.rb

@@ -0,0 +1,21 @@
+module BreezyTemplate
+  class Configuration
+    attr_accessor :track_assets
+
+    def initialize
+      @track_assets = ['application.js', 'application.css']
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  def self.configure
+    yield configuration
+  end
+end