mustache_render 0.0.1 → 0.0.3

data/lib/mustache_render/models/mustache_render_template_mixin.rb

@@ -0,0 +1,44 @@
+# -*- encoding : utf-8 -*-
+module MustacheRender::Models
+  module MustacheRenderTemplateMixin
+    def self.included(base)
+      base.class_eval do
+        table_name = 'mustache_render_templates'
+
+        attr_accessible :folder_id, :name, :note, :content
+
+        belongs_to :folder, :class_name => 'MustacheRenderFolder'
+
+        validates_presence_of   :folder_id
+        validates_presence_of   :name
+
+        extend  ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+      #
+      # TODO: add cache here!
+      #
+      def find_with_full_path(name)
+        # 首先获取文件夹的名称, 然后获取文件名
+        tmp_paths = name.to_s.split('/')
+
+        template_name = tmp_paths.pop.to_s
+
+        folder_full_path = "#{tmp_paths.join('/')}"
+        folder = ::MustacheRenderFolder.find_by_full_path(folder_full_path)
+
+        self.find_by_folder_id_and_name(folder.try(:id), template_name)
+      end
+    end
+
+    module InstanceMethods
+      def full_path
+        "#{self.folder.try :full_path}/#{self.name}"
+      end
+    end
+  end
+end
+

data/lib/mustache_render/mustache.rb

