The list is empty.
<% end %> hamlit-2.7.5/benchmark/slim/view.haml 0000664 0000000 0000000 00000000507 13000345661 0017516 0 ustar 00root root 0000000 0000000 !!! html %html %head %title Simple Benchmark %body %h1= header - unless item.empty? %ul - for i in item - if i[:current] %li %strong= i[:name] - else %li %a{:href => i[:url]}= i[:name] - else %p The list is empty. hamlit-2.7.5/benchmark/slim/view.slim 0000664 0000000 0000000 00000000475 13000345661 0017545 0 ustar 00root root 0000000 0000000 doctype html html head title Simple Benchmark body h1 = header - unless item.empty? ul - for i in item - if i[:current] li strong = i[:name] - else li a href=i[:url] = i[:name] - else p The list is empty. hamlit-2.7.5/benchmark/utils/ 0000775 0000000 0000000 00000000000 13000345661 0016073 5 ustar 00root root 0000000 0000000 hamlit-2.7.5/benchmark/utils/benchmark_ips_extension.rb 0000664 0000000 0000000 00000002200 13000345661 0023313 0 ustar 00root root 0000000 0000000 # Monkey patch to show milliseconds module Benchmark module IPS class Report module EntryExtension def body return super if Benchmark::IPS.options[:format] != :human left = "%s i/s (%1.3fms)" % [Helpers.scale(ips), (1000.0 / ips)] iters = Helpers.scale(@iterations) if @show_total_time left.ljust(20) + (" - %s in %10.6fs" % [iters, runtime]) else left.ljust(20) + (" - %s" % iters) end end end Entry.prepend(EntryExtension) end end module CompareExtension def compare(*reports) return if reports.size < 2 sorted = reports.sort_by(&:ips).reverse best = sorted.shift $stdout.puts "\nComparison:" $stdout.printf "%20s: %10.1f i/s (%1.3fms)\n", best.label, best.ips, (1000.0 / best.ips) sorted.each do |report| name = report.label.to_s x = (best.ips.to_f / report.ips.to_f) $stdout.printf "%20s: %10.1f i/s (%1.3fms) - %.2fx slower\n", name, report.ips, (1000.0 / report.ips), x end $stdout.puts end end extend CompareExtension end hamlit-2.7.5/bin/ 0000775 0000000 0000000 00000000000 13000345661 0013551 5 ustar 00root root 0000000 0000000 hamlit-2.7.5/bin/bench 0000775 0000000 0000000 00000004701 13000345661 0014560 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby require 'bundler/setup' require 'hamlit' require 'faml' require 'thor' require 'benchmark/ips' require_relative '../benchmark/utils/benchmark_ips_extension' class Bench < Thor class_option :show_template, type: :boolean, aliases: ['-t'] desc 'bench HAML', 'Benchmark haml template' option :compile, type: :boolean, aliases: ['-c'] option :show_code, type: :boolean, aliases: ['-s'] def bench(*files) files.each { |file| render(file) } files.each { |file| compile(file) if options[:compile] } files.each { |file| code(file) if options[:show_code] } end desc 'compile HAML', 'Benchmark compilation' def compile(file) puts "#{?= * 49}\n Compilation: #{file}\n#{?= * 49}" haml = File.read(file) Benchmark.ips do |x| x.report("haml v#{Haml::VERSION}") { Haml::Engine.new(haml, escape_html: true, escape_attrs: true, ugly: true).precompiled } x.report("faml v#{Faml::VERSION}") { Faml::Engine.new.call(haml) } x.report("hamlit v#{Hamlit::VERSION}") { Hamlit::Engine.new.call(haml) } x.compare! end end desc 'render HAML', 'Benchmark rendering' def render(file) puts "#{?= * 49}\n Rendering: #{file}\n#{?= * 49}" haml = File.read(file) puts haml + "\n" if options[:show_template] object = Object.new ruby_file = file.gsub(/\.haml\z/, '.rb') if File.exist?(ruby_file) object.instance_eval(File.read(ruby_file)) end Haml::Engine.new(haml, escape_html: true, escape_attrs: true, ugly: true).def_method(object, :haml) object.instance_eval "def faml; #{Faml::Engine.new.call(haml)}; end" object.instance_eval "def hamlit; #{Hamlit::Engine.new.call(haml)}; end" Benchmark.ips do |x| x.report("haml v#{Haml::VERSION}") { object.haml } x.report("faml v#{Faml::VERSION}") { object.faml } x.report("hamlit v#{Hamlit::VERSION}") { object.hamlit } x.compare! end end desc 'code HAML', 'Show compiled code' def code(file) haml = File.read(file) puts "#{?= * 49}\n Haml Source: #{file}\n#{?= * 49}" puts Haml::Engine.new(haml, escape_html: true, escape_attrs: true, ugly: true).precompiled puts "\n#{?= * 49}\n Faml Source: #{file}\n#{?= * 49}" puts Faml::Engine.new.call(haml) puts "\n#{?= * 49}\n Hamlit Source: #{file}\n#{?= * 49}" puts Hamlit::Engine.new.call(haml) end private def method_missing(*args) return super if args.length > 1 render(args.first.to_s) end end Bench.start hamlit-2.7.5/bin/console 0000775 0000000 0000000 00000000456 13000345661 0015146 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby require 'bundler/setup' require 'hamlit' # You can add fixtures and/or initialization code here to make experimenting # with your gem easier. You can also use a different console, if you like. # (If you use this, don't forget to add pry to your Gemfile!) require 'pry' Pry.start hamlit-2.7.5/bin/lineprof 0000775 0000000 0000000 00000001574 13000345661 0015324 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby require 'bundler/setup' require 'hamlit' require 'lineprof' require 'tempfile' require 'thor' class CLI < Thor desc 'render HAML', 'Benchmark render' def render(file) haml = File.read(file) compiled = Hamlit::Engine.new.call(haml) code = [ 'require "lineprof"', 'require "hamlit"', 'Lineprof.profile(/./) do', '100.times do', compiled, 'end', 'end', ].join("\n") file = Tempfile.create('compiled') file.write(code) file.close system("bundle exec ruby #{file.path}") end desc 'compile HAML', 'Benchmark compile' def compile(file) haml = File.read(file) Lineprof.profile(/./) do 100.times { Hamlit::Engine.new.call(haml) } end end private def method_missing(*args) return super if args.length > 1 render(args.first.to_s) end end CLI.start hamlit-2.7.5/bin/ruby 0000775 0000000 0000000 00000000072 13000345661 0014457 0 ustar 00root root 0000000 0000000 #!/bin/bash bundle exec ruby -Ilib:test -rtest_helper $@ hamlit-2.7.5/bin/setup 0000775 0000000 0000000 00000000163 13000345661 0014637 0 ustar 00root root 0000000 0000000 #!/bin/bash set -euo pipefail IFS=$'\n\t' bundle install # Do any other automated setup that you need to do here hamlit-2.7.5/bin/stackprof 0000775 0000000 0000000 00000001301 13000345661 0015466 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby require 'bundler/setup' require 'hamlit' require 'stackprof' def open_flamegraph(report) temp = `mktemp /tmp/stackflame-XXXXXXXX`.strip data_path = "#{temp}.js" system("mv #{temp} #{data_path}") File.open(data_path, 'w') do |f| report.print_flamegraph(f) end viewer_path = File.join(`bundle show stackprof`.strip, 'lib/stackprof/flamegraph/viewer.html') url = "file://#{viewer_path}?data=#{data_path}" system(%Q[osascript -e 'open location "#{url}"']) end haml = File.read(ARGV.first) StackProf.start(mode: :wall, interval: 1, raw: false) Hamlit::Engine.new.call(haml) StackProf.stop report = StackProf::Report.new(StackProf.results) report.print_text(false) hamlit-2.7.5/bin/test 0000775 0000000 0000000 00000000505 13000345661 0014456 0 ustar 00root root 0000000 0000000 #!/bin/bash VERSIONS=( 2.1.10 2.2.5 2.3.1 ) set -e trap 'echo "${VERSIONS[2]}" > .ruby-version' 0 function test_with() { version=$1 rbenv local $version if ! bundle check > /dev/null; then bundle install fi ruby -v bundle exec rake test } for version in ${VERSIONS[@]}; do test_with $version done hamlit-2.7.5/exe/ 0000775 0000000 0000000 00000000000 13000345661 0013562 5 ustar 00root root 0000000 0000000 hamlit-2.7.5/exe/hamlit 0000775 0000000 0000000 00000000166 13000345661 0014771 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby $:.unshift File.expand_path('../../lib', __FILE__) require 'hamlit/cli' Hamlit::CLI.start(ARGV) hamlit-2.7.5/ext/ 0000775 0000000 0000000 00000000000 13000345661 0013601 5 ustar 00root root 0000000 0000000 hamlit-2.7.5/ext/hamlit/ 0000775 0000000 0000000 00000000000 13000345661 0015057 5 ustar 00root root 0000000 0000000 hamlit-2.7.5/ext/hamlit/extconf.rb 0000664 0000000 0000000 00000000164 13000345661 0017053 0 ustar 00root root 0000000 0000000 require 'mkmf' $CFLAGS << ' -Wall -Wextra' $srcs = %w[ hamlit.c hescape.c ] create_makefile('hamlit/hamlit') hamlit-2.7.5/ext/hamlit/hamlit.c 0000664 0000000 0000000 00000031412 13000345661 0016502 0 ustar 00root root 0000000 0000000 #includeAll the stuff
#A book about all the stuff.
#bar
# baz # # @param i [Fixnum] The number of tabs by which to increase the indentation # @see #tab_down def tab_up(i = 1) haml_buffer.tabulation += i end # Decrements the number of tabs the buffer automatically adds # to the lines of the template. # # @param i [Fixnum] The number of tabs by which to decrease the indentation # @see #tab_up def tab_down(i = 1) haml_buffer.tabulation -= i end # Sets the number of tabs the buffer automatically adds # to the lines of the template, # but only for the duration of the block. # For example: # # %h1 foo # - with_tabs(2) do # %p bar # %strong baz # # Produces: # #bar
# baz # # # @param i [Fixnum] The number of tabs to use # @yield A block in which the indentation will be `i` spaces def with_tabs(i) old_tabs = haml_buffer.tabulation haml_buffer.tabulation = i yield ensure haml_buffer.tabulation = old_tabs end # Surrounds a block of Haml code with strings, # with no whitespace in between. # For example: # # = surround '(', ')' do # %a{:href => "food"} chicken # # Produces: # # (chicken) # # and # # = surround '*' do # %strong angry # # Produces: # # *angry* # # @param front [String] The string to add before the Haml # @param back [String] The string to add after the Haml # @yield A block of Haml to surround def surround(front, back = front, &block) output = capture_haml(&block) "#{front}#{output.chomp}#{back}\n" end # Prepends a string to the beginning of a Haml block, # with no whitespace between. # For example: # # = precede '*' do # %span.small Not really # # Produces: # # *Not really # # @param str [String] The string to add before the Haml # @yield A block of Haml to prepend to def precede(str, &block) "#{str}#{capture_haml(&block).chomp}\n" end # Appends a string to the end of a Haml block, # with no whitespace between. # For example: # # click # = succeed '.' do # %a{:href=>"thing"} here # # Produces: # # click # here. # # @param str [String] The string to add after the Haml # @yield A block of Haml to append to def succeed(str, &block) "#{capture_haml(&block).chomp}#{str}\n" end # Captures the result of a block of Haml code, # gets rid of the excess indentation, # and returns it as a string. # For example, after the following, # # .foo # - foo = capture_haml(13) do |a| # %p= a # # the local variable `foo` would be assigned to `"13
\n"`. # # @param args [Array] Arguments to pass into the block # @yield [args] A block of Haml code that will be converted to a string # @yieldparam args [Array] `args` def capture_haml(*args, &block) buffer = eval('if defined? _hamlout then _hamlout else nil end', block.binding) || haml_buffer with_haml_buffer(buffer) do position = haml_buffer.buffer.length haml_buffer.capture_position = position value = block.call(*args) captured = haml_buffer.buffer.slice!(position..-1) if captured == '' and value != haml_buffer.buffer captured = (value.is_a?(String) ? value : nil) end return nil if captured.nil? return (haml_buffer.options[:ugly] ? captured : prettify(captured)) end ensure haml_buffer.capture_position = nil end # Outputs text directly to the Haml buffer, with the proper indentation. # # @param text [#to_s] The text to output def haml_concat(text = "") haml_internal_concat text ErrorReturn.new("haml_concat") end # Internal method to write directly to the buffer with control of # whether the first line should be indented, and if there should be a # final newline. # # Lines added will have the proper indentation. This can be controlled # for the first line. # # Used by #haml_concat and #haml_tag. # # @param text [#to_s] The text to output # @param newline [Boolean] Whether to add a newline after the text # @param indent [Boolean] Whether to add indentation to the first line def haml_internal_concat(text = "", newline = true, indent = true) if haml_buffer.options[:ugly] || haml_buffer.tabulation == 0 haml_buffer.buffer << "#{text}#{"\n" if newline}" else haml_buffer.buffer << %[#{haml_indent if indent}#{text.to_s.gsub("\n", "\n#{haml_indent}")}#{"\n" if newline}] end end private :haml_internal_concat # Allows writing raw content. `haml_internal_concat_raw` isn't # effected by XSS mods. Used by #haml_tag to write the actual tags. alias :haml_internal_concat_raw :haml_internal_concat # @return [String] The indentation string for the current line def haml_indent ' ' * haml_buffer.tabulation end # Creates an HTML tag with the given name and optionally text and attributes. # Can take a block that will run between the opening and closing tags. # If the block is a Haml block or outputs text using \{#haml\_concat}, # the text will be properly indented. # # `name` can be a string using the standard Haml class/id shorthand # (e.g. "span#foo.bar", "#foo"). # Just like standard Haml tags, these class and id values # will be merged with manually-specified attributes. # # `flags` is a list of symbol flags # like those that can be put at the end of a Haml tag # (`:/`, `:<`, and `:>`). # Currently, only `:/` and `:<` are supported. # # `haml_tag` outputs directly to the buffer; # its return value should not be used. # If you need to get the results as a string, # use \{#capture\_haml\}. # # For example, # # haml_tag :table do # haml_tag :tr do # haml_tag 'td.cell' do # haml_tag :strong, "strong!" # haml_concat "data" # end # haml_tag :td do # haml_concat "more_data" # end # end # end # # outputs # #| # # strong! # # data # | ## more_data # | #
# A (possibly) important paragraph. #
## A (possibly) important paragraph. #
# # otherwise. # # Like \{#haml_tag}, `haml_tag_if` outputs directly to the buffer and its # return value should not be used. Use \{#capture_haml} if you need to use # its results as a string. # # @param condition The condition to test to determine whether to render # the enclosing tag # @param tag Definition of the enclosing tag. See \{#haml_tag} for details # (specifically the form that takes a block) def haml_tag_if(condition, *tag) if condition haml_tag(*tag){ yield } else yield end ErrorReturn.new("haml_tag_if") end # Characters that need to be escaped to HTML entities from user input HTML_ESCAPE = { '&' => '&', '<' => '<', '>' => '>', '"' => '"', "'" => ''' } HTML_ESCAPE_REGEX = /[\"><&]/ # Returns a copy of `text` with ampersands, angle brackets and quotes # escaped into HTML entities. # # Note that if ActionView is loaded and XSS protection is enabled # (as is the default for Rails 3.0+, and optional for version 2.3.5+), # this won't escape text declared as "safe". # # @param text [String] The string to sanitize # @return [String] The sanitized string def html_escape(text) text = text.to_s text.gsub(HTML_ESCAPE_REGEX, HTML_ESCAPE) end HTML_ESCAPE_ONCE_REGEX = /[\"><]|&(?!(?:[a-zA-Z]+|#(?:\d+|[xX][0-9a-fA-F]+));)/ # Escapes HTML entities in `text`, but without escaping an ampersand # that is already part of an escaped entity. # # @param text [String] The string to sanitize # @return [String] The sanitized string def escape_once(text) text = text.to_s text.gsub(HTML_ESCAPE_ONCE_REGEX, HTML_ESCAPE) end # Returns whether or not the current template is a Haml template. # # This function, unlike other {Haml::Helpers} functions, # also works in other `ActionView` templates, # where it will always return false. # # @return [Boolean] Whether or not the current template is a Haml template def is_haml? !@haml_buffer.nil? && @haml_buffer.active? end # Returns whether or not `block` is defined directly in a Haml template. # # @param block [Proc] A Ruby block # @return [Boolean] Whether or not `block` is defined directly in a Haml template def block_is_haml?(block) eval('!!defined?(_hamlout)', block.binding) end private # Parses the tag name used for \{#haml\_tag} # and merges it with the Ruby attributes hash. def merge_name_and_attributes(name, attributes_hash = {}) # skip merging if no ids or classes found in name return name, attributes_hash unless name =~ /^(.+?)?([\.#].*)$/ return $1 || "div", ::Hamlit::HamlBuffer.merge_attrs( ::Hamlit::HamlParser.parse_class_and_id($2), attributes_hash) end # Runs a block of code with the given buffer as the currently active buffer. # # @param buffer [Haml::Buffer] The Haml buffer to use temporarily # @yield A block in which the given buffer should be used def with_haml_buffer(buffer) @haml_buffer, old_buffer = buffer, @haml_buffer old_buffer.active, old_was_active = false, old_buffer.active? if old_buffer @haml_buffer.active, was_active = true, @haml_buffer.active? yield ensure @haml_buffer.active = was_active old_buffer.active = old_was_active if old_buffer @haml_buffer = old_buffer end # The current {Haml::Buffer} object. # # @return [Haml::Buffer] def haml_buffer @haml_buffer if defined? @haml_buffer end # Gives a proc the same local `_hamlout` and `_erbout` variables # that the current template has. # # @param proc [#call] The proc to bind # @return [Proc] A new proc with the new variables bound def haml_bind_proc(&proc) _hamlout = haml_buffer #double assignment is to avoid warnings _erbout = _erbout = _hamlout.buffer proc { |*args| proc.call(*args) } end def prettify(text) text = text.split(/^/) text.delete('') min_tabs = nil text.each do |line| tabs = line.index(/[^ ]/) || line.length min_tabs ||= tabs min_tabs = min_tabs > tabs ? tabs : min_tabs end text.each_with_object('') do |line, str| str << line.slice(min_tabs, line.length) end end end end # @private class Object # Haml overrides various `ActionView` helpers, # which call an \{#is\_haml?} method # to determine whether or not the current context object # is a proper Haml context. # Because `ActionView` helpers may be included in non-`ActionView::Base` classes, # it's a good idea to define \{#is\_haml?} for all objects. def is_haml? false end end hamlit-2.7.5/lib/hamlit/parser/haml_options.rb 0000664 0000000 0000000 00000024355 13000345661 0021353 0 ustar 00root root 0000000 0000000 require 'hamlit/parser/haml_parser' require 'hamlit/parser/haml_compiler' require 'hamlit/parser/haml_error' module Hamlit # This class encapsulates all of the configuration options that Haml # understands. Please see the {file:REFERENCE.md#options Haml Reference} to # learn how to set the options. class HamlOptions @defaults = { :attr_wrapper => "'", :autoclose => %w(area base basefont br col command embed frame hr img input isindex keygen link menuitem meta param source track wbr), :encoding => "UTF-8", :escape_attrs => true, :escape_html => false, :filename => '(haml)', :format => :html5, :hyphenate_data_attrs => true, :line => 1, :mime_type => 'text/html', :preserve => %w(textarea pre code), :remove_whitespace => false, :suppress_eval => false, :ugly => false, :cdata => false, :parser_class => ::Hamlit::HamlParser, :compiler_class => ::Hamlit::HamlCompiler, :trace => false } @valid_formats = [:html4, :html5, :xhtml] @buffer_option_keys = [:autoclose, :preserve, :attr_wrapper, :ugly, :format, :encoding, :escape_html, :escape_attrs, :hyphenate_data_attrs, :cdata] # The default option values. # @return Hash def self.defaults @defaults end # An array of valid values for the `:format` option. # @return Array def self.valid_formats @valid_formats end # An array of keys that will be used to provide a hash of options to # {Haml::Buffer}. # @return Hash def self.buffer_option_keys @buffer_option_keys end # The character that should wrap element attributes. This defaults to `'` # (an apostrophe). Characters of this type within the attributes will be # escaped (e.g. by replacing them with `'`) if the character is an # apostrophe or a quotation mark. attr_reader :attr_wrapper # A list of tag names that should be automatically self-closed if they have # no content. This can also contain regular expressions that match tag names # (or any object which responds to `#===`). Defaults to `['meta', 'img', # 'link', 'br', 'hr', 'input', 'area', 'param', 'col', 'base']`. attr_accessor :autoclose # The encoding to use for the HTML output. # This can be a string or an `Encoding` Object. Note that Haml **does not** # automatically re-encode Ruby values; any strings coming from outside the # application should be converted before being passed into the Haml # template. Defaults to `Encoding.default_internal`; if that's not set, # defaults to the encoding of the Haml template; if that's `US-ASCII`, # defaults to `"UTF-8"`. attr_reader :encoding # Sets whether or not to escape HTML-sensitive characters in attributes. If # this is true, all HTML-sensitive characters in attributes are escaped. If # it's set to false, no HTML-sensitive characters in attributes are escaped. # If it's set to `:once`, existing HTML escape sequences are preserved, but # other HTML-sensitive characters are escaped. # # Defaults to `true`. attr_accessor :escape_attrs # Sets whether or not to escape HTML-sensitive characters in script. If this # is true, `=` behaves like {file:REFERENCE.md#escaping_html `&=`}; # otherwise, it behaves like {file:REFERENCE.md#unescaping_html `!=`}. Note # that if this is set, `!=` should be used for yielding to subtemplates and # rendering partials. See also {file:REFERENCE.md#escaping_html Escaping HTML} and # {file:REFERENCE.md#unescaping_html Unescaping HTML}. # # Defaults to false. attr_accessor :escape_html # The name of the Haml file being parsed. # This is only used as information when exceptions are raised. This is # automatically assigned when working through ActionView, so it's really # only useful for the user to assign when dealing with Haml programatically. attr_accessor :filename # If set to `true`, Haml will convert underscores to hyphens in all # {file:REFERENCE.md#html5_custom_data_attributes Custom Data Attributes} As # of Haml 4.0, this defaults to `true`. attr_accessor :hyphenate_data_attrs # The line offset of the Haml template being parsed. This is useful for # inline templates, similar to the last argument to `Kernel#eval`. attr_accessor :line # Determines the output format. The default is `:html5`. The other options # are `:html4` and `:xhtml`. If the output is set to XHTML, then Haml # automatically generates self-closing tags and wraps the output of the # Javascript and CSS-like filters inside CDATA. When the output is set to # `:html5` or `:html4`, XML prologs are ignored. In all cases, an appropriate # doctype is generated from `!!!`. # # If the mime_type of the template being rendered is `text/xml` then a # format of `:xhtml` will be used even if the global output format is set to # `:html4` or `:html5`. attr :format # The mime type that the rendered document will be served with. If this is # set to `text/xml` then the format will be overridden to `:xhtml` even if # it has set to `:html4` or `:html5`. attr_accessor :mime_type # A list of tag names that should automatically have their newlines # preserved using the {Haml::Helpers#preserve} helper. This means that any # content given on the same line as the tag will be preserved. For example, # `%textarea= "Foo\nBar"` compiles to ``. # Defaults to `['textarea', 'pre']`. See also # {file:REFERENCE.md#whitespace_preservation Whitespace Preservation}. attr_accessor :preserve # If set to `true`, all tags are treated as if both # {file:REFERENCE.md#whitespace_removal__and_ whitespace removal} options # were present. Use with caution as this may cause whitespace-related # formatting errors. # # Defaults to `false`. attr_reader :remove_whitespace # Whether or not attribute hashes and Ruby scripts designated by `=` or `~` # should be evaluated. If this is `true`, said scripts are rendered as empty # strings. # # Defaults to `false`. attr_accessor :suppress_eval # If set to `true`, Haml makes no attempt to properly indent or format the # HTML output. This significantly improves rendering performance but makes # viewing the source unpleasant. # # Defaults to `true` in Rails production mode, and `false` everywhere else. attr_accessor :ugly # Whether to include CDATA sections around javascript and css blocks when # using the `:javascript` or `:css` filters. # # This option also affects the `:sass`, `:scss`, `:less` and `:coffeescript` # filters. # # Defaults to `false` for html, `true` for xhtml. Cannot be changed when using # xhtml. attr_accessor :cdata # The parser class to use. Defaults to Haml::Parser. attr_accessor :parser_class # The compiler class to use. Defaults to Haml::Compiler. attr_accessor :compiler_class # Enable template tracing. If true, it will add a 'data-trace' attribute to # each tag generated by Haml. The value of the attribute will be the # source template name and the line number from which the tag was generated, # separated by a colon. On Rails applications, the path given will be a # relative path as from the views directory. On non-Rails applications, # the path will be the full path. attr_accessor :trace def initialize(values = {}, &block) defaults.each {|k, v| instance_variable_set :"@#{k}", v} values.each {|k, v| send("#{k}=", v) if defaults.has_key?(k) && !v.nil?} yield if block_given? end # Retrieve an option value. # @param key The value to retrieve. def [](key) send key end # Set an option value. # @param key The key to set. # @param value The value to set for the key. def []=(key, value) send "#{key}=", value end [:escape_attrs, :hyphenate_data_attrs, :remove_whitespace, :suppress_eval, :ugly].each do |method| class_eval(<<-END) def #{method}? !! @#{method} end END end # @return [Boolean] Whether or not the format is XHTML. def xhtml? not html? end # @return [Boolean] Whether or not the format is any flavor of HTML. def html? html4? or html5? end # @return [Boolean] Whether or not the format is HTML4. def html4? format == :html4 end # @return [Boolean] Whether or not the format is HTML5. def html5? format == :html5 end def attr_wrapper=(value) @attr_wrapper = value || self.class.defaults[:attr_wrapper] end # Undef :format to suppress warning. It's defined above with the `:attr` # macro in order to make it appear in Yard's list of instance attributes. undef :format def format mime_type == "text/xml" ? :xhtml : @format end def format=(value) unless self.class.valid_formats.include?(value) raise ::Hamlit::HamlError, "Invalid output format #{value.inspect}" end @format = value end undef :cdata def cdata xhtml? || @cdata end def remove_whitespace=(value) @ugly = true if value @remove_whitespace = value end def encoding=(value) return unless value @encoding = value.is_a?(Encoding) ? value.name : value.to_s @encoding = "UTF-8" if @encoding.upcase == "US-ASCII" end # Returns a subset of options: those that {Haml::Buffer} cares about. # All of the values here are such that when `#inspect` is called on the hash, # it can be `Kernel#eval`ed to get the same result back. # # See {file:REFERENCE.md#options the Haml options documentation}. # # @return [{Symbol => Object}] The options hash def for_buffer self.class.buffer_option_keys.inject({}) do |hash, key| hash[key] = send(key) hash end end private def defaults self.class.defaults end end end hamlit-2.7.5/lib/hamlit/parser/haml_parser.rb 0000664 0000000 0000000 00000065036 13000345661 0021155 0 ustar 00root root 0000000 0000000 require 'strscan' require 'hamlit/parser/haml_util' require 'hamlit/parser/haml_buffer' require 'hamlit/parser/haml_error' module Hamlit class HamlParser include ::Hamlit::HamlUtil attr_reader :root # Designates an XHTML/XML element. ELEMENT = ?% # Designates a `You may have mistyped the address or the page may have moved.
If you are the application owner check the logs for more information.
Maybe you tried to change something you didn't have access to.
If you are the application owner check the logs for more information.
If you are the application owner check the logs for more information.
foo
", render("%p{:class => 1+2} foo").chomp) end def test_class_attr_with_array assert_equal("foo
\n", render("%p{:class => %w[a b]} foo")) # basic assert_equal("foo
\n", render("%p.css{:class => %w[a b]} foo")) # merge with css assert_equal("foo
\n", render("%p.css{:class => %w[css b]} foo")) # merge uniquely assert_equal("foo
\n", render("%p{:class => [%w[a b], %w[c d]]} foo")) # flatten assert_equal("foo
\n", render("%p{:class => [:a, :b] } foo")) # stringify # [INCOMPATIBILITY] Hamlit limits boolean attributes # assert_equal("foo
\n", render("%p{:class => [nil, false] } foo")) # strip falsey assert_equal("foo
\n", render("%p{:class => [nil, false] } foo")) # strip falsey assert_equal("foo
\n", render("%p{:class => :a} foo")) # single stringify # [INCOMPATIBILITY] Hamlit limits boolean attributes # assert_equal("foo
\n", render("%p{:class => false} foo")) # single falsey assert_equal("foo
\n", render("%p{:class => false} foo")) # single falsey assert_equal("foo
\n", render("%p(class='html'){:class => %w[a b]} foo")) # html attrs end def test_id_attr_with_array assert_equal("foo
\n", render("%p{:id => %w[a b]} foo")) # basic assert_equal("foo
\n", render("%p#css{:id => %w[a b]} foo")) # merge with css assert_equal("foo
\n", render("%p{:id => [%w[a b], %w[c d]]} foo")) # flatten assert_equal("foo
\n", render("%p{:id => [:a, :b] } foo")) # stringify # [INCOMPATIBILITY] Hamlit limits boolean attributes # assert_equal("foo
\n", render("%p{:id => [nil, false] } foo")) # strip falsey assert_equal("foo
\n", render("%p{:id => [nil, false] } foo")) # strip falsey assert_equal("foo
\n", render("%p{:id => :a} foo")) # single stringify # [INCOMPATIBILITY] Hamlit limits boolean attributes # assert_equal("foo
\n", render("%p{:id => false} foo")) # single falsey assert_equal("foo
\n", render("%p{:id => false} foo")) # single falsey assert_equal("foo
\n", render("%p(id='html'){:id => %w[a b]} foo")) # html attrs end def test_colon_in_class_attr assert_equal("\n", render("%p#foo:bar/"))
end
def test_dynamic_attributes_with_no_content
assert_haml_ugly(<
Hello
", render('%p Hello').chomp) end def test_one_liner_with_newline_shouldnt_be_one_line assert_haml_ugly('%p= "foo\nbar"') end def test_multi_render; skip engine = engine("%strong Hi there!") assert_equal("Hi there!\n", engine.render) assert_equal("Hi there!\n", engine.render) assert_equal("Hi there!\n", engine.render) end def test_interpolation assert_haml_ugly('%p Hello #{who}', locals: {who: 'World'}, escape_html: false) assert_haml_ugly("%p\n Hello \#{who}", locals: {who: 'World'}, escape_html: false) assert_haml_ugly('%p Hello #{who}', locals: {who: 'World'}, escape_html: true) assert_haml_ugly("%p\n Hello \#{who}", locals: {who: 'World'}, escape_html: true) end def test_interpolation_with_instance_var; skip # special interpolation scope = Object.new scope.instance_variable_set(:@who, 'World') assert_equal("Hello World
\n", render('%p Hello #@who', scope: scope, escape_html: false)) assert_equal("\n Hello World\n
\n", render("%p\n Hello \#@who", scope: scope, escape_html: false)) assert_equal("Hello World
\n", render('%p Hello #@who', scope: scope, escape_html: true)) assert_equal("\n Hello World\n
\n", render("%p\n Hello \#@who", scope: scope, escape_html: true)) end def test_interpolation_with_global; skip # special interpolation $global_var_for_testing = 'World' assert_equal("Hello World
\n", render('%p Hello #$global_var_for_testing', escape_html: false)) assert_equal("\n Hello World\n
\n", render("%p\n Hello \#$global_var_for_testing", escape_html: false)) assert_equal("Hello World
\n", render('%p Hello #$global_var_for_testing', escape_html: true)) assert_equal("\n Hello World\n
\n", render("%p\n Hello \#$global_var_for_testing", escape_html: true)) ensure $global_var_for_testing = nil end def test_interpolation_in_the_middle_of_a_string assert_equal("\"title 'Title'. \"\n", render("\"title '\#{\"Title\"}'. \"")) end def test_interpolation_with_instance_var_in_the_middle_of_a_string; skip # special interpolation scope = Object.new scope.instance_variable_set(:@title, 'Title') assert_equal("\"title 'Title'. \"\n", render("\"title '\#@title'. \"", :scope => scope)) end def test_interpolation_with_global_in_the_middle_of_a_string; skip # special interpolation $global_var_for_testing = 'Title' assert_equal("\"title 'Title'. \"\n", render("\"title '\#$global_var_for_testing'. \"")) ensure $global_var_for_testing = nil end def test_interpolation_at_the_beginning_of_a_line assert_haml_ugly('%p #{1 + 1}') assert_haml_ugly("%p\n \#{1 + 1}") end def test_interpolation_with_instance_var_at_the_beginning_of_a_line; skip # special interpolation scope = Object.new scope.instance_variable_set(:@foo, 2) assert_equal("2
\n", render('%p #@foo', :scope => scope)) assert_equal("\n 2\n
\n", render("%p\n \#@foo", :scope => scope)) end def test_interpolation_with_global_at_the_beginning_of_a_line; skip # special interpolation $global_var_for_testing = 2 assert_equal("2
\n", render('%p #$global_var_for_testing')) assert_equal("\n 2\n
\n", render("%p\n \#$global_var_for_testing")) ensure $global_var_for_testing = nil end def test_escaped_interpolation assert_equal("Foo & Bar & Baz
\n", render('%p& Foo #{"&"} Bar & Baz')) end def test_nil_tag_value_should_render_as_empty assert_equal("\n", render("%p= nil")) end def test_tag_with_failed_if_should_render_as_empty assert_equal("\n", render("%p= 'Hello' if false")) end def test_static_attributes_with_empty_attr assert_equal("
\n", render("%img{:src => '/foo.png', :alt => ''}"))
end
def test_dynamic_attributes_with_empty_attr
# [INCOMPATIBILITY] Hamlit limits boolean attributes
# assert_equal("\n", render("%img{:width => nil, :src => '/foo.png', :alt => String.new}"))
assert_equal("\n", render("%img{:width => nil, :src => '/foo.png', :alt => String.new}"))
end
def test_attribute_hash_with_newlines
assert_haml_ugly("%p{:a => 'b',\n :c => 'd'} foop")
assert_haml_ugly("%p{:a => 'b',\n :c => 'd'}\n foop")
assert_haml_ugly("%p{:a => 'b',\n :c => 'd'}/")
assert_haml_ugly("%p{:a => 'b',\n :c => 'd',\n :e => 'f'}")
end
def test_attr_hashes_not_modified
hash = {:color => 'red'}
assert_haml_ugly(<foo
foo
foo bar
foo bar
foo
HTML %p{:a => 1 + 1} %p{:a => 1 + 1} foo %p{:a => 1 + 1}/ %p{:a => 1 + 1}= "foo" %p{:a => 1 + 1}= "foo\\nbar" %p{:a => 1 + 1}~ "foo\\nbar" %p{:a => 1 + 1} foo HAML end def test_end_of_file_multiline assert_equal("0
\n1
\n2
\n", render("- for i in (0...3)\n %p= |\n i |")) end def test_cr_newline assert_equal("foo
\nbar
\nbaz
\nboom
\n", render("%p foo\r%p bar\r\n%p baz\n\r%p boom")) end def test_textareas; skip # script bug assert_equal("\n", render('%textarea= "Foo\n bar\n baz"')) assert_equal("Foo bar baz\n", render('%pre= "Foo\n bar\n baz"')) assert_equal("\n", render("%textarea #{'a' * 100}")) assert_equal("
\n \n
\n", render(<Foo
bar
baz
HTML
%pre
%code
:preserve
Foo
bar
baz
HAML
end
def test_boolean_attributes
# [INCOMPATIBILITY] Hamlit limits boolean attributes
# assert_equal("\n",
# render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :html4))
# assert_equal("\n",
# render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :xhtml))
#
# assert_equal("\n",
# render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :html4))
# assert_equal("\n",
# render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :xhtml))
assert_equal("\n",
render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :html4))
assert_equal("\n",
render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :xhtml))
assert_equal("\n",
render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :html4))
assert_equal("\n",
render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :xhtml))
end
def test_nuke_inner_whitespace_in_loops
assert_equal(<Foo BarRESULT %p %q><= "Foo\\nBar" SOURCE end def test_nil_option assert_equal("\n", render('%p{:foo => "bar"}', :attr_wrapper => nil)) end def test_comment_with_crazy_nesting assert_equal(<
foo
\n", render('%p<= "\nfoo\n"')) assert_equal(<foo
HTML %p %p<= "\\nfoo\\n" HAML end def test_whitespace_nuke_with_tags_and_else assert_haml_ugly(<Three
HTML - for name in ["One", "Two", "Three"] %p= name unless name == "Two" HAML end def test_end_with_method_call; skip # block script # silent script assert_equal(<&
&
HTML assert_equal(tag_html, render(<bar-end
HTML - ("foo-end-bar-end".gsub(/\\w+-end/) do |s| %p= s - end; nil) HAML end end def test_if_without_content_and_else assert_equal(<foo & bar
\n", render("%p&= 'foo & bar'", :escape_html => false)) end def test_ampersand_equals_should_escape_before_preserve; skip # script bug assert_equal("\n", render('%textarea&= "foo\nbar"', :escape_html => false)) end def test_bang_equals_should_not_escape assert_haml_ugly("%p\n != 'foo & bar'", :escape_html => true) end def test_bang_equals_inline_should_not_escape assert_equal("foo & bar
\n", render("%p!= 'foo & bar'", :escape_html => true)) end def test_static_attributes_should_be_escaped; skip # attribute escape assert_equal("foo
\n", render("%p.atlantis{:style => 'ugly&stupid'}= 'foo'")) assert_equal("\n", render("%p.atlantis{:style => \"ugly\\nstupid\"}")) end def test_dynamic_attributes_should_be_escaped; skip # script bug assert_equal("
\n",
render("%img{:width => nil, :src => '&foo.png', :alt => String.new}"))
assert_equal("foo
\n", render("%p{:width => nil, :src => '&foo.png', :alt => String.new} foo")) assert_equal("4&<
\n", render("%p== \#{2+2}&\#{'<'}", :escape_html => true)) assert_equal("4&<
\n", render("%p== \#{2+2}&\#{'<'}", :escape_html => false)) end def test_escaped_inline_string_double_equals assert_equal("4&<
\n", render("%p&== \#{2+2}&\#{'<'}", :escape_html => true)) assert_equal("4&<
\n", render("%p&== \#{2+2}&\#{'<'}", :escape_html => false)) end def test_unescaped_inline_string_double_equals assert_equal("4&<
\n", render("%p!== \#{2+2}&\#{'<'}", :escape_html => true)) assert_equal("4&<
\n", render("%p!== \#{2+2}&\#{'<'}", :escape_html => false)) end def test_escaped_string_double_equals assert_haml_ugly("%p\n &== \#{2+2}&\#{'<'}", :escape_html => true) assert_haml_ugly("%p\n &== \#{2+2}&\#{'<'}", :escape_html => false) end def test_unescaped_string_double_equals assert_haml_ugly("%p\n !== \#{2+2}&\#{'<'}", :escape_html => true) assert_haml_ugly("%p\n !== \#{2+2}&\#{'<'}", :escape_html => false) end def test_string_interpolation_should_be_esaped assert_equal("4&<
\n", render("%p \#{2+2}&\#{'<'}", :escape_html => true)) assert_equal("4&<
\n", render("%p \#{2+2}&\#{'<'}", :escape_html => false)) end def test_escaped_inline_string_interpolation assert_equal("4&<
\n", render("%p& \#{2+2}&\#{'<'}", :escape_html => true)) assert_equal("4&<
\n", render("%p& \#{2+2}&\#{'<'}", :escape_html => false)) end def test_unescaped_inline_string_interpolation assert_equal("4&<
\n", render("%p! \#{2+2}&\#{'<'}", :escape_html => true)) assert_equal("4&<
\n", render("%p! \#{2+2}&\#{'<'}", :escape_html => false)) end def test_escaped_string_interpolation assert_haml_ugly("%p\n & \#{2+2}&\#{'<'}", :escape_html => true) assert_haml_ugly("%p\n & \#{2+2}&\#{'<'}", :escape_html => false) end def test_escaped_string_interpolation_with_no_space assert_equal("<br>\n", render('&#{"foo & bar
\n", render("%p= 'foo & bar'", :escape_html => true)) assert_equal("foo & bar
\n", render("%p= 'foo & bar'", :escape_html => false)) end def test_script_ending_in_comment_should_render_when_html_is_escaped assert_equal("foo&bar\n", render("= 'foo&bar' #comment", :escape_html => true)) end def test_script_with_if_shouldnt_output assert_equal(<biddly='bar => baz'>
\n", render("%p{'boom=>biddly' => 'bar => baz'}")) assert_equal("\n", render("%p{'foo,bar' => 'baz, qux'}")) assert_equal("\n", render("%p{ :escaped => \"quo\\nte\"}")) assert_equal("\n", render("%p{ :escaped => \"quo\#{2 + 2}te\"}")) end def test_correct_parsing_with_brackets; skip # script bug assert_equal("{tada} foo
\n", render("%p{:class => 'foo'} {tada} foo")) assert_equal("deep {nested { things }}
\n", render("%p{:class => 'foo'} deep {nested { things }}")) assert_equal("\n", render("%p{{:class => 'foo'}, :class => 'bar'} {a { d")) assert_equal("a}
\n", render("%p{:foo => 'bar'} a}")) foo = [] foo[0] = Struct.new('Foo', :id).new assert_equal("New User]
\n", render("%p[foo[0]] New User]", :locals => {:foo => foo})) assert_equal("New User]
\n", render("%p[foo[0], :prefix] New User]", :locals => {:foo => foo})) foo[0].id = 1 assert_equal("New User]
\n", render("%p[foo[0]] New User]", :locals => {:foo => foo})) assert_equal("New User]
\n", render("%p[foo[0], :prefix] New User]", :locals => {:foo => foo})) end def test_empty_attrs assert_haml_ugly("%p{ :attr => '' } empty") assert_haml_ugly("%p{ :attr => x } empty", :locals => {:x => ''}) end def test_nil_attrs skip '[INCOMPATIBILITY] Hamlit limits boolean attributes' assert_equal("nil
\n", render("%p{ :attr => nil } nil")) assert_equal("nil
\n", render("%p{ :attr => x } nil", :locals => {:x => nil})) end def test_nil_id_with_syntactic_id assert_equal("nil
\n", render("%p#foo{:id => nil} nil")) assert_equal("nil
\n", render("%p#foo{{:id => 'bar'}, :id => nil} nil")) assert_equal("nil
\n", render("%p#foo{{:id => nil}, :id => 'bar'} nil")) end def test_nil_class_with_syntactic_class assert_equal("nil
\n", render("%p.foo{:class => nil} nil")) assert_equal("\n", render("%p.bar.foo{:class => nil} nil")) assert_equal("\n", render("%p.foo{{:class => 'bar'}, :class => nil} nil")) assert_equal("\n", render("%p.foo{{:class => nil}, :class => 'bar'} nil")) end def test_locals assert_haml_ugly("%p= text", :locals => { :text => "Paragraph!" }) end def test_dynamic_attrs_shouldnt_register_as_literal_values assert_equal("\n", render('%p{:a => "b#{1 + 1}c"}')) assert_equal("\n", render("%p{:a => 'b' + (1 + 1).to_s + 'c'}")) end def test_dynamic_attrs_with_self_closed_tag assert_equal("\nc\n", render("%a{'b' => 1 + 1}/\n= 'c'\n")) end EXCEPTION_MAP.each do |key, value| define_method("test_exception (#{key.inspect})") do begin silence_warnings do render(key, :filename => "(test_exception (#{key.inspect}))") end rescue Exception => err value = [value] unless value.is_a?(Array) expected_message, line_no = value line_no ||= key.split("\n").length if expected_message == :compile assert_match(/(compile error|syntax error|unterminated string|expecting)/, err.message, "Line: #{key}") else assert_equal(expected_message, err.message, "Line: #{key}") end else assert(false, "Exception not raised for\n#{key}") end end end def test_exception_map skip EXCEPTION_MAP end def test_exception_line; skip # error render("a\nb\n!!!\n c\nd") rescue Haml::SyntaxError => e assert_equal("(test_exception_line):4", e.backtrace[0]) else assert(false, '"a\nb\n!!!\n c\nd" doesn\'t produce an exception') end def test_exception; skip # error render("%p\n hi\n %a= undefined\n= 12") rescue Exception => e skip backtrace = e.backtrace backtrace.shift if rubinius? assert_match("(test_exception):3", backtrace[0]) else # Test failed... should have raised an exception assert(false) end def test_compile_error; skip # error render("a\nb\n- fee)\nc") rescue Exception => e skip assert_match(/\(test_compile_error\):3:/i, e.message) assert_match(/(syntax error|expecting \$end)/i, e.message) else assert(false, '"a\nb\n- fee)\nc" doesn\'t produce an exception!') end def test_unbalanced_brackets; skip # error render('foo #{1 + 5} foo #{6 + 7 bar #{8 + 9}') rescue Hamlit::SyntaxError => e assert_equal(Hamlit::Error.message(:unbalanced_brackets), e.message) end def test_single_line_comments_are_interpolated; skip # comment assert_equal("\n", render('/ Hello #{1 + 1}')) end def test_single_line_comments_are_not_interpolated_with_suppress_eval; skip # comment assert_equal("\n", render('/ Hello #{1 + 1}', :suppress_eval => true)) end def test_single_line_comments_with_interpolation_dont_break_tabulation; skip # comment assert_equal("\nconcatted\n", render("/ Hello \#{1 + 1}\n- haml_concat 'concatted'")) end def test_balanced_conditional_comments assert_equal("\n", render("/[if !(IE 6)|(IE 7)] Bracket: ]")) end def test_downlevel_revealed_conditional_comments; skip assert_equal(" A comment \n", render("/![if !IE] A comment")) end def test_downlevel_revealed_conditional_comments_block; skip assert_equal("\n A comment\n\n", render("/![if !IE]\n A comment")) end def test_local_assigns_dont_modify_class assert_haml_ugly("= foo", :locals => {:foo => 'bar'}) assert_equal(nil, defined?(foo)) end def test_object_ref_with_nil_id; skip # object reference user = User.new assert_equal("New User
\n", render("%p[user] New User", :locals => {:user => user})) end def test_object_ref_before_attrs; skip # object reference user = User.new 42 assert_equal("New User
\n", render("%p[user]{:style => 'width: 100px;'} New User", :locals => {:user => user})) end def test_object_ref_with_custom_haml_class; skip # object reference custom = CustomHamlClass.new 42 assert_equal("My Thing
\n", render("%p[custom]{:style => 'width: 100px;'} My Thing", :locals => {:custom => custom})) end def test_object_ref_with_multiple_ids; skip # object reference cpk_record = CpkRecord.new([42,6,9]) assert_equal("CPK Record
\n", render("%p[cpk_record]{:style => 'width: 100px;'} CPK Record", :locals => {:cpk_record => cpk_record})) end def test_non_literal_attributes assert_haml_ugly("%p{a2, a1, :a3 => 'baz'}", :locals => {:a1 => {:a1 => 'foo'}, :a2 => {:a2 => 'bar'}}) end def test_render_should_accept_a_binding_as_scope; skip string = "This is a string!" string.instance_variable_set(:@var, "Instance variable") b = string.instance_eval do var = "Local variable" # Silence unavoidable warning; Ruby doesn't know we're going to use this # later. nil if var binding end assert_haml_ugly("%p= upcase\n%p= @var\n%p= var", :scope => b) end def test_yield_should_work_with_binding; skip # options assert_equal("12\nFOO\n", render("= yield\n= upcase", :scope => "foo".instance_eval{binding}) { 12 }) end def test_yield_should_work_with_def_method; skip # def_method s = "foo" engine("= yield\n= upcase").def_method(s, :render) assert_equal("12\nFOO\n", s.render { 12 }) end def test_def_method_with_module; skip # def_method engine("= yield\n= upcase").def_method(String, :render_haml) assert_equal("12\nFOO\n", "foo".render_haml { 12 }) end def test_def_method_locals; skip # def_method obj = Object.new engine("%p= foo\n.bar{:baz => baz}= boom").def_method(obj, :render, :foo, :baz, :boom) assert_equal("1
\n\n", obj.render(:foo => 1, :baz => 2, :boom => 3)) end def test_render_proc_locals; skip # render_proc proc = engine("%p= foo\n.bar{:baz => baz}= boom").render_proc(Object.new, :foo, :baz, :boom) assert_equal("1
\n\n", proc[:foo => 1, :baz => 2, :boom => 3]) end def test_render_proc_with_binding; skip # render_proc assert_equal("FOO\n", engine("= upcase").render_proc("foo".instance_eval{binding}).call) end def test_haml_buffer_gets_reset_even_with_exception; skip # haml_buffer scope = Object.new render("- raise Hamlit::Error", :scope => scope) assert(false, "Expected exception") rescue Exception skip assert_nil(scope.send(:haml_buffer)) end def test_def_method_haml_buffer_gets_reset_even_with_exception; skip # def_method scope = Object.new engine("- raise Hamlit::Error").def_method(scope, :render) scope.render assert(false, "Expected exception") rescue Exception; skip assert_nil(scope.send(:haml_buffer)) end def test_render_proc_haml_buffer_gets_reset_even_with_exception; skip # render_proc scope = Object.new proc = engine("- raise Hamlit::Error").render_proc(scope) proc.call assert(false, "Expected exception") rescue Exception; skip assert_nil(scope.send(:haml_buffer)) end def test_render_proc_should_raise_haml_syntax_error_not_ruby_syntax_error assert_raises(Haml::SyntaxError) do Haml::Engine.new("%p{:foo => !}").render_proc(Object.new, :foo).call end end def test_render_should_raise_haml_syntax_error_not_ruby_syntax_error assert_raises(Haml::SyntaxError) do Haml::Engine.new("%p{:foo => !}").render end end def test_ugly_true assert_equal("hello world
\n#{'s' * 75}
\n", render("%p #{'s' * 75}", :ugly => true)) assert_equal("#{'s' * 75}
\n", render("%p= 's' * 75", :ugly => true)) end def test_remove_whitespace_true; skip # options assert_equal("hello world
hello world
foo bar\nbaz", render(<
foo bar\n", render('%pre="foo\nbar"')) assert_equal("
foo\nbar\n", render("%pre\n foo\n bar")) assert_equal("
foo\nbar\n", render('%pre="foo\nbar"', :ugly => true)) assert_equal("
foo\nbar\n", render("%pre\n foo\n bar", :ugly => true)) end def test_xhtml_output_option assert_haml_ugly("%p\n %br", :format => :xhtml) assert_haml_ugly("%a/", :format => :xhtml) end def test_arbitrary_output_option; skip # error assert_raises_message(Hamlit::Error, "Invalid output format :html1") do engine("%br", :format => :html1) end end def test_static_hashes assert_equal("\n", render("%a{:b => 'a => b'}", :suppress_eval => true)) assert_equal("\n", render("%a{:b => 'a, b'}", :suppress_eval => true)) assert_equal("\n", render('%a{:b => "a\tb"}', :suppress_eval => true)) assert_equal("\n", render('%a{:b => "a\\#{foo}b"}', :suppress_eval => true)) assert_equal("\n", render("%a{:b => '#f00'}", :suppress_eval => true)) end def test_dynamic_hashes_with_suppress_eval; skip # options assert_equal("\n", render('%a{:b => "a #{1 + 1} b", :c => "d"}', :suppress_eval => true)) end def test_interpolates_instance_vars_in_attribute_values; skip # special interpolation scope = Object.new scope.instance_variable_set :@foo, 'bar' assert_haml_ugly('%a{:b => "a #@foo b"}', :scope => scope) end def test_interpolates_global_vars_in_attribute_values # make sure the value isn't just interpolated in during template compilation engine = Haml::Engine.new('%a{:b => "a #$global_var_for_testing b"}') $global_var_for_testing = 'bar' assert_equal("\n", engine.to_html) ensure $global_var_for_testing = nil end def test_utf8_attrs assert_equal("\n", render("%a{:href => 'héllo'}")) assert_equal("\n", render("%a(href='héllo')")) end # HTML 4.0 def test_html_has_no_self_closing_tags assert_haml_ugly("%p\n %br", :format => :html4) assert_haml_ugly("%br/", :format => :html4) end def test_html_renders_empty_node_with_closing_tag assert_equal "\n", render(".foo", :format => :html4) end def test_html_doesnt_add_slash_to_self_closing_tags assert_equal "\n", render("%a/", :format => :html4) assert_equal "\n", render("%a{:foo => 1 + 1}/", :format => :html4) assert_equal "\n", render("%meta", :format => :html4) assert_equal "\n", render("%meta{:foo => 1 + 1}", :format => :html4) end def test_html_ignores_xml_prolog_declaration assert_equal "", render('!!! XML', :format => :html4) end def test_html_has_different_doctype assert_equal %{\n}, render('!!!', :format => :html4) end # because anything before the doctype triggers quirks mode in IE def test_xml_prolog_and_doctype_dont_result_in_a_leading_whitespace_in_html refute_match(/^\s+/, render("!!! xml\n!!!", :format => :html4)) end # HTML5 def test_html5_doctype assert_equal %{\n}, render('!!!', :format => :html5) end # HTML5 custom data attributes def test_html5_data_attributes_without_hyphenation; skip # hyphenate assert_equal("\n", render("%div{:data => {:author_id => 123, :foo => 'bar', :biz => 'baz'}}", :hyphenate_data_attrs => false)) assert_equal("\n", render("%div{:data => {:one_plus_one => 1+1}}", :hyphenate_data_attrs => false)) assert_equal("\n", render(%{%div{:data => {:foo => %{Here's a "quoteful" string.}}}}, :hyphenate_data_attrs => false)) #' end def test_html5_data_attributes_with_hyphens assert_equal("\n", render("%div{:data => {:foo_bar => 'blip'}}")) assert_equal("\n", render("%div{:data => {:foo_bar => 'blip', :baz => 'bang'}}")) end def test_html5_arbitrary_hash_valued_attributes_with skip '[INCOMPATIBILITY] Hamlit supports hyphenation only for data attributes' assert_equal("\n", render("%div{:aria => {:foo => 'blip'}}")) assert_equal("\n", render("%div{:foo => {:baz => 'bang'}}")) end def test_arbitrary_attribute_hash_merging skip '[INCOMPATIBILITY] Hamlit supports hyphenation only for data attributes' assert_equal(%Q{\n}, render(<<-HAML)) - h1 = {:aria => {:foo => :bar}} - h2 = {:baz => :qux} %a{h1, :aria => h2} HAML end def test_html5_data_attributes_with_nested_hash; skip # cyclic reference assert_equal("\n", render(<<-HAML)) - hash = {:a => {:b => 'c'}} - hash[:d] = hash %div{:data => hash} HAML end def test_html5_data_attributes_with_nested_hash_and_without_hyphenation; skip # hyphenate assert_equal("\n", render(<<-HAML, :hyphenate_data_attrs => false)) - hash = {:a => {:b => 'c'}} - hash[:d] = hash %div{:data => hash} HAML end def test_html5_data_attributes_with_multiple_defs; skip # hyphenate # Should always use the more-explicit attribute assert_equal("\n", render("%div{:data => {:foo => 'first'}, 'data-foo' => 'second'}")) assert_equal("\n", render("%div{'data-foo' => 'first', :data => {:foo => 'second'}}")) end def test_html5_data_attributes_with_attr_method; skip # runtime attribute obj = Object.new def obj.data_hash {:data => {:foo => "bar", :baz => "bang"}} end def obj.data_val {:data => "dat"} end assert_equal("\n", render("%div{data_hash, :data => {:foo => 'blip', :brat => 'wurst'}}", scope: obj)) assert_equal("\n", render("%div{data_hash, 'data-foo' => 'blip'}", scope: obj)) assert_equal("\n", render("%div{data_hash, :data => 'dat'}", scope: obj)) assert_equal("\n", render("%div{data_val, :data => {:foo => 'blip', :brat => 'wurst'}}", scope: obj)) end def test_html5_data_attributes_with_identical_attribute_values assert_equal("\n", render("%div{:data => {:x => 50, :y => 50}}")) end def test_xml_doc_using_html5_format_and_mime_type; skip # mime_type assert_equal(<
bar
HTML = ["bar", "baz", "bang"].join(", ") %p foo %p bar HAML end def test_ruby_multiline_with_punctuated_methods_is_continuation assert_equal(<bar
HTML = ["bar", " ".strip!, "".empty?, "bang"].join(", ") %p foo %p bar HAML end def test_ruby_character_literals_are_not_continuation html = ",\n,\nfoo
\n" assert_equal(html, render(<bar
HTML &= ["bar<", "baz", "bang"].join(", ") %p foo %p bar HAML end def test_unescaped_loud_ruby_multiline assert_equal(<foo
bar
HTML != ["bar<", "baz", "bang"].join(", ") %p foo %p bar HAML end def test_flattened_loud_ruby_multiline assert_equal(<foo
bar
HTML ~ "" + ["bar",
"baz",
"bang"].join("\\n") + ""
%p foo
%p bar
HAML
end
def test_loud_ruby_multiline_with_block; skip # block script
assert_equal(<bar
HTML = ["bar", "baz", "bang"].map do |str| - str.gsub("ba", "fa") %p foo %p bar HAML end def test_silent_ruby_multiline_with_block assert_equal(<bar
HTML - ["bar", "baz", "bang"].map do |str| = str.gsub("ba", "fa") %p foo %p bar HAML end def test_ruby_multiline_in_tag assert_equal(<foo
bar
HTML %p= ["foo", "bar", "baz"].join(", ") %p foo %p bar HAML end def test_escaped_ruby_multiline_in_tag; skip # script bug assert_equal(<foo
bar
HTML %p&= ["foo<", "bar", "baz"].join(", ") %p foo %p bar HAML end def test_unescaped_ruby_multiline_in_tag assert_equal(<foo<, bar, baz
foo
bar
HTML %p!= ["foo<", "bar", "baz"].join(", ") %p foo %p bar HAML end def test_ruby_multiline_with_normal_multiline assert_equal(<bar
HTML = "foo" + | "bar" + | ["bar", | "baz", "bang"].join(", ") %p foo %p bar HAML end def test_ruby_multiline_after_filter assert_equal(<bar
HTML :plain foo bar = ["bar", "baz", "bang"].join(", ") %p foo %p bar HAML end # Encodings def test_utf_8_bom; skip # encoding assert_equal <baz
bâr
föö
HTML %p bâr %p föö HAML end def test_convert_template_render_proc assert_converts_template_properly {|e| e.render_proc.call} end def test_convert_template_render assert_converts_template_properly {|e| e.render} end def test_convert_template_def_method assert_converts_template_properly do |e| o = Object.new e.def_method(o, :render) o.render end end def test_encoding_error; skip # encoding render("foo\nbar\nb\xFEaz".force_encoding("utf-8")) assert(false, "Expected exception") rescue Hamlit::Error => e; skip assert_equal(3, e.line) assert_match(/Invalid .* character/, e.message) end def test_ascii_incompatible_encoding_error; skip # encoding template = "foo\nbar\nb_z".encode("utf-16le") template[9] = "\xFE".force_encoding("utf-16le") render(template) assert(false, "Expected exception") rescue Hamlit::Error => e assert_equal(3, e.line) assert_match(/Invalid .* character/, e.message) end def test_same_coding_comment_as_encoding assert_renders_encoded(<föö
HTML -# coding: utf-8 %p bâr %p föö HAML end def test_coding_comments; skip # encoding assert_valid_encoding_comment("-# coding: ibm866") assert_valid_encoding_comment("-# CodINg: IbM866") assert_valid_encoding_comment("-#coding:ibm866") assert_valid_encoding_comment("-# CodINg= ibm866") assert_valid_encoding_comment("-# foo BAR FAOJcoding: ibm866") assert_valid_encoding_comment("-# coding: ibm866 ASFJ (&(&#!$") assert_valid_encoding_comment("-# -*- coding: ibm866") assert_valid_encoding_comment("-# coding: ibm866 -*- coding: blah") assert_valid_encoding_comment("-# -*- coding: ibm866 -*-") assert_valid_encoding_comment("-# -*- encoding: ibm866 -*-") assert_valid_encoding_comment('-# -*- coding: "ibm866" -*-') assert_valid_encoding_comment("-#-*-coding:ibm866-*-") assert_valid_encoding_comment("-#-*-coding:ibm866-*-") assert_valid_encoding_comment("-# -*- foo: bar; coding: ibm866; baz: bang -*-") assert_valid_encoding_comment("-# foo bar coding: baz -*- coding: ibm866 -*-") assert_valid_encoding_comment("-# -*- coding: ibm866 -*- foo bar coding: baz") end def test_different_coding_than_system; skip # encoding assert_renders_encoded(<тАЬ
HTML #{comment} %p ЖЛЫ %p тАЬ HAML end def assert_converts_template_properly engine = Haml::Engine.new(<föö
HTML end def assert_renders_encoded(html, haml) result = render(haml) assert_encoded_equal html, result end def assert_encoded_equal(expected, actual) assert_equal expected.encoding, actual.encoding assert_equal expected, actual end end hamlit-2.7.5/test/haml/erb/ 0000775 0000000 0000000 00000000000 13000345661 0015451 5 ustar 00root root 0000000 0000000 hamlit-2.7.5/test/haml/erb/_av_partial_1.erb 0000664 0000000 0000000 00000000443 13000345661 0020645 0 ustar 00root root 0000000 0000000It has several nested partials,
Nesting level <%= @nesting %>
<% if @nesting > 0 %> <%= render :partial => 'erb/av_partial_2' %> <% end %><%= "Holy cow " + "multiline " + "tags! " + "A pipe (|) even!" %> <%= [1, 2, 3].collect { |n| "PipesIgnored|" } %> <%= [1, 2, 3].collect { |n| n.to_s }.join("|") %>
<%= "Holy cow " + "multiline " + "tags! " + "A pipe (|) even!" %> <%= [1, 2, 3].collect { |n| "PipesIgnored|" }.join %> <%= [1, 2, 3].collect { |n| n.to_s }.join("|") %>
<% bar = 17 %>hello
" Inline content tag with CSS: haml: "%p.class1 hello" html: "hello
" Inline content multiple simple tags: haml: |- %div %div %p text html: |-text
hello
Nested content tag with CSS: haml: |- %p.class1 hello html: |-hello
Nested content multiple simple tags: haml: |- %div %div %p text html: |-text
value
" optional: true locals: var: value no interpolation when escaped: haml: "%p \\#{var}" html: "#{var}
" optional: true locals: var: value interpolation when the escape character is escaped: haml: "%p \\\\#{var}" html: "\\value
" optional: true locals: var: value interpolation inside filtered content: haml: |- :plain #{var} interpolated: #{var} html: 'value interpolated: value' optional: true locals: var: value HTML escaping: code following '&=': haml: '&= ''<"&>''' html: "<"&>" code following '=' when escape_haml is set to true: haml: = '<"&>' html: "<"&>" config: escape_html: 'true' code following '!=' when escape_haml is set to true: haml: '!= ''<"&>''' html: <"&> config: escape_html: 'true' boolean attributes: boolean attribute with XHTML: haml: "%input(checked=true)" html: "" config: format: xhtml boolean attribute with HTML: haml: "%input(checked=true)" html: "" config: format: html5 whitespace preservation: following the '~' operator: haml: ~ "Foo\nBar\nBaz" html: |- Foo
Bar Bazoptional: true inside a textarea tag: haml: |- %textarea hello hello html: |- inside a pre tag: haml: |- %pre hello hello html: |-
hello
hello
whitespace removal:
a tag with '>' appended and inline content:
haml: |-
%li hello
%li> world
%li again
html: "hello world
hamlit-2.7.5/test/haml/haml-spec/ugly_test.rb 0000664 0000000 0000000 00000106674 13000345661 0021134 0 ustar 00root root 0000000 0000000 $:.unshift File.expand_path('../../test', __dir__) require 'test_helper' require 'haml' require 'minitest/autorun' # This is a spec converted by haml-spec. # See: https://github.com/haml/haml-spec class UglyTest < MiniTest::Test HAML_DEFAULT_OPTIONS = { ugly: true, escape_html: true, escape_attrs: true }.freeze HAMLIT_DEFAULT_OPTIONS = { escape_html: true }.freeze def self.haml_result(haml, options, locals) Haml::Engine.new(haml, HAML_DEFAULT_OPTIONS.merge(options)).render(Object.new, locals) end def self.hamlit_result(haml, options, locals) Hamlit::Template.new(HAMLIT_DEFAULT_OPTIONS.merge(options)) { haml }.render(Object.new, locals) end class Headers < MiniTest::Test def test_an_XHTML_XML_prolog haml = %q{!!! XML} html = %q{} locals = {} options = {:format=>:xhtml} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_XHTML_default_transitional_doctype haml = %q{!!!} html = %q{} locals = {} options = {:format=>:xhtml} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_XHTML_1_1_doctype haml = %q{!!! 1.1} html = %q{} locals = {} options = {:format=>:xhtml} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_XHTML_1_2_mobile_doctype haml = %q{!!! mobile} html = %q{} locals = {} options = {:format=>:xhtml} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_XHTML_1_1_basic_doctype haml = %q{!!! basic} html = %q{} locals = {} options = {:format=>:xhtml} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_XHTML_1_0_frameset_doctype haml = %q{!!! frameset} html = %q{} locals = {} options = {:format=>:xhtml} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_HTML_5_doctype_with_XHTML_syntax haml = %q{!!! 5} html = %q{} locals = {} options = {:format=>:xhtml} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_HTML_5_XML_prolog_silent_ haml = %q{!!! XML} html = %q{} locals = {} options = {:format=>:html5} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_HTML_5_doctype haml = %q{!!!} html = %q{} locals = {} options = {:format=>:html5} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_HTML_4_XML_prolog_silent_ haml = %q{!!! XML} html = %q{} locals = {} options = {:format=>:html4} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_HTML_4_default_transitional_doctype haml = %q{!!!} html = %q{} locals = {} options = {:format=>:html4} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_HTML_4_frameset_doctype haml = %q{!!! frameset} html = %q{} locals = {} options = {:format=>:html4} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_an_HTML_4_strict_doctype haml = %q{!!! strict} html = %q{} locals = {} options = {:format=>:html4} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end end class Basichamltagsandcss < MiniTest::Test def test_a_simple_Haml_tag haml = %q{%p} html = %q{} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_a_self_closing_tag_XHTML_ haml = %q{%meta} html = %q{} locals = {} options = {:format=>:xhtml} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_a_self_closing_tag_HTML4_ haml = %q{%meta} html = %q{} locals = {} options = {:format=>:html4} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_a_self_closing_tag_HTML5_ haml = %q{%meta} html = %q{} locals = {} options = {:format=>:html5} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_a_self_closing_tag_modifier_XHTML_ haml = %q{%zzz/} html = %q{hello
} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_Inline_content_tag_with_CSS haml = %q{%p.class1 hello} html = %q{hello
} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_Inline_content_multiple_simple_tags haml = %q{%div %div %p text} html = %q{text
hello
} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_Nested_content_tag_with_CSS haml = %q{%p.class1 hello} html = %q{hello
} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_Nested_content_multiple_simple_tags haml = %q{%div %div %p text} html = %q{text
value
} locals = {:var=>"value"} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_no_interpolation_when_escaped haml = %q{%p \#{var}} html = %q{#{var}
} locals = {:var=>"value"} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_interpolation_when_the_escape_character_is_escaped haml = %q{%p \\#{var}} html = %q{\value
} locals = {:var=>"value"} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_interpolation_inside_filtered_content haml = %q{:plain #{var} interpolated: #{var}} html = %q{value interpolated: value} locals = {:var=>"value"} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end end class Htmlescaping < MiniTest::Test def test_code_following_ haml = %q{&= '<"&>'} html = %q{<"&>} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_code_following_when_escape_haml_is_set_to_true haml = %q{= '<"&>'} html = %q{<"&>} locals = {} options = {:escape_html=>"true"} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_code_following_when_escape_haml_is_set_to_true haml = %q{!= '<"&>'} html = %q{<"&>} locals = {} options = {:escape_html=>"true"} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end end class Booleanattributes < MiniTest::Test def test_boolean_attribute_with_XHTML haml = %q{%input(checked=true)} html = %q{} locals = {} options = {:format=>:xhtml} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_boolean_attribute_with_HTML haml = %q{%input(checked=true)} html = %q{} locals = {} options = {:format=>:html5} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end end class Whitespacepreservation < MiniTest::Test def test_following_the_operator haml = %q{~ "Foo\nBar\nBaz"} html = %q{Foo
Bar Baz} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_inside_a_textarea_tag haml = %q{%textarea hello hello} html = %q{} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end def test_inside_a_pre_tag haml = %q{%pre hello hello} html = %q{
hello hello} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end end class Whitespaceremoval < MiniTest::Test def test_a_tag_with_appended_and_inline_content haml = %q{%li hello %li> world %li again} html = %q{
hello world
} locals = {} options = {} haml_result = UglyTest.haml_result(haml, options, locals) hamlit_result = UglyTest.hamlit_result(haml, options, locals) assert_equal haml_result, hamlit_result end end end hamlit-2.7.5/test/haml/helper_test.rb 0000664 0000000 0000000 00000052277 13000345661 0017561 0 ustar 00root root 0000000 0000000 require 'test_helper' require "active_model/naming" class FormModel extend ActiveModel::Naming end class HelperTest < Haml::TestCase TEXT_AREA_CONTENT_REGEX = /<(textarea)[^>]*>\n(.*?)<\/\1>/im Post = Struct.new('Post', :body, :error_field, :errors) class PostErrors def on(name) return unless name == 'error_field' ["Really bad error"] end alias_method :full_messages, :on def [](name) on(name) || [] end end def setup @base = Class.new(ActionView::Base) { def nested_tag content_tag(:span) {content_tag(:div) {"something"}} end def wacky_form form_tag("/foo") {"bar"} end }.new @base.controller = ActionController::Base.new @base.view_paths << File.expand_path("../templates", __FILE__) @base.instance_variable_set(:@post, Post.new("Foo bar\nbaz", nil, PostErrors.new)) end def render(text, options = {}) return @base.render :inline => text, :type => :haml if options == :action_view super end def test_rendering_with_escapes; skip def @base.render_something_with_haml_concat haml_concat ""
end
def @base.render_something_with_haml_tag_and_concat
haml_tag 'p' do
haml_concat ' \n <foo>\n A word! A word! A word! A word! A word! A word! A word! A word! tabbedFee
\n Fi
\n Fo
\n Fum
\n Fee
\n Fi
\n Fo
\n Fum
\n
bar
barbaz
\n", render("%p{:id => 'foo&bar'} baz", :escape_html => true)) end def test_haml_tag_autoclosed_tags_are_closed_xhtml; skip assert_equal("foo
\n", render("- haml_tag :p, 'foo', :class => %w[a b]")) assert_equal("foo
\n", render("- haml_tag 'p.c.d', 'foo', :class => %w[a b]")) end def test_haml_tag_with_id_array; skip assert_equal("foo
\n", render("- haml_tag :p, 'foo', :id => %w[a b]")) assert_equal("foo
\n", render("- haml_tag 'p#c', 'foo', :id => %w[a b]")) end def test_haml_tag_with_data_hash; skip assert_equal("foo
\n", render("- haml_tag :p, 'foo', :data => {:foo => 'bar', :baz => true}")) end def test_haml_tag_non_autoclosed_tags_arent_closed; skip assert_equal("\n", render("- haml_tag :p")) end def test_haml_tag_renders_text_on_a_single_line; skip assert_equal("#{'a' * 100}
\n", render("- haml_tag :p, 'a' * 100")) end def test_haml_tag_raises_error_for_multiple_content; skip assert_raises(Haml::Error) { render("- haml_tag :p, 'foo' do\n bar") } end def test_haml_tag_flags; skip assert_equal("\n", render("- haml_tag :p, :/", :format => :xhtml)) assert_equal("\n", render("- haml_tag :p, :/", :format => :html5)) assert_equal("
kumquat
\n", render("- haml_tag :p, :< do\n kumquat")) assert_raises(Haml::Error) { render("- haml_tag :p, 'foo', :/") } assert_raises(Haml::Error) { render("- haml_tag :p, :/ do\n foo") } end def test_haml_tag_error_return; skip assert_raises(Haml::Error) { render("= haml_tag :p") } end def test_haml_tag_with_multiline_string; skip assert_equal(<\n <>&\n
\n", render(<Hi!
HTML - haml_tag :p do - haml_tag :strong, "Hi!" HAML end def test_haml_tag_if_positive; skip assert_equal(<A para
A para
Foo Bar\nFoo\nBar\n", render("= find_and_preserve do\n %pre\n Foo\n Bar\n Foo\n Bar")) end def test_find_and_preserve_with_block_and_tags; skip assert_equal("
Foo\nBar\nFoo\nBar\n", render("= find_and_preserve([]) do\n %pre\n Foo\n Bar\n Foo\n Bar")) end def test_preserve_with_block; skip assert_equal("
Foo BarFoo Bar\n", render("= preserve do\n %pre\n Foo\n Bar\n Foo\n Bar")) end def test_init_haml_helpers context = Object.new class << context include Haml::Helpers end context.init_haml_helpers result = context.capture_haml do context.haml_tag :p, :attr => "val" do context.haml_concat "Blah" end end assert_equal("
\n Blah\n
\n", result) end def test_non_haml; skip assert_equal("false\n", render("= non_haml { is_haml? }")) end def test_content_tag_nested; skip assert_equal "some tag content
", ActsLikeTag.new.to_s end def test_capture_with_nuke_outer; skip assert_equal "\n*All
This
Should renderTitle
Woah this is really crazy I mean wow, man.
Title
Woah this is really crazy I mean wow, man.
Title
Woah this is really crazy I mean wow, man.
foo
reeeeeeeeeeeeeeeeeeeeeeeeeeeeeeally loooooooooooooooooong
Small
foo
baz
boom
foofoo
| strong! data | more_data |
Embedded? false!
Embedded? true!
Embedded? true!
Embedded? twice! true!
Embedded? one af"t"er another!
stuff followed by whitespace block with whitespaceEscape - character %p foo yee\ha don't lstrip me
class attribute should appear!
this attribute shouldn't appear
testtestBlah
Blump
Whee
Woah inner quoteshello
Foo
Foo
Foo
Bar
Foo
Bar
Foo
Bar
Foo
Bar
Foo
Bar
Foo
Bar
foo
bar
Foo
Foo
Foo
Foo
Foo
Foo
Foo
Foo
Foo
Bar
Foo
Bar
Foo
Bar
Foo
Bar
foo
Foo
bar
foo
Foo
bar
fooFoo
bar
fooFoo
bar
foo
Foo
bar
foo
Foo
bar
fooFoo
bar
fooFoo
bar
foo
Foo
Bar
bar
foo
Foo
Bar
bar
fooFoo
Bar
bar
fooFoo
Bar
bar
hamlit-2.7.5/test/haml/results/original_engine.xhtml 0000664 0000000 0000000 00000000733 13000345661 0022614 0 ustar 00root root 0000000 0000000
Lorem ipsum dolor sit amet, consectetur adipisicing elit
Cigarettes!
This is some text that's in a pre block! Let's see what happens when it's rendered! What about now, since we're on a new line?
Some content within a layout
@foo = value one
@foo = value two
@foo = value two
Toplevel? false@foo = value three
@foo = value three
hamlit-2.7.5/test/haml/results/render_layout.xhtml 0000664 0000000 0000000 00000000024 13000345661 0022330 0 ustar 00root root 0000000 0000000 Before During After hamlit-2.7.5/test/haml/results/silent_script.xhtml 0000664 0000000 0000000 00000001303 13000345661 0022337 0 ustar 00root root 0000000 0000000"false" is: false
Even! Odd! Even! Odd! Even!boom
Holy cow multiline tags! A pipe (|) even! PipesIgnored|PipesIgnored|PipesIgnored| 1|2|3
<pre>foo bar</pre>
foo bar
foo bar
foo bar
foo bar
foo bar
___
,o88888
,o8888888'
,:o:o:oooo. ,8O88Pd8888"
,.::.::o:ooooOoOoO. ,oO8O8Pd888'"
,.:.::o:ooOoOoOO8O8OOo.8OOPd8O8O"
, ..:.::o:ooOoOOOO8OOOOo.FdO8O8"
, ..:.::o:ooOoOO8O888O8O,COCOO"
, . ..:.::o:ooOoOOOO8OOOOCOCO"
. ..:.::o:ooOoOoOO8O8OCCCC"o
. ..:.::o:ooooOoCoCCC"o:o
. ..:.::o:o:,cooooCo"oo:o:
` . . ..:.:cocoooo"'o:o:::'
.` . ..::ccccoc"'o:o:o:::'
:.:. ,c:cccc"':.:.:.:.:.'
..:.:"'`::::c:"'..:.:.:.:.:.' http://www.chris.com/ASCII/
...:.'.:.::::"' . . . . .'
.. . ....:."' ` . . . ''
. . . ...."'
.. . ."' -hrr-
.
It's a planet!
%strong This shouldn't be bold!
This should!
__ ______ __ ______ .----.| |--.|__ |.----.| |--..--------.| __ | | __|| ||__ || __|| < | || __ | |____||__|__||______||____||__|__||__|__|__||______|
foo barhamlit-2.7.5/test/haml/template_test.rb 0000664 0000000 0000000 00000022472 13000345661 0020107 0 ustar 00root root 0000000 0000000 require 'test_helper' require 'haml/mocks/article' require 'action_pack/version' require 'hamlit/rails_template' module Haml::Filters::Test include Haml::Filters::Base def render(text) "TESTING HAHAHAHA!" end end module Hamlit::RailsHelpers def test_partial(name, locals = {}) Hamlit::Template.new { File.read(File.join(TemplateTest::TEMPLATE_PATH, "_#{name}.haml")) }.render(self, locals) end end class Egocentic def method_missing(*args) self end end class DummyController attr_accessor :logger def initialize @logger = Egocentic.new end def self.controller_path '' end def controller_path '' end end class TemplateTest < Haml::TestCase TEMPLATE_PATH = File.join(File.dirname(__FILE__), "templates") TEMPLATES = [ 'very_basic', #'standard', #'helpers', #'whitespace_handling', 'original_engine', 'list', 'helpful', 'silent_script', 'tag_parsing', #'just_stuff', #'partials', #'nuke_outer_whitespace', #'nuke_inner_whitespace', #'render_layout', #'partial_layout', 'partial_layout_erb', ] def setup @base = create_base # filters template uses :sass # Sass::Plugin.options.update(:line_comments => true, :style => :compact) end def create_base vars = { 'article' => Article.new, 'foo' => 'value one' } base = ActionView::Base.new(TEMPLATE_PATH, vars) # This is needed by RJS in (at least) Rails 3 base.instance_variable_set(:@template, base) # This is used by form_for. # It's usually provided by ActionController::Base. def base.protect_against_forgery?; false; end base end def render(text, options = {}) return @base.render(:inline => text, :type => :haml) if options == :action_view options = options.merge(:format => :xhtml) super(text, options, @base) end def load_result(name) @result = '' File.new(File.dirname(__FILE__) + "/results/#{name}.xhtml").each_line { |l| @result += l } @result end def assert_renders_correctly(name, &render_method) old_options = Haml::Template.options.dup Haml::Template.options[:escape_html] = false render_method ||= proc { |n| @base.render(:file => n) } silence_warnings do load_result(name).split("\n").zip(render_method[name].split("\n")).each_with_index do |pair, line| message = "template: #{name}\nline: #{line}" assert_equal(pair.first, pair.last, message) end end rescue ActionView::Template::Error => e if e.message =~ /Can't run [\w:]+ filter; required (one of|file) ((?:'\w+'(?: or )?)+)(, but none were found| not found)/ puts "\nCouldn't require #{$2}; skipping a test." else raise e end ensure Haml::Template.options = old_options end def test_empty_render_should_remain_empty assert_equal('', render('')) end TEMPLATES.each do |template| define_method "test_template_should_render_correctly [template: #{template}]" do assert_renders_correctly template end end def test_templates skip TEMPLATES end def test_render_method_returning_null_with_ugly; skip @base.instance_eval do def empty nil end def render_something(&block) capture(self, &block) end end content_to_render = "%h1 This is part of the broken view.\n= render_something do |thing|\n = thing.empty do\n = 'test'" result = render(content_to_render, :ugly => true) expected_result = "
foo baz
HTML %p foo -# Parenthesis required due to Rails 3.0 deprecation of block helpers -# that return strings. - (with_output_buffer do bar = "foo".gsub(/./) do |s| - "flup" - end) baz HAML end def test_exceptions_should_work_correctly; skip begin render("- raise 'oops!'") rescue Exception => e assert_equal("oops!", e.message) assert_match(/^\(haml\):1/, e.backtrace[0]) else assert false end template = <foo bar" ~ "
foo\nbar" %p~ "
foo\nbar" %p~ "foo\nbar" .foo ~ 13 ~ "".each_line do |l| - haml_concat l.strip #whitespace_test = test_partial "text_area", :value => "Oneline" = test_partial "text_area", :value => "Two\nlines" = find_and_preserve test_partial("text_area", :value => "Oneline") = find_and_preserve test_partial("text_area", :value => "Two\nlines") #flattened= find_and_preserve test_partial("text_area", :value => "Two\nlines") .hithere = find_and_preserve("Foo bar") = find_and_preserve("
foo bar") = find_and_preserve("
foo\nbar") %p= find_and_preserve("
foo\nbar") %p= find_and_preserve("foo\nbar") %pre :preserve ___ ,o88888 ,o8888888' ,:o:o:oooo. ,8O88Pd8888" ,.::.::o:ooooOoOoO. ,oO8O8Pd888'" ,.:.::o:ooOoOoOO8O8OOo.8OOPd8O8O" , ..:.::o:ooOoOOOO8OOOOo.FdO8O8" , ..:.::o:ooOoOO8O888O8O,COCOO" , . ..:.::o:ooOoOOOO8OOOOCOCO" . ..:.::o:ooOoOoOO8O8OCCCC"o . ..:.::o:ooooOoCoCCC"o:o . ..:.::o:o:,cooooCo"oo:o: ` . . ..:.:cocoooo"'o:o:::' .` . ..::ccccoc"'o:o:o:::' :.:. ,c:cccc"':.:.:.:.:.' ..:.:"'`::::c:"'..:.:.:.:.:.' http://www.chris.com/ASCII/ ...:.'.:.::::"' . . . . .' .. . ....:."' ` . . . '' . . . ...."' .. . ."' -hrr- . It's a planet! %strong This shouldn't be bold! %strong This should! %textarea :preserve ___ ___ ___ ___ /\__\ /\ \ /\__\ /\__\ /:/ / /::\ \ /::| | /:/ / /:/__/ /:/\:\ \ /:|:| | /:/ / /::\ \ ___ /::\~\:\ \ /:/|:|__|__ /:/ / /:/\:\ /\__\ /:/\:\ \:\__\ /:/ |::::\__\ /:/__/ \/__\:\/:/ / \/__\:\/:/ / \/__/~~/:/ / \:\ \ \::/ / \::/ / /:/ / \:\ \ /:/ / /:/ / /:/ / \:\ \ /:/ / /:/ / /:/ / \:\__\ \/__/ \/__/ \/__/ \/__/ Many thanks to http://www.network-science.de/ascii/ %strong indeed! .foo = find_and_preserve(13) %pre :preserve __ ______ __ ______ .----.| |--.|__ |.----.| |--..--------.| __ | | __|| ||__ || __|| < | || __ | |____||__|__||______||____||__|__||__|__|__||______| %pre :preserve foo bar hamlit-2.7.5/test/haml/templates/with_bom.haml 0000664 0000000 0000000 00000000007 13000345661 0021347 0 ustar 00root root 0000000 0000000 BOMG hamlit-2.7.5/test/hamlit/ 0000775 0000000 0000000 00000000000 13000345661 0015236 5 ustar 00root root 0000000 0000000 hamlit-2.7.5/test/hamlit/attribute_parser_test.rb 0000664 0000000 0000000 00000011335 13000345661 0022204 0 ustar 00root root 0000000 0000000 describe Hamlit::AttributeParser do describe '.parse' do def assert_parse(expected, haml) actual = Hamlit::AttributeParser.parse(haml) assert_equal expected, actual end it { assert_parse({}, '') } it { assert_parse({}, '{}') } describe 'invalid hash' do it { assert_parse(nil, ' hash ') } it { assert_parse(nil, 'hash, foo: bar') } it { assert_parse(nil, ' {hash} ') } it { assert_parse(nil, ' { hash, foo: bar } ') } end describe 'dynamic key' do it { assert_parse(nil, 'foo => bar') } it { assert_parse(nil, '[] => bar') } it { assert_parse(nil, '[1,2,3] => bar') } end describe 'foo: bar' do it { assert_parse({ '_' => '1' }, '_:1,') } it { assert_parse({ 'foo' => 'bar' }, ' foo: bar ') } it { assert_parse({ 'a' => 'b', 'c' => ':d' }, 'a: b, c: :d') } it { assert_parse({ 'a' => '[]', 'c' => '"d"' }, 'a: [], c: "d"') } it { assert_parse({ '_' => '1' }, ' { _:1, } ') } it { assert_parse({ 'foo' => 'bar' }, ' { foo: bar } ') } it { assert_parse({ 'a' => 'b', 'c' => ':d' }, ' { a: b, c: :d } ') } it { assert_parse({ 'a' => '[]', 'c' => '"d"' }, ' { a: [], c: "d" } ') } end describe ':foo => bar' do it { assert_parse({ 'foo' => ':bar' }, ' :foo => :bar ') } it { assert_parse({ '_' => '"foo"' }, ':_=>"foo"') } it { assert_parse({ 'a' => '[]', 'c' => '""', 'b' => '"#{3}"' }, ':a => [], c: "", :b => "#{3}"') } it { assert_parse({ 'foo' => ':bar' }, ' { :foo => :bar } ') } it { assert_parse({ '_' => '"foo"' }, ' { :_=>"foo" } ') } it { assert_parse({ 'a' => '[]', 'c' => '""', 'b' => '"#{3}"' }, ' { :a => [], c: "", :b => "#{3}" } ') } it { assert_parse(nil, ':"f#{o}o" => bar') } it { assert_parse(nil, ':"#{f}oo" => bar') } it { assert_parse(nil, ':"#{foo}" => bar') } end describe '"foo" => bar' do it { assert_parse({ 'foo' => '[1]' }, '"foo"=>[1]') } it { assert_parse({ 'foo' => 'nya' }, " 'foo' => nya ") } it { assert_parse({ 'foo' => 'bar' }, '%q[foo] => bar ') } it { assert_parse({ 'foo' => '[1]' }, ' { "foo"=>[1] } ') } it { assert_parse({ 'foo' => 'nya' }, " { 'foo' => nya } ") } it { assert_parse({ 'foo' => 'bar' }, ' { %q[foo] => bar } ') } it { assert_parse(nil, '"f#{o}o" => bar') } it { assert_parse(nil, '"#{f}oo" => bar') } it { assert_parse(nil, '"#{foo}" => bar') } it { assert_parse({ 'f#{o}o' => 'bar' }, '%q[f#{o}o] => bar ') } it { assert_parse({ 'f#{o}o' => 'bar' }, ' { %q[f#{o}o] => bar, } ') } it { assert_parse(nil, '%Q[f#{o}o] => bar ') } end if RUBY_VERSION >= '2.2.0' describe '"foo": bar' do it { assert_parse({ 'foo' => '()' }, '"foo":()') } it { assert_parse({ 'foo' => 'nya' }, " 'foo': nya ") } it { assert_parse({ 'foo' => '()' }, ' { "foo":() , }') } it { assert_parse({ 'foo' => 'nya' }, " { 'foo': nya , }") } it { assert_parse(nil, '"f#{o}o": bar') } it { assert_parse(nil, '"#{f}oo": bar') } it { assert_parse(nil, '"#{foo}": bar') } end end describe 'nested array' do it { assert_parse({ 'foo' => '[1,2,]' }, 'foo: [1,2,],') } it { assert_parse({ 'foo' => '[1,2,[3,4],5]' }, 'foo: [1,2,[3,4],5],') } it { assert_parse({ 'foo' => '[1,2,[3,4],5]', 'bar' => '[[1,2],]'}, 'foo: [1,2,[3,4],5],bar: [[1,2],],') } it { assert_parse({ 'foo' => '[1,2,]' }, ' { foo: [1,2,], } ') } it { assert_parse({ 'foo' => '[1,2,[3,4],5]' }, ' { foo: [1,2,[3,4],5], } ') } it { assert_parse({ 'foo' => '[1,2,[3,4],5]', 'bar' => '[[1,2],]'}, ' { foo: [1,2,[3,4],5],bar: [[1,2],], } ') } end describe 'nested hash' do it { assert_parse({ 'foo' => '{ }', 'bar' => '{}' }, 'foo: { }, bar: {}') } it { assert_parse({ 'foo' => '{ bar: baz, hoge: fuga, }' }, 'foo: { bar: baz, hoge: fuga, }, ') } it { assert_parse({ 'data' => '{ confirm: true, disable: false }', 'hello' => '{ world: foo, }' }, 'data: { confirm: true, disable: false }, :hello => { world: foo, },') } it { assert_parse({ 'foo' => '{ }', 'bar' => '{}' }, ' { foo: { }, bar: {} } ') } it { assert_parse({ 'foo' => '{ bar: baz, hoge: fuga, }' }, ' { foo: { bar: baz, hoge: fuga, }, } ') } it { assert_parse({ 'data' => '{ confirm: true, disable: false }', 'hello' => '{ world: foo, }' }, ' { data: { confirm: true, disable: false }, :hello => { world: foo, }, } ') } end describe 'nested method' do it { assert_parse({ 'foo' => 'bar(a, b)', 'hoge' => 'piyo(a, b,)' }, 'foo: bar(a, b), hoge: piyo(a, b,),') } it { assert_parse({ 'foo' => 'bar(a, b)', 'hoge' => 'piyo(a, b,)' }, ' { foo: bar(a, b), hoge: piyo(a, b,), } ') } end end end hamlit-2.7.5/test/hamlit/cli_test.rb 0000664 0000000 0000000 00000000637 13000345661 0017377 0 ustar 00root root 0000000 0000000 require 'hamlit/cli' describe Hamlit::CLI do describe '#temple' do def redirect_output out, $stdout = $stdout, StringIO.new yield ensure $stdout = out end it 'does not crash when compiling a tag' do redirect_output do f = Tempfile.open('hamlit') f.write('%input{ hash }') f.close Hamlit::CLI.new.temple(f.path) end end end end hamlit-2.7.5/test/hamlit/engine/ 0000775 0000000 0000000 00000000000 13000345661 0016503 5 ustar 00root root 0000000 0000000 hamlit-2.7.5/test/hamlit/engine/attributes_test.rb 0000664 0000000 0000000 00000050205 13000345661 0022257 0 ustar 00root root 0000000 0000000 describe Hamlit::Engine do include RenderHelper describe 'id attributes' do describe 'compatilibity' do it { assert_haml(%q|#a|) } it { assert_haml(%q|#a{ id: nil }|) } it { assert_haml(%q|#a{ id: nil }(id=nil)|) } it { assert_haml(%q|#a{ id: false }|) } it { assert_haml(%q|#a{ id: 'b' }|) } it { assert_haml(%q|#b{ id: 'a' }|) } it { assert_haml(%q|%a{ 'id' => 60 }|) } it { assert_haml(%q|#a{ id: 'b' }(id=id)|, locals: { id: 'c' }) } it { assert_haml(%q|#c{ id: a = 'a' }(id=id)|, locals: { id: 'b' }) } it { assert_haml(%q|#d#c{ id: a = 'b' }(id=id)|, locals: { id: 'a' }) } it { assert_haml(%q|#d#c{ id: %w[b e] }(id=id)|, locals: { id: 'a' }) } it { assert_haml(%q|%div{ hash }|, locals: { hash: { id: 'a' } }) } it { assert_haml(%q|#b{ hash }|, locals: { hash: { id: 'a' } }) } it { assert_haml(%q|#b{ hash }(id='c')|, locals: { hash: { id: 'a' }, id: 'c' }) } it { assert_haml(%q|#b{ hash }(id=id)|, locals: { hash: { id: 'a' }, id: 'c' }) } end describe 'incompatibility' do it { assert_render(%Q|\n|, %q|#a{ id: [] }|) } it { assert_render(%Q|\n|, %q|%div{ id: [nil, false] }|) } it { assert_render(%Q|\n|, %q|#d#c{ id: [] }(id=id)|, locals: { id: 'a' }) } it { assert_render(%Q|\n|, %q|%div{ id: nil }|) } it { assert_render(%Q|\n|, %q|%input{ id: false }|) } it { assert_render(%Q|\n|, %q|%input{ id: val }|, locals: { val: false }) } it { assert_render(%Q|\n|, %q|%input{ hash }|, locals: { hash: { id: false } }) } end end describe 'class attributes' do describe 'compatibility' do it { assert_haml(%q|.bar.foo|) } it { assert_haml(%q|.foo.bar|) } it { assert_haml(%q|%div(class='bar foo')|) } it { assert_haml(%q|%div(class='foo bar')|) } it { assert_haml(%q|%div{ class: 'bar foo' }|) } it { assert_haml(%q|.b{ class: 'a' }|) } it { assert_haml(%q|.a{ class: 'b a' }|) } it { assert_haml(%q|.b.a{ class: 'b a' }|) } it { assert_haml(%q|.b{ class: 'b a' }|) } it { assert_haml(%q|.a{ class: klass }|, locals: { klass: 'b a' }) } it { assert_haml(%q|.b{ class: klass }|, locals: { klass: 'b a' }) } it { assert_haml(%q|.b.a{ class: klass }|, locals: { klass: 'b a' }) } it { assert_haml(%q|.b{ class: 'c a' }|) } it { assert_haml(%q|.b{ class: 'a c' }|) } it { assert_haml(%q|.a{ class: [] }|) } it { assert_haml(%q|.a{ class: %w[c b] }|) } it { assert_haml(%q|.a.c(class='b')|) } it { assert_haml(%q|%a{ 'class' => 60 }|) } it { assert_haml(%q|%div{ class: 'b a' }(class=klass)|, locals: { klass: 'b a' }) } it { assert_haml(%q|%div(class=klass){ class: 'b a' }|, locals: { klass: 'b a' }) } it { assert_haml(%q|.a.d(class=klass){ class: 'c d' }|, locals: { klass: 'b a' }) } it { assert_haml(%q|.a.d(class=klass)|, locals: { klass: 'b a' }) } it { assert_haml(%q|.a{:class => klass}|, locals: { klass: nil }) } it { assert_haml(%q|.a{:class => nil}(class=klass)|, locals: { klass: nil }) } it { assert_haml(%q|.a{:class => nil}|) } it { assert_haml(%q|.a{:class => false}|) } it { assert_haml(%q|.b{ hash, class: 'a' }|, locals: { hash: { class: nil } }) } it { assert_haml(%q|.b{ hash, :class => 'a' }|, locals: { hash: { class: nil } }) } it { assert_haml(%q|.b{ hash, 'class' => 'a' }|, locals: { hash: { class: nil } }) } it { assert_haml(%q|.a{ hash }|, locals: { hash: { class: 'd' } }) } it { assert_haml(%q|.b{ hash, class: 'a' }(class='c')|, locals: { hash: { class: 'd' } }) } it { assert_haml(%q|.b{ hash, class: 'a' }(class=klass)|, locals: { hash: { class: 'd' }, klass: nil }) } it { assert_haml(%q|%div{ class: 'b a' }|) } it { assert_haml(%q|%div{ class: klass }|, locals: { klass: 'b a' }) } it { assert_haml(%q|%div(class='b a')|) } it { assert_haml(%q|%div(class=klass)|, locals: { klass: 'b a' }) } it { assert_haml(%q|%div{ class: [false, 'a', nil] }|) } it { assert_haml(%q|%div{ class: %q[b a] }|) } it { assert_haml(%q|%div{ class: %q[b a b] }|) } it { assert_haml(%q|%span.c2{class: ["c1", "c3", :c2]}|) } it { assert_haml(%q|%span{class: [1, nil, false, true]}|) } it do assert_haml(<<-HAML.unindent) - v = [1, nil, false, true] %span{class: v} HAML end it do assert_haml(<<-HAML.unindent) - h1 = {class: 'c1', id: ['id1', 'id3']} - h2 = {class: [{}, 'c2'], id: 'id2'} %span#main.content{h1, h2} hello HAML end end describe 'incompatibility' do it { assert_render(%Q|\n|, %q|%div{ class: nil }|) } it { assert_render(%Q|\n|, %q|%div{ class: false }|) } it { assert_render(%Q|\n|, %q|%div{ class: false }|) } it { assert_render(%Q|\n|, %q|%div{ class: val }|, locals: { val: false }) } it { assert_render(%Q|\n|, %q|%div{ hash }|, locals: { hash: { class: false } }) } end end describe 'data attributes' do it { assert_haml(%q|#foo.bar{ data: { disabled: val } }|, locals: { val: false }) } it { skip; assert_haml(%q|%div{:data => hash}|, locals: { hash: { :a => { :b => 'c' } }.tap { |h| h[:d] = h } }) } it { skip; assert_haml(%q|%div{ hash }|, locals: { hash: { data: { :a => { :b => 'c' } }.tap { |h| h[:d] = h } } }) } it { assert_haml(%q|%div{:data => {:foo_bar => 'blip', :baz => 'bang'}}|) } it { assert_haml(%q|%div{ data: { raw_src: 'foo' } }|) } it { assert_haml(%q|%a{ data: { value: [count: 1] } }|) } it { assert_haml(%q|%a{ 'data-disabled' => true }|) } it { assert_haml(%q|%a{ :'data-disabled' => true }|) } it { assert_haml(%q|%a{ data: { nil => 3 } }|) } it { assert_haml(%q|%a{ data: 3 }|) } it { assert_haml(%q|%a(data=3)|) } it { assert_haml(%q|%a{ 'data-bar' => 60 }|) } it { assert_haml(%q|%a{ data: { overlay_modal: 'foo' } }|) } it { assert_haml(%q|%a{ data: { overlay_modal: true } }|) } it { assert_haml(%q|%a{ data: { overlay_modal: false } }|) } it { assert_haml(%q|%a{ data: true }|) } it { assert_haml(%q|%a{ data: { nil => true } }|) } it { assert_haml(%q|%a{ data: { false => true } }|) } it { skip; assert_haml(%q|%a{ { data: { 'foo-bar' => 1 } }, data: { foo: { bar: 2 } } }|) } it { assert_haml(%q|%a{ { data: { foo: { bar: 2 } } }, data: { 'foo-bar' => 2 } }|) } it { assert_haml(%q|%a{ { data: { :'foo-bar' => 1 } }, data: { 'foo-bar' => 2 } }|) } it do assert_haml(<<-HAML.unindent) - old = { disabled: true, checked: false, href: false, 'hello-world' => '<>/' } - new = { disabled: false, checked: true, href: '<>/', hello: {}, 'hello_hoge' => true, foo: { 'bar&baz' => 'hoge' } } - hash = { data: { href: true, hash: true } } %a(data=new){ hash, data: old } HAML end it do assert_haml(<<-HAML.unindent) - h1 = { data: 'should be overwritten' } - h2 = { data: nil } %div{ h1, h2 } HAML end end describe 'boolean attributes' do it { assert_haml(%q|%input{ disabled: nil }|) } it { assert_haml(%q|%input{ disabled: false }|) } it { assert_haml(%q|%input{ disabled: true }|) } it { assert_haml(%q|%input{ disabled: 'false' }|) } it { assert_haml(%q|%input{ disabled: val = nil }|) } it { assert_haml(%q|%input{ disabled: val = false }|) } it { assert_haml(%q|%input{ disabled: val = true }|) } it { assert_haml(%q|%input{ disabled: val = 'false' }|) } it { assert_haml(%q|%input{ disabled: nil }(disabled=true)|) } it { assert_haml(%q|%input{ disabled: false }(disabled=true)|) } it { assert_haml(%q|%input{ disabled: true }(disabled=false)|) } it { assert_haml(%q|%a{ hash }|, locals: { hash: { disabled: false } }) } it { assert_haml(%q|%a{ hash }|, locals: { hash: { disabled: nil } }) } it { assert_haml(%q|input(disabled=true){ disabled: nil }|) } it { assert_haml(%q|input(disabled=true){ disabled: false }|) } it { assert_haml(%q|input(disabled=false){ disabled: true }|) } it { assert_haml(%q|%input(disabled=val){ disabled: false }|, locals: { val: true }) } it { assert_haml(%q|%input(disabled=val){ disabled: false }|, locals: { val: false }) } it { assert_haml(%q|%input(disabled=nil)|) } it { assert_haml(%q|%input(disabled=false)|) } it { assert_haml(%q|%input(disabled=true)|) } it { assert_haml(%q|%input(disabled='false')|) } it { assert_haml(%q|%input(disabled=val)|, locals: { val: 'false' }) } it { assert_haml(%q|%input(disabled='false'){ disabled: true }|) } it { assert_haml(%q|%input(disabled='false'){ disabled: false }|) } it { assert_haml(%q|%input(disabled='false'){ disabled: nil }|) } it { assert_haml(%q|%input(disabled=''){ disabled: nil }|) } it { assert_haml(%q|%input(checked=true)|) } it { assert_haml(%q|%input(checked=true)|, format: :xhtml) } it { assert_haml(%q|%input{ 'data-overlay_modal' => nil }|) } it { assert_haml(%q|%input{ 'data-overlay_modal' => false }|) } it { assert_haml(%q|%input{ 'data-overlay_modal' => true }|) } it { assert_haml(%q|%input{ 'data-overlay_modal' => 'false' }|) } it { assert_haml(%q|%input{ :'data-overlay_modal' => val = nil }|) } it { assert_haml(%q|%input{ :'data-overlay_modal' => val = false }|) } it { assert_haml(%q|%input{ :'data-overlay_modal' => val = true }|) } it { assert_haml(%q|%input{ :'data-overlay_modal' => val = 'false' }|) } it { assert_haml(%q|%a{ hash }|, locals: { hash: { 'data-overlay_modal' => false } }) } it { assert_haml(%q|%a{ hash }|, locals: { hash: { 'data-overlay_modal' => true } }) } it { assert_haml(%q|%a{ 'disabled' => 60 }|) } end describe 'common attributes' do describe 'compatibility' do it { assert_haml(%Q|%a{ href: '/search?foo=bar&hoge=
foo
HTML %p %span foo HAML end it 'accepts N-tab indentation' do assert_render(<<-HTML.unindent, <<-HAML.unindent)foo
HTML %p \t%span \t\tfoo HAML end end end hamlit-2.7.5/test/hamlit/engine/multiline_test.rb 0000664 0000000 0000000 00000001437 13000345661 0022076 0 ustar 00root root 0000000 0000000 describe Hamlit::Engine do include RenderHelper describe 'multiline' do it 'joins multi-lines ending with pipe' do assert_render(<<-HTML.unindent, <<-HAML.unindent) a b HTML a | b | HAML end it 'renders multi lines' do assert_render(<<-HTML.unindent, <<-HAML.unindent) abc 'd' HTML = 'a' + | 'b' + | 'c' | 'd' HAML end it 'accepts invalid indent' do assert_render(<<-HTML.unindent, <<-HAML.unindent)bar
HTML %p(class='foo') bar HAML end it 'renders multiple attributes' do assert_render(<<-HTML.unindent, <<-HAML.unindent)bar
HTML %p(a=1 b=2) bar HAML end it 'renders hyphenated attributes properly' do assert_render(<<-HTML.unindent, <<-HAML.unindent)bar
HTML %p(data-foo='bar') bar HAML end it 'renders multiply hyphenated attributes properly' do assert_render(<<-HTML.unindent, <<-HAML.unindent)bar
HTML %p(data-x-foo='bar') bar HAML end describe 'html escape' do it 'escapes attribute values on static attributes' do assert_render(<<-HTML.unindent, <<-'HAML'.unindent) HTML %a(title="'") %a(title = "'\"") %a(href='/search?foo=bar&hoge=hello\nworld"
HAML
end
it 'renders comment-only nested script' do
assert_render('1', <<-HAML.unindent)
= 1.times do # comment
- # comment only
HAML
end
it 'renders inline script with comment' do
assert_render(%Q|3\n|, %q|%span= 1 + 2 # comments|)
end
end
end
hamlit-2.7.5/test/hamlit/engine/silent_script_test.rb 0000664 0000000 0000000 00000010016 13000345661 0022747 0 ustar 00root root 0000000 0000000 describe Hamlit::Engine do
include RenderHelper
describe 'silent script' do
it 'renders nothing' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
- nil
- 3
- 'foo'
HAML
end
it 'renders silent script' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
5
HTML
- foo = 3
- bar = 2
= foo + bar
HAML
end
it 'renders nested block' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
0
1
2
3
4
HTML
- 2.times do |i|
= i
2
- 3.upto(4).each do |i|
= i
HAML
end
it 'renders if' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
ok
HTML
- if true
ok
HAML
end
it 'renders if-else' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
ok
ok
HTML
- if true
ok
- else
ng
- if false
ng
- else
ok
HAML
end
it 'renders nested if-else' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
ok
HTML
%span
- if false
ng
- else
ok
HAML
end
it 'renders empty elsif statement' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
%span
- if false
- elsif false
HAML
end
it 'renders empty else statement' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
%span
- if false
ng
- else
HAML
end
it 'renders empty when statement' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
%span
- case
- when false
HAML
end
it 'accept if inside if-else' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
ok
HTML
- if false
- if true
ng
- else
ok
HAML
end
it 'renders if-elsif' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
ok
ok
HTML
- if false
- elsif true
ok
- if false
- elsif false
- else
ok
HAML
end
it 'renders case-when' do
assert_render(<<-HTML.unindent, <<-'HAML'.unindent)
ok
HTML
- case 'foo'
- when /\Ao/
ng
- when /\Af/
ok
- else
ng
HAML
end
it 'renders case-when with multiple candidates' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
ok
HTML
- case 'a'
- when 'a', 'b'
ok
HAML
end
it 'renders begin-rescue' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
hello
world
HTML
- begin
- raise 'error'
- rescue
hello
- ensure
world
HAML
end
it 'renders rescue with error' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
hello
HTML
- begin
- raise 'error'
- rescue RuntimeError => e
hello
HAML
end
it 'joins a next line if a current line ends with ","' do
assert_render(<<-HTML.unindent, "- foo = [', \n ']\n= foo")
[", "]
HTML
end
it 'accepts illegal indent in continuing code' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
'}
HAML
end
it 'renders ~ operator' do
assert_render(<<-HTML.unindent, <<-HAML.unindent, escape_html: false)
1
HTML
%span~ 1
HAML
end
end
describe 'string interpolation' do
it { assert_render("\n", '#{}') }
it { assert_render("1\n", '1#{}') }
it { assert_render("12\n", '1#{2}') }
it { assert_render("}1\n", '}#{1}') }
it { assert_render("12\n", '#{1}2') }
it { assert_render("12345\n", '1#{ "2#{3}4" }5') }
it { assert_render("123456789\n", '#{1}2#{3}4#{5}6#{7}8#{9}') }
it { assert_render(%Q{'"!@$%^&*|=1112\n}, %q{'"!@$%^&*|=#{1}1#{1}2}) }
it { assert_render("あ1\n", 'あ#{1}') }
it { assert_render("あいう\n", 'あ#{"い"}う') }
it { assert_render("a<b>c\n", 'a#{""}c') }
end
end
end
hamlit-2.7.5/test/hamlit/engine/whitespace_test.rb 0000664 0000000 0000000 00000005015 13000345661 0022224 0 ustar 00root root 0000000 0000000 describe Hamlit::Engine do
include RenderHelper
describe 'whitespace removal' do
it 'removes outer whitespace by >' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
ab
c
d
e
f
HTML
%span> a
%span b
%span c
%span>
d
%span
e
%span f
HAML
end
it 'removes outer whitespace by > from inside of block' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
a
b
c
HTML
%span a
- if true
%span>
b
%span
c
HAML
end
it 'removes whitespaces inside block script' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
foofoo2bar
HTML
%span<
= 2.times do
= 'foo'
%span> bar
HAML
end
it 'removes whitespace inside script inside silent script' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
.bar<
- 3.times do
= 'foo'
HAML
end
it 'removes whitespace inside script recursively' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
bar1bar1bar1bar12
HTML
.foo<
- 1.times do
= 2.times do
- 2.times do
= 1.times do
= 'bar'
HAML
end
it 'does not remove whitespace after string interpolation' do
assert_render(<<-HTML.unindent, <<-'HAML'.unindent)
helloworld
HTML
%div<
#{'hello'}
world
HAML
end
it 'removes whitespace inside script inside silent script' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
.bar<
- 1.times do
= '1'
= '2'
HAML
end
it 'does not nuke internal recursively' do
assert_render(%Q|\nhello\n|, <<-HAML.unindent)
%div><
%span>
hello
HAML
end
it 'does not nuke inside script' do
assert_render(%Q|\nhello\n1|, <<-HAML.unindent)
%div><
= 1.times do
%span>
hello
HAML
end
end
end
hamlit-2.7.5/test/hamlit/error_test.rb 0000664 0000000 0000000 00000002406 13000345661 0017755 0 ustar 00root root 0000000 0000000 describe Hamlit::Engine do
describe 'HamlSyntaxError' do
it 'raises on runtime' do
code = Hamlit::Engine.new.call(" %a")
assert_raises(Hamlit::HamlSyntaxError) do
eval code
end
end
it 'returns error with lines before error' do
code = Hamlit::Engine.new.call("\n\n %a")
begin
eval code
rescue Hamlit::HamlSyntaxError => e
assert_equal(2, e.line)
end
end
describe 'Hamlit v1 syntax' do
it 'returns an error with proper line number' do
code = Hamlit::Engine.new.call(<<-HAML.unindent)
%span
- if true
%div{ data: {
hello: 'world',
} }
HAML
begin
eval code
rescue Hamlit::HamlSyntaxError => e
assert_equal(3, e.line)
end
end
end
end
describe 'FilterNotFound' do
it 'raises on runtime' do
code = Hamlit::Engine.new.call(":k0kubun")
assert_raises(Hamlit::FilterNotFound) do
eval code
end
end
it 'returns error with lines before error' do
code = Hamlit::Engine.new.call("\n\n:k0kubun")
begin
eval code
rescue Hamlit::FilterNotFound => e
assert_equal(2, e.line)
end
end
end
end
hamlit-2.7.5/test/hamlit/filters/ 0000775 0000000 0000000 00000000000 13000345661 0016706 5 ustar 00root root 0000000 0000000 hamlit-2.7.5/test/hamlit/filters/cdata_test.rb 0000664 0000000 0000000 00000000771 13000345661 0021353 0 ustar 00root root 0000000 0000000 describe Hamlit::Filters do
include RenderHelper
describe '#compile' do
it 'renders cdata' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
:cdata
foo bar
HAML
end
it 'parses string interpolation' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
bar
]]>
HTML
:cdata
foo #{'<&>'} bar
HAML
end
end
end
hamlit-2.7.5/test/hamlit/filters/coffee_test.rb 0000664 0000000 0000000 00000002406 13000345661 0021523 0 ustar 00root root 0000000 0000000 describe Hamlit::Filters do
include RenderHelper
describe '#compile' do
it 'renders coffee filter' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
:coffee
foo = ->
alert('hello')
HAML
end
it 'renders coffeescript filter' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
:coffeescript
foo = ->
alert('hello')
HAML
end
it 'renders coffeescript filter' do
assert_render(<<-HTML.unindent, <<-'HAML'.unindent)
HTML
:coffee
foo = ->
alert("#{'<&>'}")
HAML
end
end
end
hamlit-2.7.5/test/hamlit/filters/css_test.rb 0000664 0000000 0000000 00000001205 13000345661 0021060 0 ustar 00root root 0000000 0000000 describe Hamlit::Filters do
include RenderHelper
describe '#compile' do
it 'renders css' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
:css
.foo {
width: 100px;
}
HAML
end
it 'parses string interpolation' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
:css
.foo {
content: "#{'<&>'}";
}
HAML
end
end
end
hamlit-2.7.5/test/hamlit/filters/erb_test.rb 0000664 0000000 0000000 00000000500 13000345661 0021035 0 ustar 00root root 0000000 0000000 describe Hamlit::Filters do
include RenderHelper
describe '#compile' do
it 'renders erb filter' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
ok
HTML
:erb
<% if true %>
ok
<% else %>
ng
<% end %>
HAML
end
end
end
hamlit-2.7.5/test/hamlit/filters/javascript_test.rb 0000664 0000000 0000000 00000003136 13000345661 0022443 0 ustar 00root root 0000000 0000000 describe Hamlit::Filters do
include RenderHelper
describe '#compile' do
it 'just renders script tag for empty filter' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
before
after
HTML
before
:javascript
after
HAML
end
it 'compiles javascript filter' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
before
after
HTML
before
:javascript
alert('hello');
after
HAML
end
it 'accepts illegal indentation' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
:javascript
if {
alert('hello');
}
:javascript
if {
alert('hello');
}
HAML
end
it 'accepts illegal indentation' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
:javascript
if {
alert('a');
}
HAML
end
it 'parses string interpolation' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
HTML
:javascript
var a = "#{'<&>'}";
HAML
end
end
end
hamlit-2.7.5/test/hamlit/filters/markdown_test.rb 0000664 0000000 0000000 00000001346 13000345661 0022120 0 ustar 00root root 0000000 0000000 describe Hamlit::Filters do
include RenderHelper
describe '#compile' do
it 'renders markdown filter' do
assert_render(<<-HTML.unindent, <<-HAML.unindent)
Hamlit
Yet another haml implementation
HTML :markdown # Hamlit Yet another haml implementation HAML end it 'renders markdown filter with string interpolation' do assert_render(<<-HTML.unindent, <<-'HAML'.unindent)<&> Yet another haml implementation
HTML - project = '