semplice 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04fd3c1918454d7570629679f3147f0d760c025d
+  data.tar.gz: 879ea0e7f14022d7d93b5af7d592dd62b883887d
+SHA512:
+  metadata.gz: fa9abc4e188c3a12737840e4e383043a535fefa3758a67bdefaafbf206a9b12793c0ffee2a64f256f50de7e9647cdb6a4eb740fbbb67105a440acb9e747dfa59
+  data.tar.gz: 101b04a47ca1025bf01c2b9a24f1973ea210c874d405d5abd9cf64a55835327d4f9d30f855407a9d660d9d776792a904d8d655b43f1857bfe3831ceb819e60a8

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015 Matías Aguirre
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,182 @@
+# Semplice
+
+``Semplice`` is a [mote](https://github.com/soveran/mote) inspired
+template engine with Django-like syntax and inheritance.
+
+
+## Usage
+
+``Semplice`` use is quite strightforward, put your content on a
+template (or not) and call render.
+
+```ruby
+Semplice.render('path/to/template', {
+  foo: 'bar',
+  baz: 'quox'
+})
+```
+
+Or you can render directly from text:
+
+```ruby
+Semplice.render_text('hello {{ world }}', {
+  world: 'earthlings'
+})
+```
+
+## Templates
+
+### Values
+
+Values passed through context can be ``rendered`` into the content by
+using ``{{ ... }}`` (automatically escapes HTML) or ``{! ... !}``
+(doesn't escape the content). For instance, consider ``val`` equals
+to ``<strong>world</strong>``:
+
+```
+Hello {{ val }} -> Hello &lt;strong&gt;world&lt;/strong&gt;
+Hello {! val !} -> Hello <strong>world</strong>
+```
+
+There's also the syntax ``{- ... -}`` that will supress the output,
+this is useful for small computations, usually assignments:
+
+```
+{- foo = "bar" -}
+Hello {{ foo }}
+```
+
+
+### Code blocks
+
+Ruby code can be injected using the ``{% ... %}...{% end %}`` syntax:
+
+
+Loops:
+
+```
+{% val.map do |v| %}
+  ...
+{% end %}
+```
+
+```
+{% while ... %}
+  ...
+{% end %}
+```
+
+Conditionals:
+
+```
+{% if val == "foo" %}
+  ...
+{% elsif val == "bar" %}
+  ...
+{% else %}
+  ...
+{% end %}
+```
+
+```
+{% case val %}
+  ...
+{% when "foo" %}
+  ...
+{% when "bar" %}
+  ...
+{% else %}
+  ...
+{% end %}
+```
+
+Any ruby construct is valid here.
+
+
+### Comments
+
+Comments can be added with ``{# ... #}``, they will be ignored from
+the output.
+
+
+### Inclusion
+
+Include other templates using the ``{% include ... %}`` tag:
+
+```
+{% include "path/to/other-template" %}
+```
+
+
+### Content blocks
+
+A template can define content blocks that can be overriden later when
+using inheritance. For example:
+
+```
+This content goes before the block.
+{% block content %}
+  This is the default content of this block.
+{% end %}
+This content goes after the block.
+```
+
+
+### Inheritance
+
+Templates can be ``extended`` using the ``{% extends ... %}`` syntax,
+content blocks can be overriden to provide new content. Take for
+instance this base template:
+
+```
+{# this is foo.html #}
+<h1>{% block title %}Foo title{% end %}</h1>
+```
+
+Then we can extend it:
+
+```
+{# this is bar.html #}
+{% extends "foo.html" %}
+{% block title %}Bar title{% end %}
+```
+
+Rendering ``foo.html`` will output:
+
+```
+<h1>Foo title</h1>
+```
+
+But rendering ``bar.html``:
+
+```
+<h1>Bar title</h1>
+```
+
+## Global context
+
+Any method defined in ``Semplice::GlobalContext`` will be available in
+the template context at rendering time:
+
+```ruby
+module Semplice::GlobalContext
+  def twice(val)
+    val * 2
+  end
+end
+```
+
+Then:
+
+```
+10 * 2 = {{ twice(10) }}
+```
+
+## Helpers
+
+You can include the ``Helpers`` module to simplify access to
+``render`` and ``render_text`` methods.
+
+```ruby
+include Semplice::Helpers
+```

data/lib/semplice.rb

@@ -0,0 +1,152 @@
+require 'cgi'
+
+module Semplice
+  VERSION = '0.0.1'
+  TPL_PATTERN = /(\{[%\{\-#!])\s*(.*?)\s*[%\}\-#!]\}/
+
+  @locations = []
+
+  module GlobalContext
+    # Define your methods in this module, they will be included
+    # automatically in the template context
+  end
+
+  class Template
+    include GlobalContext
+
+    def self.render(__params)
+      new.__render(__params)
+    end
+
+    def __render(__params)
+      ''
+    end
+
+    def include(path, params)
+      Semplice.render(path, params).chomp
+    end
+
+    def h(val)
+      val = CGI.escape_html(val) if val.is_a?(String)
+      val
+    end
+  end
+
+  module TemplateParser
+    @@template_dirs = []
+
+    def self.parse(content, names=[])
+      tpl = parse_content(content.split(TPL_PATTERN))
+      context_vars = names.map{|name| "%s = __params[%p]" % [name, name]}.join(';')
+      render_code = tpl[:methods].map{|name, code|
+        "def __block_#{name}(__params);#{context_vars};__out = [];#{code};__out.join;end"
+      }
+
+      unless tpl[:base]
+        render_code << "def __render(__params)"
+        render_code <<   context_vars
+        render_code <<   "__out = [super(__params)]"
+        render_code <<   tpl[:code].join("\n")
+        render_code <<   "__out.join.chomp"
+        render_code << "end"
+      end
+
+      cls = Class.new(tpl[:base] ? template(tpl[:base], names) : Semplice::Template)
+      cls.class_eval(render_code.join("\n"))
+      cls
+    end
+
+    def self.template(path, names)
+      cache[path] ||= parse(content_for(path), names)
+    end
+
+    private
+
+    def self.content_for(path)
+      unless File.exists?(path)
+        path = @@template_dirs.map{|l|
+          File.join(l, path)
+        }.select{|p|
+          File.exists?(p)
+        }.first
+      end
+               
+      File.read(path)
+    end
+
+    def self.template_dirs(dirs = [])
+      @@template_dirs = dirs
+    end
+
+    def self.parse_content(tokens, content: nil, stopwords: [])
+      content ||= {code: [], methods: {}, base: nil}
+
+      while token = tokens.shift
+        case token
+        when '{%' then
+          sub_token = tokens.shift
+          case sub_token
+          when /^\bblock\b/
+            block_name = /^block (?<name>.*)$/.match(sub_token)[:name]
+            block_content = parse_content(tokens, stopwords: ['end'])
+            content[:methods].merge!(block_content[:methods])
+            content[:methods][block_name.to_sym] = block_content[:code].join("\n")
+            content[:code] << "__out << __block_#{block_name}(__params)"
+          when /\bextends\b/
+            content[:base] = /^extends\s+["'](?<tpl>.*)["']$/.match(sub_token)[:tpl]
+          when /\binclude\b/
+            path = /^include\s+["'](?<tpl>.*)["']$/.match(sub_token)[:tpl]
+            content[:code] << "__out << include(\"#{path}\", __params)"
+          when /\bend\b/
+            return content if stopwords.include?('end')
+            content[:code] << 'end'
+          else
+            content[:code] << sub_token
+          end
+        when '{{' then # output value
+          content[:code] << "__out << (h(#{tokens.shift})).to_s"
+        when '{!' then # output value
+          content[:code] << "__out << (#{tokens.shift}).to_s"
+        when '{-' then # suppress output
+          content[:code] << "(#{tokens.shift}).to_s"
+        when '{#' then # igore comments
+          tokens.shift
+        else
+          content[:code] << "__out << #{token.dump}" if token != ''
+        end
+      end
+
+      content
+    end
+
+    def self.cache
+      Thread.current[:simplex_cache] ||= {}
+    end
+  end
+
+  module Helpers
+    def self.render(path, params={})
+      TemplateParser
+        .template(path, params.keys)
+        .render(params)
+    end
+
+    def self.render_text(content, params={})
+      TemplateParser
+        .parse(content, params.keys)
+        .render(params)
+    end
+  end
+
+  def self.render(*args)
+    Helpers.render(*args)
+  end
+
+  def self.render_text(*args)
+    Helpers.render_text(*args)
+  end
+
+  def self.template_dirs(dirs = [])
+    TemplateParser.template_dirs(dirs)
+  end
+end

data/semplice.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+require './lib/semplice'
+
+
+Gem::Specification.new do |s|
+  s.name = 'semplice'
+  s.version = Semplice::VERSION
+  s.summary = 'Simple Template Engine.'
+  s.description = 'Semplice is a mote inspired template engine with Django-like syntax and inheritance.'
+  s.license = 'MIT'
+  s.authors = ['Matías Aguirre']
+  s.email = ['matiasaguirre@gmail.com']
+  s.homepage = 'http://github.com/omab/semplice'
+  s.files = Dir[
+    'LICENSE',
+    'README.md',
+    'lib/**/*.rb',
+    '*.gemspec',
+    'test/**/*.rb'
+  ]
+  s.add_development_dependency 'minitest', '~> 5.7'
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: semplice
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matías Aguirre
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+description: Semplice is a mote inspired template engine with Django-like syntax and
+  inheritance.
+email:
+- matiasaguirre@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/semplice.rb
+- semplice.gemspec
+homepage: http://github.com/omab/semplice
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple Template Engine.
+test_files: []