mustache_render 0.0.21 → 0.0.22

data/lib/mustache_render/errors.rb

@@ -0,0 +1,5 @@
+# -*- encoding : utf-8 -*-
+module MustacheRender
+  autoload :MustacheTemplateMissError, "#{File.dirname(__FILE__)}/errors/mustache_template_miss_error"
+end
+

data/lib/mustache_render/errors/mustache_template_miss_error.rb

@@ -0,0 +1,6 @@
+# -*- encoding : utf-8 -*-
+module MustacheRender
+  class MustacheTemplateMissError < ::RuntimeError
+
+  end
+end

data/lib/mustache_render/mustache.rb

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
-require 'mustache_render/mustache/template'
-require 'mustache_render/mustache/context'
-require 'mustache_render/mustache/data'
+require "#{File.dirname(__FILE__)}/mustache/template"
+require "#{File.dirname(__FILE__)}/mustache/context"
+require "#{File.dirname(__FILE__)}/mustache/data"
 
 module MustacheRender
   class Mustache
@@ -20,19 +20,21 @@ module MustacheRender
     end
 
     def render(data = template, ctx = {})
-      impl_logger :level => :debug, :operation => 'MustacheRender::Mustache.render' do
-        impl_template_render data, ctx
-      end
-    end
+      self.template = data
 
-    # TODO: 语法检查,片段树
-    def partials_tree
+      return self.template.render(context) if ctx == {}
 
+      begin
+        context.push(ctx)
+        self.template.render(context)
+      ensure
+        context.pop
+      end
     end
 
     # Context accessors.
     #
-    # view = ::MustacheRender::Mustache.new
+    # view = Mustache.new
     # view[:name] = "Jon"
     # view.template = "Hi, {{name}}!"
     # view.render # => "Hi, Jon!"
@@ -51,15 +53,6 @@ module MustacheRender
       @context ||= Context.new(self)
     end
 
-    # 使用default_media 进行渲染
-    def self.impl_render(name, context={})
-      self.new.send :impl_render, name, context
-    end
-
-    def impl_render name, context={}
-      send "#{::MustacheRender.config.default_render_media}_render".to_sym, name, context
-    end
-
     # Given a file name and an optional context, attempts to load and
     # render the file as a template.
     def self.file_render(name, context = {})
@@ -69,10 +62,22 @@ module MustacheRender
     # Given a file name and an optional context, attempts to load and
     # render the file as a template.
     def file_render(name, context = {})
-      impl_logger :level => :debug, :operation => "#{self.class}.file_render" do
-        @media = :file
-        render(partial(name), context)
-      end
+      @media = :file
+      render(partial(name), context)
+    end
+
+    def self.db_render(full_path, context={})
+      self.new.db_render full_path, context
+    end
+
+    def db_render(full_path, context={})
+      @media = :db
+      render(partial(full_path), context)
+    end
+
+    def impl_read_db_template name
+      db_template = ::MustacheRenderTemplate.find_with_full_path(name)
+      db_template.try :content
     end
 
     def self.generate_template_name(name, template_extension)
@@ -98,7 +103,7 @@ module MustacheRender
         File.read full_path
       rescue
         if config.raise_on_file_template_miss?
-          raise ::MustacheRender::Mustache::TemplateMiss.new("read file template error: #{full_path}")
+          raise ::MustacheRender::MustacheTemplateMissError.new("miss read file template error: #{full_path}")
         else
           ''
         end
@@ -106,23 +111,10 @@ module MustacheRender
     end
 
     def read_template_from_media name, media
-      # ::MustacheRender.logger.debug "MustacheRender render -> read template from #{media}: #{name}"
-
-      impl_logger :level => :debug,
-        :operation => "MustacheRender render -> read template from #{media}: #{name}" do
-
-        case media
-        when :file
-          # if ::MustacheRender.config.file_template_cache?
-          #   self.class.fetch_partial_cache name, media, :expires_in => ::MustacheRender.config.file_template_cache_expires_in do
-          #     impl_read_file_template name
-          #   end
-          # else
-          #   impl_read_file_template name
-          # end
-
-          impl_read_file_template name
-        end
+      ::MustacheRender.logger.debug "MustacheRender render -> read template from #{media}: #{name}"
+      case media
+      when :file
+        impl_read_file_template name
       end
     end
 
@@ -132,6 +124,7 @@ module MustacheRender
     def partial(name)
       name = self.class.generate_template_name name, config.file_template_extension
 
+      # return self.read_template_from_media name, media
       @_cached_partials ||= {}
       (@_cached_partials[media] ||= {})[name] ||= self.read_template_from_media name, media
     end
@@ -149,6 +142,56 @@ module MustacheRender
       CGI.escapeHTML(str)
     end
 
