mustache-sinatra 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff55e20ce7e3821875601fb0b2c8cfb81103e7d8
-  data.tar.gz: 8b7b161f5110d393ca53c1f8eb86b4de32372144
+  metadata.gz: 0a10facd8c6cb6543e7a19ba8c8b5881b5af1907
+  data.tar.gz: c53a8137cd6dc6512b40aac096cb87e94bece9eb
 SHA512:
-  metadata.gz: 75f801d22be8f58faaeff17d749ccd4921bfe3a0d5cffc2997eebe6f4262f9f100dee5d156a73fb72b39064f558a0a0cf030549b82da4cab240f6d530efc5c88
-  data.tar.gz: fb6e7613d8042bcdc139b20ef03ede699e72c3829042b29ed34c3a7a3c35184c9b6a707502bfeb3a4d07e93d3ab182ed677e931ec7a7173cc4168c8f952664cb
+  metadata.gz: 4fff4466c64df75740c7ffd5c45e9fc6cf76386f5f0724801292d8426e75be987bf0a931ec3b5e36b408c5acc6b1bc717a523a56bd50a4be679f8c2604535b00
+  data.tar.gz: 05be9a0162b4f93588bdd79a52220decc4c057ce36aad1819f1260800dfdce3a367506c2455a234f8c3ff7351714c2a134aadfd1a4f390b799ad745b9489fa69

data/lib/mustache/sinatra.rb

@@ -1,149 +1,9 @@
-require "mustache/sinatra/version"
+require 'mustache/sinatra/version'
+require 'mustache'
+require 'mustache/sinatra/helpers'
 
 class Mustache
   module Sinatra