@@ -0,0 +1,314 @@
+require 'mustache_render/mustache/template'
+require 'mustache_render/mustache/context'
+require 'mustache_render/mustache/settings'
+
+# Mustache is the base class from which your Mustache subclasses
+# should inherit (though it can be used on its own).
+#
+# The typical Mustache workflow is as follows:
+#
+# * Create a Mustache subclass: class Stats < Mustache
+# * Create a template: stats.mustache
+# * Instantiate an instance: view = Stats.new
+# * Render that instance: view.render
+#
+# You can skip the instantiation by calling `Stats.render` directly.
+#
+# While Mustache will do its best to load and render a template for
+# you, this process is completely customizable using a few options.
+#
+# All settings can be overriden at the class level.
+#
+# For example, going with the above example, we can use
+# `Stats.template_path = "/usr/local/templates"` to specify the path
+# Mustache uses to find templates.
+#
+# Here are the available options:
+#
+# * template_path
+#
+# The `template_path` setting determines the path Mustache uses when
+# looking for a template. By default it is "."
+# Setting it to /usr/local/templates, for example, means (given all
+# other settings are default) a Mustache subclass `Stats` will try to
+# load /usr/local/templates/stats.mustache
+#
+# * template_extension
+#
+# The `template_extension` is the extension Mustache uses when looking
+# for template files. By default it is "mustache"
+#
+# * template_file
+#
+# You can tell Mustache exactly which template to us with this
+# setting. It can be a relative or absolute path.
+#
+# * template
+#
+# Sometimes you want Mustache to render a string, not a file. In those
+# cases you may set the `template` setting. For example:
+#
+#   >> Mustache.render("Hello {{planet}}", :planet => "World!")
+#   => "Hello World!"
+#
+# The `template` setting is also available on instances.
+#
+#   view = Mustache.new
+#   view.template = "Hi, {{person}}!"
+#   view[:person] = 'Mom'
+#   view.render # => Hi, mom!
+#
+# * view_namespace
+#
+# To make life easy on those developing Mustache plugins for web frameworks or
+# other libraries, Mustache will attempt to load view classes (i.e. Mustache
+# subclasses) using the `view_class` class method. The `view_namespace` tells
+# Mustache under which constant view classes live. By default it is `Object`.
+#
+# * view_path
+#
+# Similar to `template_path`, the `view_path` option tells Mustache where to look
+# for files containing view classes when using the `view_class` method.
+#
+module MustacheRender
+  class Mustache
+
+    #
+    # Public API
+    #
+
+    # Instantiates an instance of this class and calls `render` with
+    # the passed args.
+    #
+    # Returns a rendered String version of a template
+    def self.render(*args)
+      new.render(*args)
+    end
+
+    class << self
+      alias_method :to_html, :render
+      alias_method :to_text, :render
+    end
+
+    # Parses our fancy pants template file and returns normal file with
+    # all special {{tags}} and {{#sections}}replaced{{/sections}}.
+    #
+    # data - A String template or a Hash context. If a Hash is given,
+    #        we'll try to figure out the template from the class.
+    #  ctx - A Hash context if `data` is a String template.
+    #
+    # Examples
+    #
+    #   @view.render("Hi {{thing}}!", :thing => :world)
+    #
+    #   View.template = "Hi {{thing}}!"
+    #   @view = View.new
+    #   @view.render(:thing => :world)
+    #
+    # Returns a rendered String version of a template
+    def render(data = template, ctx = {})
+      if data.is_a? Hash
+        ctx = data
+        tpl = templateify(template)
+      elsif data.is_a? Symbol
+        self.template_name = data
+        tpl = templateify(template)
+      else
+        tpl = templateify(data)
+      end
+
+      return tpl.render(context) if ctx == {}
+
+      begin
+        context.push(ctx)
+        tpl.render(context)
+      ensure
+        context.pop
+      end
+    end
+
+    alias_method :to_html, :render
+    alias_method :to_text, :render
+
+    # Context accessors.
+    #
+    # view = Mustache.new
+    # view[:name] = "Jon"
+    # view.template = "Hi, {{name}}!"
+    # view.render # => "Hi, Jon!"
+    def [](key)
+      context[key.to_sym]
+    end
+
+    def []=(key, value)
+      context[key.to_sym] = value
+    end
+
+    # A helper method which gives access to the context at a given time.
+    # Kind of a hack for now, but useful when you're in an iterating section
+    # and want access to the hash currently being iterated over.
+    def context
+      @context ||= Context.new(self)
+    end
+
+    # Given a file name and an optional context, attempts to load and
+    # render the file as a template.
+    def self.render_file(name, context = {})
+      render(partial(name), context)
+    end
+
+    # Given a file name and an optional context, attempts to load and
+    # render the file as a template.
+    def render_file(name, context = {})
+      self.class.render_file(name, context)
+    end
+
+    def self.read_template(name)
+      db_template = ::MustacheRenderTemplate.find_with_full_path(name)
+      db_template.try :content
+    end
+
+    # Given a name, attempts to read a file and return the contents as a
+    # string. The file is not rendered, so it might contain
+    # {{mustaches}}.
+    #
+    # Call `render` if you need to process it.
+    def self.partial(name)
+      self.read_template(name)
+
+      # File.read("#{template_path}/#{name}.#{template_extension}")
+    end
+
+    # Override this in your subclass if you want to do fun things like
+    # reading templates from a database. It will be rendered by the
+    # context, so all you need to do is return a string.
+    def partial(name)
+      self.class.partial(name)
+    end
+
+    # Override this to provide custom escaping.
+    #
+    # class PersonView < Mustache
+    #   def escapeHTML(str)
+    #     my_html_escape_method(str)
+    #   end
+    # end
+    #
+    # Returns a String
+    def escapeHTML(str)
+      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?
+      @template.is_a? Template
+    end
+
+    # Has this instance or its class already compiled a template?
+    def compiled?
+      (@template && @template.is_a?(Template)) || self.class.compiled?
+    end
+
+    # template_partial => TemplatePartial
+    # template/partial => Template::Partial
+    def self.classify(underscored)
+      underscored.split('/').map do |namespace|
+        namespace.split(/[-_]/).map do |part|
+          part[0] = part[0].chr.upcase; part
+        end.join
+      end.join('::')
+    end
+
+    #   TemplatePartial => template_partial
+    # Template::Partial => template/partial
+    # Takes a string but defaults to using the current class' name.
+    def self.underscore(classified = name)
+      classified = name if classified.to_s.empty?
+      classified = superclass.name if classified.to_s.empty?
+
+      string = classified.dup.split("#{view_namespace}::").last
+
+      string.split('::').map do |part|
+        part[0] = part[0].chr.downcase
+        part.gsub(/[A-Z]/) { |s| "_#{s.downcase}"}
+      end.join('/')
+    end
+
+    # Turns a string into a Mustache::Template. If passed a Template,
+    # returns it.
+    def self.templateify(obj)
+      if obj.is_a?(Template)
+        obj
+      else
+        Template.new(obj.to_s)
+      end
+    end
+
+    def templateify(obj)
+      self.class.templateify(obj)
+    end
+
+    # Return the value of the configuration setting on the superclass, or return
+    # the default.
+    #
+    # attr_name - Symbol name of the attribute.  It should match the instance variable.
+    # default   - Default value to use if the superclass does not respond.
+    #
+    # Returns the inherited or default configuration setting.
+    def self.inheritable_config_for(attr_name, default)
+      superclass.respond_to?(attr_name) ? superclass.send(attr_name) : default
+    end
+  end
+end