+    #
+    # Private API
+    #
+
+    # When given a symbol or string representing a class, will try to produce an
+    # appropriate view class.
+    # e.g.
+    #   Mustache.view_namespace = Hurl::Views
+    #   Mustache.view_class(:Partial) # => Hurl::Views::Partial
+    def self.view_class(name)
+      if name != classify(name.to_s)
+        name = classify(name.to_s)
+      end
+
+      # Emptiness begets emptiness.
+      if name.to_s == ''
+        return Mustache
+      end
+
+      file_name = underscore(name)
+
+      name = "#{view_namespace}::#{name}"
+
+      if const = const_get!(name)
+        const
+      elsif File.exists?(file = "#{view_path}/#{file_name}.rb")
+        require "#{file}".chomp('.rb')
+        const_get!(name) || Mustache
+      else
+        Mustache
+      end
+    end
+
+    # Supercharged version of Module#const_get.
+    #
+    # Always searches under Object and can find constants by their full name,
+    #   e.g. Mustache::Views::Index
+    #
+    # name - The full constant name to find.
+    #
+    # Returns the constant if found
+    # Returns nil if nothing is found
+    def self.const_get!(name)
+      name.split('::').inject(Object) do |klass, name|
+        klass.const_get(name)
+      end
+    rescue NameError
+      nil
+    end
+
     # Has this template already been compiled? Compilation is somewhat
     # expensive so it may be useful to check this before attempting it.
     def self.compiled?
@@ -180,7 +223,7 @@ module MustacheRender
       end.join('::')
     end
 
-    # TemplatePartial => template_partial
+    #   TemplatePartial => template_partial
     # Template::Partial => template/partial
     # Takes a string but defaults to using the current class' name.
     def self.underscore(classified = name)
@@ -219,42 +262,5 @@ module MustacheRender
     def self.inheritable_config_for(attr_name, default)
       superclass.respond_to?(attr_name) ? superclass.send(attr_name) : default
     end
-
-    private
-
-    def impl_logger options={}
-      level = options[:level] || :debug
-
-      result = nil
-
-      if block_given?
-        start_at = Time.now
-        result = yield
-        ms = ((Time.now - start_at) * 1000).to_i
-        MustacheRender.logger.send level, impl_format_log_entry(
-          "#{options[:operation]} (#{ms}ms)", options[:message]
-        )
-      end
-
-      result
-    end
-
-    def impl_format_log_entry(operation, message = nil)
-      "  \033[4;34;1m#{operation}\033[0m   \033[0;1m#{message}\033[0m"
-    end
-
-    def impl_template_render(data=template, ctx={})
-      self.template = data
-
-      return self.template.render(context) if ctx == {}
-
-      begin
-        context.push(ctx)
-        self.template.render(context)
-      ensure
-        context.pop
-      end
-    end
-
   end
 end

data/lib/mustache_render/mustache/data.rb

@@ -1,93 +1,187 @@
 # -*- encoding : utf-8 -*-
 module MustacheRender
-  class Mustache
-    # 将所有的key转为字符串
-    class Data < ::Hash
-      def initialize options = {}
-        self.merge! options
+  class Mustache::Data < ::Hash
+    def initialize(options={})
+      self.merge! options
+    end
+
+    [:render, :file_render, :impl_render].each do |method_name|
+      define_method method_name do |path_or_template|
+        ::MustacheRender::Mustache.send method_name, path_or_template, self
       end
+    end
+
+    def []=(name, value)
+      super(name.to_sym, value)
+    end
+
+    def to_ary
+    end
 
-      [:render, :file_render, :impl_render].each do |method_name|
-        define_method method_name do |path_or_template|
-          ::MustacheRender::Mustache.send method_name, path_or_template, self
+    def [](name)
+      super(name.to_sym)
+    end
+
+    def deep_merge(other_hash)
+      self.deep_dup.deep_merge!(other_hash)
+    end
+
+    # 深层的合并
+    def deep_merge!(other_hash)
+      other_hash = self.class.new(other_hash) unless other_hash.is_a?(self.class)
+
+      other_hash.each_pair do |k,v|
+        tv = self[k]
+
+        unless v.is_a?(self.class)
+          v = self.class.new(v) if v.is_a?(Hash)
         end
+
+        self[k] = tv.is_a?(self.class) && v.is_a?(self.class) ? tv.deep_merge(v) : v
       end
 
-      def []=(name, value)
-        result = super(name.to_s, value)
-        self.each_pair do |k, v|
-          impl_stringify_keys v
+      self
+    end
+
+    def deep_dup
+      impl_deep_dup self
+    end
+
+    def method_missing method_name, *args, &block
+      # 如果方法是赋值, 则直接赋值
+      if method_name.to_s.end_with?('=')
+        self[method_name.to_s.chop!] = args.first
+      else
+        result = self[method_name.to_sym]
+
+        if result.is_a?(Hash) && !(result.is_a?(self.class))
+          self[method_name] = self.class.new(result)
+        elsif result.nil?
+          self[method_name] = self.class.new
+        else
+          result
         end
