slim 0.7.0.beta.2 → 0.7.0

data/extra/test.slim

@@ -0,0 +1,41 @@
+! doctype html
+html
+  head
+    title Slim Test
+    meta name="keywords" content="slim, syntax"
+
+    javascript:
+      $(function() {
+        alert('Hello World');
+      });
+
+  body
+    / comment block
+      with multiple lines
+
+    h1 = @page_title
+    p#notice.message
+      | Welcome to the the syntax test.
+        This file is to excercise the various markup.
+
+    - unless @users.empty?
+      table
+        - for user in users do
+          tr
+            td.user id=user.name = user.name
+    - else
+      p There are no users.
+
+    #content Hello #{@user.name}! Welcome to the test page!
+             Try out Slim!
+
+    = function_with_many_parameters(:a, \
+      variable, :option => 1)
+
+    p.text
+      ' Another text block
+        with multiple lines
+
+    .text#footer
+      ` Footer text block
+        with multiple lines

data/lib/slim.rb

@@ -11,6 +11,7 @@ require 'slim/embedded_engine'
 require 'slim/compiler'
 require 'slim/engine'
 require 'slim/template'
+require 'slim/version'
 
 begin
   require 'escape_utils'
@@ -19,6 +20,6 @@ end
 
 module Slim
   def self.version
-    Slim::VERSION
+    VERSION
   end
 end

data/lib/slim/command.rb

@@ -0,0 +1,80 @@
+require 'slim'
+require 'optparse'
+
+module Slim
+  # Slim commandline interface
+  # @api private
+  class Command
+    def initialize(args)
+      @args = args
+      @options = {}
+    end
+
+    # Run command
+    def run
+      @opts = OptionParser.new(&method(:set_opts))
+      @opts.parse!(@args)
+      process
+      exit 0
+    rescue Exception => ex
+      raise ex if @options[:trace] || SystemExit === ex
+      $stderr.print "#{ex.class}: " if ex.class != RuntimeError
+      $stderr.puts ex.message
+      $stderr.puts '  Use --trace for backtrace.'
+      exit 1
+    end
+
+    private
+
+    # Configure OptionParser
+    def set_opts(opts)
+      opts.on('-s', '--stdin', :NONE, 'Read input from standard input instead of an input file') do
+        @options[:input] = $stdin
+      end
+
+      opts.on('--trace', :NONE, 'Show a full traceback on error') do
+        @options[:trace] = true
+      end
+
+      opts.on('-c', '--compile', :NONE, 'Compile only but do not run') do
+        @options[:compile] = true
+      end
+
+      opts.on_tail('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+
+      opts.on_tail('-v', '--version', 'Print version') do
+        puts "Slim #{Slim.version}"
+        exit
+      end
+    end
+
+    # Process command
+    def process
+      args = @args.dup
+      unless @options[:input]
+        file = args.shift
+        if file
+          @options[:file] = file
+          @options[:input] = File.open(file, 'r')
+        else
+          @options[:file] = 'STDIN'
+          @options[:input] = $stdin
+        end
+      end
+
+      unless @options[:output]
+        file = args.shift
+        @options[:output] = file ? File.open(file, 'w') : $stdout
+      end
+
+      if @options[:compile]
+        @options[:output].puts(Slim::Engine.new(:file => @options[:file]).compile(@options[:input].read))
+      else
+        @options[:output].puts(Slim::Template.new(@options[:file]) { @options[:input].read }.render)
+      end
+    end
+  end
+end

data/lib/slim/compiler.rb

@@ -1,33 +1,64 @@
 module Slim
   # Compiles Slim expressions into Temple::HTML expressions.
+  # @api private
   class Compiler < Filter
+    # Handle text expression `[:slim, :text, string]`
+    #
+    # @param [String] string Static text
+    # @return [Array] Compiled temple expression
     def on_text(string)
-      if string.include?('#{')
-        [:dynamic, escape_interpolation(string)]
-      else
-        [:static, string]
+      # Interpolate variables in text (#{variable}).
+      # Split the text into multiple dynamic and static parts.
+      block = [:multi]
+      until string.empty?
+        case string
+        when /^\\(\#\{[^\}]*\})/
+          # Escaped interpolation
+          block << [:static, $1]
+        when /^\#\{([^\}]*)\}/
+          # Interpolation
+          block << [:dynamic, escape_code($1)]
+        when /^([^\#]+|\#)/
+          # Static text
+          block << [:static, $&]
+        end
+        string = $'
       end
+      block
     end
 
+    # Handle control expression `[:slim, :control, code, content]`
+    #
+    # @param [String] ruby code
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
     def on_control(code, content)
       [:multi,
         [:block, code],
         compile(content)]
     end
 
-    def on_embedded(engine, *body)
-      EmbeddedEngine[engine].compile(body)
-    end
-
-    # why is escaping not handled by temple?
+    # Handle output expression `[:slim, :output, escape, code, content]`
+    #
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
     def on_output(escape, code, content)
       if empty_exp?(content)
-        [:dynamic, escape ? escape_code(code) : code]
+        [:multi, [:dynamic, escape ? escape_code(code) : code], content]
       else
         on_output_block(escape, code, content)
       end
     end
 
+    # Handle output expression `[:slim, :output, escape, code, content]`
+    # if content is not empty.
+    #
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
     def on_output_block(escape, code, content)
       tmp1, tmp2 = tmp_var, tmp_var
 
@@ -47,28 +78,36 @@ module Slim
         [:block, tmp2],
 
         # Close the block.
-        [:block, "end"],
+        [:block, 'end'],
 
         # Output the content.
         on_output(escape, tmp1, [:multi])]
     end
 
+    # Handle directive expression `[:slim, :directive, type]`
+    #
+    # @param [String] type Directive type
+    # @return [Array] Compiled temple expression
     def on_directive(type)
-      case type
-      when /^doctype/
+      if type =~ /^doctype/
         [:html, :doctype, $'.strip]
-      else
       end
     end
 
+    # Handle tag expression `[:slim, :tag, name, attrs, content]`
+    #
+    # @param [String] name Tag name
+    # @param [Array] attrs Attributes
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
     def on_tag(name, attrs, content)
-      attrs = attrs.inject([:html, :attrs]) do |m, (key, value)|
-        if value.include?('#{')
-          value = [:dynamic, escape_interpolation(value)]
-        else
-          value = [:static, value]
-        end
-        m << [:html, :basicattr, [:static, key], value]
+      attrs = attrs.inject([:html, :attrs]) do |m, (key, dynamic, value)|
+        value = if dynamic
+                  [:dynamic, escape_code(value)]
+                else
+                  on_text(value)
+                end
+        m << [:html, :basicattr, [:static, key.to_s], value]
       end
 
       [:html, :tag, name, attrs, compile(content)]
@@ -76,17 +115,17 @@ module Slim
 
     private
 
-    def escape_interpolation(string)
-      string.gsub!(/(.?)\#\{(.*?)\}/) do
-        $1 == '\\' ? $& : "#{$1}#\{#{escape_code($2)}}"
-      end
-      '"%s"' % string
-    end
-
+    # Generate code to escape html
+    #
+    # @param [String] param Ruby code
+    # @return [String] Ruby code
     def escape_code(param)
       "Slim::Helpers.escape_html#{@options[:use_html_safe] ? '_safe' : ''}((#{param}))"
     end
 
+    # Generate unique temporary variable name
+    #
+    # @return [String] Variable name
     def tmp_var
       @tmp_var ||= 0
       "_slimtmp#{@tmp_var += 1}"

data/lib/slim/embedded_engine.rb

@@ -1,11 +1,11 @@
 module Slim
-  class EmbeddedEngine
+  # Temple filter which processes embedded engines
+  # @api private
+  class EmbeddedEngine < Filter
     @engines = {}
 
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
+    def self.register(name, klass, options = {})
+      @engines[name.to_s] = klass.new(options)
     end
 
     def self.[](name)
@@ -14,9 +14,8 @@ module Slim
       engine.dup
     end
 
-    def self.register(name, klass, options = {})
-      options.merge!(:name => name.to_s)
-      @engines[name.to_s] = klass.new(options)
+    def on_embedded(engine, *body)
+      EmbeddedEngine[engine].on_embedded(engine, *body)
     end
 
     def collect_text(body)
@@ -34,20 +33,20 @@ module Slim
       # Code to collect local variables
       COLLECT_LOCALS = %q{eval('{' + local_variables.select {|v| v[0] != ?_ }.map {|v| ":#{v}=>#{v}" }.join(',') + '}')}
 
-      def compile(body)
+      def on_embedded(engine, *body)
         text = collect_text(body)
-        engine = Tilt[options[:name]]
-        if options[:precompiled]
+        engine = Tilt[engine]
+        if @options[:precompiled]
           # Wrap precompiled code in proc, local variables from out the proc are accessible
           # WARNING: This is a bit of a hack. Tilt::Engine#precompiled is protected
           precompiled = engine.new { text }.send(:precompiled, {}).first
           [:dynamic, "proc { #{precompiled} }.call"]
-        elsif options[:dynamic]
+        elsif @options[:dynamic]
           # Fully dynamic evaluation of the template during runtime (Slow and uncached)
           [:dynamic, "#{engine.name}.new { #{text.inspect} }.render(self, #{COLLECT_LOCALS})"]
-        elsif options[:interpolate]
+        elsif @options[:interpolate]
           # Static template with interpolated ruby code
-          [:dynamic, '"%s"' % engine.new { text }.render]
+          [:slim, :text, engine.new { text }.render]
         else
           # Static template
           [:static, engine.new { text }.render]
@@ -56,23 +55,14 @@ module Slim
     end
 
     class TagEngine < EmbeddedEngine
-      def compile_text(body)
-        body.inject([:multi]) do |block, exp|
-          block << (exp[0] == :slim && exp[1] == :text ? [:static, exp[2]] : exp)
-        end
-      end
-
-      def compile(body)
-        attrs = [:html, :attrs]
-        options[:attributes].each do |key, value|
-          attrs << [:html, :basicattr, [:static, key.to_s], [:static, value.to_s]]
-        end
-        [:html, :tag, options[:tag], attrs, compile_text(body)]
+      def on_embedded(engine, *body)
+        content = @options[:engine] ? @options[:engine].new.on_embedded(engine, *body) : [:multi, *body]
+        [:slim, :tag, @options[:tag], @options[:attributes].map {|k, v| [k, false, v ] }, content]
       end
     end
 
     class RubyEngine < EmbeddedEngine
-      def compile(body)
+      def on_embedded(engine, *body)
         [:block, collect_text(body)]
       end
     end
@@ -83,9 +73,10 @@ module Slim
     register :rdoc, TiltEngine, :interpolate => true
 
     # These engines are executed at compile time
-    register :sass, TiltEngine
-    register :less, TiltEngine
-    register :coffee, TiltEngine
+    register :coffee, TagEngine, :tag => 'script', :attributes => { :type => 'text/javascript' }, :engine => TiltEngine
+    register :sass, TagEngine, :tag => 'style', :attributes => { :type => 'text/css' }, :engine => TiltEngine
+    register :scss, TagEngine, :tag => 'style', :attributes => { :type => 'text/css' }, :engine => TiltEngine
+    register :less, TagEngine, :tag => 'style', :attributes => { :type => 'text/css' }, :engine => TiltEngine
 
     # These engines are precompiled, code is embedded
     register :erb, TiltEngine, :precompiled => true

data/lib/slim/end_inserter.rb

@@ -7,10 +7,13 @@ module Slim
   # However, the parser is not smart enough (and that's a good thing) to
   # automatically insert end's where they are needed. Luckily, this filter
   # does *exactly* that (and it does it well!)
+  #
+  # @api private
   class EndInserter < Filter
     ELSE_REGEX = /^(else|elsif|when|end)\b/
     END_REGEX = /^end\b/
 
+    # Handle multi expression `[:multi, *exps]`
     def on_multi(*exps)
       result = [:multi]
       # This variable is true if the previous line was

data/lib/slim/engine.rb

@@ -1,7 +1,10 @@
 module Slim
+  # Slim engine which transforms slim code to executable ruby code
+  # @api public
   class Engine < Temple::Engine
-    use Slim::Parser
+    use Slim::Parser, :file
     use Slim::EndInserter
+    use Slim::EmbeddedEngine
     use Slim::Compiler, :use_html_safe
     #use Slim::Debugger
     use Temple::HTML::Fast, :format, :attr_wrapper => '"', :format => :html5
@@ -9,13 +12,5 @@ module Slim
     filter :StaticMerger
     filter :DynamicInliner
     generator :ArrayBuffer
-
-    def self.new(*args)
-      if args.first.respond_to?(:each_line)
-        Template.new(Hash === args.last ? args.last : {}) { args.first }
-      else
-        super
-      end
-    end
   end
 end

data/lib/slim/filter.rb

@@ -1,4 +1,6 @@
 module Slim
+  # Base class for Temple filters used in Slim
+  # @api private
   class Filter
     include Temple::Utils
 
@@ -35,6 +37,8 @@ module Slim
     end
   end
 
+  # Simple filter which prints Temple expression
+  # @api private
   class Debugger < Filter
     def compile(exp)
       puts exp.inspect

data/lib/slim/helpers.rb

@@ -1,32 +1,76 @@
 module Slim
+  # Slim helper functions
+  #
+  # @api public
   module Helpers
+    # Iterate over `Enumerable` object
+    # yielding each element to a Slim block
+    # and putting the result into `<li>` elements.
+    # For example:
+    #
+    #     = list_of([1,2]) do |i|
+    #       = i
+    #
+    # Produces:
+    #
+    #     <li>1</li>
+    #     <li>2</li>
+    #
+    # @param enum [Enumerable] The enumerable objects to iterate over
+    # @yield [item] A block which contains Slim code that goes within list items
+    # @yieldparam item An element of `enum`
+    # @api public
     def list_of(enum, &block)
-      enum.map do |i|
+      list = enum.map do |i|
         "<li>#{yield(i)}</li>"
       end.join("\n")
+      list.respond_to?(:html_safe) ? list.html_safe : list
     end
 
+    # Returns an escaped copy of `html`.
+    # Strings which are declared as html_safe are not escaped.
+    #
+    # @param html [String] The string to escape
+    # @return [String] The escaped string
+    # @api public
     def escape_html_safe(html)
       html.html_safe? ? html : escape_html(html)
     end
 
     if defined?(EscapeUtils)
+      # Returns an escaped copy of `html`.
+      #
+      # @param html [String] The string to escape
+      # @return [String] The escaped string
+      # @api public
       def escape_html(html)
         EscapeUtils.escape_html(html.to_s)
       end
     elsif RUBY_VERSION > '1.9'
+      # Used by escape_html
+      # @api private
       ESCAPE_HTML = {
         '&' => '&amp;',
         '"' => '&quot;',
         '<' => '&lt;',
         '>' => '&gt;',
         '/' => '&#47;',
-      }
+      }.freeze
 
+      # Returns an escaped copy of `html`.
+      #
+      # @param html [String] The string to escape
+      # @return [String] The escaped string
+      # @api public
       def escape_html(html)
         html.to_s.gsub(/[&\"<>\/]/, ESCAPE_HTML)
       end
     else
+      # Returns an escaped copy of `html`.
+      #
+      # @param html [String] The string to escape
+      # @return [String] The escaped string
+      # @api public
       def escape_html(html)
         html.to_s.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;').gsub(/\//, '&#47;')
       end