brakeman 4.3.1 → 4.4.0

data/bundle/ruby/2.5.0/gems/{slim-3.0.7 → slim-4.0.1}/README.md

@@ -1,6 +1,6 @@
 # Slim
 
-[![Gem Version](https://img.shields.io/gem/v/slim.svg)](http://rubygems.org/gems/slim) [![Build Status](https://img.shields.io/travis/slim-template/slim.svg?branch=master)](http://travis-ci.org/slim-template/slim) [![Dependency Status](https://img.shields.io/gemnasium/slim-template/slim.svg?travis)](https://gemnasium.com/slim-template/slim) [![Code Climate](https://codeclimate.com/github/slim-template/slim/badges/gpa.svg)](https://codeclimate.com/github/slim-template/slim) [![Test Coverage](https://codeclimate.com/github/slim-template/slim/badges/coverage.svg)](https://codeclimate.com/github/slim-template/slim/coverage) [![Gittip donate button](https://img.shields.io/gratipay/bevry.svg)](https://www.gittip.com/min4d/ "Donate weekly to this project using Gittip")
+[![Gem Version](https://img.shields.io/gem/v/slim.svg)](http://rubygems.org/gems/slim) [![Build Status](https://img.shields.io/travis/slim-template/slim.svg?branch=master)](http://travis-ci.org/slim-template/slim) [![Code Climate](https://codeclimate.com/github/slim-template/slim/badges/gpa.svg)](https://codeclimate.com/github/slim-template/slim) [![Test Coverage](https://codeclimate.com/github/slim-template/slim/badges/coverage.svg)](https://codeclimate.com/github/slim-template/slim/coverage)
 [![Flattr donate button](https://raw.github.com/balupton/flattr-buttons/master/badge-89x18.gif)](https://flattr.com/submit/auto?user_id=min4d&url=http%3A%2F%2Fslim-lang.org%2F "Donate monthly to this project using Flattr")
 
 Slim is a template language whose goal is to reduce the view syntax to the essential parts without becoming cryptic. It started as an exercise to see how much could be removed from a standard html template (<, >, closing tags, etc...). As more people took an interest in Slim, the functionality grew and so did the flexibility of the syntax.
@@ -40,7 +40,7 @@ A short list of the features...
 
 ### What is Slim?
 
-Slim is a fast, lightweight templating engine with support for __Rails 3 and 4__. It has been heavily tested on all major ruby implementations. We use
+Slim is a fast, lightweight templating engine with support for __Rails 3 and later__. It has been heavily tested on all major ruby implementations. We use
 continuous integration (travis-ci).
 
 Slim's core syntax is guided by one thought: "What's the minimum required to make this work".
@@ -55,7 +55,7 @@ by the logic less plugin and the translator plugin which provides I18n. In logic
 ### Why use Slim?
 
 * Slim allows you to write very minimal templates which are easy to maintain and pretty much guarantees that you write well-formed HTML and XML
-* We also think that the Slim syntax is also aesthetic and makes it much more fun to write templates. Since you can use Slim as a drop-in replacement in all the major framework you can start easily.
+* The Slim syntax is aesthetic and makes it more fun to write templates. Since you can use Slim as a drop-in replacement in all the major frameworks it is easy to adopt.
 * The Slim architecture is very flexible and allows you to write syntax extensions and plugins.
 
 ___Yes, Slim is speedy!___ Slim was developed right from the start with performance in mind.
@@ -252,7 +252,7 @@ The doctype keyword can be used to generate the complex doctypes in a very simpl
 
 XML VERSION
 
-~~~~ slim
+~~~ slim
 doctype xml
   <?xml version="1.0" encoding="utf-8" ?>
 
@@ -464,7 +464,7 @@ You can break quoted attributes with backslash `\`
 
 ~~~ slim
 a data-title="help" data-content="extremely long help text that goes on\
-  and one and one and then starts over...."
+  and on and on and then starts over...."
 ~~~
 
 #### Ruby attributes
@@ -487,7 +487,7 @@ The attribute value will be escaped by default. Use == if you want to disable es
 a href==action_path(:start)
 ~~~
 
-You can also break ruby attributes with backslash `\` or trailing `,` as describe for control sections.
+You can also break ruby attributes with backslash `\` or trailing `,` as described for control sections.
 
 #### Boolean attributes
 
@@ -559,6 +559,8 @@ This renders as:
 div class="first second third"
 ~~~
 
+Splat attributes prefix may be configured via `splat_prefix` option. Default value is `'*'`
+
 #### Dynamic tags `*`
 
 You can create completely dynamic tags using the splat attributes. Just create a method which returns a hash
@@ -824,7 +826,7 @@ fits your purposes. You should also be aware that most frameworks already bring
 
 ## Text interpolation
 
-Use standard Ruby interpolation. The text will be html escaped by default.
+Use standard Ruby interpolation. The text will be html escaped by default, but you can avoid escaping by using double braces.
 
 ~~~ slim
 body
@@ -867,17 +869,10 @@ Supported engines:
 | sass: | sass | Compile time | Embed sass code and wrap in style tag |
 | scss: | sass | Compile time | Embed scss code and wrap in style tag |
 | less: | less | Compile time | Embed less css code and wrap in style tag |
-| styl: | styl | Compile time | Embed stylus css code and wrap in style tag |
 | coffee: | coffee-script | Compile time | Compile coffee script code and wrap in script tag |
-| asciidoc: | asciidoctor | Compile time + Interpolation | Compile AsciiDoc code and interpolate #\{variables} in text |
 | markdown: | redcarpet/rdiscount/kramdown | Compile time + Interpolation | Compile markdown code and interpolate #\{variables} in text |
 | textile: | redcloth | Compile time + Interpolation | Compile textile code and interpolate #\{variables} in text |
-| creole: | creole | Compile time + Interpolation | Compile creole code and interpolate #\{variables} in text |
-| wiki:, mediawiki: | wikicloth | Compile time + Interpolation | Compile wiki code and interpolate #\{variables} in text |
 | rdoc: | rdoc | Compile time + Interpolation | Compile rdoc code and interpolate #\{variables} in text |
-| builder: | builder | Precompiled | Embed builder code |
-| nokogiri: | nokogiri | Precompiled | Embed nokogiri builder code |
-| erb: | none | Precompiled | Embed erb code |
 
 The embedded engines can be configured in Slim by setting the options directly on the `Slim::Embedded` filter. Example:
 
@@ -885,6 +880,28 @@ The embedded engines can be configured in Slim by setting the options directly o
 Slim::Embedded.options[:markdown] = {auto_ids: false}
 ~~~
 
+You can also specify HTML attributes for the following embedded engines:
+* Javascript
+* CSS
+* CoffeeScript
+* LESS
+* SASS
+* SCSS
+
+Example:
+
+~~~ scss
+scss class="myClass":
+  $color: #f00;
+  body { color: $color; }
+~~~
+
+This will generate the following HTML:
+
+~~~ html
+<style class="myClass" type="text/css">body{color:red}</style>
+~~~
+
 ## Configuring Slim
 
 Slim and the underlying [Temple](https://github.com/judofyr/temple) framework are highly configurable.
@@ -965,9 +982,9 @@ There are a lot of them but the good thing is, that Slim checks the configuratio
 | Boolean | :pretty | false | Pretty HTML indenting, only block level tags are indented <b>(This is slower!)</b> |
 | String | :indent | '  ' | Indentation string |
 | Boolean | :streaming | false (true in Rails, see below how to disable it!) | Enable output streaming, improves the perceived performance |
-| Class | :generator | Temple::Generators::ArrayBuffer/ RailsOutputBuffer | Temple code generator (default generator generates array buffer) |
+| Class | :generator | Temple::Generators::StringBuffer/ RailsOutputBuffer | Temple code generator (default generator generates string buffer) |
 | String | :buffer | '_buf' ('@output_buffer' in Rails) | Variable used for buffer |
-
+| String | :splat_prefix | '*' | Prefix used for splat attributes |
 
 There are more options which are supported by the Temple filters but which are not exposed and are not officially supported. You
 have to take a look at the Slim and Temple code for that.
@@ -1035,7 +1052,7 @@ html
 ### Rails
 
 Rails generators are provided by [slim-rails](https://github.com/slim-template/slim-rails). slim-rails
-is not necessary to use Slim in Rails though. Just install Slim and add it to your Gemfile with `gem 'slim-rails'`.
+is not necessary to use Slim in Rails though. Just install Slim and add it to your Gemfile with `gem 'slim'`.
 Then just use the .slim extension and you're good to go.
 
 #### Streaming
@@ -1047,6 +1064,47 @@ performance. The rendering time in total will increase. If you want to disable i
 Slim::RailsTemplate.set_options streaming: false
 ~~~
 
+### Angular2
+
+Slim now supports Angular2 syntax. But you need to set some configuration options:
+
+#### `splat_prefix` option
+
+This option tells parser what syntax to use for splat attributes.
+Default value is asterisk: `splat_prefix: '*'`
+Asterisk is also used in Angular2 for structural directives such as `*ngIf` and others, so default configuration causes a conflict between slim and angular2 syntax.
+
+There are two ways to resolve it:
+
+* Set `splat_prefix` to any custom value, double asterisk, for example: `splat_prefix: '**'`. Now structural directives should work as expected. Remember that now splat attributes should be written with new custom prefix before them.
+* Use alternative directive syntax without asterisk.
+
+#### Attribute delimeters
+
+Angular and slim both uses brackets in their syntax. So there are also two ways:
+* Use alternative syntax for binding (`bind-...` and so on)
+* Limit attribute delimeters to curly braces only:
+```
+code_attr_delims: {
+ '{' => '}',
+},
+attr_list_delims: {
+ '{' => '}',
+},
+```
+
+Now you can use something like this:
+```
+h1{ #var (bind1)="test" [bind2]="ok" [(bind3)]="works?" *ngIf="expr" *ngFor="expression" } {{it works}}
+```
+
+Will be compiled to:
+```
+<h1 #var="" (bind1)="test" [bind2]="ok" [(bind3)]="works?" *ngIf="expr" *ngFor="expression">
+  {{it works}}
+</h1>
+```
+
 ## Tools
 
 ### Slim Command 'slimrb'
@@ -1062,7 +1120,7 @@ Usage: slimrb [options]
     -e, --erb                        Convert to ERB
         --rails                      Generate rails compatible code (Implies --compile)
     -r, --require library            Load library or plugin with -r slim/plugin
-    -p, --pretty                     Produce pretty html
+    -p, --pretty                     Produce pretty html for debugging purposes
     -o, --option name=code           Set slim option
     -l, --locals Hash|YAML|JSON      Set local variables
     -h, --help                       Show this message
@@ -1140,8 +1198,7 @@ Travis-CI is used for continuous integration testing: <http://travis-ci.org/slim
 
 Slim is working well on all major Ruby implementations:
 
-* Ruby 1.9.3, 2.0.0, 2.1.0 and 2.2.0
-* Ruby EE
+* Ruby 2.0, 2.1, 2.2 and 2.3
 * JRuby 1.9 mode
 * Rubinius 2.0
 
@@ -1155,7 +1212,7 @@ $ git clone git://github.com/slim-template/slim
 
 Work your magic and then submit a pull request. We love pull requests!
 
-Please remember to keep the compatibility with Ruby versions 1.9.3, 2.0.0, 2.1.0  and 2.2.0.
+Please remember to keep the compatibility with Ruby versions 2.0.0, 2.1.0, 2.2.0 and 2.3.0.
 
 If you find the documentation lacking, help us out and update this README.md. If you don't have the time to work on Slim, but found something we should know about, please submit an issue.
 
@@ -1209,6 +1266,7 @@ Static code analysis:
 
 Template Converters (HAML, ERB, ...):
 
+* [ERB 2 Slim](http://erb2slim.com/)
 * [Haml2Slim converter](https://github.com/slim-template/haml2slim)
 * [ERB2Slim, HTML2Slim converter](https://github.com/slim-template/html2slim)
 
@@ -1226,5 +1284,7 @@ Language ports/Similar languages:
 * [Faml (Faster Haml implementation, also using Temple like Slim)](https://github.com/eagletmt/faml)
 * [Haml (Older engine which inspired Slim)](https://github.com/haml/haml)
 * [Jade (Similar engine for javascript)](https://github.com/visionmedia/jade)
+* [Pug (Successor of Jade, Similar engine for javascript)](https://github.com/pugjs/pug)
 * [Sweet (Similar engine which also allows to write classes and functions)](https://github.com/joaomdmoura/sweet)
 * [Amber (Similar engine for Go)](https://github.com/eknkc/amber)
+* [Slang (Slim-inspired templating language for Crystal)](https://github.com/jeromegn/slang)

data/bundle/ruby/2.5.0/gems/{slim-3.0.7 → slim-4.0.1}/lib/slim/embedded.rb

@@ -96,11 +96,11 @@ module Slim
       @disabled = normalize_engine_list(options[:disable_engines])
     end
 
-    def on_slim_embedded(name, body)
+    def on_slim_embedded(name, body, attrs)
       name = name.to_sym
       raise(Temple::FilterError, "Embedded engine #{name} is disabled") unless enabled?(name)
       @engines[name] ||= self.class.create(name, options)
-      @engines[name].on_slim_embedded(name, body)
+      @engines[name].on_slim_embedded(name, body, attrs)
     end
 
     def enabled?(name)
@@ -131,9 +131,10 @@ module Slim
 
     # Basic tilt engine
     class TiltEngine < Engine
-      def on_slim_embedded(engine, body)
+      def on_slim_embedded(engine, body, attrs)
         tilt_engine = Tilt[engine] || raise(Temple::FilterError, "Tilt engine #{engine} is not available.")
         tilt_options = options[engine.to_sym] || {}
+        tilt_options[:default_encoding] ||= 'utf-8'
         [:multi, tilt_render(tilt_engine, tilt_options, collect_text(body)), collect_newlines(body)]
       end
 
@@ -159,16 +160,6 @@ module Slim
       end
     end
 
-    # Tilt-based engine which is precompiled
-    class PrecompiledTiltEngine < TiltEngine
-      protected
-
-      def tilt_render(tilt_engine, tilt_options, text)
-        # HACK: Tilt::Engine#precompiled is protected
-        [:dynamic, tilt_engine.new(tilt_options) { text }.send(:precompiled, {}).first]
-      end
-    end
-
     # Static template with interpolated ruby code
     class InterpolateTiltEngine < TiltEngine
       def collect_text(body)
@@ -190,35 +181,31 @@ module Slim
       end
     end
 
-    # ERB engine (uses the Temple ERB implementation)
-    class ERBEngine < Engine
-      def on_slim_embedded(engine, body)
-        [:multi, [:newline], erb_parser.call(collect_text(body))]
-      end
-
-      protected
-
-      def erb_parser
-        @erb_parser ||= Temple::ERB::Parser.new
-      end
-    end
-
     # Tag wrapper engine
     # Generates a html tag and wraps another engine (specified via :engine option)
     class TagEngine < Engine
       disable_option_validator!
 
-      def on_slim_embedded(engine, body)
+      def on_slim_embedded(engine, body, attrs)
+
+        unless options[:attributes].empty?
+          options[:attributes].map do|k, v|
+            attrs << [:html, :attr, k, [:static, v]]
+          end
+        end
+
         if options[:engine]
           opts = {}.update(options)
           opts.delete(:engine)
           opts.delete(:tag)
           opts.delete(:attributes)
           @engine ||= options[:engine].new(opts)
-          body = @engine.on_slim_embedded(engine, body)
+          body = @engine.on_slim_embedded(engine, body, attrs)
         end
-        [:html, :tag, options[:tag], [:html, :attrs, *options[:attributes].map {|k, v| [:html, :attr, k, [:static, v]] }], body]
+
+        [:html, :tag, options[:tag], attrs, body]
       end
+
     end
 
     # Javascript wrapper engine.
@@ -228,41 +215,29 @@ module Slim
 
       set_options tag: :script, attributes: {}
 
-      def on_slim_embedded(engine, body)
-        super(engine, [:html, :js, body])
+      def on_slim_embedded(engine, body, attrs)
+        super(engine, [:html, :js, body], attrs)
       end
     end
 
     # Embeds ruby code
     class RubyEngine < Engine
-      def on_slim_embedded(engine, body)
-        [:multi, [:newline], [:code, collect_text(body)]]
+      def on_slim_embedded(engine, body, attrs)
+        [:multi, [:newline], [:code, "#{collect_text(body)}\n"]]
       end
     end
 
     # These engines are executed at compile time, embedded ruby is interpolated
-    register :asciidoc,   InterpolateTiltEngine
     register :markdown,   InterpolateTiltEngine
     register :textile,    InterpolateTiltEngine
     register :rdoc,       InterpolateTiltEngine
-    register :creole,     InterpolateTiltEngine
-    register :wiki,       InterpolateTiltEngine
-    register :mediawiki,  InterpolateTiltEngine
-    register :org,        InterpolateTiltEngine
 
     # These engines are executed at compile time
     register :coffee,     JavaScriptEngine, engine: TiltEngine
-    register :opal,       JavaScriptEngine, engine: TiltEngine
     register :less,       TagEngine, tag: :style,  attributes: { type: 'text/css' },         engine: TiltEngine
-    register :styl,       TagEngine, tag: :style,  attributes: { type: 'text/css' },         engine: TiltEngine
     register :sass,       TagEngine, :pretty, tag: :style, attributes: { type: 'text/css' }, engine: SassEngine
     register :scss,       TagEngine, :pretty, tag: :style, attributes: { type: 'text/css' }, engine: SassEngine
 
-    # These engines are precompiled, code is embedded
-    register :erb,        ERBEngine
-    register :nokogiri,   PrecompiledTiltEngine
-    register :builder,    PrecompiledTiltEngine
-
     # Embedded javascript/css
     register :javascript, JavaScriptEngine
     register :css,        TagEngine, tag: :style,  attributes: { type: 'text/css' }

data/bundle/ruby/2.5.0/gems/{slim-3.0.7 → slim-4.0.1}/lib/slim/engine.rb

@@ -13,7 +13,7 @@ module Slim
                    format: :xhtml,
                    attr_quote: '"',
                    merge_attrs: {'class' => ' '},
-                   generator: Temple::Generators::ArrayBuffer,
+                   generator: Temple::Generators::StringBuffer,
                    default_tag: 'div'
 
     filter :Encoding

data/bundle/ruby/2.5.0/gems/{slim-3.0.7 → slim-4.0.1}/lib/slim/filter.rb

@@ -13,8 +13,8 @@ module Slim
     end
 
     # Pass-through handler
-    def on_slim_embedded(type, content)
-      [:slim, :embedded, type, compile(content)]
+    def on_slim_embedded(type, content, attrs)
+      [:slim, :embedded, type, compile(content), attrs]
     end
 
     # Pass-through handler

data/bundle/ruby/2.5.0/gems/slim-4.0.1/lib/slim/grammar.rb

@@ -0,0 +1,23 @@
+module Slim
+  # Slim expression grammar
+  # @api private
+  module Grammar
+    extend Temple::Grammar
+
+    TextTypes << :verbatim | :explicit | :implicit | :inline
+
+    Expression <<
+      [:slim, :control, String, Expression]                 |
+      [:slim, :output, Bool, String, Expression]            |
+      [:slim, :interpolate, String]                         |
+      [:slim, :embedded, String, Expression, HTMLAttrGroup] |
+      [:slim, :text, TextTypes, Expression]                 |
+      [:slim, :attrvalue, Bool, String]
+
+    HTMLAttr <<
+      [:slim, :splat, String]
+
+    HTMLAttrGroup <<
+      [:html, :attrs, 'HTMLAttr*']
+  end
+end

data/bundle/ruby/2.5.0/gems/{slim-3.0.7 → slim-4.0.1}/lib/slim/logic_less/context.rb

@@ -63,7 +63,7 @@ module Slim
           @lookup.each do |lookup|
             case lookup
             when :method
-              return @dict.send(name, &block) if @dict.respond_to?(name)
+              return @dict.public_send(name, &block) if @dict.respond_to?(name, false)
             when :symbol
               return @dict[name].call(&block) if has_key?(name)
             when :string
@@ -80,7 +80,7 @@ module Slim
           @lookup.each do |lookup|
             case lookup
             when :method
-              return @dict.send(name) if @dict.respond_to?(name)
+              return @dict.public_send(name) if @dict.respond_to?(name, false)
             when :symbol
               return @dict[name] if has_key?(name)
             when :string

data/bundle/ruby/2.5.0/gems/{slim-3.0.7 → slim-4.0.1}/lib/slim/parser.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 module Slim
   # Parses Slim code and transforms it to a Temple expression
   # @api private
@@ -19,7 +18,8 @@ module Slim
                    shortcut: {
                      '#' => { attr: 'id' },
                      '.' => { attr: 'class' }
-                   }
+                   },
+                   splat_prefix: '*'
 
     class SyntaxError < StandardError
       attr_reader :error, :file, :line, :lineno, :column
@@ -77,17 +77,21 @@ module Slim
       @code_attr_delims_re = /\A[#{keys}]/
       keys = Regexp.escape @attr_list_delims.keys.join
       @attr_list_delims_re = /\A\s*([#{keys}])/
-      @embedded_re = /\A(#{Regexp.union(Embedded.engines.keys.map(&:to_s))}):(\s*)/
+      @embedded_re = /\A(#{Regexp.union(Embedded.engines.keys.map(&:to_s))})(?:\s*(?:(.*)))?:(\s*)/
       keys = Regexp.escape ('"\'></='.split(//) + @attr_list_delims.flatten + @code_attr_delims.flatten).uniq.join
       @attr_name = "\\A\\s*([^\0\s#{keys}]+)"
       @quoted_attr_re = /#{@attr_name}\s*=(=?)\s*("|')/
       @code_attr_re = /#{@attr_name}\s*=(=?)\s*/
+
+      splat_prefix = Regexp.escape(options[:splat_prefix])
+      splat_regexp_source = '\A\s*' << splat_prefix << '(?=[^\s]+)'
+      @splat_attrs_regexp = Regexp.new(splat_regexp_source)
     end
 
     # Compile string to Temple expression
     #
     # @param [String] str Slim code
-    # @return [Array] Temple expression representing the code]]
+    # @return [Array] Temple expression representing the code
     def call(str)
       result = [:multi]
       reset(str.split(/\r?\n/), [result])
@@ -180,7 +184,7 @@ module Slim
           @stacks.pop
         end
 
-        # This line's indentation happens lie "between" two other line's
+        # This line's indentation happens to lie "between" two other line's
         # indentation:
         #
         #   hello
@@ -238,7 +242,9 @@ module Slim
         @stacks << block
       when @embedded_re
         # Embedded template detected. It is treated as block.
-        @stacks.last << [:slim, :embedded, $1, parse_text_block($', @orig_line.size - $'.size + $2.size)]
+        @line = $2
+        attrs = parse_attributes
+        @stacks.last << [:slim, :embedded, $1, parse_text_block($', @orig_line.size - $'.size + $2.size), attrs]
       when /\Adoctype\b/
         # Found doctype declaration
         @stacks.last << [:html, :doctype, $'.strip]
@@ -362,7 +368,11 @@ module Slim
         # Block expansion
         @line = $'
         if @line =~ @embedded_re
-          tag << [:slim, :embedded, $1, parse_text_block($', @orig_line.size - @line.size + $2.size)]
+
+          # Parse attributes
+          @line = $2
+          attrs = parse_attributes
+          tag << [:slim, :embedded, $1, parse_text_block($', @orig_line.size - $'.size + $2.size), attrs]
         else
           (@line =~ @tag_re) || syntax_error!('Expected tag')
           @line = $' if $1
@@ -401,7 +411,7 @@ module Slim
       end
     end
 
-    def parse_attributes(attributes)
+    def parse_attributes(attributes = [:html, :attrs])
       # Check to see if there is a delimiter right after the tag name
       delimiter = nil
       if @line =~ @attr_list_delims_re
@@ -416,7 +426,7 @@ module Slim
 
       while true
         case @line
-        when /\A\s*\*(?=[^\s]+)/
+        when @splat_attrs_regexp
           # Splat attribute
           @line = $'
           attributes << [:slim, :splat, parse_ruby_code(delimiter)]
@@ -457,6 +467,7 @@ module Slim
           end
         end
       end
+      attributes || [:html, :attrs]
     end
 
     def parse_ruby_code(outer_delimiter)
@@ -523,7 +534,7 @@ module Slim
       line = @orig_line.lstrip
       column = (@orig_line && @line ? @orig_line.size - @line.size : 0) + line.size - @orig_line.size
       warn %{Deprecated syntax: #{message}
-  #{options[:file]}, Line #{@lineno}, Column #{@column}
+  #{options[:file]}, Line #{@lineno}, Column #{column + 1}
     #{line}
     #{' ' * column}^
 }