slim 1.3.2 → 1.3.3

data/.yardopts

@@ -1,2 +1,3 @@
---title Slim
---files CHANGES,LICENSE
+--markup-provider redcarpet
+--markup markdown
+- README.md CHANGES LICENSE test/literate/TESTS.md

data/CHANGES

@@ -1,3 +1,15 @@
+1.3.3
+
+  * Attribute handling made consistent:
+    - Splat attributes, static and dynamic attributes are now all handled the same
+    - Merged attributes are removed if empty (in the default configuration this is only "class")
+    - Dynamic attributes which are not merged are checked for false or nil and removed if this is the case
+    - Dynamic attributes which are not merged are checked for true and generated as attribute-name="attribute-name"
+  * Rename class BooleanAttributes to CodeAttributes
+  * Add literate test suite (still incomplete), run with `rake test:literate`
+  * Remove UTF BOM when parsing Slim code
+  * Fixed issue #303
+
 1.3.2
 
   * Fix boolean attributes #299

data/README.md

@@ -119,9 +119,9 @@ You can also embed html in the text line
     - articles.each do |a|
       | <tr><td>#{a.name}</td><td>#{a.description}</td></tr>
 
-### Text with trailing space `'`
+### Text with trailing white space `'`
 
-The single quote tells Slim to copy the line (similar to `|`), but makes sure that a single trailing space is appended.
+The single quote tells Slim to copy the line (similar to `|`), but makes sure that a single trailing white space is appended.
 
 ### Inline html `<` (HTML style)
 
@@ -148,7 +148,7 @@ If your ruby code needs to use multiple lines, append a backslash `\` at the end
       - if articles.empty?
         | No inventory
 
-### Dynamic output `=`
+### Output `=`
 
 The equal sign tells Slim it's a Ruby call that produces output to add to the buffer. If your ruby code needs to use multiple lines, append a backslash `\` at the end of the lines, for example:
 
@@ -158,7 +158,7 @@ The equal sign tells Slim it's a Ruby call that produces output to add to the bu
 
 ### Output with trailing white space `='`
 
-Same as the single equal sign (`=`), except that it adds a trailing whitespace.
+Same as the single equal sign (`=`), except that it adds a trailing white space.
 
 ### Output without HTML escaping `==`
 
@@ -166,7 +166,7 @@ Same as the single equal sign (`=`), but does not go through the `escape_html` m
 
 ### Output without HTML escaping and trailing ws `=='`
 
-Same as the double equal sign (`==`), except that it adds a trailing whitespace.
+Same as the double equal sign (`==`), except that it adds a trailing white space.
 
 ### Code comment `/`
 
@@ -321,7 +321,6 @@ you can use the characters `{...}`, `(...)`, `[...]` to wrap the attributes.
       h1(id="logo") = page_logo
       h2[id="tagline" class="small tagline"] = page_tagline
 