-    module Helpers
-      # Call this in your Sinatra routes.
-      def mustache(template, options={}, locals={})
-        # Locals can be passed as options under the :locals key.
-        locals.update(options.delete(:locals) || {})
-
-        # Grab any user-defined settings.
-        if settings.respond_to?(:mustache)
-          options = settings.send(:mustache).merge(options)
-        end
-
-        # If they aren't explicitly disabling layouts, try to find
-        # one.
-        if options[:layout] != false
-          # Let the user pass in a layout name.
-          layout_name = options[:layout]
-
-          # If all they said was `true` (or nothing), default to :layout.
-          layout_name = :layout if layout_name == true || !layout_name
-
-          # If they passed a layout name use that.
-          layout = mustache_class(layout_name, options)
-
-          # If it's just an anonymous subclass then don't bother, otherwise
-          # give us a layout instance.
-          if layout.name && layout.name.empty?
-            layout = nil
-          else
-            layout = layout.new
-          end
-        end
-
-        # If instead of a symbol they gave us a Mustache class,
-        # use that for rendering.
-        klass = template if template.is_a?(Class) && template < Mustache
-
-        # Find and cache the view class we want if we don't have
-        # one yet. This ensures the compiled template is cached,
-        # too - no looking up and compiling templates on each page
-        # load.
-        if klass.nil?
-          klass = mustache_class(template, options)
-        end
-
-        # Does the view subclass the layout? If so we'll use the
-        # view to render the layout so you can override layout
-        # methods in your view - tricky.
-        view_subclasses_layout = klass < layout.class if layout
-
-        # Create a new instance for playing with.
-        instance = klass.new
-
-        # Copy instance variables set in Sinatra to the view
-        instance_variables.each do |name|
-          instance.instance_variable_set(name, instance_variable_get(name))
-        end
-
-        # Render with locals.
-        rendered = instance.render(instance.template, locals)
-
-        # Now render the layout with the view we just rendered, if we
-        # need to.
-        if layout && view_subclasses_layout
-          rendered = instance.render(layout.template, :yield => rendered)
-        elsif layout
-          rendered = layout.render(layout.template, :yield => rendered)
-        end
-
-        # That's it.
-        rendered
-      end
-
-      # Returns a View class for a given template name.
-      def mustache_class(template, options = {})
-        @template_cache.fetch(:mustache, template) do
-          compile_mustache(template, options)
-        end
-      end
-
-      # Given a view name and settings, finds and prepares an
-      # appropriate view class for this view.
-      def compile_mustache(view, options = {})
-        options[:templates] ||= settings.views if settings.respond_to?(:views)
-        options[:namespace] ||= self.class
-
-        unless options[:namespace].to_s.include? 'Views'
-          options[:namespace] = options[:namespace].const_get(:Views) rescue Object
-        end
-
-        factory = Class.new(Mustache) do
-          self.view_namespace = options[:namespace]
-          self.view_path      = options[:views]
-        end
-
-        # If we were handed :"positions.atom" or some such as the
-        # template name, we need to remember the extension.
-        if view.to_s.include?('.')
-          view, ext = view.to_s.split('.')
-        end
-
-        # Try to find the view class for a given view, e.g.
-        # :view => Hurl::Views::Index.
-        klass = factory.view_class(view)
-        klass.view_namespace = options[:namespace]
-        klass.view_path      = options[:views]
-
-        # If there is no view class, issue a warning and use the one
-        # we just generated to cache the compiled template.
-        if klass == Mustache
-          warn "No view class found for #{view} in #{factory.view_path}"
-          klass = factory
-
-          # If this is a generic view class make sure we set the
-          # template name as it was given. That is, an anonymous
-          # subclass of Mustache won't know how to find the
-          # "index.mustache" template unless we tell it to.
-          klass.template_name = view.to_s
-        elsif ext
-          # We got an ext (like "atom"), so look for an "Atom" class
-          # under the current View's namespace.
-          #
-          # So if our template was "positions.atom", try to find
-          # Positions::Atom.
-          if klass.const_defined?(ext_class = ext.capitalize)
-            # Found Positions::Atom - set it
-            klass = klass.const_get(ext_class)
-          else
-            # Didn't find Positions::Atom - create it by creating an
-            # anonymous subclass of Positions and setting that to
-            # Positions::Atom.
-            new_class = Class.new(klass)
-            new_class.template_name = "#{view}.#{ext}"
-            klass.const_set(ext_class, new_class)
-            klass = new_class
-          end
-        end
-
-        # Set the template path and return our class.
-        klass.template_path = options[:templates] if options[:templates]
-        klass
-      end
-    end
 
     # Called when you `register Mustache::Sinatra` in your Sinatra app.
     def self.registered(app)

data/lib/mustache/sinatra/helpers.rb

