cutaneous 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 012024660b2cd0de6db4295f59f2dd7f627280a4
-  data.tar.gz: ae08e8b3fcdc18c3060104beb02acb4f7e77b3f6
+  metadata.gz: d90ff3764cf47bc3c932b85e5d9833adbb86edcb
+  data.tar.gz: a996afd411cb3e846cd1237c13b49a9ef4e99e17
 SHA512:
-  metadata.gz: 034dc2af99470678f14e0e687c09d946cd52545fc1b515a59c53b379b90d5a01920572db4d28c1bd1d3ae169840b8a9d0aa04ac75e6b94a119c27e6a749ebeaf
-  data.tar.gz: 0e083ff19ecab0be7f48e40a23a2166c188ab41521c0b0c784584369b2a098457f69b34e32bc69fd9733660952d79c5236766b3818823449188a978928df1099
+  metadata.gz: a01dd50c0274e1fd17d7913d48b0e52913842fbc8ed479442356ff17e83aec31112ae93041b68e47c3c6e4d268f7f33d69c5d4c7975ec6305ee2a5f54abec298
+  data.tar.gz: 8e94956de888f9b8a12a5494245dfc3e242ef33e5ebdf0fd4c61dd443c59a2eb90163fd2890a3fe4e7e188d6a2bda97fd5e664ed7cc4a4d7da0263dbcb660868

data/cutaneous.gemspec

@@ -8,14 +8,14 @@ Gem::Specification.new do |s|
   s.specification_version = 2 if s.respond_to? :specification_version=
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.rubygems_version = '1.3.5'
-  s.required_ruby_version = ">= 1.9.2"
+  s.required_ruby_version = ">= 1.9.3"
 
   ## Leave these as is they will be modified for you by the rake gemspec task.
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'cutaneous'
-  s.version           = '0.1.7'
-  s.date              = '2013-11-14'
+  s.version           = '0.2.0'
+  s.date              = '2014-01-29'
   s.rubyforge_project = 'cutaneous'
 
   ## Make sure your summary is short. The description may be as long

data/lib/cutaneous/engine.rb

@@ -18,8 +18,11 @@ module Cutaneous
 
     alias_method :render, :render_file
 
+    # need an explicit #render_string method so it's possible to distinguish
+    # between a String which is a path to a template & a String which is a
+    # template itself.
     def render_string(template_string, context, format = default_format)
-      string_loader(format).render(template_string, context)
+      render_file(proc_template(template_string), context, format)
     end
 
     # Create and cache a file loader on a per-format basis
@@ -29,14 +32,24 @@ module Cutaneous
       end
     end
 
-    # Not worth caching string templates as they are most likely to be one-off
-    # instances & not repeated in the lifetime of the engine.
-    def string_loader(format)
-      StringLoader.new(file_loader(format))
+    def template_exists?(relative_path, format)
+      @roots.each do |root|
+        return true if file_loader(format).exists?(root, relative_path)
+      end
+      false
+    end
+
+    def template_location(relative_path, format)
+      @roots.each do |root|
+        if (path = file_loader(format).location(root, relative_path))
+          return path
+        end
+      end
+      nil
     end
 
-    def template_exists?(root, relative_path, format)
-      file_loader(format).exists?(root, relative_path)
+    def dynamic_template?(template_string)
+      @syntax.is_dynamic?(template_string)
     end
 
     def convert(template, to_syntax, format = default_format)
@@ -44,7 +57,11 @@ module Cutaneous
     end
 
     def convert_string(template_string, to_syntax, format = default_format)
-      string_loader(format).convert(template_string, to_syntax)
+      convert(proc_template(template_string), to_syntax, format)
+    end
+
+    def proc_template(template_string)
+      Proc.new { template_string }
     end
 
     protected

data/lib/cutaneous/lexer.rb

@@ -24,10 +24,6 @@ module Cutaneous
       template
     end
 
-    # def script
-    #   @script ||= compile
-    # end
-
     protected
 
     BRACES ||= /\{|\}/
