breezy_template 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1034948b51df6045cd4ebed1fec5278d578b6232
-  data.tar.gz: 37f2073cb2c299d22fa2d12b0b022d34d531ed7e
+  metadata.gz: 5615a0d5186cccdec50df4bc728c6d472f877254
+  data.tar.gz: ae3d4643bfa89ebbf2d38fd285b74ee909a73b06
 SHA512:
-  metadata.gz: ceab85197a0d71c53c3b4ac25263bc392fcf700b1a23e88f5dcb8a79f6634b7bc6d6e93e10d3ff0f2222a3c5d8b3345e02b66978d44e452463ae53aa05c567a4
-  data.tar.gz: 7fc963e83b28dfdbb7a2216815e7e3319089c7bb6745ffe92f3e37d583490d492adc8607cc097b21c905052d5077ba5a6994474f60c28773315be42c0659fc64
+  metadata.gz: 4e639ce8e936ebb85324b90830425f005b3f17d7e1366ddb2f9d1d0a096cf4275e56b64ccc0c64aa32c66c365f94c6ca1c7e933a7ea71c50ef35101940f1d7d8
+  data.tar.gz: 30b7c0e630b346d037447f26ca3a5265c8d0839c42c3218060fcbd37e2b5dd431819e7ab27136789b202dd8295794fb49d74d4f17c0c5178b74648867ce7805c

data/lib/breezy_template.rb

@@ -1,7 +1,9 @@
-require 'jbuilder'
-require 'digest/md5'
-require 'action_view'
-require 'active_support'
+require 'breezy_template/breezy_template'
+
+require 'breezy_template/blank'
+require 'breezy_template/key_formatter'
+require 'breezy_template/errors'
+
 require 'breezy_template/active_support'
 require 'breezy_template/digestor'
 require 'breezy_template/configuration'
@@ -11,258 +13,330 @@ 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
+require 'digest/md5'
+require 'action_view'
+require 'active_support'
+require 'multi_json'
+require 'ostruct'
 
-  class Template < ::Jbuilder
-    include PartialDigestor
-    prepend PartialExtension
+class BreezyTemplate
+  include PartialDigestor
 
-    prepend CacheExtension
-    prepend SearchExtension
-    prepend DefermentExtension
+  prepend PartialExtension
+  prepend CacheExtension
+  prepend SearchExtension
+  prepend DefermentExtension
 
-    class << self
-      attr_accessor :template_lookup_options
-    end
+  class << self
+    attr_accessor :template_lookup_options
+  end
 
-    self.template_lookup_options = { handlers: [:breezy] }
+  self.template_lookup_options = { handlers: [:breezy, :props] }
 
-    def initialize(context, *args)
-      @context = context
-      @js = []
-      @path = []
-      @joints = {}
-      @extensions = {}
-      super(*args)
-    end
+  @@key_formatter = nil
+  @@ignore_nil    = false
 
-    def empty!
-      attributes = @attributes
-      @attributes = {}
-      attributes
-    end
+  def initialize(context, options = {})
+    @context = context
+    @js = []
+    @path = []
+    @joints = {}
 
-    def wrap!(name, *args)
-      @extensions[name.to_sym] = args
-    end
+    @attributes = {}
+    @key_formatter = options.fetch(:key_formatter){ @@key_formatter ? @@key_formatter.clone : nil}
+    @ignore_nil = options.fetch(:ignore_nil, @@ignore_nil)
 
-    def _blank
-      BLANK
-    end
+    yield self if ::Kernel.block_given?
+  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)
+    # Yields a builder and automatically turns the result into a JSON string
+  def self.encode(*args, &block)
+    new(*args, &block).target!
+  end
+
+  BLANK = Blank.new
+  NON_ENUMERABLES = [ ::Struct, ::OpenStruct ].to_set
+
+  def set!(key, value = BLANK, *args)
+    result = if ::Kernel.block_given?
+      _result(value, *args, &::Proc.new)
+    else
+      if _is_collection?(value) && !args.last.is_a?(::Hash)
+        _scope{ array! value, *args }
+      # elsif args.empty?
+      #   _result(value, *args)
+      # elsif !args.last.is_a? ::Hash
+      #   _merge_block(key){ extract! value, *args }
       else
-        args = _args_for_set(*args)
-        set!(*args)
+        _result(value, *args)
+        # value
       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
 
-      _set_value key, result
+  def _result(value, *args)
+    if ::Kernel.block_given?
+      _scope { yield self }
+    elsif ::BreezyTemplate === value
+      # json.age 32
+      # json.person another_jbuilder
+      # { "age": 32, "person": { ...  }
+      value.attributes!
+    else
+      # json.age 32
+      # { "age": 32 }
+      value
     end
+  end
 
-    def _ensure_valid_key(key)
-      current_value = _blank? ? _blank : @attributes.fetch(_key(key), _blank)
-      raise NullError.build(key) if current_value.nil?
+  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
+    @path.pop
+  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 key_format!(*args)
+    @key_formatter = KeyFormatter.new(*args)
+  end
 
-    def _set_value(key, result)
-      super
-    end
+  # Same as the instance method key_format! except sets the default.
+  def self.key_format(*args)
+    @@key_formatter = KeyFormatter.new(*args)
+  end
+
+  def empty!
+    attributes = @attributes
+    @attributes = {}
+    attributes
+  end
 
