skim 0.8.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+bin

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 John Firebaugh
+
+MIT License
+
+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,125 @@
+Skim
+====
+
+Take the fat out of your client-side templates with Skim. Skim is the [Slim](http://slim-lang.com/) templating engine
+with embedded CoffeeScript. It compiles to JavaScript templates (`.jst`), which can then be served by Rails or any other
+Sprockets-based asset pipeline.
+
+# Usage
+
+`gem install skim`, or add `skim` to your `Gemfile` in the `:assets` group:
+
+    group :assets do
+      gem 'skim'
+    end
+
+Create template files with the extension `.jst.skim`. For example, `test.jst.skim`:
+
+    p Hello #{@world}!
+
+In your JavaScript or CoffeeScript, render the result, passing a context object:
+
+    $("body").html(JST["test"]({world: "World"}));
+
+Order up a skinny latte and enjoy!
+
+# Caveats
+
+Skim is an early proof-of-concept. Some Slim features are still missing:
+
+* Skim does not currently support embedded engines. Being a client-side templating languages, it will only be able to
+  support embedded engines with a client-side implementation.
+* Skim does not currently support HTML pretty-printing (Slim's `:pretty` option). This is low priority, as
+  pretty-printing is even less important client-side than server-side.
+* Skim does not currently support backslash line continuations.
+
+# Language reference
+
+Skim supports the following Slim language features:
+
+* doctype declarations (`doctype`)
+* HTML Comments (`/!`) and conditional comments (`/[...]`)
+* static content (same line and nested)
+* dynamic content, escaped and not (`=` and `==`)
+* control logic (`-`)
+* string interpolation, escaped and not (`#{}` and `#{{}}`)
+* id and class attribute shortcuts (`#` and `.`)
+* attribute and attribute value wrappers
+* logic-less (sections) mode
+
+Several Coffee/JavaScript considerations are specific to Skim:
+
+* When interpolating the results of evaluating code, Skim will replace `null` and `undefined` results with an empty
+string.
+* You will typically want to use the fat arrow `=>` function definition to create callbacks, to preserve the binding of
+`this` analogously to how `self` behaves in a Ruby block.
+
+## The context object
+
+The context object you pass to the compiled template function becomes the value of this inside your template. You can
+use CoffeeScript's `@` sigil to easily access properties and call helper methods on the context object.
+
+## Escaping and unescaping
+
+Like Slim, Skim escapes dynamic output by default, and it supports the same `==` and `#{{}}` syntaxes for bypassing
+escaping. In addition, the special `safe` method on the context object tells Skim that the string can be output without
+being escaped. You can use this in conjunction with `escape` context method to selectively sanitize parts of the string.
+For example, given the template:
+
+    = @linkTo(@project)
+
+you could render it with the following context:
+
+    JST["my_template"]
+      project: { id: 4, name: "Crate & Barrel" }
+      linkTo: (project) ->
+        url  = "/projects/#{project.id}"
+        name = @escape project.name
+        @safe "<a href='#{url}'>#{name}</a>"
+
+to produce:
+
+    <a href='/projects/4'>Crate &amp; Barrel</a>
+
+## The Skim asset
+
+By default, all you need to do to start using Skim is add it to your Gemfile. Skim will embed a small amount of
+supporting code in each generated template asset. You can remove this duplication by manually including Skim's asset,
+and setting Skim's `:use_asset` option to true.
+
+In Rails, this can be done by adding the following to `application.js`:
+
+    //= require skim
+
+And the following in an initializer:
+
+    Skim::Engine.default_options[:use_asset] = true
+
+# License (MIT)
+
+Copyright (c) 2012 John Firebaugh
+
+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.
+
+# Special Thanks
+
+* Andrew Stone, for Slim
+* Magnus Holm, for Temple
+* Daniel Mendler, for maintenance of both

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new('test') do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/test_*.rb']
+  t.verbose = true
+end
+
+task :default => 'test'

data/lib/skim/compiler.rb

@@ -0,0 +1,36 @@
+module Skim
+  class Compiler < Slim::Compiler
+    def on_slim_control(code, content)
+      [:multi,
+        [:code, code],
+        [:indent, compile(content)]]
+    end
+
+    def on_slim_attr(name, escape, code)
+      value = case code
+      when 'true'
+        escape = false
+        [:static, name]
+      when 'false', 'null'
+        escape = false
+        [:multi]
+      else
+        tmp = unique_name
+        [:multi,
+         [:code, "#{tmp} = #{code}"],
+         [:case, tmp,
+          ['true', [:static, name]],
+          ['false, null', [:multi]],
+          [:else,
+           [:dynamic,
+            #if delimiter = options[:attr_delimiter][name]
+            #  "#{tmp}.respond_to?(:join) ? #{tmp}.flatten.compact.join(#{delimiter.inspect}) : #{tmp}"
+            #else
+              tmp
+            #end
+           ]]]]
+      end
+      [:html, :attr, name, [:escape, escape, value]]
+    end
+  end
+end

data/lib/skim/engine.rb

@@ -0,0 +1,24 @@
+module Skim
+  class Engine < Temple::Engine
+    set_default_options :pretty => false,
+                        :attr_wrapper => '"',
+                        :attr_delimiter => {'class' => ' '},
+                        :generator => Temple::CoffeeScript::Generator,
+                        :use_asset => false
+
+    use Slim::Parser, :file, :tabsize, :encoding, :default_tag
+    use Slim::EmbeddedEngine, :enable_engines, :disable_engines, :pretty
+    use Slim::Interpolation
+    use Skim::Sections, :sections
+    use Skim::Compiler, :disable_capture, :attr_delimiter
+    use Temple::CoffeeScript::AttributeMerger, :attr_delimiter
+    use Temple::HTML::AttributeSorter
+    use Temple::CoffeeScript::AttributeRemover
+    use Temple::HTML::Fast, :format, :attr_wrapper
+    use Temple::CoffeeScript::Filters::Escapable, :disable_escape
+    use Temple::CoffeeScript::Filters::ControlFlow
+    filter :MultiFlattener
+    use(:Optimizer) { Temple::Filters::StaticMerger.new }
+    use(:Generator) { options[:generator].new(options) }
+  end
+end

data/lib/skim/rails.rb

@@ -0,0 +1,4 @@
+module Skim
+  class RailsEngine < ::Rails::Engine
+  end
+end

data/lib/skim/sections.rb

@@ -0,0 +1,32 @@
+require "multi_json"
+
+module Skim
+  class Sections < Slim::Sections
+    def call(exp)
+      if options[:sections]
+        compile(exp)
+      else
+        exp
+      end
+    end
+
+    protected
+
+    def on_slim_inverted_section(name, content)
+      [:if, "not #{access(name)}", compile(content)]
+    end
+
+    def on_slim_section(name, content)
+      tmp1, tmp2 = unique_name, unique_name
+      [:if, "#{tmp1} = #{access(name)}",
+       [:block, "for #{tmp2} in #{tmp1}",
+        [:block, "Skim.withContext.call @, #{tmp2}, ->", compile(content)]]]
+    end
+
+    private
+
+    def access(name)
+      "Skim.access.call(@, #{MultiJson.encode(name.to_s)})"
+    end
+  end
+end

data/lib/skim/template.rb

@@ -0,0 +1,31 @@
+module Skim
+  Template = Temple::Templates::Tilt(Skim::Engine, :register_as => :skim)
+
+  class Template
+    def coffee_script_src
+      engine = self.class.build_engine({
+        :streaming => false, # Overwrite option: No streaming support in Tilt
+        :file => eval_file,
+        :indent => 2 }, options)
+      <<SRC
+return (context = {}) ->
+  #{self.class.skim_src unless engine.options[:use_asset]}
+  Skim.withContext.call {}, context, ->
+#{engine.call(data)}
+SRC
+    end
+
+    def prepare
+      @src = CoffeeScript.compile(coffee_script_src)
+    end
+
+    def evaluate(scope, locals, &block)
+      precompiled_template
+    end
+
+    def self.skim_src
+      @@skim_src ||=
+        File.read(File.expand_path("../../../vendor/assets/javascripts/skim.js.coffee", __FILE__))
+    end
+  end
+end

data/lib/skim/version.rb

@@ -0,0 +1,3 @@
+module Skim
+  VERSION = "0.8.0"
+end

data/lib/skim.rb

@@ -0,0 +1,15 @@
+require "temple"
+require "temple/coffee_script"
+
+require "slim"
+require "skim/compiler"
+require "skim/sections"
+require "skim/engine"
+require "skim/template"
+require "skim/version"
+
+require "skim/rails" if Object.const_defined?(:Rails)
+
+require "sprockets"
+Sprockets::Engines # force autoload
+Sprockets.register_engine ".skim", Skim::Template

data/lib/temple/coffee_script/filters/attribute_merger.rb

@@ -0,0 +1,33 @@
+module Temple
+  module CoffeeScript
+    class AttributeMerger < Filter
+      include Temple::HTML::Dispatcher
+
+      default_options[:attr_delimiter] = {'id' => '_', 'class' => ' '}
+
+      def on_html_attrs(*attrs)
+        names = []
+        result = {}
+
+        attrs.each do |html, attr, name, value|
+          raise(InvalidExpression, 'Attribute is not a html attr') if html != :html || attr != :attr
+          name = name.to_s
+          if delimiter = options[:attr_delimiter][name]
+            if current = result[name]
+              current << [:static, delimiter] << value
+            else
+              result[name] = [:multi, value]
+              names << name
+            end
+          else
+            raise "Multiple #{name} attributes specified" if result[name]
+            result[name] = value
+            names << name
+          end
+        end
+
+        [:html, :attrs, *names.map {|name| [:html, :attr, name, result[name]]}]
+      end
+    end
+  end
+end

data/lib/temple/coffee_script/filters/attribute_remover.rb

@@ -0,0 +1,28 @@
+module Temple
+  module CoffeeScript
+    class AttributeRemover < Filter
+      include Temple::HTML::Dispatcher
+
+      default_options[:remove_empty_attrs] = true
+
+      def on_html_attrs(*attrs)
+        [:multi, *(options[:remove_empty_attrs] ?
+                   attrs.map {|attr| compile(attr) } : attrs)]
+      end
+
+      def on_html_attr(name, value)
+        if empty_exp?(value)
+          value
+        elsif contains_static?(value)
+          [:html, :attr, name, value]
+        else
+          tmp = unique_name
+          [:multi,
+           [:capture, tmp, compile(value)],
+           [:if, "#{tmp}.length > 0",
+            [:html, :attr, name, [:dynamic, tmp]]]]
+        end
+      end
+    end
+  end
+end

data/lib/temple/coffee_script/filters/control_flow.rb

@@ -0,0 +1,37 @@
+module Temple
+  module CoffeeScript
+    module Filters
+      class ControlFlow < Filter
+        def on_if(condition, yes, no = nil)
+          result = [:multi, [:code, "if #{condition}"], [:indent, compile(yes)]]
+          while no && no.first == :if
+            result << [:code, "else if #{no[1]}"] << [:indent, compile(no[2])]
+            no = no[3]
+          end
+          result << [:code, 'else'] << [:indent, compile(no)] if no
+          result
+        end
+
+        def on_case(arg, *cases)
+          result = [:multi, [:code, arg ? "switch (#{arg})" : 'switch'], [:indent, [:multi]]]
+          cases.map do |c|
+            condition, *exps = c
+            result[2][1] << [:code, condition == :else ? 'else' : "when #{condition}"]
+            exps.each {|e| result[2][1] << [:indent, compile(e)] }
+          end
+          result
+        end
+
+        def on_cond(*cases)
+          on_case(nil, *cases)
+        end
+
+        def on_block(code, exp)
+          [:multi,
+           [:code, code],
+           [:indent, compile(exp)]]
+        end
+      end
+    end
+  end
+end

data/lib/temple/coffee_script/filters/escapable.rb

@@ -0,0 +1,34 @@
+module Temple
+  module CoffeeScript
+    module Filters
+      class Escapable < Filter
+        # Activate the usage of html_safe? if it is available (for Rails 3 for example)
+        set_default_options :use_html_safe => ''.respond_to?(:html_safe?),
+                            :disable_escape => false
+
+        def initialize(opts = {})
+          super
+          @escape_code = "::Temple::Utils.escape_html#{options[:use_html_safe] ? '_safe' : ''}((%s))"
+          @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+          @escape = false
+        end
+
+        def on_escape(flag, exp)
+          old = @escape
+          @escape = flag && !options[:disable_escape]
+          compile(exp)
+        ensure
+          @escape = old
+        end
+
+        def on_static(value)
+          [:static, @escape ? @escaper[value] : value]
+        end
+
+        def on_dynamic(value)
+          [:dynamic, @escape ? "@escape(#{value})" : value]
+        end
+      end
+    end
+  end
+end

data/lib/temple/coffee_script/filters.rb

@@ -0,0 +1,4 @@
+require "temple/coffee_script/filters/attribute_merger"
+require "temple/coffee_script/filters/attribute_remover"
+require "temple/coffee_script/filters/control_flow"
+require "temple/coffee_script/filters/escapable"

data/lib/temple/coffee_script/generators.rb

@@ -0,0 +1,53 @@
+require "multi_json"
+
+module Temple
+  module CoffeeScript
+    class Generator < Temple::Generator
+      default_options[:indent] = 0
+
+      def call(exp)
+        @indent = options[:indent]
+
+        compile [:multi,
+                 [:code, "#{buffer} = []"],
+                 exp,
+                 [:code, "#{buffer}.join('')"]]
+      end
+
+      def on_multi(*exp)
+        exp.map {|e| compile(e) }.join("\n")
+      end
+
+      def on_static(text)
+        concat(MultiJson.encode(text))
+      end
+
+      def on_dynamic(code)
+        concat(code)
+      end
+
+      def on_code(code)
+        indent(code)
+      end
+
+      def on_indent(exp)
+        @indent += 1
+        compile(exp)
+      ensure
+        @indent -= 1
+      end
+
+      def on_capture(name, exp)
+        self.class.new(:buffer => name, :indent => @indent).call(exp)
+      end
+
+      def concat(str)
+        indent("#{buffer}.push(#{str})")
+      end
+
+      def indent(str, indent = @indent)
+        "  " * indent + str
+      end
+    end
+  end
+end

data/lib/temple/coffee_script.rb

@@ -0,0 +1,3 @@
+require "temple/mixins/indent_dispatcher.rb"
+require "temple/coffee_script/filters"
+require "temple/coffee_script/generators"

data/lib/temple/mixins/indent_dispatcher.rb

@@ -0,0 +1,13 @@
+module Temple
+  module Mixins
+    module IndentDispatcher
+      def on_indent(exp)
+        [:indent, compile(exp)]
+      end
+    end
+
+    module Dispatcher
+      include IndentDispatcher
+    end
+  end
+end

data/skim.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/skim/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["John Firebaugh"]
+  gem.email         = ["john.firebaugh@gmail.com"]
+  gem.description   = %q{Fat-free client-side templates with Slim and CoffeeScript}
+  gem.summary       = %q{Take the fat out of your client-side templates with Skim. Skim is the Slim templating engine
+with embedded CoffeeScript. It compiles to JavaScript templates (.jst), which can then be served by Rails or any other
+Sprockets-based asset pipeline.}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "skim"
+  gem.require_paths = ["lib"]
+  gem.version       = Skim::VERSION
+
+  gem.add_dependency "slim", "~> 1.1.0"
+  gem.add_dependency "temple", "~> 0.4.0"
+  gem.add_dependency "coffee-script"
+  gem.add_dependency "multi_json"
+  gem.add_dependency "sprockets"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "execjs"
+  gem.add_development_dependency "minitest-reporters"
+  gem.add_development_dependency "therubyracer"
+end

data/test/context.coffee

@@ -0,0 +1,82 @@
+class Context
+  constructor: ->
+    @var = 'instance'
+    @x = 0
+
+  id_helper: ->
+    "notice"
+
+  hash: ->
+    a: 'The letter a', b: 'The letter b'
+
+  show_first: (show = false) ->
+    show
+
+  define_macro: (name, block) ->
+    @macro ||= {}
+    @macro[name] = block
+    ''
+
+  call_macro: (name, args...) ->
+    @macro[name](args...)
+
+  hello_world: (text = "Hello World from @env", opts = {}) ->
+    text + ("#{key} #{value}" for key, value of opts).join(" ")
+
+  callback: (text, block) ->
+    if block
+      "#{text} #{block()} #{text}"
+    else
+      text
+
+  message: (args...) ->
+    args.join(' ')
+
+  action_path: (args...) ->
+    "/action-#{args.join('-')}"
+
+  in_keyword: ->
+    "starts with keyword"
+
+  evil_method: ->
+    "<script>do_something_evil();</script>"
+
+  method_which_returns_true: ->
+    true
+
+  output_number: ->
+    1337
+
+  succ_x: ->
+    @x = @x + 1
+
+  person: ->
+    [{name: 'Joe'}, {name: 'Jack'}]
+
+  people: ->
+    ['Andy', 'Fred', 'Daniel'].map (n) -> new Person(n)
+
+  cities: ->
+    ['Atlanta', 'Melbourne', 'Karlsruhe']
+
+  people_with_locations: ->
+    @people().map (p, i) =>
+      p.location = new Location(@cities()[i])
+      p
+
+  constant_object: ->
+    @_constant_object ||= {a: 1, b: 2}
+
+  constant_object_size: ->
+    i = 0
+    i++ for k, v of @constant_object()
+    i
+
+class Person
+  constructor: (@_name) ->
+  name: => @_name
+  city: => @location.city()
+
+class Location
+  constructor: (@_city) ->
+  city: => @_city