@@ -35,7 +31,7 @@ module Cutaneous
 
     def parse
       tokens    = []
-      scanner   = StringScanner.new(@template.to_s)
+      scanner   = StringScanner.new(template_string)
       tag_start = syntax.tag_start_pattern
       tags      = syntax.tags
       token_map = syntax.token_map
@@ -84,5 +80,17 @@ module Cutaneous
       expression.gsub!(ESCAPE_STRING, '\\\\\&')
       [:text, expression]
     end
+
+    def template_string
+      return read_file_template if @template.respond_to?(:read)
+      return @template.call if @template.respond_to?(:call)
+      @template.to_s
+    end
+
+    def read_file_template
+      source = @template.read
+      @template.close if @template.respond_to?(:close)
+      source
+    end
   end
 end

data/lib/cutaneous/loader.rb

@@ -19,26 +19,22 @@ module Cutaneous
     end
 
     def template(template)
-      return proc_template(template) if template.is_a?(Proc)
-      template_path = path(template)
-      raise UnknownTemplateError.new(@roots, filename(template)) if template_path.nil?
-
-      @template_class.new(file_lexer(template_path)).tap do |template|
-        template.path   = template_path
-        template.loader = self
-      end
-    end
-
-    def proc_template(lmda)
-      StringLoader.new(self).template(lmda.call)
+      template = open_template(template) if String === template
+      instance = @template_class.new(lexer(template))
+      instance.path   = template.path if template.respond_to?(:path)
+      instance.loader = self
+      instance
     end
 
-    def file_lexer(template_path)
-      lexer(SourceFile.new(template_path))
+    def open_template(template)
+      template_path = path(template)
+      raise UnknownTemplateError.new(@roots, filename(template)) if template_path.nil?
+      # TODO: Make the encoding configurable?
+      TemplateReader.new(template_path, Encoding::UTF_8)
     end
 
-    def lexer(template_string)
-      Lexer.new(template_string, syntax)
+    def lexer(template)
+      Lexer.new(template, syntax)
     end
 
     def path(template_name)
@@ -52,40 +48,29 @@ module Cutaneous
     end
 
     def exists?(template_root, template_name)
-      File.exists?(File.join(template_root, filename(template_name)))
-    end
-  end
-
-  # Converts a template string into a Template instance.
-  #
-  # Because a string template can only come from the engine instance
-  # we need a FileLoader to delegate all future template loading to.
-  class StringLoader < FileLoader
-    def initialize(file_loader)
-      @file_loader = file_loader
+      path = ::File.join(template_root, filename(template_name))
+      ::File.exists?(path)
     end
 
-    def syntax
-      @file_loader.syntax
+    def location(template_root, template_name)
+      return ::File.join(template_root, template_name) if exists?(template_root, template_name)
+      nil
     end
 
-    def template(template_string)
-      Template.new(lexer(template_string)).tap do |template|
-        template.loader = @file_loader
+    # An IO-like interface that provides #read and #path methods
+    class TemplateReader
+      def initialize(path, encoding)
+        @path     = path
+        @encoding = encoding
       end
-    end
-  end
 
-  # Converts a filepath to a template string as and when necessary
-  class SourceFile
-    attr_reader :path
-
-    def initialize(filepath)
-      @path = filepath
-    end
+      def read(*args)
+        ::File.open(@path, 'r', external_encoding: @encoding) { |f| f.read }
+      end
 
-    def to_s
-      File.read(@path)
+      def path
+        @path
+      end
     end
   end
 
@@ -119,13 +104,13 @@ module Cutaneous
   class CachedTemplate < Template
 
     def script
-      if cached?
-        script = File.read(script_path)
+      script = nil
+      path = script_path
+      if path && cached?
+        script = File.read(path)
       else
         script = super
-        File.open(script_path, "w") do |f|
-          f.write(script)
-        end
+        write_cached_script(script, path) unless path.nil?
       end
       script
     end
@@ -135,7 +120,7 @@ module Cutaneous
     end
 
     def template_path