@@ -0,0 +1,149 @@
+class Mustache
+  module Sinatra
+
+    module Helpers
+
+      # Call this in your Sinatra routes.
+      def mustache(template, options={}, locals={})
+        # Locals can be passed as options under the :locals key.
+        locals.update(options.delete(:locals) || {})
+
+        # Grab any user-defined settings.
+        if settings.respond_to?(:mustache)
+          options = settings.send(:mustache).merge(options)
+        end
+
+        # If they aren't explicitly disabling layouts, try to find
+        # one.
+        if options[:layout] != false
+          # Let the user pass in a layout name.
+          layout_name = options[:layout]
+
+          # If all they said was `true` (or nothing), default to :layout.
+          layout_name = :layout if layout_name == true || !layout_name
+
+          # If they passed a layout name use that.
+          layout = mustache_class(layout_name, options)
+
+          # If it's just an anonymous subclass then don't bother, otherwise
+          # give us a layout instance.
+          if layout.name && layout.name.empty?
+            layout = nil
+          else
+            layout = layout.new
+          end
+        end
+
+        # If instead of a symbol they gave us a Mustache class,
+        # use that for rendering.
+        klass = template if template.is_a?(Class) && template < Mustache
+
+        # Find and cache the view class we want if we don't have
+        # one yet. This ensures the compiled template is cached,
+        # too - no looking up and compiling templates on each page
+        # load.
+        if klass.nil?
+          klass = mustache_class(template, options)
+        end
+
+        # Does the view subclass the layout? If so we'll use the
+        # view to render the layout so you can override layout
+        # methods in your view - tricky.
+        view_subclasses_layout = klass < layout.class if layout
+
+        # Create a new instance for playing with.
+        instance = klass.new
+
+        # Copy instance variables set in Sinatra to the view
+        instance_variables.each do |name|
+          instance.instance_variable_set(name, instance_variable_get(name))
+        end
+
+        # Render with locals.
+        rendered = instance.render(instance.template, locals)
+
+        # Now render the layout with the view we just rendered, if we
+        # need to.
+        if layout && view_subclasses_layout
+          rendered = instance.render(layout.template, :yield => rendered)
+        elsif layout
+          rendered = layout.render(layout.template, :yield => rendered)
+        end
+
+        # That's it.
+        rendered
+      end
+
+      # Returns a View class for a given template name.
+      def mustache_class(template, options = {})
+        @template_cache.fetch(:mustache, template) do
+          compile_mustache(template, options)
+        end
+      end
+
+      # Given a view name and settings, finds and prepares an
+      # appropriate view class for this view.
+      def compile_mustache(view, options = {})
+        options[:templates] ||= settings.views if settings.respond_to?(:views)
+        options[:namespace] ||= self.class
+
+        unless options[:namespace].to_s.include? 'Views'
+          options[:namespace] = options[:namespace].const_get(:Views) rescue Object
+        end
+
+        factory = Class.new(Mustache) do
+          self.view_namespace = options[:namespace]
+          self.view_path      = options[:views]
+        end
+
+        # If we were handed :"positions.atom" or some such as the
+        # template name, we need to remember the extension.
+        if view.to_s.include?('.')
+          view, ext = view.to_s.split('.')
+        end
+
+        # Try to find the view class for a given view, e.g.
+        # :view => Hurl::Views::Index.
+        klass = factory.view_class(view)
+        klass.view_namespace = options[:namespace]
+        klass.view_path      = options[:views]
+
+        # If there is no view class, issue a warning and use the one
+        # we just generated to cache the compiled template.
+        if klass == Mustache
+          warn "No view class found for #{view} in #{factory.view_path}"
+          klass = factory
+
+          # If this is a generic view class make sure we set the
+          # template name as it was given. That is, an anonymous
+          # subclass of Mustache won't know how to find the
+          # "index.mustache" template unless we tell it to.
+          klass.template_name = view.to_s
+        elsif ext
+          # We got an ext (like "atom"), so look for an "Atom" class
+          # under the current View's namespace.
+          #
+          # So if our template was "positions.atom", try to find
+          # Positions::Atom.
+          if klass.const_defined?(ext_class = ext.capitalize)
+            # Found Positions::Atom - set it
+            klass = klass.const_get(ext_class)
+          else
+            # Didn't find Positions::Atom - create it by creating an
+            # anonymous subclass of Positions and setting that to
+            # Positions::Atom.
+            new_class = Class.new(klass)
+            new_class.template_name = "#{view}.#{ext}"
+            klass.const_set(ext_class, new_class)
+            klass = new_class
+          end
+        end
+
+        # Set the template path and return our class.
+        klass.template_path = options[:templates] if options[:templates]
+        klass
+      end
+    end
+
+  end
+end

data/lib/mustache/sinatra/version.rb

@@ -1,5 +1,5 @@
 class Mustache
   module Sinatra
-    VERSION = "1.0.0"
+    VERSION = "1.0.1"
   end
 end

data/mustache-sinatra.gemspec

@@ -20,4 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "mustache", "<= 0.99.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mustache-sinatra
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Ricardo Mendes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2015-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.99.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.99.8
 description: Mustache support for Sinatra applications
 email:
 - rokusu@gmail.com
@@ -52,6 +66,7 @@ files:
 - README.md
 - Rakefile
 - lib/mustache/sinatra.rb
+- lib/mustache/sinatra/helpers.rb
 - lib/mustache/sinatra/version.rb
 - mustache-sinatra.gemspec
 homepage: https://github.com/mustache/mustache-sinatra