-        # self.stringify_keys!
-        result
       end
+    end
 
-      def [](name)
-        super(name.to_s)
-      end
+    def stringify_keys!
+      impl_stringify_keys! self
+    end
 
-      # 深层复制
-      def deep_dup
-        duplicate = self.dup
-        duplicate.each_pair do |k, v|
-          tv = duplicate[k]
-          duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
-        end
-        duplicate
+    def symbolize_keys!
+      impl_symbolize_keys! self
+    end
+
+    #
+    # origin_hash_symbolize
+    # origin_hash_stringify
+    # origin_hash_symbolize! key全是 symbol的
+    # origin_hash_stringify! key全市 string 的
+    #
+    [:symbolize, :stringify].each do |method_name|
+      define_method "origin_hash_#{method_name}".to_sym do
+        self.deep_dup.send "origin_hash_#{method_name}!".to_sym
       end
 
-      #
-      # data = MustacheRender::Mustache::Data.new
-      # data.site = {
-      #   :name => 'abc'
-      # }
-      #
-      # 等价于
-      #
-      # data['site'] = {
-      #   :name => 'abc'
-      # }
-      #
-      def method_missing method_name, *args, &block
-        # 如果方法是赋值, 则直接赋值
-        if method_name.to_s[-1,1] == "="
-          self[method_name.to_s.chop!] = args.first
-        else
-          result = self[method_name.to_s]
-
-          if result.is_a?(Hash)
-            self[method_name.to_s] = Data.new(result)
-          elsif result.nil? # 如果为空的话，则生成一个新的对象
-            self[method_name.to_s] = Data.new {}
-          else
-            result
-          end
-        end
+      define_method "origin_hash_#{method_name}!".to_sym do
+        self.send "impl_origin_hash_#{method_name}".to_sym, self
       end
+    end
 
-      def stringify_keys!
-        raise 'not impl'
+    #
+    # deep_stringify_keys
+    # deep_stringify_keys!
+    #
+    [:stringify, :symbolize].each do |method_name|
+      method_name_impl     = "impl_#{method_name}_keys".to_sym
+      method_name_new_soft = "deep_#{method_name}_keys".to_sym
+      method_name_new      = "deep_#{method_name}_keys!".to_sym
+
+      define_method method_name_new_soft do
+        self.deep_dup.send method_name_new
       end
 
-      def symbolize_keys!
-        raise 'not impl'
+      define_method method_name_new do
+        tmp = self.send method_name_impl, self
+
+        tmp.keys.each do |key|
+          tmp[key] = self.send method_name_impl, tmp[key]
+        end
+
+        tmp
       end
+    end
 
-      private
+    private
+
+    def impl_deep_dup v
+      if v.is_a?(::Hash)
+        tv = v.dup
+
+        v.each do |key, value|
+          tv[key] = impl_deep_dup value
+        end
+
+        tv
+      elsif v.is_a?(::Array)
+        v.map do |_v|
+          impl_deep_dup _v
+        end
+      else
+        v
+      end
+    end
 
-      def impl_stringify_keys(v)
+    [:stringify, :symbolize].each do |method_name|
+      typify_method = {:symbolize => :to_sym, :stringify => :to_s}[method_name]
+      method_name_new = "impl_origin_hash_#{method_name}".to_sym
+      define_method method_name_new do |v|
         if v.is_a?(::Hash)
+          tv = Hash.new
+
           v.keys.each do |key|
-            v[key.to_s] = v.delete(key) unless key.is_a?(::String)
+            tv[key.send(typify_method)] = self.send(method_name_new, v[key])
           end
+
+          tv
         elsif v.is_a?(::Array)
-          v.each do |_v|
-            impl_stringify_keys _v
+          v.map do |_v|
+            self.send(method_name_new, _v)
           end
+        else
+          v
         end
       end
+    end
+
+    [:stringify, :symbolize].each do |method_name|
+      typify_clazz = {:stringify => ::String, :symbolize => ::Hash}[method_name]
+      method_name_new = "impl_#{method_name}_keys".to_sym
+      typify_method = {:symbolize => :to_sym, :stringify => :to_s}[method_name]
+
+      define_method method_name_new do |v|
+        if v.is_a?(Hash)
+          v.keys.each do |key|
+            kv = v.delete key
 
+            unless key.is_a?(typify_clazz)
+              if(kv.is_a?(::Hash) && !(kv.is_a?(self.class)))
+                kv = self.class.new(kv)
+              end
+            end
+
+            v[key.send(typify_method)] = self.send method_name_new, kv
+          end
+        elsif v.is_a?(Array)
+          v = v.map do |_v|
+            self.send method_name_new, _v
+          end
+        end
+
+        v
+      end
     end
+
   end
 end