-      lexer.template.path
+      path
     end
 
     def script_path
@@ -144,8 +129,15 @@ module Cutaneous
 
     def generate_script_path
       path = template_path
+      return nil if path.nil?
       ext  = File.extname path
       path.gsub(/#{ext}$/, ".rb")
     end
+
+    def write_cached_script(script, path)
+      File.open(script_path, "w") do |f|
+        f.write(script)
+      end
+    end
   end
 end

data/lib/cutaneous.rb

@@ -7,7 +7,7 @@ require 'cutaneous/lexer'
 require 'cutaneous/compiler'
 
 module Cutaneous
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
 
   class CompilationError < Exception; end
 

data/test/helper.rb

@@ -5,6 +5,8 @@ require 'minitest/autorun'
 
 require 'cutaneous'
 
+require 'stringio'
+
 class TestContext < Cutaneous::Context
 end
 

data/test/test_cache.rb

@@ -101,4 +101,9 @@ describe Cutaneous do
     script_path   = template_path("c", "html", "rb")
     refute ::File.exists?(script_path), "Template cache should not have created '#{script_path}'"
   end
+
+  it "doesn't attempt to write a cached script for Proc templates" do
+    context = ContextHash(right: "right")
+    result1 = engine.render(Proc.new { "This is ${right}"}, context)
+  end
 end

data/test/test_core.rb

@@ -35,6 +35,14 @@ describe "Parsers" do
       result.must_equal expected
     end
 
+    it "will render an object that responds to #read" do
+      template = StringIO.new("This is ${ right }")
+      context = ContextHash(right: "right")
+      result = subject.render(template, context)
+      result.must_equal "This is right"
+    end
+
+
     it "can convert a template to another syntax" do
       result = subject.convert('statements1', Cutaneous::SecondPassSyntax)
       result.must_equal read_template('statements2.html.cut')
@@ -194,6 +202,17 @@ describe Cutaneous do
     result.must_equal "right"
   end
 
+  it "calls #close on any IO instances passed to it" do
+    context = ContextHash(right: "correct")
+    template = MiniTest::Mock.new
+    template.expect(:close, nil)
+    template.expect(:read, "${ right }")
+    template.expect(:path, "/path/to/template.html.cut")
+    result = engine.render(template, context, "rss")
+    template.verify
+    result.must_equal "correct"
+  end
+
   it "Allows for configuration of the engine's default format" do
     engine.default_format = "rss"
     context = ContextHash(right: "right")
@@ -208,10 +227,20 @@ describe Cutaneous do
   end
 
   it "Tests for the existence of a template file for a certain format" do
-    assert engine.template_exists?(template_root, "expressions1", "html")
-    assert engine.template_exists?(template_root, "other/error", "html")
-    assert engine.template_exists?(template_root, "include", "rss")
-    refute engine.template_exists?(template_root, "missing", "rss")
+    assert engine.template_exists?("expressions1", "html")
+    assert engine.template_exists?("other/error", "html")
+    assert engine.template_exists?("include", "rss")
+    refute engine.template_exists?("missing", "rss")
+  end
+
+  it "returns the full path to a template if found" do
+    assert_equal "#{template_root}/expressions1", engine.template_location("expressions1", "html")
+    assert_equal nil, engine.template_location("missing", "rss")
+  end
+
+  it "can determine if a template contains tags for its syntax" do
+    assert engine.dynamic_template?("i am ${dynamic}")
+    refute engine.dynamic_template?("i am not dynamic")
   end
 
   it "Passes any instance variables & locals between contexts" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cutaneous
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Garry Hill
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-14 00:00:00.000000000 Z
+date: 2014-01-29 00:00:00.000000000 Z
 dependencies: []
 description: Cutaneous is the Ruby templating language designed for use with Spontaneous
   CMS. It has a simple syntax but powerful features such as Djano style template inheritance
@@ -78,7 +78,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
@@ -86,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: cutaneous
-rubygems_version: 2.0.3
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 2
 summary: A Ruby templating language with Django style template inheritance