-    def array!(collection = [], *attributes)
-      options = attributes.first || {}
-      options = _normalize_options(options)
+  def ignore_nil!(value = true)
+    @ignore_nil = value
+  end
 
-      collection = [] if collection.nil?
-      collection = _prepare_collection_for_map(collection)
+  # Same as instance method ignore_nil! except sets the default.
+  def self.ignore_nil(value = true)
+    @@ignore_nil = value
+  end
+
+  def child!
+    @attributes = [] unless ::Array === @attributes
+    @attributes << _scope{ yield self }
+  end
 
-      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
+  def array!(collection = [], *attributes)
+    options = attributes.first || {}
+
+    collection = [] if collection.nil?
+    collection = _prepare_collection_for_map(collection)
+    array = if ::Kernel.block_given?
+      _map_collection(collection, options, &::Proc.new)
+    # elsif attributes.any?
+    #   if (!attributes.last.is_a? ::Hash)
+    #     _map_collection(collection) { |element|
+    #       extract! element, *attributes
+    #     }
+    #   else
+    #     _map_collection(collection, options) { |element|
+    #       extract! element, *attributes
+    #     }
+    #   end
+    else
+      collection.to_a
     end
 
-    def target!
-      js = _breezy_return(@attributes)
+    merge! array #remove this depednacy
+  end
 
-      @js.push(js)
-      "(function(){var joints={};var cache={};var defers=[];#{@js.join}})()"
+  def extract!(object, *attributes)
+    if ::Hash === object
+      _extract_hash_values(object, attributes)
+    else
+      _extract_method_values(object, attributes)
     end
+  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.
+  # def call(object, *attributes)
+  #   if ::Kernel.block_given?
+  #     array! object, &::Proc.new
+  #   else
+  #     extract! object, *attributes
+  #   end
+  # end
+
+  # Returns the nil JSON.
+  def nil!
+    @attributes = nil
+  end
 
-        updates
-      end
+  alias_method :null!, :nil!
 
-      def _prepare_collection_for_map(collection)
-        collection
-      end
+  def attributes!
+    @attributes
+  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 target!
+    js = _breezy_return(@attributes)
 
-      def _args_for_set(*args)
-        if args.length == 3
-          key, value, options = args
+    @js.push(js)
+    "(function(){var joints={};var cache={};var defers=[];#{@js.join}})()"
+  end
 
-          [key, value, options]
-        else
-          key, value = args
+  # Merges hash or array into current builder.
+  # No longer works on Breezy
+  def merge!(hash_or_array)
+    @attributes = _merge_values(@attributes, hash_or_array)
+  end
 
-          [key, value]
-        end
-      end
+  private
 
-      def _extended_options?(value)
-        false
-      end
+  def _extract_hash_values(object, attributes)
+    attributes.each{ |key| _set_value key, object.fetch(key) }
+  end
 
-      def _mapping_element(element, options)
-        _scope { yield element }
-      end
+  def _extract_method_values(object, attributes)
+    attributes.each{ |key| _set_value key, object.public_send(key) }
+  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 _merge_block(key)
+    current_value = _blank? ? BLANK : @attributes.fetch(_key(key), BLANK)
+    raise NullError.build(key) if current_value.nil?
+    new_value = _scope{ yield self }
+    _merge_values(current_value, new_value)
+  end
 
+  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.
 
-      def _breezy_return(results)
-        "return (#{_dump(results)});"
-      end
+    updates
+  end
 
-      def _dump(value)
-        ::MultiJson.dump(value)
-      end
+  def _key(key)
+    @key_formatter ? @key_formatter.format(key) : key.to_s
+  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 _set_value(key, value)
+    raise NullError.build(key) if @attributes.nil?
+    raise ArrayError.build(key) if ::Array === @attributes
+    return if @ignore_nil && value.nil? or _blank?(value)
+    @attributes = {} if _blank?
+    @attributes[_key(key)] = value
+  end
+
+  def _prepare_collection_for_map(collection)
+    collection
+  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
+  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 _mapping_element(element, options)
+    _scope { yield element }
+  end
+
+  def _scope
+    parent_attributes, parent_formatter = @attributes, @key_formatter
+    @attributes = BLANK
+    yield
+    @attributes
+  ensure
+    @attributes, @key_formatter = parent_attributes, parent_formatter
+  end
+
+  def _is_collection?(object)
+    _object_respond_to?(object, :map, :count) && NON_ENUMERABLES.none?{ |klass| klass === object }
+  end
 
-      def _logger
-        ::ActionView::Base.logger
+  def _blank?(value=@attributes)
+    BLANK == value
+  end
+
+  def _blank
+    BLANK
+  end
+
+  def _object_respond_to?(object, *methods)
+    methods.all?{ |m| object.respond_to?(m) }
+  end
+
+  def _args_for_set_with_block(*args)
+    # return 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)
+    return args
+    # if args.length >= 3
+    #   return args
+    #   # key, value, options = args
+    #   #
+    #   # [key, value, options]
+    # else
+    #   key, value = args
+    #
+    #   [key, value]
+    # end
+  end
+
+  def _extended_options?(value)
+    false
+  end
+
+  def _breezy_return(results)
+    "return (#{_dump(results)});"
+  end
+
+  def _dump(value)
+    ::MultiJson.dump(value)
+  end
+
+  def _logger
+    ::ActionView::Base.logger
+  end
+
+  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
 end