data/lib/mustache_render/mustache/context.rb

@@ -0,0 +1,144 @@
+module MustacheRender
+  class Mustache
+    # A ContextMiss is raised whenever a tag's target can not be found
+    # in the current context if `Mustache#raise_on_context_miss?` is
+    # set to true.
+    #
+    # For example, if your View class does not respond to `music` but
+    # your template contains a `{{music}}` tag this exception will be raised.
+    #
+    # By default it is not raised. See Mustache.raise_on_context_miss.
+    class ContextMiss < RuntimeError;  end
+
+    # A Context represents the context which a Mustache template is
+    # executed within. All Mustache tags reference keys in the Context.
+    class Context
+      # Expect to be passed an instance of `Mustache`.
+      def initialize(mustache)
+        @stack = [mustache]
+      end
+
+      # A {{>partial}} tag translates into a call to the context's
+      # `partial` method, which would be this sucker right here.
+      #
+      # If the Mustache view handling the rendering (e.g. the view
+      # representing your profile page or some other template) responds
+      # to `partial`, we call it and render the result.
+      def partial(name, indentation = '')
+        # Look for the first Mustache in the stack.
+        mustache = mustache_in_stack
+
+        # Indent the partial template by the given indentation.
+        part = mustache.partial(name).to_s.gsub(/^/, indentation)
+
+        # Call the Mustache's `partial` method and render the result.
+        result = mustache.render(part, self)
+      end
+
+      # Find the first Mustache in the stack. If we're being rendered
+      # inside a Mustache object as a context, we'll use that one.
+      def mustache_in_stack
+        @stack.detect { |frame| frame.is_a?(Mustache) }
+      end
+
+      # Allows customization of how Mustache escapes things.
+      #
+      # Returns a String.
+      def escapeHTML(str)
+        mustache_in_stack.escapeHTML(str)
+      end
+
+      # Adds a new object to the context's internal stack.
+      #
+      # Returns the Context.
+      def push(new)
+        @stack.unshift(new)
+        self
+      end
+      alias_method :update, :push
+
+      # Removes the most recently added object from the context's
+      # internal stack.
+      #
+      # Returns the Context.
+      def pop
+        @stack.shift
+        self
+      end
+
+      # Can be used to add a value to the context in a hash-like way.
+      #
+      # context[:name] = "Chris"
+      def []=(name, value)
+        push(name => value)
+      end
+
+      # Alias for `fetch`.
+      def [](name)
+        fetch(name, nil)
+      end
+
+      # Do we know about a particular key? In other words, will calling
+      # `context[key]` give us a result that was set. Basically.
+      def has_key?(key)
+        !!fetch(key)
+      rescue ContextMiss
+        false
+      end
+
+      # Similar to Hash#fetch, finds a value by `name` in the context's
+      # stack. You may specify the default return value by passing a
+      # second parameter.
+      #
+      # If no second parameter is passed (or raise_on_context_miss is
+      # set to true), will raise a ContextMiss exception on miss.
+      def fetch(name, default = :__raise)
+        @stack.each do |frame|
+          # Prevent infinite recursion.
+          next if frame == self
+
+          value = find(frame, name, :__missing)
+          if value != :__missing
+            return value
+          end
+        end
+
+        if default == :__raise || mustache_in_stack.raise_on_context_miss?
+          raise ContextMiss.new("Can't find #{name} in #{@stack.inspect}")
+        else
+          default
+        end
+      end
+
+      # Finds a key in an object, using whatever method is most
+      # appropriate. If the object is a hash, does a simple hash lookup.
+      # If it's an object that responds to the key as a method call,
+      # invokes that method. You get the idea.
+      #
+      #     obj - The object to perform the lookup on.
+      #     key - The key whose value you want.
+      # default - An optional default value, to return if the
+      #           key is not found.
+      #
+      # Returns the value of key in obj if it is found and default otherwise.
+      def find(obj, key, default = nil)
+        hash = obj.respond_to?(:has_key?)
+
+        if hash && obj.has_key?(key)
+          obj[key]
+        elsif hash && obj.has_key?(key.to_s)
+          obj[key.to_s]
+        elsif !hash && obj.respond_to?(key)
+          meth = obj.method(key) rescue proc { obj.send(key) }
+          if meth.arity == 1
+            meth.to_proc
+          else
+            meth[]
+          end
+        else
+          default
+        end
+      end
+    end
+  end
+end