-
 If you wrap the attributes, you can spread them across multiple lines:
 
     h2[id="tagline"
@@ -337,7 +336,7 @@ You can use text interpolation in the quoted attributes:
 
     a href="http://#{url}" Goto the #{url}
 
-The attribute value will be escaped by default. Use == if you want to disable escaping in the attribute.
+The attribute value will be escaped if the option `:escape_quoted_attrs` is set. Use == if you want to disable escaping in the attribute.
 
     a href=="&amp;"
 
@@ -370,17 +369,44 @@ as booleans. If you use the attribut wrapper you can omit the attribute assigmen
     input type="text" disabled=false
     input type="text" disabled=nil
 
+#### Attribute merging
+
+You can configure attributes to be merged if multiple are given (See option `:attr_delimiter`). In the default configuration
+this is done for class attributes with the white space as delimiter.
+
+    a.menu class="highlight" href="http://slim-lang.com/" Slim-lang.com
+
+This renders as
+
+    <a class="menu highlight" href="http://slim-lang.com/">Slim-lang.com</a>
+
+You can also use an `Array` as attribute value and the array elements will be merged using the delimiter.
+
+    a class=["menu","highlight"]
+    a class=:menu,:highlight
+
 #### Splat attributes `*`
 
 The splat shortcut allows you turn a hash in to attribute/value pairs
 
     .card*{'data-url'=>place_path(place), 'data-id'=>place.id} = place.name
+
+renders as
+
+    <div class="card" data-id="1234" data-url="/place/1234">Slim's house</div>
+
+You can also use methods or instance variables which return a hash as shown here:
+
     .card *method_which_returns_hash = place.name
     .card *@hash_instance_variable = place.name
 
+The hash attributes which support attribute merging (see Slim option `:attr_delimiter`) can be given as an `Array`
+
+    .first *{:class => [:second, :third]} Text
+
 renders as
 
-    <div class="card" data-id="1234" data-url="/place/1234">Slim's house</div>
+    div class="first second third"
 
 #### ID shortcut `#` and class shortcut `.`
 
@@ -408,7 +434,23 @@ This is the same as
 
 You can define custom shortcuts (Similar to `#` for id and `.` for class).
 
-In this example we add `@` to create a shortcut for the role attribute.
+In this example we add `&` to create a shortcut for the input elements with type attribute.
+
+    Slim::Engine.set_default_options :shortcut => {'&' => 'input type', '#' => 'id', '.' => 'class'}
+
+We can use it in Slim code like this
+
+    &text name="user"
+    &password name="pw"
+    &submit
+
+which renders to
+
+    <input type="text" name="user" />
+    <input type="password" name="pw" />
+    <input type="submit" />
+
+In another example we add `@` to create a shortcut for the role attribute.
 
     Slim::Engine.set_default_options :shortcut => {'@' => 'role', '#' => 'id', '.' => 'class'}
 
@@ -528,7 +570,7 @@ There are a lot of them but the good thing is, that Slim checks the configuratio
 <thead style="font-weight:bold"><tr><td>Type</td><td>Name</td><td>Default</td><td>Purpose</td></tr></thead>
 <tbody>
 <tr><td>String</td><td>:file</td><td>nil</td><td>Name of parsed file, set automatically by Slim::Template</td></tr>
-<tr><td>Integer</td><td>:tabsize</td><td>4</td><td>Number of whitespaces per tab (used by the parser)</td></tr>
+<tr><td>Integer</td><td>:tabsize</td><td>4</td><td>Number of white spaces per tab (used by the parser)</td></tr>
 <tr><td>String</td><td>:encoding</td><td>"utf-8"</td><td>Set encoding of template</td></tr>
 <tr><td>String</td><td>:default_tag</td><td>"div"</td><td>Default tag to be used if tag name is omitted</td></tr>
 <tr><td>Hash</td><td>:shortcut</td><td>\{'.' => 'class', '#' => 'id'}</td><td>Attribute shortcuts</td></tr>
@@ -792,6 +834,7 @@ There are plugins for various text editors (including the most important ones -
 * [Emacs](https://github.com/minad/emacs-slim)
 * [Textmate / Sublime Text](https://github.com/fredwu/ruby-slim-tmbundle)
 * [Espresso text editor](https://github.com/CiiDub/Slim-Sugar)
+* [Coda](https://github.com/nwalton3/Coda-2-Slim.mode)
 
 ### Template Converters (HAML, ERB, ...)
 
@@ -875,6 +918,8 @@ overhead added by the Temple framework compared to ERB.
 Slim provides an extensive test-suite based on minitest. You can run the tests
 with 'rake test' and the rails integration tests with 'rake test:rails'.
 
+We are currently experimenting with human-readable literate tests which are written as markdown files: {file:test/literate/TESTS.md TESTS.md}
+
 Travis-CI is used for continous integration testing: {http://travis-ci.org/#!/stonean/slim}
 
 Slim is working well on all major Ruby implementations:
@@ -934,6 +979,7 @@ Syntax highlighting:
 * [Emacs](https://github.com/minad/emacs-slim)
 * [Textmate / Sublime Text](https://github.com/fredwu/ruby-slim-tmbundle)
 * [Espresso text editor](https://github.com/CiiDub/Slim-Sugar)
+* [Coda](https://github.com/nwalton3/Coda-2-Slim.mode)
 
 Template Converters (HAML, ERB, ...):
 

data/Rakefile

@@ -14,7 +14,7 @@ end
 task 'test' => %w(test:core_and_plugins)
 
 namespace 'test' do
-  task 'core_and_plugins' => %w(core logic_less translator)
+  task 'core_and_plugins' => %w(core literate logic_less translator)
 
   Rake::TestTask.new('core') do |t|
     t.libs << 'lib' << 'test/core'
@@ -22,6 +22,12 @@ namespace 'test' do
     t.verbose = true
   end
 
+  Rake::TestTask.new('literate') do |t|
+    t.libs << 'lib' << 'test/literate'
+    t.test_files = FileList['test/literate/run.rb']
+    t.verbose = true
+  end
+
   Rake::TestTask.new('logic_less') do |t|
     t.libs << 'lib' << 'test/core'
     t.test_files = FileList['test/logic_less/test_*.rb']

data/lib/slim.rb

@@ -6,7 +6,7 @@ require 'slim/embedded_engine'
 require 'slim/interpolation'
 require 'slim/control_structures'
 require 'slim/splat_attributes'
-require 'slim/boolean_attributes'
+require 'slim/code_attributes'
 require 'slim/engine'
 require 'slim/template'
 require 'slim/version'

data/lib/slim/code_attributes.rb

@@ -0,0 +1,67 @@
+module Slim
+  # @api private
+  class CodeAttributes < Filter
+    define_options :attr_delimiter
+
+    # Handle attributes expression `[:html, :attrs, *attrs]`
+    #
+    # @param [Array] attrs Array of temple expressions
+    # @return [Array] Compiled temple expression
+    def on_html_attrs(*attrs)
+      [:multi, *attrs.map {|a| compile(a) }]
+    end
+
+    # Handle attribute expression `[:slim, :attr, escape, code]`
+    #
+    # @param [String] name Attribute name
+    # @param [Array] value Value expression
+    # @return [Array] Compiled temple expression
+    def on_html_attr(name, value)
+      unless value[0] == :slim && value[1] == :attrvalue && !options[:attr_delimiter][name]
+        # We perform merging on the attribute
+        @attr = name
+        return super
+      end
+
+      # We handle the attribute as a boolean attribute
+      escape, code = value[2], value[3]
+      case code
+      when 'true'
+        [:html, :attr, name, [:static, name]]
+      when 'false', 'nil'
+        [:multi]
+      else
+        tmp = unique_name
+        [:multi,
+         [:code, "#{tmp} = #{code}"],
+         [:case, tmp,
+          ['true', [:html, :attr, name, [:static, name]]],
+          ['false, nil', [:multi]],
+          [:else, [:html, :attr, name, [:escape, escape, [:dynamic, tmp]]]]]]
+      end
+    end
+
+    # Handle attribute expression `[:slim, :attrvalue, escape, code]`
+    #
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
+    # @return [Array] Compiled temple expression
+    def on_slim_attrvalue(escape, code)
+      # We perform attribute merging on Array values
+      if delimiter = options[:attr_delimiter][@attr]
+        tmp = unique_name
+        [:multi,
+         [:code, "#{tmp} = #{code}"],
+         [:if, "Array === #{tmp}",
+          [:multi,
+           [:code, "#{tmp}.flatten!"],
+           [:code, "#{tmp}.map!(&:to_s)"],
+           [:code, "#{tmp}.reject!(&:empty?)"],
+           [:escape, escape, [:dynamic, "#{tmp}.join(#{delimiter.inspect})"]]],
+          [:escape, escape, [:dynamic, tmp]]]]
+      else
+        [:escape, escape, [:dynamic, code]]
+      end
+    end
+  end
+end

data/lib/slim/engine.rb

@@ -23,7 +23,8 @@ module Slim
     use Slim::SplatAttributes, :attr_delimiter, :attr_wrapper, :sort_attrs, :default_tag
     html :AttributeSorter, :sort_attrs
     html :AttributeMerger, :attr_delimiter
-    use Slim::BooleanAttributes, :attr_delimiter
+    use Slim::CodeAttributes, :attr_delimiter
+    use(:AttributeRemover) { Temple::HTML::AttributeRemover.new(:remove_empty_attrs => options[:attr_delimiter].keys) }
     html :Pretty, :format, :attr_wrapper, :pretty, :indent
     filter :Escapable, :use_html_safe, :disable_escape
     filter :ControlFlow

data/lib/slim/parser.rb

@@ -55,14 +55,7 @@ module Slim
     # @param [String] str Slim code
     # @return [Array] Temple expression representing the code]]
     def call(str)
-      # Set string encoding if option is set
-      if options[:encoding] && str.respond_to?(:encoding)
-        old_enc = str.encoding
-        str = str.dup if str.frozen?
-        str.force_encoding(options[:encoding])
-        # Fall back to old encoding if new encoding is invalid
-        str.force_encoding(old_enc) unless str.valid_encoding?
-      end
+      str = remove_bom(set_encoding(str))
 
       result = [:multi]
       reset(str.split(/\r?\n/), [result])
@@ -86,6 +79,31 @@ module Slim
     QUOTED_ATTR_REGEX = /#{ATTR_NAME}=(=?)("|')/
     CODE_ATTR_REGEX = /#{ATTR_NAME}=(=?)/
 
+    # Set string encoding if option is set
+    def set_encoding(s)
+      if options[:encoding] && s.respond_to?(:encoding)
+        old_enc = s.encoding
+        s = s.dup if s.frozen?
+        s.force_encoding(options[:encoding])
+        # Fall back to old encoding if new encoding is invalid
+        s.force_encoding(old_enc) unless s.valid_encoding?
+      end
+      s
+    end
+
+    # Remove unicode byte order mark from string
+    def remove_bom(s)
+      if s.respond_to?(:encoding)
+        if s.encoding.name =~ /^UTF-(8|16|32)(BE|LE)?/
+          s.gsub(Regexp.new("\\A\uFEFF".encode(s.encoding.name)), '')
+        else
+          s
+        end
+      else
+        s.gsub(/\A\xEF\xBB\xBF/, '')
+      end
+    end
+
     def reset(lines = nil, stacks = nil)
       # Since you can indent however you like in Slim, we need to keep a list
       # of how deeply indented you are. For instance, in a template like this:
@@ -347,7 +365,7 @@ module Slim
       end
 
       if delimiter
-        boolean_attr_regex = /#{ATTR_NAME}(?=(\s|#{Regexp.escape delimiter}))/
+        boolean_attr_regex = /#{ATTR_NAME}(?=(\s|#{Regexp.escape delimiter}|\Z))/
         end_regex = /\A\s*#{Regexp.escape delimiter}/
       end
 

data/lib/slim/splat_attributes.rb

@@ -79,30 +79,31 @@ module Slim
         end
       end
 
-      merger << [:block, "#{hash}.each do |#{name},#{value}|",
+      merger << [:block, "#{hash}.keys.each do |#{name}|",
                  [:multi,
-                  [:code, "#{value}.flatten!"],
-                  [:if, "#{value}.size > 1 && !#{@attr_delimiter}[#{name}]",
-                   [:code, %{raise("Multiple #\{#{name}\} attributes specified")}]],
-                  [:code, "#{value}.compact!"],
-                  [:case, "#{value}.size",
-                   ['0',
-                    [:code, "#{hash}[#{name}] = nil"]],
-                   ['1',
+                  [:code, "#{value} = #{hash}[#{name}]"],
+                  [:if, "#{@attr_delimiter}[#{name}]",
+                   [:multi,
+                    [:code, "#{value}.flatten!"],
+                    [:code, "#{value}.map!(&:to_s)"],
+                    [:code, "#{value}.reject!(&:empty?)"],
+                    [:if, "#{value}.empty?",
+                     [:code, "#{hash}.delete(#{name})"],
+                     [:code, "#{hash}[#{name}] = #{value}.join(#{@attr_delimiter}[#{name}].to_s)"]]],
+                   [:multi,
+                    [:if, "#{value}.size > 1",
+                     [:code, %{raise("Multiple #\{#{name}\} attributes specified")}]],
                     [:case, "#{value}.first",
                      ['true', [:code, "#{hash}[#{name}] = #{name}"]],
-                     ['false, nil', [:code, "#{hash}[#{name}] = nil"]],
-                     [:else, [:code, "#{hash}[#{name}] = #{value}.first"]]]],
-                   [:else,
-                    [:code, "#{hash}[#{name}] = #{value}.join(#{@attr_delimiter}[#{name}].to_s)"]]]]]
+                     ['false, nil', [:code, "#{hash}.delete(#{name})"]],
+                     [:else, [:code, "#{hash}[#{name}] = #{value}.first"]]]]]]]
 
-      attr = [:if, value,
-              [:multi,
-               [:static, ' '],
-               [:dynamic, name],
-               [:static, "=#{options[:attr_wrapper]}"],
-               [:escape, true, [:dynamic, value]],
-               [:static, options[:attr_wrapper]]]]
+      attr = [:multi,
+              [:static, ' '],
+              [:dynamic, name],
+              [:static, "=#{options[:attr_wrapper]}"],
+              [:escape, true, [:dynamic, value]],
+              [:static, options[:attr_wrapper]]]
       enumerator = options[:sort_attrs] ? "#{hash}.sort_by {|#{name},#{value}| #{name} }" : hash
       formatter = [:block, "#{enumerator}.each do |#{name},#{value}|", attr]
 

data/lib/slim/version.rb

@@ -1,5 +1,5 @@
 module Slim
   # Slim version string
   # @api public
-  VERSION = '1.3.2'
+  VERSION = '1.3.3'
 end

data/slim.gemspec

@@ -11,15 +11,13 @@ Gem::Specification.new do |s|
   s.summary           = 'Slim is a template language.'
   s.description       = 'Slim is a template language whose goal is reduce the syntax to the essential parts without becoming cryptic.'
   s.homepage          = 'http://slim-lang.com/'
-  s.extra_rdoc_files  = %w(README.md LICENSE CHANGES)
-  s.rdoc_options      = %w(--charset=UTF-8)
   s.rubyforge_project = s.name
 
   s.files         = `git ls-files`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = %w(lib)
 
-  s.add_runtime_dependency('temple', ['~> 0.5.0'])
+  s.add_runtime_dependency('temple', ['~> 0.5.5'])
   s.add_runtime_dependency('tilt', ['~> 1.3.3'])
 
   s.add_development_dependency('rake', ['>= 0.8.7'])

data/test/core/test_encoding.rb

@@ -12,4 +12,10 @@ class TestSlimEncoding < TestSlim
     result = "\xFF\xFF"
     assert_html result, source
   end
+
+  def test_bom
+    source = "\xEF\xBB\xBFh1 Hello World!"
+    result = '<h1>Hello World!</h1>'
+    assert_html result, source
+  end
 end

data/test/core/test_html_attributes.rb

@@ -99,15 +99,15 @@ option(selected class="clazz") Text
     assert_html '<option class="clazz" selected="selected">Text</option><option class="clazz" selected="selected">Text</option>', source
   end
 
-  def test_array_attribute
+  def test_array_attribute_merging
     source = %{
-.alpha class="beta" class=[:gamma, nil, :delta, [true, false]]
+.alpha class="beta" class=[[""], :gamma, nil, :delta, [true, false]]
+.alpha class=:beta,:gamma
 }
 
-    assert_html '<div class="alpha beta gamma delta true false"></div>', source
+    assert_html '<div class="alpha beta gamma delta true false"></div><div class="alpha beta gamma"></div>', source
   end
 
-
   def test_shortcut_splat
     source = %q{
 *hash This is my title
@@ -213,6 +213,22 @@ a class=true
 a class=false
 }
 
-    assert_html '<a class="true false"></a><a class="false true"></a><a class="class"></a><a></a>', source
+    assert_html '<a class="true false"></a><a class="false true"></a><a class="true"></a><a class="false"></a>', source
+  end
+
+  def test_static_empty_attribute
+    source = %q{
+p(id="marvin" name="" class="" data-info="Illudium Q-36")= output_number
+}
+
+    assert_html '<p data-info="Illudium Q-36" id="marvin" name="">1337</p>', source
+  end
+
+  def test_dynamic_empty_attribute
+    source = %q{
+p(id="marvin" class=nil nonempty=("".to_s) data-info="Illudium Q-36")= output_number
+}
+
+    assert_html '<p data-info="Illudium Q-36" id="marvin" nonempty="">1337</p>', source
   end
 end