vendor/plugins/haml/.gitignore vendor/plugins/haml/README.rdoc vendor/plugins/haml/haml.gemspec vendor/plugins/haml/test/haml/results/nuke_inner_whitespace.xhtml vendor/plugins/haml/test/haml/results/nuke_outer_whitespace.xhtml vendor/plugins/haml/test/haml/templates/nuke_inner_whitespace.haml vendor/plugins/haml/test/haml/templates/nuke_outer_whitespace.haml vendor/plugins/haml/test/haml/test_helper.rb vendor/plugins/haml/test/sass/results/mixins.css vendor/plugins/haml/test/sass/results/multiline.css vendor/plugins/haml/test/sass/templates/mixins.sass vendor/plugins/haml/test/sass/templates/multiline.sass @@ -1,4 +1,4 @@ -Copyright (c) 2006-2007 Hampton Catlin +Copyright (c) 2006-2008 Hampton Catlin Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the vendor/plugins/haml/MIT-LICENSE @@ -20,153 +20,139 @@ END desc temp_desc.chomp task :benchmark do - require 'test/benchmark' - - puts "Running benchmarks #{ENV['TIMES']} times..." if ENV['TIMES'] - times = ENV['TIMES'].to_i if ENV['TIMES'] - Haml.benchmark(times || 100) - puts '-'*51 + sh "ruby test/benchmark.rb #{ENV['TIMES']}" end -# Benchmarking gets screwed up if some other tasks have been -# initialized. -unless ARGV[0] == 'benchmark' +# ----- Default: Testing ------ - # ----- Default: Testing ------ +desc 'Default: run unit tests.' +task :default => :test - desc 'Default: run unit tests.' - task :default => :test +require 'rake/testtask' - require 'rake/testtask' +Rake::TestTask.new do |t| + t.libs << 'lib' + t.pattern = 'test/**/*_test.rb' + t.verbose = true +end +Rake::Task[:test].send(:add_comment, <<END) +To run with an alternate version of Rails, make test/rails a symlink to that version. +END - desc 'Test the Haml plugin' - Rake::TestTask.new(:test) do |t| - t.libs << 'lib' - t.pattern = 'test/**/*_test.rb' - t.verbose = true - end +# ----- Packaging ----- - # ----- Packaging ----- - - require 'rake/gempackagetask' - - spec = Gem::Specification.new do |spec| - spec.name = 'haml' - spec.summary = "An elegant, structured XHTML/XML templating engine.\nComes with Sass, a similar CSS templating engine." - spec.version = File.read('VERSION').strip - spec.author = 'Hampton Catlin' - spec.email = 'haml@googlegroups.com' - spec.description = <<-END - Haml (HTML Abstraction Markup Language) is a layer on top of XHTML or XML - that's designed to express the structure of XHTML or XML documents - in a non-repetitive, elegant, easy way, - using indentation rather than closing tags - and allowing Ruby to be embedded with ease. - It was originally envisioned as a plugin for Ruby on Rails, - but it can function as a stand-alone templating engine. - END - #' - - readmes = FileList.new('*') do |list| - list.exclude(/[a-z]/) - list.exclude('TODO') - end.to_a - spec.executables = ['haml', 'html2haml', 'sass'] - spec.files = FileList['lib/**/*', 'bin/*', 'test/**/*', 'Rakefile', 'init.rb'].to_a + readmes - spec.autorequire = ['haml', 'sass'] - spec.homepage = 'http://haml.hamptoncatlin.com/' - spec.has_rdoc = true - spec.extra_rdoc_files = readmes - spec.rdoc_options += [ - '--title', 'Haml', - '--main', 'README', - '--exclude', 'lib/haml/buffer.rb', - '--line-numbers', - '--inline-source' - ] - spec.test_files = FileList['test/**/*_test.rb'].to_a - end +require 'rake/gempackagetask' +require 'lib/haml' +load 'haml.gemspec' - Rake::GemPackageTask.new(spec) do |pkg| - pkg.need_zip = true +Rake::GemPackageTask.new(HAML_GEMSPEC) do |pkg| + if Rake.application.top_level_tasks.include?('release') pkg.need_tar_gz = true pkg.need_tar_bz2 = true + pkg.need_zip = true end +end - task :install => [:package] do - sh %{gem install --no-ri pkg/haml-#{File.read('VERSION').strip}} +desc "This is an internal task." +task :revision_file do + if Haml.version[:rev] && !Rake.application.top_level_tasks.include?('release') + File.open('REVISION', 'w') { |f| f.puts Haml.version[:rev] } + elsif Rake.application.top_level_tasks.include?('release') + File.open('REVISION', 'w') { |f| f.puts "(release)" } + else + File.open('REVISION', 'w') { |f| f.puts "(unknown)" } end +end +Rake::Task[:package].prerequisites.insert(0, :revision_file) + +# We also need to get rid of this file after packaging. +Rake::Task[:package].enhance { File.delete('REVISION') if File.exists?('REVISION') } + +task :install => [:package] do + sudo = RUBY_PLATFORM =~ /win32/ ? '' : 'sudo' + sh %{#{sudo} gem install --no-ri pkg/haml-#{File.read('VERSION').strip}} +end + +task :release => [:package] do + name, version = ENV['NAME'], ENV['VERSION'] + raise "Must supply NAME and VERSION for release task." unless name && version + sh %{rubyforge login} + sh %{rubyforge add_release haml haml "#{name} (v#{version})" pkg/haml-#{version}.gem} + sh %{rubyforge add_file haml haml "#{name} (v#{version})" pkg/haml-#{version}.tar.gz} + sh %{rubyforge add_file haml haml "#{name} (v#{version})" pkg/haml-#{version}.tar.bz2} + sh %{rubyforge add_file haml haml "#{name} (v#{version})" pkg/haml-#{version}.zip} +end - # ----- Documentation ----- +# ----- Documentation ----- +begin + require 'hanna/rdoctask' +rescue LoadError require 'rake/rdoctask' +end - rdoc_task = Proc.new do |rdoc| - rdoc.title = 'Haml/Sass' - rdoc.options << '--line-numbers' << '--inline-source' - rdoc.rdoc_files.include('README') - rdoc.rdoc_files.include('lib/**/*.rb') - rdoc.rdoc_files.exclude('lib/haml/buffer.rb') - rdoc.rdoc_files.exclude('lib/haml/util.rb') - rdoc.rdoc_files.exclude('lib/sass/tree/*') - end +rdoc_task = Proc.new do |rdoc| + rdoc.title = 'Haml/Sass' + rdoc.options << '--line-numbers' << '--inline-source' + rdoc.rdoc_files.include('README.rdoc') + rdoc.rdoc_files.include('lib/**/*.rb') + rdoc.rdoc_files.exclude('lib/haml/buffer.rb') + rdoc.rdoc_files.exclude('lib/sass/tree/*') +end - Rake::RDocTask.new do |rdoc| - rdoc_task.call(rdoc) - rdoc.rdoc_dir = 'rdoc' - end +Rake::RDocTask.new do |rdoc| + rdoc_task.call(rdoc) + rdoc.rdoc_dir = 'rdoc' +end - Rake::RDocTask.new(:rdoc_devel) do |rdoc| - rdoc_task.call(rdoc) - rdoc.rdoc_dir = 'rdoc_devel' - rdoc.options << '--all' - rdoc.rdoc_files.include('test/*.rb') - - # Get rid of exclusion rules - rdoc.rdoc_files = Rake::FileList.new(*rdoc.rdoc_files.to_a) - rdoc.rdoc_files.include('lib/haml/buffer.rb') - rdoc.rdoc_files.include('lib/sass/tree/*') - end +Rake::RDocTask.new(:rdoc_devel) do |rdoc| + rdoc_task.call(rdoc) + rdoc.rdoc_dir = 'rdoc_devel' + rdoc.options << '--all' + rdoc.rdoc_files.include('test/*.rb') - # ----- Coverage ----- - - unless not_loaded.include? 'rcov/rcovtask' - Rcov::RcovTask.new do |t| - t.libs << "test" - t.test_files = FileList['test/**/*_test.rb'] - t.rcov_opts << '-x' << '"^\/"' - if ENV['NON_NATIVE'] - t.rcov_opts << "--no-rcovrt" - end - t.verbose = true + # Get rid of exclusion rules + rdoc.rdoc_files = Rake::FileList.new(*rdoc.rdoc_files.to_a) + rdoc.rdoc_files.include('lib/haml/buffer.rb') + rdoc.rdoc_files.include('lib/sass/tree/*') +end + +# ----- Coverage ----- + +unless not_loaded.include? 'rcov/rcovtask' + Rcov::RcovTask.new do |t| + t.test_files = FileList['test/**/*_test.rb'] + t.rcov_opts << '-x' << '"^\/"' + if ENV['NON_NATIVE'] + t.rcov_opts << "--no-rcovrt" end + t.verbose = true end +end - # ----- Profiling ----- +# ----- Profiling ----- - temp_desc = <<-END +temp_desc = <<-END Run a profile of haml. ENGINE=str sets the engine to be profiled (Haml or Sass). TIMES=n sets the number of runs. Defaults to 100. FILE=n sets the file to profile. Defaults to 'standard'. END - desc temp_desc.chomp - task :profile do - require 'test/profile' - - engine = ENV['ENGINE'] && ENV['ENGINE'].downcase == 'sass' ? Sass : Haml - - puts '-'*51, "Profiling #{engine}", '-'*51 - - args = [] - args.push ENV['TIMES'].to_i if ENV['TIMES'] - args.push ENV['FILE'] if ENV['FILE'] - - profiler = engine::Profiler.new - res = profiler.profile(*args) - puts res - - puts '-'*51 - end +desc temp_desc.chomp +task :profile do + require 'test/profile' + + engine = ENV['ENGINE'] && ENV['ENGINE'].downcase == 'sass' ? Sass : Haml + puts '-'*51, "Profiling #{engine}", '-'*51 + + args = [] + args.push ENV['TIMES'].to_i if ENV['TIMES'] + args.push ENV['FILE'] if ENV['FILE'] + + profiler = engine::Profiler.new + res = profiler.profile(*args) + puts res + + puts '-'*51 end vendor/plugins/haml/Rakefile @@ -1,17 +1,9 @@ -Bugs: - If an @imported document is changed, Sass should recompile the template - Testing: Test html2haml and css2sass -Documentation: - Haml::Engine public method documentation could use work - !! Document at-rules. - Features: Sass should throw generic errors for undefined constants, not syntax errors Sass::Plugin should log errors - There should be a way to represent options in-document There should be a way to make Haml tags not insert whitespace "%li, %a"? Sass::Engine load_paths option should be set by executable vendor/plugins/haml/TODO @@ -1,5 +1,4 @@ ;;; haml-mode.el -- Major mode for editing Haml files -;;; Version 0.0.1 ;;; Written by Nathan Weizenbaum ;;; Because Haml's indentation schema is similar @@ -7,13 +6,16 @@ ;;; functions are similar to those in yaml-mode and python-mode. ;;; To install, save this somewhere and add the following to your .emacs file: -;;; +;;; ;;; (add-to-list 'load-path "/path/to/haml-mode.el") ;;; (require 'haml-mode nil 't) -;;; +;;; (add-to-list 'auto-mode-alist '("\\.sass$" . sass-mode)) +;;; ;;; Code: +(eval-when-compile (require 'cl)) + ;; User definable variables (defgroup haml nil @@ -22,120 +24,73 @@ :prefix "haml-") (defcustom haml-mode-hook nil - "*Hook run by `haml-mode'." + "Hook run when entering Haml mode." :type 'hook :group 'haml) (defcustom haml-indent-offset 2 - "*Amount of offset per level of indentation." + "Amount of offset per level of indentation." :type 'integer :group 'haml) -(defcustom haml-backspace-function 'backward-delete-char-untabify - "*Function called by `haml-electric-backspace' when deleting backwards." - :type 'function +(defcustom haml-backspace-backdents-nesting t + "Non-nil to have `haml-electric-backspace' re-indent all code +nested beneath the backspaced line be re-indented along with the +line itself." + :type 'boolean :group 'haml) (defface haml-tab-face - '((((class color)) (:background "red" :foreground "red" :bold t)) - (t (:reverse-video t))) + '((((class color)) (:background "hotpink")) + (t (:reverse-video t))) "Face to use for highlighting tabs in Haml files." :group 'faces :group 'haml) -;; Helper Functions - -(defun string-* (str n) - "Concatenates a string with itself n times." - (if (= n 0) "" - (concat str (string-* str (- n 1))))) - -(defun find-if (f lst) - "Returns the first element of a list for which a function returns a non-nil value, or nil if no such element is found." - (while (not (or (null lst) - (apply f (list (car lst))))) - (setq lst (cdr lst))) - (if (null lst) nil (car lst))) - -(defun hre (str) - "Prepends a Haml-tab-matching regexp to str." - (concat "^\$" (string-* " " haml-indent-offset) "\$*" str)) +(defvar haml-indent-function 'haml-indent-p + "This function should look at the current line and return true +if the next line could be nested within this line.") + +(defvar haml-block-openers + `("^ *\$[%\\.#][^ \t]*\$\$\\[.*\\]\$?\${.*}\$?\$\\[.*\\]\$?[ \t]*$" + "^ *[-=].*do[ \t]*\$|.*|[ \t]*\$?$" + ,(concat "^ *-[ \t]*\$" + (regexp-opt '("else" "elsif" "rescue" "ensure" "when")) + "\$") + "^ */\$\\[.*\\]\$?[ \t]*$" + "^ *-#" + "^ *:") + "A list of regexps that match lines of Haml that could have +text nested beneath them.") ;; Font lock -(defconst haml-font-lock-keywords-1 - (list - ;; instruct - '("^!!!.*" 0 font-lock-constant-face) - ;; strings - '("\$'[^']*'\$" 1 font-lock-string-face append) - '("\$\"[^\"]*\"\$" 1 font-lock-string-face append) - ;; symbol - '("&?:\\w+" 0 font-lock-constant-face append) - ;; ruby varible - '("@[a-z0-9_]+" 0 font-lock-variable-name-face append) - ;; pipe - '("| *$" 0 font-lock-string-face) - ;; comment - '("^[ \t]*\$/.*\$$" 1 font-lock-comment-face append) - ;; id - '("^ *\$#[a-z0-9_]+\/?\$" 1 font-lock-keyword-face) - ;; class - '("^ *\$\\.[a-z0-9_]+\/?\$" 1 font-lock-type-face) - ;; tag - '("^ *\$%[a-z0-9_]+\/?\$" 1 font-lock-function-name-face ) - ;; class after id - '("^ *\$#[a-z0-9_]+\/?\$" (1 font-lock-keyword-face) ("\\.[a-z0-9_]+" nil nil (0 font-lock-type-face))) - ;; class after class - '("^ *\$\\.[a-z0-9_]+\/?\$" (1 font-lock-type-face) ("\\.[a-z0-9_]+" nil nil (0 font-lock-type-face))) - ;; id after class - '("^ *\$\\.[a-z0-9_]+\/?\$" (1 font-lock-type-face) ("\\#[a-z0-9_]+" nil nil (0 font-lock-keyword-face))) - ;; class after tag - '("^ *\$%[a-z0-9_]+\/?\$" (1 font-lock-function-name-face) ("\\.[a-z0-9_]+" nil nil (0 font-lock-type-face))) - ;; id after tag - '("^ *\$%[a-z0-9_]+\/?\$" (1 font-lock-function-name-face) ("\\#[a-z0-9_]+" nil nil (0 font-lock-keyword-face))) - ;; embeded ruby: beggin of line - '("^ *\$[~=-] .*\$" 1 font-lock-preprocessor-face prepend) - ;; embeded ruby: after tag,class,id - '("^ *[\\.#%a-z0-9_]+\$[~=-] .*\$" 1 font-lock-preprocessor-face prepend) - ;; embeded ruby: attributes - '("^ *[\\.#%a-z0-9_]+\${[^}]+}\$" 1 font-lock-preprocessor-face prepend) - ;; embeded ruby: square - '("^ *[\\.#%a-z0-9_]+\$\\[[^]]+\\]\$" 1 font-lock-preprocessor-face prepend))) - -;; Constants - -(defconst haml-mode-version "0.0.1" "Version of `haml-mode.'") - -(defconst haml-blank-line-re "^[ \t]*$" - "Regexp matching a line containing only whitespace.") - -; Base for Regexen matching a Haml tag. -(setq haml-tag-re-base (hre "\$[%\\.#][^ \t]*\$\${.*}\$?\$\\[.*\\]\$?")) - -(defconst haml-tag-nest-re (concat haml-tag-re-base "[ \t]*$") - "Regexp matching a Haml tag that can have nested elements.") - -(defconst haml-tag-re (concat haml-tag-re-base "\$.?\$") - "Regexp matching a Haml tag.") - -(defconst haml-block-re (hre "[-=].*do[ \t]*\$|.*|[ \t]*\$?$") - "Regexp matching a Ruby block in Haml.") - -(defconst haml-block-cont-re (hre (concat "-[ \t]*" - (regexp-opt '("else" "elsif" - "rescue" "ensure" - "when")))) - "Regexp matching a continued Ruby block in Haml.") - -(defconst haml-html-comment-re (hre "/\$\\[.*\\]\$?[ \t]*$") - "Regexp matching a Haml HTML comment command.") - -(defconst haml-comment-re (hre "-#[ \t]$") - "Regexp matching a Haml comment command.") - -(defconst haml-filter-re (hre ":") - "Regexp matching a Haml filter command.") +(defconst haml-font-lock-keywords + '(("^ *\$\t\$" 1 'haml-tab-face) + ("^!!!.*" 0 font-lock-constant-face) + ("\$'[^']*'\$" 1 font-lock-string-face append) + ("\$\"[^\"]*\"\$" 1 font-lock-string-face append) + ("&?:\\w+" 0 font-lock-constant-face append) + ("@[a-z0-9_]+" 0 font-lock-variable-name-face append) + ("| *$" 0 font-lock-string-face) + ("^[ \t]*\$/.*\$$" 1 font-lock-comment-face append) + ("^ *\$#[a-z0-9_]+\/?\$" 1 font-lock-keyword-face) + ("^ *\$\\.[a-z0-9_]+\/?\$" 1 font-lock-type-face) + ("^ *\$%[a-z0-9_]+\/?\$" 1 font-lock-function-name-face) + ("^ *\$#[a-z0-9_]+\/?\$" (1 font-lock-keyword-face) + ("\\.[a-z0-9_]+" nil nil (0 font-lock-type-face))) + ("^ *\$\\.[a-z0-9_]+\/?\$" (1 font-lock-type-face) + ("\\.[a-z0-9_]+" nil nil (0 font-lock-type-face))) + ("^ *\$\\.[a-z0-9_]+\/?\$" (1 font-lock-type-face) + ("\\#[a-z0-9_]+" nil nil (0 font-lock-keyword-face))) + ("^ *\$%[a-z0-9_]+\/?\$" (1 font-lock-function-name-face) + ("\\.[a-z0-9_]+" nil nil (0 font-lock-type-face))) + ("^ *\$%[a-z0-9_]+\/?\$" (1 font-lock-function-name-face) + ("\\#[a-z0-9_]+" nil nil (0 font-lock-keyword-face))) + ("^ *\$[~=-] .*\$" 1 font-lock-preprocessor-face prepend) + ("^ *[\\.#%a-z0-9_]+\$[~=-] .*\$" 1 font-lock-preprocessor-face prepend) + ("^ *[\\.#%a-z0-9_]+\${[^}]+}\$" 1 font-lock-preprocessor-face prepend) + ("^ *[\\.#%a-z0-9_]+\$\\[[^]]+\\]\$" 1 font-lock-preprocessor-face prepend))) ;; Mode setup @@ -146,45 +101,169 @@ table) "Syntax table in use in haml-mode buffers.") -(defvar haml-mode-map () - "Keymap used in `haml-mode' buffers.") -(if haml-mode-map - nil - (setq haml-mode-map (make-sparse-keymap)) - (define-key haml-mode-map [backspace] 'haml-electric-backspace) - (define-key haml-mode-map "\C-?" 'haml-electric-backspace) - (define-key haml-mode-map "\C-j" 'newline-and-indent)) +(defvar haml-mode-map + (let ((map (make-sparse-keymap))) + (define-key map [backspace] 'haml-electric-backspace) + (define-key map "\C-?" 'haml-electric-backspace) + (define-key map "\C-\M-f" 'haml-forward-sexp) + (define-key map "\C-\M-b" 'haml-backward-sexp) + (define-key map "\C-\M-u" 'haml-up-list) + (define-key map "\C-\M-d" 'haml-down-list) + (define-key map "\C-C\C-k" 'haml-kill-line-and-indent) + map)) (define-derived-mode haml-mode fundamental-mode "Haml" - "Simple mode to edit Haml. + "Major mode for editing Haml files. \\{haml-mode-map}" (set-syntax-table haml-mode-syntax-table) (set (make-local-variable 'indent-line-function) 'haml-indent-line) - (set (make-local-variable 'font-lock-defaults) - '((haml-font-lock-keywords-1) - nil - t))) + (set (make-local-variable 'indent-region-function) 'haml-indent-region) + (set (make-local-variable 'forward-sexp-function) 'haml-forward-sexp) + (setq font-lock-defaults '((haml-font-lock-keywords) nil t))) + +;; Navigation + +(defun haml-forward-through-whitespace (&optional backward) + "Move the point forward at least one line, until it reaches +either the end of the buffer or a line with no whitespace. + +If `backward' is non-nil, move the point backward instead." + (let ((arg (if backward -1 1)) + (endp (if backward 'bobp 'eobp))) + (loop do (forward-line arg) + while (and (not (funcall endp)) + (looking-at "^[ \t]*$"))))) + +(defun haml-at-indent-p () + "Returns whether or not the point is at the first +non-whitespace character in a line or whitespace preceding that +character." + (let ((opoint (point))) + (save-excursion + (back-to-indentation) + (>= (point) opoint)))) + +(defun haml-forward-sexp (&optional arg) + "Move forward across one nested expression. +With `arg', do it that many times. Negative arg -N means move +backward across N balanced expressions. + +A sexp in Haml is defined as a line of Haml code as well as any +lines nested beneath it." + (interactive "p") + (or arg (setq arg 1)) + (if (and (< arg 0) (not (haml-at-indent-p))) + (back-to-indentation) + (while (/= arg 0) + (let ((indent (current-indentation))) + (loop do (haml-forward-through-whitespace (< arg 0)) + while (and (not (eobp)) + (not (bobp)) + (> (current-indentation) indent))) + (back-to-indentation) + (setq arg (+ arg (if (> arg 0) -1 1))))))) + +(defun haml-backward-sexp (&optional arg) + "Move backward across one nested expression. +With ARG, do it that many times. Negative arg -N means move +forward across N balanced expressions. + +A sexp in Haml is defined as a line of Haml code as well as any +lines nested beneath it." + (interactive "p") + (haml-forward-sexp (if arg (- arg) -1))) + +(defun haml-up-list (&optional arg) + "Move out of one level of nesting. +With ARG, do this that many times." + (interactive "p") + (or arg (setq arg 1)) + (while (> arg 0) + (let ((indent (current-indentation))) + (loop do (haml-forward-through-whitespace t) + while (and (not (bobp)) + (>= (current-indentation) indent))) + (setq arg (- arg 1)))) + (back-to-indentation)) + +(defun haml-down-list (&optional arg) + "Move down one level of nesting. +With ARG, do this that many times." + (interactive "p") + (or arg (setq arg 1)) + (while (> arg 0) + (let ((indent (current-indentation))) + (haml-forward-through-whitespace) + (when (<= (current-indentation) indent) + (haml-forward-through-whitespace t) + (back-to-indentation) + (error "Nothing is nested beneath this line")) + (setq arg (- arg 1)))) + (back-to-indentation)) + +(defun haml-mark-sexp-but-not-next-line () + "Marks the next Haml sexp, but puts the mark at the end of the +last line of the sexp rather than the first non-whitespace +character of the next line." + (mark-sexp) + (set-mark + (save-excursion + (goto-char (mark)) + (forward-line -1) + (end-of-line) + (point)))) ;; Indentation and electric keys +(defun haml-indent-p () + "Returns true if the current line can have lines nested beneath it." + (loop for opener in haml-block-openers + if (looking-at opener) return t + finally return nil)) + (defun haml-compute-indentation () "Calculate the maximum sensible indentation for the current line." (save-excursion (beginning-of-line) - (if (bobp) 10 - (forward-line -1) - (while (and (looking-at haml-blank-line-re) - (> (point) (point-min))) - (forward-line -1)) + (if (bobp) 0 + (haml-forward-through-whitespace t) (+ (current-indentation) - (if (or (looking-at haml-filter-re) - (looking-at haml-comment-re) - (looking-at haml-html-comment-re) - (looking-at haml-block-cont-re) - (looking-at haml-tag-nest-re) - (looking-at haml-block-re)) - haml-indent-offset 0))))) + (if (funcall haml-indent-function) haml-indent-offset + 0))))) + +(defun haml-indent-region (start end) + "Indent each nonblank line in the region. +This is done by indenting the first line based on +`haml-compute-indentation' and preserving the relative +indentation of the rest of the region. + +If this command is used multiple times in a row, it will cycle +between possible indentations." + (save-excursion + (goto-char end) + (setq end (point-marker)) + (goto-char start) + (let (this-line-column current-column + (next-line-column + (if (and (equal last-command this-command) (/= (current-indentation) 0)) + (* (/ (- (current-indentation) 1) haml-indent-offset) haml-indent-offset) + (haml-compute-indentation)))) + (while (< (point) end) + (setq this-line-column next-line-column + current-column (current-indentation)) + ;; Delete whitespace chars at beginning of line + (delete-horizontal-space) + (unless (eolp) + (setq next-line-column (save-excursion + (loop do (forward-line 1) + while (and (not (eobp)) (looking-at "^[ \t]*$"))) + (+ this-line-column + (- (current-indentation) current-column)))) + ;; Don't indent an empty line + (unless (eolp) (indent-to this-line-column))) + (forward-line 1))) + (move-marker end nil))) (defun haml-indent-line () "Indent the current line. @@ -205,33 +284,46 @@ back-dent the line by `haml-indent-offset' spaces. On reaching column (if (< (current-column) (current-indentation)) (forward-to-indentation 0)))) +(defun haml-reindent-region-by (n) + "Add N spaces to the beginning of each line in the region. +If N is negative, will remove the spaces instead. Assumes all +lines in the region have indentation >= that of the first line." + (let ((ci (current-indentation))) + (save-excursion + (replace-regexp (concat "^" (make-string ci ? )) + (make-string (max 0 (+ ci n)) ? ) + nil (point) (mark))))) + (defun haml-electric-backspace (arg) "Delete characters or back-dent the current line. -If invoked following only whitespace on a line, will back-dent to the -immediately previous multiple of `haml-indent-offset' spaces." +If invoked following only whitespace on a line, will back-dent +the line and all nested lines to the immediately previous +multiple of `haml-indent-offset' spaces. + +Set `haml-backspace-backdents-nesting' to nil to just back-dent +the current line." (interactive "*p") - (if (or (/= (current-indentation) (current-column)) (bolp)) - (funcall haml-backspace-function arg) + (if (or (/= (current-indentation) (current-column)) + (bolp) + (looking-at "^[ \t]+$")) + (backward-delete-char arg) (let ((ci (current-column))) (beginning-of-line) - (delete-horizontal-space) - (indent-to (* (/ (- ci (* arg haml-indent-offset)) - haml-indent-offset) - haml-indent-offset))))) + (if haml-backspace-backdents-nesting + (haml-mark-sexp-but-not-next-line) + (set-mark (save-excursion (end-of-line) (point)))) + (haml-reindent-region-by (* (- arg) haml-indent-offset)) + (back-to-indentation) + (pop-mark)))) + +(defun haml-kill-line-and-indent () + "Kill the current line, and re-indent all lines nested beneath it." + (interactive) + (beginning-of-line) + (haml-mark-sexp-but-not-next-line) + (kill-line 1) + (haml-reindent-region-by (* -1 haml-indent-offset))) ;; Setup/Activation -(defun haml-mode-version () - "Diplay version of `haml-mode'." - (interactive) - (message "haml-mode %s" haml-mode-version) - haml-mode-version) - (provide 'haml-mode) - -(unless (find-if - #'(lambda(it) (string= it "\\.haml\\'")) - (mapcar 'car auto-mode-alist)) - (add-to-list 'auto-mode-alist '("\\.haml\\'" . haml-mode))) - -;;; haml-mode.el ends here vendor/plugins/haml/extra/haml-mode.el @@ -1,5 +1,4 @@ ;;; sass-mode.el -- Major mode for editing Sass files -;;; Version 0.0.1 ;;; Written by Nathan Weizenbaum ;;; Because Sass's indentation schema is similar @@ -7,13 +6,16 @@ ;;; functions are similar to those in yaml-mode and python-mode. ;;; To install, save this somewhere and add the following to your .emacs file: -;;; +;;; ;;; (add-to-list 'load-path "/path/to/sass-mode.el") ;;; (require 'sass-mode nil 't) -;;; +;;; (add-to-list 'auto-mode-alist '("\\.sass$" . sass-mode)) +;;; ;;; Code: +(require 'haml-mode) + ;; User definable variables (defgroup sass nil @@ -22,134 +24,65 @@ :prefix "sass-") (defcustom sass-mode-hook nil - "*Hook run by `sass-mode'." + "Hook run when entering Sass mode." :type 'hook :group 'sass) (defcustom sass-indent-offset 2 - "*Amount of offset per level of indentation." + "Amount of offset per level of indentation." :type 'integer :group 'sass) -(defcustom sass-backspace-function 'backward-delete-char-untabify - "*Function called by `sass-electric-backspace' when deleting backwards." - :type 'function - :group 'sass) - -(defface sass-tab-face - '((((class color)) (:background "red" :foreground "red" :bold t)) - (t (:reverse-video t))) - "Face to use for highlighting tabs in Sass files." - :group 'faces - :group 'sass) - -;; Helper Functions - -(defun string-* (str n) - "Concatenates a string with itself n times." - (if (= n 0) "" - (concat str (string-* str (- n 1))))) - -(defun find-if (f lst) - "Returns the first element of a list for which a function returns a non-nil value, or nil if no such element is found." - (while (not (or (null lst) - (apply f (list (car lst))))) - (setq lst (cdr lst))) - (if (null lst) nil (car lst))) - -(defun sre (str) - "Prepends a Sass-tab-matching regexp to str." - (concat "^\$" (string-* " " sass-indent-offset) "\$*" str)) +(defvar sass-non-block-openers + '("^ *:[^ \t]+[ \t]+[^ \t]" + "^ *[^ \t:]+[ \t]*[=:][ \t]*[^ \t]") + "A list of regexps that match lines of Sass that couldn't have +text nested beneath them.") + +;; Font lock + +(defconst sass-font-lock-keywords + '(("^ *\$\t\$" 1 'haml-tab-face) + ("^@.*" 0 font-lock-constant-face) + ("\$\'[^']*'\$" 1 font-lock-string-face append) + ("\$\"[^\"]*\"\$" 1 font-lock-string-face append) + ("\$#[0-9a-fA-F]\\{3\\}\\{1,2\\}\\>\$" 1 font-lock-string-face append) + ("\$:[A-Za-z-]+\\|[A-Za-z-]+:\$" 0 font-lock-constant-face append) + ("![a-z0-9_-]+" 0 font-lock-variable-name-face append) + ("^ *\$/[/*].*\$$" 1 font-lock-comment-face append) + ("\$?:^\\|,\$ *\$#[a-z0-9_-]+\/?\$" 1 font-lock-keyword-face) + ("\$?:^\\|,\$ *\$\\.[a-z0-9_-]+\/?\$" 1 font-lock-type-face) + ("\$?:^\\|,\$ *\$&\\|[a-z0-9_]+\/?\$" 1 font-lock-function-name-face) + ("\$[=]\$" 0 font-lock-preprocessor-face prepend) + ("\$?:^\\|,\$ *\$#[a-z0-9_]+\/?\$" (1 font-lock-keyword-face) + ("\\.[a-z0-9_-]+" nil nil (0 font-lock-type-face))) + ("\$?:^\\|,\$ *\$\\.[a-z0-9_]+\/?\$" (1 font-lock-type-face) + ("\\.[a-z0-9_-]+" nil nil (0 font-lock-type-face))) + ("\$?:^\\|,\$ *\$\\.[a-z0-9_]+\/?\$" (1 font-lock-type-face) + ("\\#[a-z0-9_-]+" nil nil (0 font-lock-keyword-face))) + ("\$?:^\\|,\$ *\$&\\|[a-z0-9_]+\/?\$" (1 font-lock-function-name-face) + ("\\.[a-z0-9_-]+" nil nil (0 font-lock-type-face))) + ("\$?:^\\|,\$ *\$&\\|[a-z0-9_]+\/?\$" (1 font-lock-function-name-face) + ("\\#[a-z0-9_-]+" nil nil (0 font-lock-keyword-face))))) ;; Constants -(defconst sass-mode-version "0.0.1" "Version of `sass-mode.'") - -(defconst sass-blank-line-re "^[ \t]*$" - "Regexp matching a line containing only whitespace.") +;; Mode setup -(defconst sass-full-attr-re (sre ":[^ \t]+[ \t]+[^ \t]") - "Regexp matching a Sass attribute with content.") +(define-derived-mode sass-mode haml-mode "Sass" + "Major mode for editing Sass files." + (set (make-local-variable 'haml-indent-function) 'sass-indent-p) + (set (make-local-variable 'haml-indent-offset) sass-indent-offset) + (setq font-lock-defaults '(sass-font-lock-keywords nil t))) -;; Mode setup +;; Indentation -(defvar sass-mode-map () - "Keymap used in `sass-mode' buffers.") -(if sass-mode-map - nil - (setq sass-mode-map (make-sparse-keymap)) - (define-key sass-mode-map [backspace] 'sass-electric-backspace) - (define-key sass-mode-map "\C-?" 'sass-electric-backspace) - (define-key sass-mode-map "\C-j" 'newline-and-indent)) - -(define-derived-mode sass-mode fundamental-mode "Sass" - "Simple mode to edit Sass. - -\\{sass-mode-map}" - (set (make-local-variable 'indent-line-function) 'sass-indent-line)) - -;; Indentation and electric keys - -(defun sass-compute-indentation () - "Calculate the maximum sensible indentation for the current line." - (save-excursion - (beginning-of-line) - (if (bobp) 10 - (forward-line -1) - (while (and (looking-at sass-blank-line-re) - (> (point) (point-min))) - (forward-line -1)) - (+ (current-indentation) - (if (not (looking-at sass-full-attr-re)) - sass-indent-offset 0))))) - -(defun sass-indent-line () - "Indent the current line. -The first time this command is used, the line will be indented to the -maximum sensible indentation. Each immediately subsequent usage will -back-dent the line by `sass-indent-offset' spaces. On reaching column -0, it will cycle back to the maximum sensible indentation." - (interactive "*") - (let ((ci (current-indentation)) - (cc (current-column)) - (need (sass-compute-indentation))) - (save-excursion - (beginning-of-line) - (delete-horizontal-space) - (if (and (equal last-command this-command) (/= ci 0)) - (indent-to (* (/ (- ci 1) sass-indent-offset) sass-indent-offset)) - (indent-to need))) - (if (< (current-column) (current-indentation)) - (forward-to-indentation 0)))) - -(defun sass-electric-backspace (arg) - "Delete characters or back-dent the current line. -If invoked following only whitespace on a line, will back-dent to the -immediately previous multiple of `sass-indent-offset' spaces." - (interactive "*p") - (if (or (/= (current-indentation) (current-column)) (bolp)) - (funcall sass-backspace-function arg) - (let ((ci (current-column))) - (beginning-of-line) - (delete-horizontal-space) - (indent-to (* (/ (- ci (* arg sass-indent-offset)) - sass-indent-offset) - sass-indent-offset))))) +(defun sass-indent-p () + "Returns true if the current line can have lines nested beneath it." + (loop for opener in sass-non-block-openers + unless (looking-at opener) return t + return nil)) ;; Setup/Activation -(defun sass-mode-version () - "Diplay version of `sass-mode'." - (interactive) - (message "sass-mode %s" sass-mode-version) - sass-mode-version) - (provide 'sass-mode) - - -(unless (find-if - #'(lambda(it) (string= it "\\.sass\\'")) - (mapcar 'car auto-mode-alist)) - (add-to-list 'auto-mode-alist '("\\.sass\\'" . sass-mode))) - -;;; sass-mode.el ends here vendor/plugins/haml/extra/sass-mode.el @@ -2,18 +2,18 @@ dir = File.dirname(__FILE__) $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # = Haml (XHTML Abstraction Markup Language) -# +# # Haml is a markup language # that's used to cleanly and simply describe the XHTML of any web document, # without the use of inline code. # Haml functions as a replacement -# for inline page templating systems such as PHP, ERB, and ASP. -# However, Haml avoids the need for explicitly coding XHTML into the template, +# for inline page templating systems such as PHP, ERB, and ASP. +# However, Haml avoids the need for explicitly coding XHTML into the template, # because it is actually an abstract description of the XHTML, # with some code to generate dynamic content. -# +# # == Features -# +# # * Whitespace active # * Well-formatted markup # * DRY @@ -36,9 +36,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # # To enable it as a Rails plugin, # then run -# +# # haml --rails path/to/rails/app -# +# # Haml is enabled in Merb by default, # so Merb users don't have to do anything more. # @@ -50,24 +50,24 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # the same way you do in ERb templates. # Helper methods are also available in Haml templates. # For example (this example uses Rails, but the principle for Merb is the same): -# +# # # file: app/controllers/movies_controller.rb -# +# # class MoviesController < ApplicationController # def index # @title = "Teen Wolf" # end # end -# +# # -# file: app/views/movies/index.haml -# +# # #content # .title # %h1= @title # = link_to 'Home', home_url -# +# # may be compiled to: -# +# # <div id='content'> # <div class='title'> # <h1>Teen Wolf</h1> @@ -89,41 +89,41 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # engine.render #=> "<p>Haml code!</p>\n" # # == Characters with meaning to Haml -# +# # Various characters, when placed at a certain point in a line, # instruct Haml to render different types of things. -# +# # === XHTML Tags -# +# # These characters render XHTML tags. -# +# # ==== % -# -# +# +# # The percent character is placed at the beginning of a line. # It's followed immediately by the name of an element, # then optionally by modifiers (see below), a space, # and text to be rendered inside the element. # It creates an element in the form of <tt><element></element></tt>. # For example: -# +# # %one # %two # %three Hey there -# +# # is compiled to: -# +# # <one> # <two> # <three>Hey there</three> # </two> # </one> -# +# # Any string is a valid element name; # Haml will automatically generate opening and closing tags for any element. -# +# # ==== {} -# +# # Brackets represent a Ruby hash # that is used for specifying the attributes of an element. # It is literally evaluated as a Ruby hash, @@ -132,20 +132,88 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # will be replaced by appropriate escape sequences. # The hash is placed after the tag is defined. # For example: -# +# # %head{ :name => "doc_head" } # %script{ 'type' => "text/" + "javascript", # :src => "javascripts/script_#{2 + 7}" } -# +# # is compiled to: -# +# # <head name="doc_head"> # <script src='javascripts/script_9' type='text/javascript'> # </script> # </head> -# +# +# ===== Attribute Methods +# +# A Ruby method call that returns a hash +# can be substituted for the hash contents. +# For example, Haml::Helpers defines the following method: +# +# def html_attrs(lang = 'en-US') +# {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang} +# end +# +# This can then be used in Haml, like so: +# +# %html{html_attrs('fr-fr')} +# +# This is compiled to: +# +# <html lang='fr-fr' xml:lang='fr=fr' xmlns='http://www.w3.org/1999/xhtml'> +# </html> +# +# You can use as many such attribute methods as you want +# by separating them with commas, +# like a Ruby argument list. +# All the hashes will me merged together, from left to right. +# For example, if you defined +# +# def hash1 +# {:bread => 'white', :filling => 'peanut butter and jelly'} +# end +# +# def hash2 +# {:bread => 'whole wheat'} +# end +# +# then +# +# %sandwich{hash1, hash2, :delicious => true}/ +# +# would compile to: +# +# <sandwich bread='whole wheat' delicious='true' filling='peanut butter and jelly' /> +# +# ===== Boolean Attributes +# +# Some attributes, such as "checked" for <tt>input</tt> tags or "selected" for <tt>option</tt> tags, +# are "boolean" in the sense that their values don't matter - +# it only matters whether or not they're present. +# In HTML (but not XHTML), these attributes can be written as +# +# <input selected> +# +# To do this in Haml, just assign a Ruby true value to the attribute: +# +# %input{:selected => true} +# +# In XHTML, the only valid value for these attributes is the name of the attribute. +# Thus this will render in XHTML as +# +# <input selected="selected"> +# +# To set these attributes to false, simply assign them to a Ruby false value. +# In both XHTML and HTML +# +# %input{:selected => false} +# +# will just render as +# +# <input> +# # ==== [] -# +# # Square brackets follow a tag definition and contain a Ruby object # that is used to set the class and id of that tag. # The class is set to the object's class @@ -153,41 +221,40 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # and the id is set to the object's class, followed by its id. # Because the id of an object is normally an obscure implementation detail, # this is most useful for elements that represent instances of Models. +# Additionally, the second argument (if present) will be used as a prefix for +# both the id and class attributes. # For example: -# +# # # file: app/controllers/users_controller.rb -# +# # def show # @user = CrazyUser.find(15) # end -# +# # -# file: app/views/users/show.haml -# -# %div[@user] +# +# %div[@user, :greeting] # %bar[290]/ # Hello! -# +# # is compiled to: -# -# <div class="crazy_user" id="crazy_user_15"> +# +# <div class="greeting_crazy_user" id="greeting_crazy_user_15"> # <bar class="fixnum" id="fixnum_581" /> # Hello! # </div> -# -# This is based off of DHH's SimplyHelpful syntax, -# as presented at RailsConf Europe 2006. -# +# # ==== / -# +# # The forward slash character, when placed at the end of a tag definition, # causes the tag to be self-closed. # For example: -# +# # %br/ # %meta{'http-equiv' => 'Content-Type', :content => 'text/html'}/ -# +# # is compiled to: -# +# # <br /> # <meta http-equiv='Content-Type' content='text/html' /> # @@ -203,9 +270,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # # <br /> # <meta http-equiv='Content-Type' content='text/html' /> -# +# # ==== . and # -# +# # The period and pound sign are borrowed from CSS. # They are used as shortcuts to specify the <tt>class</tt> # and <tt>id</tt> attributes of an element, respectively. @@ -213,22 +280,22 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # by chaining the class names together with periods. # They are placed immediately after the tag and before an attributes hash. # For example: -# +# # %div#things # %span#rice Chicken Fried # %p.beans{ :food => 'true' } The magical fruit # %h1.class.otherclass#id La La La -# +# # is compiled to: -# +# # <div id='things'> # <span id='rice'>Chicken Fried</span> # <p class='beans' food='true'>The magical fruit</p> # <h1 class='class otherclass' id='id'>La La La</h1> # </div> -# +# # And, -# +# # #content # .articles # .article.title @@ -237,9 +304,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # 2006-11-05 # .article.entry # Neil Patrick Harris would like to dispel any rumors that he is straight -# +# # is compiled to: -# +# # <div id="content"> # <div class="articles"> # <div class="article title">Doogie Howser Comes Out</div> @@ -249,34 +316,89 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # </div> # </div> # </div> -# +# # ==== Implicit Div Elements -# +# # Because the div element is used so often, it is the default element. # If you only define a class and/or id using the <tt>.</tt> or <tt>#</tt> syntax, # a div element is automatically used. # For example: -# +# # #collection # .item # .description What a cool item! -# +# # is the same as: -# +# # %div{:id => collection} # %div{:class => 'item'} # %div{:class => 'description'} What a cool item! -# +# # and is compiled to: -# +# # <div id='collection'> # <div class='item'> # <div class='description'>What a cool item!</div> # </div> # </div> -# +# +# ==== > and < +# +# <tt>></tt> and <tt><</tt> give you more control over the whitespace near a tag. +# <tt>></tt> will remove all whitespace surrounding a tag, +# while <tt><</tt> will remove all whitespace immediately within a tag. +# You can think of them as alligators eating the whitespace: +# <tt>></tt> faces out of the tag and eats the whitespace on the outside, +# and <tt><</tt> faces into the tag and eats the whitespace on the inside. +# They're placed at the end of a tag definition, +# after class, id, and attribute declarations +# but before <tt>/</tt> or <tt>=</tt>. +# For example: +# +# %blockquote< +# %div +# Foo! +# +# is compiled to: +# +# <blockquote><div> +# Foo! +# </div></blockquote> +# +# And: +# +# %img +# %img> +# %img +# +# is compiled to: +# +# <img /><img /><img /> +# +# And: +# +# %p<= "Foo\nBar" +# +# is compiled to: +# +# <p>Foo +# Bar</p> +# +# And finally: +# +# %img +# %pre>< +# foo +# bar +# %img +# +# is compiled to: +# +# <img /><pre>foo +# bar</pre><img /> +# # ==== = -# +# # <tt>=</tt> is placed at the end of a tag definition, # after class, id, and attribute declarations. # It's just a shortcut for inserting Ruby code into an element. @@ -285,45 +407,63 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # However, if the result is short enough, # it is displayed entirely on one line. # For example: -# +# # %p= "hello" -# +# # is not quite the same as: -# +# # %p # = "hello" -# +# # It's compiled to: -# +# # <p>hello</p> -# +# +# ==== ~ +# +# ~ works just like =, except that it runs Haml::Helpers#find_and_preserve on its input. +# For example, +# +# ~ "Foo\n<pre>Bar\nBaz</pre>" +# +# is the same as: +# +# = find_and_preserve("Foo\n<pre>Bar\nBaz</pre>") +# +# and is compiled to: +# +# Foo +# <pre>Bar
Baz</pre> +# +# See also Whitespace Preservation, below. +# # === XHTML Helpers -# +# # ==== No Special Character -# +# # If no special character appears at the beginning of a line, # the line is rendered as plain text. # For example: -# +# # %gee # %whiz # Wow this is cool! -# +# # is compiled to: -# +# # <gee> # <whiz> # Wow this is cool! # </whiz> # </gee> -# +# # ==== !!! -# +# # When describing XHTML documents with Haml, # you can have a document type or XML prolog generated automatically # by including the characters <tt>!!!</tt>. # For example: -# +# # !!! XML # !!! # %html @@ -332,9 +472,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # %body # %h1 I am the international space station # %p Sign my guestbook -# +# # is compiled to: -# +# # <?xml version="1.0" encoding="utf-8" ?> # <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> # <html> @@ -346,112 +486,112 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # <p>Sign my guestbook</p> # </body> # </html> -# +# # You can also specify the version and type of XHTML after the <tt>!!!</tt>. # XHTML 1.0 Strict, Transitional, and Frameset and XHTML 1.1 are supported. # The default version is 1.0 and the default type is Transitional. # For example: -# +# # !!! 1.1 -# +# # is compiled to: -# +# # <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> -# +# # and -# +# # !!! Strict -# +# # is compiled to: -# +# # <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> -# +# # If you're not using the UTF-8 character set for your document, # you can specify which encoding should appear # in the XML prolog in a similar way. # For example: -# +# # !!! XML iso-8859-1 -# +# # is compiled to: -# +# # <?xml version="1.0" encoding="iso-8859-1" ?> -# +# # ==== / -# +# # The forward slash character, when placed at the beginning of a line, # wraps all text after it in an HTML comment. # For example: -# +# # %peanutbutterjelly # / This is the peanutbutterjelly element # I like sandwiches! -# +# # is compiled to: -# +# # <peanutbutterjelly> #  # I like sandwiches! # </peanutbutterjelly> -# +# # The forward slash can also wrap indented sections of code. For example: -# +# # / # %p This doesn't render... # %div # %h1 Because it's commented out! -# +# # is compiled to: -# +# #  -# +# # You can also use Internet Explorer conditional comments # (about)[http://www.quirksmode.org/css/condcom.html] # by enclosing the condition in square brackets after the <tt>/</tt>. # For example: -# +# # /[if IE] # %a{ :href => 'http://www.mozilla.com/en-US/firefox/' } # %h1 Get Firefox -# +# # is compiled to: -# +# #  -# +# # ==== \ -# +# # The backslash character escapes the first character of a line, # allowing use of otherwise interpreted characters as plain text. # For example: -# +# # %title # = @title # \- MySite -# +# # is compiled to: -# +# # <title> # MyPage # - MySite # </title> -# +# # ==== | -# +# # The pipe character designates a multiline string. # It's placed at the end of a line # and means that all following lines that end with <tt>|</tt> # will be evaluated as though they were on the same line. # For example: -# +# # %whoo # %hoo I think this might get | # pretty long so I should | @@ -459,9 +599,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # multiline so it doesn't | # look awful. | # %p This is short. -# +# # is compiled to: -# +# # <whoo> # <hoo> # I think this might get pretty long so I should probably make it multiline so it doesn't look awful. @@ -491,101 +631,180 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # <p>Hello, <em>World</em></p> # </p> # +# Filters can have Ruby code interpolated, like with ==. +# For example, +# +# - flavor = "raspberry" +# #content +# :textile +# I *really* prefer _#{h flavor}_ jam. +# +# is compiled to +# +# <div id='content'> +# <p>I <strong>really</strong> prefer <em>raspberry</em> jam.</p> +# </div> +# # Haml has the following filters defined: # -# [plain] Does not parse the filtered text. -# This is useful for large blocks of text without HTML tags, -# when you don't want lines starting with <tt>.</tt> or <tt>-</tt> -# to be parsed. +# [plain] Does not parse the filtered text. +# This is useful for large blocks of text without HTML tags, +# when you don't want lines starting with <tt>.</tt> or <tt>-</tt> +# to be parsed. # -# [ruby] Parses the filtered text with the normal Ruby interpreter. -# All output sent to <tt>$stdout</tt>, like with +puts+, -# is output into the Haml document. -# Not available if the <tt>suppress_eval</tt> option is set to true. +# [javascript] Surrounds the filtered text with <script> and CDATA tags. +# Useful for including inline Javascript. # -# [preserve] Inserts the filtered text into the template with whitespace preserved. -# <tt>preserve</tt>d blocks of text aren't indented, -# and newlines are replaced with the HTML escape code for newlines, -# to preserve nice-looking output. +# [escaped] Works the same as plain, but HTML-escapes the text +# before placing it in the document. # -# [erb] Parses the filtered text with ERB, like an RHTML template. -# Not available if the <tt>suppress_eval</tt> option is set to true. -# At the moment, this doesn't support access to variables -# defined by Ruby on Rails or Haml code. +# [ruby] Parses the filtered text with the normal Ruby interpreter. +# All output sent to <tt>$stdout</tt>, like with +puts+, +# is output into the Haml document. +# Not available if the <tt>suppress_eval</tt> option is set to true. +# The Ruby code is evaluated in the same context as the Haml template. # -# [sass] Parses the filtered text with Sass to produce CSS output. +# [preserve] Inserts the filtered text into the template with whitespace preserved. +# <tt>preserve</tt>d blocks of text aren't indented, +# and newlines are replaced with the HTML escape code for newlines, +# to preserve nice-looking output. +# See also Whitespace Preservation, below. # -# [redcloth] Parses the filtered text with RedCloth (http://whytheluckystiff.net/ruby/redcloth), -# which uses both Textile and Markdown syntax. -# Only works if RedCloth is installed. +# [erb] Parses the filtered text with ERB, like an RHTML template. +# Not available if the <tt>suppress_eval</tt> option is set to true. +# Embedded Ruby code is evaluated in the same context as the Haml template. # -# [textile] Parses the filtered text with Textile (http://www.textism.com/tools/textile). -# Only works if RedCloth is installed. +# [sass] Parses the filtered text with Sass to produce CSS output. # -# [markdown] Parses the filtered text with Markdown (http://daringfireball.net/projects/markdown). -# Only works if RedCloth or BlueCloth (http://www.deveiate.org/projects/BlueCloth) -# is installed -# (BlueCloth takes precedence if both are installed). +# [redcloth] Parses the filtered text with RedCloth (http://whytheluckystiff.net/ruby/redcloth), +# which uses both Textile and Markdown syntax. +# Only works if RedCloth is installed. +# +# [textile] Parses the filtered text with Textile (http://www.textism.com/tools/textile). +# Only works if RedCloth is installed. +# +# [markdown] Parses the filtered text with Markdown (http://daringfireball.net/projects/markdown). +# Only works if RedCloth or BlueCloth (http://www.deveiate.org/projects/BlueCloth) +# is installed +# (BlueCloth takes precedence if both are installed). # # You can also define your own filters (see Setting Options, below). -# +# # === Ruby evaluators -# +# # ==== = -# +# # The equals character is followed by Ruby code, # which is evaluated and the output inserted into the document as plain text. # For example: -# +# # %p # = ['hi', 'there', 'reader!'].join " " # = "yo" -# +# # is compiled to: -# +# # <p> # hi there reader! # yo # </p> # -# You can also use two equal signs, <tt>==</tt>, -# along with conventional Ruby string-embedding syntax -# to easily embed Ruby code in otherwise static text. -# For example: +# If the <tt>:escape_html</tt> option is set, <tt>=</tt> will sanitize any +# HTML-sensitive characters generated by the script. For example: # -# %p -# == 1 + 1 = #{1 + 1} +# = '<script>alert("I\'m evil!");</script>' # -# is compiled to: +# would be compiled to +# +# <script>alert("I'm evil!");</script> # -# <p> -# 1 + 1 = 2 -# </p> -# # ==== - -# +# # The hyphen character makes the text following it into "silent script": # Ruby script that is evaluated, but not output. -# +# # <b>It is not recommended that you use this widely; # almost all processing code and logic should be restricted # to the Controller, the Helper, or partials.</b> -# +# # For example: -# +# # - foo = "hello" # - foo << " there" # - foo << " you!" # %p= foo -# +# # is compiled to: -# +# # <p> # hello there you! # </p> -# +# +# ==== == +# +# Two equals characters interpolates Ruby code into plain text, +# similarly to Ruby string interpolation. +# For example, +# +# %p== This is #{h quality} cake! +# +# is the same as +# +# %p= "This is #{h quality} cake!" +# +# and might compile to +# +# <p>This is scrumptious cake!</p> +# +# Backslashes can be used to escape "#{" strings, +# but they don't act as escapes anywhere else in the string. +# For example: +# +# %p +# == \\ Look at \\#{h word} lack of backslash: \#{foo} +# +# might compile to +# +# <p> +# \\ Look at \yon lack of backslash: #{foo} +# </p> +# +# ==== &= +# +# An ampersand followed by one or two equals characters +# evaluates Ruby code just like the equals without the ampersand, +# but sanitizes any HTML-sensitive characters in the result of the code. +# For example: +# +# &= "I like cheese & crackers" +# +# compiles to +# +# I like cheese & crackers +# +# If the <tt>:escape_html</tt> option is set, +# &= behaves identically to =. +# +# ==== != +# +# An exclamation mark followed by one or two equals characters +# evaluates Ruby code just like the equals would, +# but never sanitizes the HTML. +# +# By default, the single equals doesn't sanitize HTML either. +# However, if the <tt>:escape_html</tt> option is set, = will sanitize the HTML, but != still won't. +# For example, if <tt>:escape_html</tt> is set: +# +# = "I feel <strong>!" +# != "I feel <strong>!" +# +# compiles to +# +# I feel <strong>! +# I feel <strong>! +# # ===== Blocks -# +# # Ruby blocks, like XHTML tags, don't need to be explicitly closed in Haml. # Rather, they're automatically closed, based on indentation. # A block begins whenever the indentation is increased @@ -593,13 +812,13 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # It ends when the indentation decreases # (as long as it's not an +else+ clause or something similar). # For example: -# +# # - (42...47).each do |i| # %p= i # %p See, I can count! -# +# # is compiled to: -# +# # <p> # 42 # </p> @@ -615,9 +834,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # <p> # 46 # </p> -# +# # Another example: -# +# # %p # - case 2 # - when 1 @@ -626,9 +845,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # = "2?" # - when 3 # = "3." -# +# # is compiled to: -# +# # <p> # 2? # </p> @@ -639,35 +858,52 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # signifies a silent comment. # Any text following this isn't rendered in the resulting document # at all. -# +# # For example: # -# %p foo -# -# This is a comment -# %p bar +# %p foo +# -# This is a comment +# %p bar # # is compiled to: # -# <p>foo</p> -# <p>bar</p> +# <p>foo</p> +# <p>bar</p> # # You can also nest text beneath a silent comment. # None of this text will be rendered. # For example: # -# %p foo -# -# -# This won't be displayed -# Nor will this -# %p bar +# %p foo +# -# +# This won't be displayed +# Nor will this +# %p bar # # is compiled to: # -# <p>foo</p> -# <p>bar</p> -# +# <p>foo</p> +# <p>bar</p> +# # == Other Useful Things # +# === Whitespace Preservation +# +# Sometimes you don't want Haml to indent all your text. +# For example, tags like +pre+ and +textarea+ are whitespace-sensitive; +# indenting the text makes them render wrong. +# +# Haml deals with this by "preserving" newlines before they're put into the document -- +# converting them to the XHTML whitespace escape code, <tt>
</tt>. +# Then Haml won't try to re-format the indentation. +# +# Literal +textarea+ and +pre+ tags automatically preserve their content. +# Dynamically can't be caught automatically, +# and so should be passed through Haml::Helpers#find_and_preserve or the <tt>~</tt> command, +# which has the same effect (see above). +# +# Blocks of literal text can be preserved using the :preserve filter (see above). +# # === Helpers # # Haml offers a bunch of helpers that are useful @@ -675,19 +911,30 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # creating nicely indented output for user-defined helpers, # and other useful things. # The helpers are all documented in the Haml::Helpers and Haml::Helpers::ActionViewExtensions modules. -# +# # === Haml Options -# +# # Options can be set by setting the hash <tt>Haml::Template.options</tt> # from <tt>environment.rb</tt> in Rails, # or by passing an options hash to Haml::Engine. # Available options are: -# +# +# [<tt>:output</tt>] Determines the output format. The default is :xhtml. +# Other options are :html4 and :html5, which are +# identical to :xhtml except there are no self-closing tags, +# XML prolog is ignored and correct DOCTYPEs are generated. +# +# [<tt>:escape_html</tt>] Sets whether or not to escape HTML-sensitive characters in script. +# If this is true, = behaves like &=; +# otherwise, it behaves like !=. +# <b>Note that this escapes tag attributes.</b> +# Defaults to false. +# # [<tt>:suppress_eval</tt>] Whether or not attribute hashes and Ruby scripts # designated by <tt>=</tt> or <tt>~</tt> should be # evaluated. If this is true, said scripts are # rendered as empty strings. Defaults to false. -# +# # [<tt>:attr_wrapper</tt>] The character that should wrap element attributes. # This defaults to <tt>'</tt> (an apostrophe). Characters # of this type within the attributes will be escaped @@ -700,20 +947,81 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # so it's really only useful for the user to assign # when dealing with Haml programatically. # +# [<tt>:line</tt>] The line offset of the Haml template being parsed. +# This is useful for inline templates, +# similar to the last argument to Kernel#eval. +# # [<tt>:filters</tt>] A hash of filters that can be applied to Haml code. # The keys are the string names of the filters; # the values are references to the classes of the filters. # User-defined filters should always have lowercase keys, -# and should have: -# * An +initialize+ method that accepts one parameter, -# the text to be filtered. -# * A +render+ method that returns the result of the filtering. +# and should have the interface described in Haml::Filters::Base. # # [<tt>:autoclose</tt>] A list of tag names that should be automatically self-closed # if they have no content. -# Defaults to <tt>['meta', 'img', 'link', 'script', 'br', 'hr']</tt>. +# Defaults to <tt>['meta', 'img', 'link', 'br', 'hr', 'input', 'area', 'param', 'col', 'base']</tt>. +# +# [<tt>:preserve</tt>] 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: +# +# <textarea>Foo&
Bar</textarea> +# +# Defaults to <tt>['textarea', 'pre']</tt>. +# +# See also Whitespace Preservation, above. # module Haml + # Returns a hash representing the version of Haml. + # The :major, :minor, and :teeny keys have their respective numbers. + # The :string key contains a human-readable string representation of the version. + # If Haml is checked out from Git, + # the :rev key will have the revision hash. + def self.version + return @@version if defined?(@@version) + + numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i } + @@version = { + :major => numbers[0], + :minor => numbers[1], + :teeny => numbers[2] + } + @@version[:string] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.') + + if File.exists?(scope('REVISION')) + rev = File.read(scope('REVISION')).strip + rev = nil if rev !~ /a-f0-9+/ + end + + if rev.nil? && File.exists?(scope('.git/HEAD')) + rev = File.read(scope('.git/HEAD')).strip + if rev =~ /^ref: (.*)$/ + rev = File.read(scope(".git/#{$1}")).strip + end + end + + if rev + @@version[:rev] = rev + @@version[:string] << "." << rev[0...7] + end + + @@version + end + + # Returns the path of file relative to the Haml root. + def self.scope(file) # :nodoc: + File.join(File.dirname(__FILE__), '..', file) + end + + # A string representing the version of Haml. + # A more fine-grained representation is generated by Haml.version. + VERSION = version[:string] unless defined?(Haml::VERSION) + # This method is called by init.rb, # which is run by Rails on startup. # We use it rather than putting stuff straight into init.rb vendor/plugins/haml/lib/haml.rb @@ -6,11 +6,6 @@ module Haml class Buffer include Haml::Helpers - # Set the maximum length for a line to be considered a one-liner. - # Lines <= the maximum will be rendered on one line, - # i.e. <tt><p>Hello world</p></tt> - ONE_LINER_LENGTH = 50 - # The string that holds the compiled XHTML. This is aliased as # _erbout for compatibility with ERB-specific code. attr_accessor :buffer @@ -18,6 +13,47 @@ module Haml # The options hash passed in from Haml::Engine. attr_accessor :options + # The Buffer for the enclosing Haml document. + # This is set for partials and similar sorts of nested templates. + # It's nil at the top level (see #toplevel?). + attr_accessor :upper + + # See #active? + attr_writer :active + + # True if the format is XHTML + def xhtml? + not html? + end + + # True if the format is any flavor of HTML + def html? + html4? or html5? + end + + # True if the format is HTML4 + def html4? + @options[:format] == :html4 + end + + # True if the format is HTML5 + def html5? + @options[:format] == :html5 + end + + # True if this buffer is a top-level template, + # as opposed to a nested partial. + def toplevel? + upper.nil? + end + + # True if this buffer is currently being used to render a Haml template. + # However, this returns false if a subtemplate is being rendered, + # even if it's a subtemplate of this buffer's template. + def active? + @active + end + # Gets the current tabulation of the document. def tabulation @real_tabs + @tabulation @@ -30,9 +66,13 @@ module Haml end # Creates a new buffer. - def initialize(options = {}) + def initialize(upper = nil, options = {}) + @active = true + @upper = upper @options = { - :attr_wrapper => "'" + :attr_wrapper => "'", + :ugly => false, + :format => :xhtml }.merge options @buffer = "" @tabulation = 0 @@ -44,122 +84,140 @@ module Haml # Renders +text+ with the proper tabulation. This also deals with # making a possible one-line tag one line or not. - def push_text(text, tab_change = 0) - if(@tabulation > 0) - # Have to push every line in by the extra user set tabulation - text.gsub!(/^/m, ' ' * @tabulation) + def push_text(text, dont_tab_up = false, tab_change = 0) + if @tabulation > 0 && !@options[:ugly] + # Have to push every line in by the extra user set tabulation. + # Don't push lines with just whitespace, though, + # because that screws up precompiled indentation. + text.gsub!(/^(?!\s+$)/m, tabs) + text.sub!(tabs, '') if dont_tab_up end - - @buffer << "#{text}" + + @buffer << text @real_tabs += tab_change + @dont_tab_up_next_line = false end # Properly formats the output of a script that was run in the # instance_eval. - def push_script(result, flattened, close_tag = nil) + def push_script(result, preserve_script, in_tag = false, preserve_tag = false, + escape_html = false, nuke_inner_whitespace = false) tabulation = @real_tabs - - if flattened + + if preserve_tag + result = Haml::Helpers.preserve(result) + elsif preserve_script result = Haml::Helpers.find_and_preserve(result) end - - result = result.to_s - while result[-1] == ?\n - # String#chomp is slow - result = result[0...-1] - end - - if close_tag && Buffer.one_liner?(result) + + result = result.to_s.rstrip + result = html_escape(result) if escape_html + + has_newline = result.include?("\n") + if in_tag && (@options[:ugly] || !has_newline || preserve_tag) @buffer << result - @buffer << "</#{close_tag}>\n" @real_tabs -= 1 - else - if close_tag - @buffer << "\n" - end - - result = result.gsub(/^/m, tabs(tabulation)) - @buffer << "#{result}\n" - - if close_tag - @buffer << "#{tabs(tabulation-1)}</#{close_tag}>\n" - @real_tabs -= 1 - end + return + end + + @buffer << "\n" if in_tag && !nuke_inner_whitespace + + # Precompiled tabulation may be wrong + if @tabulation > 0 && !in_tag + result = tabs + result + end + + if has_newline && !@options[:ugly] + result = result.gsub "\n", "\n" + tabs(tabulation) + + # Add tabulation if it wasn't precompiled + result = tabs(tabulation) + result if in_tag && !nuke_inner_whitespace + end + @buffer << "#{result}" + @buffer << "\n" unless nuke_inner_whitespace + + if in_tag && !nuke_inner_whitespace + # We never get here if @options[:ugly] is true + @buffer << tabs(tabulation-1) + @real_tabs -= 1 end nil end # Takes the various information about the opening tag for an # element, formats it, and adds it to the buffer. - def open_tag(name, atomic, try_one_line, class_id, obj_ref, content, attributes_hash) + def open_tag(name, self_closing, try_one_line, preserve_tag, escape_html, class_id, + nuke_outer_whitespace, nuke_inner_whitespace, obj_ref, content, *attributes_hashes) tabulation = @real_tabs - + attributes = class_id - if attributes_hash + attributes_hashes.each do |attributes_hash| attributes_hash.keys.each { |key| attributes_hash[key.to_s] = attributes_hash.delete(key) } self.class.merge_attrs(attributes, attributes_hash) end self.class.merge_attrs(attributes, parse_object_ref(obj_ref)) if obj_ref - if atomic - str = " />\n" - elsif try_one_line - str = ">" + if self_closing + str = " />" + (nuke_outer_whitespace ? "" : "\n") else - str = ">\n" + str = ">" + (try_one_line || preserve_tag || nuke_inner_whitespace ? "" : "\n") end - @buffer << "#{tabs(tabulation)}<#{name}#{Precompiler.build_attributes(@options[:attr_wrapper], attributes)}#{str}" + + attributes = Precompiler.build_attributes(html?, @options[:attr_wrapper], attributes) + @buffer << "#{nuke_outer_whitespace || @options[:ugly] ? '' : tabs(tabulation)}<#{name}#{attributes}#{str}" + if content - if Buffer.one_liner?(content) - @buffer << "#{content}</#{name}>\n" - else - @buffer << "\n#{tabs(@real_tabs+1)}#{content}\n#{tabs(@real_tabs)}</#{name}>\n" - end - else - @real_tabs += 1 + @buffer << "#{content}</#{name}>" << (nuke_outer_whitespace ? "" : "\n") + return end + + @real_tabs += 1 unless self_closing || nuke_inner_whitespace end def self.merge_attrs(to, from) if to['id'] && from['id'] to['id'] << '_' << from.delete('id') + elsif to['id'] || from['id'] + from['id'] ||= to['id'] end if to['class'] && from['class'] # Make sure we don't duplicate class names from['class'] = (from['class'].split(' ') | to['class'].split(' ')).join(' ') + elsif to['class'] || from['class'] + from['class'] ||= to['class'] end to.merge!(from) end + private + # Some of these methods are exposed as public class methods # so they can be re-used in helpers. - # Returns whether or not the given value is short enough to be rendered - # on one line. - def self.one_liner?(value) - value.length <= ONE_LINER_LENGTH && value.scan(/\n/).empty? - end - - private - @@tab_cache = {} # Gets <tt>count</tt> tabs. Mostly for internal use. - def tabs(count) + def tabs(count = 0) tabs = count + @tabulation - ' ' * tabs @@tab_cache[tabs] ||= ' ' * tabs end # Takes an array of objects and uses the class and id of the first # one to create an attributes hash. + # The second object, if present, is used as a prefix, + # just like you can do with dom_id() and dom_class() in Rails def parse_object_ref(ref) + prefix = ref[1] ref = ref[0] # Let's make sure the value isn't nil. If it is, return the default Hash. return {} if ref.nil? class_name = underscore(ref.class) id = "#{class_name}_#{ref.id || 'new'}" + if prefix + class_name = "#{ prefix }_#{ class_name}" + id = "#{ prefix }_#{ id }" + end {'id' => id, 'class' => class_name} end vendor/plugins/haml/lib/haml/buffer.rb @@ -3,7 +3,6 @@ require 'haml/buffer' require 'haml/precompiler' require 'haml/filters' require 'haml/error' -require 'haml/util' module Haml # This is the class where all the parsing and processing of the Haml @@ -20,38 +19,76 @@ module Haml # Allow reading and writing of the options hash attr :options, true + # This string contains the source code that is evaluated + # to produce the Haml document. + attr :precompiled, true + + # True if the format is XHTML + def xhtml? + not html? + end + + # True if the format is any flavor of HTML + def html? + html4? or html5? + end + + # True if the format is HTML4 + def html4? + @options[:format] == :html4 + end + + # True if the format is HTML5 + def html5? + @options[:format] == :html5 + end + # Creates a new instace of Haml::Engine that will compile the given # template string when <tt>render</tt> is called. - # See README for available options. + # See README.rdoc for available options. # #-- # When adding options, remember to add information about them - # to README! + # to README.rdoc! #++ # def initialize(template, options = {}) @options = { :suppress_eval => false, :attr_wrapper => "'", - :autoclose => ['meta', 'img', 'link', 'br', 'hr', 'input', 'area'], + + # Don't forget to update the docs in lib/haml.rb if you update these + :autoclose => %w[meta img link br hr input area param col base], + :preserve => %w[textarea pre], + :filters => { - 'sass' => Sass::Engine, + 'sass' => Haml::Filters::Sass, 'plain' => Haml::Filters::Plain, + 'javascript' => Haml::Filters::Javascript, + 'escaped' => Haml::Filters::Escaped, 'preserve' => Haml::Filters::Preserve, 'redcloth' => Haml::Filters::RedCloth, 'textile' => Haml::Filters::Textile, 'markdown' => Haml::Filters::Markdown }, - :filename => '(haml)' + :filename => '(haml)', + :line => 1, + :ugly => false, + :format => :xhtml, + :escape_html => false } - @options.rec_merge! options + @options[:filters].merge! options.delete(:filters) if options[:filters] + @options.merge! options + + unless [:xhtml, :html4, :html5].include?(@options[:format]) + raise Haml::Error, "Invalid format #{@options[:format].inspect}" + end unless @options[:suppress_eval] @options[:filters].merge!({ - 'erb' => ERB, + 'erb' => Haml::Filters::ERB, 'ruby' => Haml::Filters::Ruby }) end - @options[:filters].rec_merge! options[:filters] if options[:filters] if @options[:locals] warn <<END @@ -61,16 +98,17 @@ Use the locals option for Haml::Engine#render instead. END end - @template = template.strip #String + @template = template.rstrip #String @to_close_stack = [] @output_tabs = 0 @template_tabs = 0 @index = 0 @flat_spaces = -1 + @newlines = 0 precompile rescue Haml::Error - $!.backtrace.unshift "#{@options[:filename]}:#{@index}" + $!.backtrace.unshift "#{@options[:filename]}:#{@index + $!.line_offset + @options[:line] - 1}" if @index raise end @@ -80,7 +118,7 @@ END # If it's a Binding or Proc object, # Haml uses it as the second argument to Kernel#eval; # otherwise, Haml just uses its #instance_eval context. - # + # # Note that Haml modifies the evaluation context # (either the scope object or the "self" object of the scope binding). # It extends Haml::Helpers, and various instance variables are set @@ -111,7 +149,7 @@ END # they won't work. def render(scope = Object.new, locals = {}, &block) locals = (@options[:locals] || {}).merge(locals) - buffer = Haml::Buffer.new(options_for_buffer) + buffer = Haml::Buffer.new(scope.instance_variable_get('@haml_buffer'), options_for_buffer) if scope.is_a?(Binding) || scope.is_a?(Proc) scope_object = eval("self", scope) @@ -125,17 +163,14 @@ END scope_object.instance_eval do extend Haml::Helpers - @haml_stack ||= Array.new - @haml_stack.push(buffer) - @haml_is_haml = true + @haml_buffer = buffer end - eval(@precompiled, scope, @options[:filename], 0) + eval(@precompiled, scope, @options[:filename], @options[:line]) # Get rid of the current buffer scope_object.instance_eval do - @haml_stack.pop - @haml_is_haml = false + @haml_buffer = buffer.upper end buffer.buffer @@ -172,7 +207,7 @@ END end eval("Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {};" + - precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], 0) + precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], @options[:line]) end # Defines a method on +object+ @@ -189,7 +224,7 @@ END # # Haml::Engine.new(".upcased= upcase").def_method(String, :upcased_div) # "foobar".upcased_div #=> "<div class='upcased'>FOOBAR</div>\n" - # + # # The first argument of the defined method is a hash of local variable names to values. # However, due to an unfortunate Ruby quirk, # the local variables which can be assigned must be pre-declared. @@ -205,7 +240,7 @@ END # obj = Object.new # Haml::Engine.new("%p= foo").def_method(obj, :render) # obj.render(:foo => "Hello!") #=> NameError: undefined local variable or method `foo' - # + # # Note that Haml modifies the evaluation context # (either the scope object or the "self" object of the scope binding). # It extends Haml::Helpers, and various instance variables are set @@ -214,7 +249,7 @@ END method = object.is_a?(Module) ? :module_eval : :instance_eval object.send(method, "def #{name}(_haml_locals = {}); #{precompiled_with_ambles(local_names)}; end", - @options[:filename], 0) + @options[:filename], @options[:line]) end private @@ -226,9 +261,15 @@ END end # Returns a hash of options that Haml::Buffer cares about. - # This should remain loadable form #inspect. + # This should remain loadable from #inspect. def options_for_buffer - {:attr_wrapper => @options[:attr_wrapper]} + { + :autoclose => @options[:autoclose], + :preserve => @options[:preserve], + :attr_wrapper => @options[:attr_wrapper], + :ugly => @options[:ugly], + :format => @options[:format] + } end end end vendor/plugins/haml/lib/haml/engine.rb @@ -1,13 +1,23 @@ module Haml - # The abstract type of exception raised by Haml code. - class Error < StandardError; end + # An exception raised by Haml code. + class Error < Exception + # :stopdoc: + + # By default, an error is taken to refer to the line of the template + # that was being processed when the exception was raised. + # However, if line_offset is non-zero, it's added to that line number + # to get the line to report for the error. + attr_reader :line_offset + + def initialize(message = nil, line_offset = 0) + super(message) + @line_offset = line_offset + end + # :startdoc: + end # SyntaxError is the type of exception raised when Haml encounters an # ill-formatted document. # It's not particularly interesting, except in that it includes Haml::Error. class SyntaxError < Haml::Error; end - - # HamlError is the type of exception raised when Haml encounters an error - # not of a syntactical nature, such as an undefined Filter. - class HamlError < Haml::Error; end end vendor/plugins/haml/lib/haml/error.rb @@ -21,7 +21,7 @@ module Haml @opts.parse!(@args) process_result - + @options rescue Exception => e raise e if e.is_a? SystemExit @@ -43,9 +43,13 @@ module Haml protected def get_line(exception) + # SyntaxErrors have weird line reporting + # when there's trailing whitespace, + # which there is for Haml documents. + return exception.message.scan(/:(\d+)/)[0] if exception.is_a?(::SyntaxError) exception.backtrace[0].scan(/:(\d+)/)[0] end - + private def set_opts(opts) @@ -63,7 +67,7 @@ module Haml end opts.on_tail("-v", "--version", "Print version") do - puts("Haml " + File.read(File.dirname(__FILE__) + '/../../VERSION')) + puts("Haml #{::Haml.version[:string]}") exit end end @@ -110,7 +114,7 @@ Description: Options: END - + opts.on('--rails RAILS_DIR', "Install Haml and Sass from the Gem to a Rails project") do |dir| original_dir = dir @@ -145,6 +149,7 @@ END end opts.on('-c', '--check', "Just check syntax, don't evaluate.") do + require 'stringio' @options[:check_syntax] = true @options[:output] = StringIO.new end @@ -170,7 +175,7 @@ END super opts.on('-t', '--style NAME', - 'Output style. Can be nested (default), compact, or expanded.') do |name| + 'Output style. Can be nested (default), compact, compressed, or expanded.') do |name| @options[:for_engine][:style] = name.to_sym end end @@ -206,6 +211,25 @@ END @name = "Haml" end + def set_opts(opts) + super + + opts.on('-t', '--style NAME', + 'Output style. Can be indented (default) or ugly.') do |name| + @options[:for_engine][:ugly] = true if name.to_sym == :ugly + end + + opts.on('-f', '--format NAME', + 'Output format. Can be xhtml (default), html4, or html5.') do |name| + @options[:for_engine][:format] = name.to_sym + end + + opts.on('-e', '--escape-html', + 'Escape HTML characters (like ampersands and angle brackets) by default.') do + @options[:for_engine][:escape_html] = true + end + end + def process_result super input = @options[:input] @@ -225,8 +249,8 @@ END raise e if @options[:trace] case e - when ::Haml::SyntaxError: raise "Syntax error on line #{get_line e}: #{e.message}" - when ::Haml::HamlError: raise "Haml error on line #{get_line e}: #{e.message}" + when ::Haml::SyntaxError; raise "Syntax error on line #{get_line e}: #{e.message}" + when ::Haml::Error; raise "Haml error on line #{get_line e}: #{e.message}" else raise "Exception on line #{get_line e}: #{e.message}\n Use --trace for backtrace." end end @@ -289,6 +313,8 @@ END def initialize(args) super + @module_opts = {} + require 'sass/css' end @@ -301,6 +327,10 @@ Description: Transforms a CSS file into corresponding Sass code. Options: END + opts.on('-a', '--alternate', 'Output using alternative Sass syntax (margin: 1px)') do + @module_opts[:alternate] = true + end + super end @@ -310,7 +340,7 @@ END input = @options[:input] output = @options[:output] - output.write(::Sass::CSS.new(input).render) + output.write(::Sass::CSS.new(input, @module_opts).render) end end end vendor/plugins/haml/lib/haml/exec.rb @@ -1,115 +1,242 @@ # This file contains redefinitions of and wrappers around various text # filters so they can be used as Haml filters. -# :stopdoc: - -require 'erb' -require 'sass/engine' -require 'stringio' - -begin - require 'rubygems' -rescue LoadError; end - -class ERB; alias_method :render, :result; end - module Haml + # The module containing the default filters, + # as well as the base module, + # Haml::Filters::Base. module Filters - class Plain - def initialize(text) - @text = text + # The base module for Haml filters. + # User-defined filters should be modules including this module. + # + # A user-defined filter should override either Base#render or Base #compile. + # Base#render is the most common. + # It takes a string, the filter source, + # and returns another string, + # the result of the filter. + # For example: + # + # module Haml::Filters::Sass + # include Haml::Filters::Base + # + # def render(text) + # ::Sass::Engine.new(text).render + # end + # end + # + # For details on overriding #compile, see its documentation. + # + module Base + def self.included(base) # :nodoc: + base.extend(base) end - def render - @text + # Takes a string, the source text that should be passed to the filter, + # and returns the string resulting from running the filter on <tt>text</tt>. + # + # This should be overridden in most individual filter modules + # to render text with the given filter. + # If compile is overridden, however, render doesn't need to be. + def render(text) + raise Error.new("#{self.inspect}#render not defined!") end - end - class Ruby - def initialize(text) - @text = text + def internal_compile(*args) # :nodoc: + resolve_lazy_requires + compile(*args) end - def render - old_stdout = $stdout - $stdout = StringIO.new - Object.new.instance_eval(@text) - old_stdout, $stdout = $stdout, old_stdout - old_stdout.pos = 0 - old_stdout.read - end - end + # compile should be overridden when a filter needs to have access + # to the Haml evaluation context. + # Rather than applying a filter to a string at compile-time, + # compile uses the Haml::Precompiler instance to compile the string to Ruby code + # that will be executed in the context of the active Haml template. + # + # Warning: the Haml::Precompiler interface is neither well-documented + # nor guaranteed to be stable. + # If you want to make use of it, + # you'll probably need to look at the source code + # and should test your filter when upgrading to new Haml versions. + def compile(precompiler, text) + resolve_lazy_requires + filter = self + precompiler.instance_eval do + if contains_interpolation?(text) + return if options[:suppress_eval] + + push_script("#{filter.inspect}.render(#{unescape_interpolation(text)})", false) + return + end + + rendered = filter.render(text) - class Preserve - def initialize(text) - @text = text + if !options[:ugly] + push_text(rendered.rstrip.gsub("\n", "\n#{' ' * @output_tabs}")) + else + push_text(rendered.rstrip) + end + end end - def render - Haml::Helpers.preserve(@text) + # This becomes a class method of modules that include Base. + # It allows the module to specify one or more Ruby files + # that Haml should try to require when compiling the filter. + # + # The first file specified is tried first, + # then the second, etc. + # If none are found, the compilation throws an exception. + # + # For example: + # + # module Haml::Filters::Markdown + # lazy_require 'bluecloth', 'redcloth' + # + # ... + # end + # + def lazy_require(*reqs) + @lazy_requires = reqs end - end - class LazyLoaded - def initialize(*reqs) - reqs[0...-1].each do |req| + private + + def resolve_lazy_requires + return unless @lazy_requires + + @lazy_requires[0...-1].each do |req| begin @required = req require @required return rescue LoadError; end # RCov doesn't see this, but it is run end - + begin - @required = reqs[-1] + @required = @lazy_requires[-1] require @required rescue LoadError => e classname = self.class.to_s.gsub(/\w+::/, '') - if reqs.size == 1 - raise HamlError.new("Can't run #{classname} filter; required file '#{reqs.first}' not found") + if @lazy_requires.size == 1 + raise Error.new("Can't run #{classname} filter; required file '#{@lazy_requires.first}' not found") else - raise HamlError.new("Can't run #{classname} filter; required #{reqs.map { |r| "'#{r}'" }.join(' or ')}, but none were found") + raise Error.new("Can't run #{classname} filter; required #{@lazy_requires.map { |r| "'#{r}'" }.join(' or ')}, but none were found") end end end end - - class RedCloth < LazyLoaded - def initialize(text) - super('redcloth') - @engine = ::RedCloth.new(text) + end +end + +# :stopdoc: + +begin + require 'rubygems' +rescue LoadError; end + +module Haml + module Filters + module Plain + include Base + + def render(text); text; end + end + + module Javascript + include Base + + def render(text) + <<END +<script type='text/javascript'> + //<![CDATA[ + #{text.rstrip.gsub("\n", "\n ")} + //]]> +</script> +END + end + end + + module Escaped + include Base + + def render(text) + Haml::Helpers.html_escape text + end + end + + module Ruby + include Base + lazy_require 'stringio' + + def compile(precompiler, text) + precompiler.instance_eval do + push_silent <<-END.gsub("\n", ';') + _haml_old_stdout = $stdout + $stdout = StringIO.new(_hamlout.buffer, 'a') + #{text} + _haml_old_stdout, $stdout = $stdout, _haml_old_stdout + _haml_old_stdout.close + END + end end + end - def render - @engine.to_html + module Preserve + include Base + + def render(text) + Haml::Helpers.preserve text end end - + + module Sass + include Base + lazy_require 'sass/engine' + + def render(text) + ::Sass::Engine.new(text).render + end + end + + module ERB + include Base + lazy_require 'erb' + + def compile(precompiler, text) + src = ::ERB.new(text).src.sub(/^_erbout = '';/, "").gsub("\n", ';') + precompiler.send(:push_silent, src) + end + end + + module RedCloth + include Base + lazy_require 'redcloth' + + def render(text) + ::RedCloth.new(text).to_html + end + end + # Uses RedCloth to provide only Textile (not Markdown) parsing - class Textile < RedCloth - def render - @engine.to_html(:textile) + module Textile + include Base + lazy_require 'redcloth' + + def render(text) + ::RedCloth.new(text).to_html(:textile) end end # Uses BlueCloth or RedCloth to provide only Markdown (not Textile) parsing - class Markdown < LazyLoaded - def initialize(text) - super('bluecloth', 'redcloth') + module Markdown + include Base + lazy_require 'bluecloth', 'redcloth' + def render(text) if @required == 'bluecloth' - @engine = ::BlueCloth.new(text) - else - @engine = ::RedCloth.new(text) - end - end - - def render - if @engine.is_a?(::BlueCloth) - @engine.to_html + ::BlueCloth.new(text).to_html else - @engine.to_html(:markdown) + ::RedCloth.new(text).to_html(:markdown) end end end vendor/plugins/haml/lib/haml/filters.rb @@ -34,28 +34,57 @@ module Haml # include Haml::Helpers # end # context.init_haml_helpers - # context.open :p, "Stuff" - # + # context.haml_tag :p, "Stuff" + # def init_haml_helpers - @haml_is_haml = true - @haml_stack = [Haml::Buffer.new] + @haml_buffer = Haml::Buffer.new(@haml_buffer, Haml::Engine.new('').send(:options_for_buffer)) nil end + # call-seq: + # non_haml { ... } + # + # Runs a block of code in a non-Haml context + # (i.e. #is_haml? will return false). + # + # This is mainly useful for rendering sub-templates such as partials in a non-Haml language, + # particularly where helpers may behave differently when run from Haml. + # + # Note that this is automatically applied to Rails partials. + def non_haml + was_active = @haml_buffer.active? + @haml_buffer.active = false + res = yield + @haml_buffer.active = was_active + res + end + + # call-seq: + # find_and_preserve(input) + # find_and_preserve {...} + # # Isolates the whitespace-sensitive tags in the string and uses preserve # to convert any endlines inside them into HTML entities for endlines. - def find_and_preserve(input) + def find_and_preserve(input = '', &block) + return find_and_preserve(capture_haml(&block)) if block + input = input.to_s input.gsub(/<(textarea|code|pre)([^>]*)>(.*?)(<\/\1>)/im) do "<#{$1}#{$2}>#{preserve($3)}</#{$1}>" end end + # call-seq: + # preserve(input) + # preserve {...} + # # Takes any string, finds all the endlines and converts them to # HTML entities for endlines so they'll render correctly in # whitespace-sensitive tags without screwing up the indentation. - def preserve(input) - input.gsub(/\n/, '
').gsub(/\r/, '') + def preserve(input = '', &block) + return preserve(capture_haml(&block)) if block + + input.chomp("\n").gsub(/\n/, '
').gsub(/\r/, '') end alias_method :flatten, :preserve @@ -95,14 +124,14 @@ module Haml def list_of(array, &block) # :yields: item to_return = array.collect do |i| result = capture_haml(i, &block) - + if result.count("\n") > 1 result.gsub!("\n", "\n ") result = "\n #{result.strip}\n" else result.strip! end - + "<li>#{result}</li>" end to_return.join("\n") @@ -141,17 +170,17 @@ module Haml # <strong>baz</strong> # def tab_up(i = 1) - buffer.tabulation += i + haml_buffer.tabulation += i end - # Increments the number of tabs the buffer automatically adds + # Decrements the number of tabs the buffer automatically adds # to the lines of the template. # - # See tab_up. + # See also tab_up. def tab_down(i = 1) - buffer.tabulation -= i + haml_buffer.tabulation -= i end - + # Surrounds the given block of Haml code with the given characters, # with no whitespace in between. # For example: @@ -175,10 +204,10 @@ module Haml def surround(front, back = nil, &block) back ||= front output = capture_haml(&block) - + "#{front}#{output.chomp}#{back}\n" end - + # Prepends the given character to the beginning of the Haml block, # with no whitespace between. # For example: @@ -193,7 +222,7 @@ module Haml def precede(char, &block) "#{char}#{capture_haml(&block).chomp}\n" end - + # Appends the given character to the end of the Haml block, # with no whitespace between. # For example: @@ -210,7 +239,7 @@ module Haml def succeed(char, &block) "#{capture_haml(&block).chomp}#{char}\n" end - + # Captures the result of the given block of Haml code, # gets rid of the excess indentation, # and returns it as a string. @@ -223,35 +252,35 @@ module Haml # the local variable <tt>foo</tt> would be assigned to "<p>13</p>\n". # def capture_haml(*args, &block) - capture_haml_with_buffer(buffer.buffer, *args, &block) + capture_haml_with_buffer(haml_buffer.buffer, *args, &block) end # Outputs text directly to the Haml buffer, with the proper tabulation def puts(text = "") - buffer.buffer << (' ' * buffer.tabulation) << text.to_s << "\n" + haml_buffer.buffer << (' ' * haml_buffer.tabulation) << text.to_s << "\n" nil end # # call-seq: - # open(name, attributes = {}) {...} - # open(name, text, attributes = {}) {...} + # haml_tag(name, attributes = {}) {...} + # haml_tag(name, text, attributes = {}) {...} # # Creates an HTML tag with the given name and optionally text and attributes. # Can take a block that will be executed # between when the opening and closing tags are output. # If the block is a Haml block or outputs text using puts, # the text will be properly indented. - # + # # For example, # - # open :table do - # open :tr do - # open :td, {:class => 'cell'} do - # open :strong, "strong!" + # haml_tag :table do + # haml_tag :tr do + # haml_tag :td, {:class => 'cell'} do + # haml_tag :strong, "strong!" # puts "data" # end - # open :td do + # haml_tag :td do # puts "more_data" # end # end @@ -273,19 +302,24 @@ module Haml # </tr> # </table> # - def open(name, attributes = {}, alt_atts = {}, &block) + def haml_tag(name, attributes = {}, alt_atts = {}, &block) + name = name.to_s + text = nil if attributes.is_a? String text = attributes attributes = alt_atts end - if text.nil? && block.nil? - puts "<#{name}#{Haml::Precompiler.build_attributes(buffer.options[:attr_wrapper], attributes)} />" + attributes = Haml::Precompiler.build_attributes( + haml_buffer.html?, haml_buffer.options[:attr_wrapper], attributes) + + if text.nil? && block.nil? && haml_buffer.options[:autoclose].include?(name) + puts "<#{name}#{attributes} />" return nil end - puts "<#{name}#{Haml::Precompiler.build_attributes(buffer.options[:attr_wrapper], attributes)}>" + puts "<#{name}#{attributes}>" unless text && text.empty? tab_up # Print out either the text (using push_text) or call the block and add an endline @@ -299,61 +333,81 @@ module Haml puts "</#{name}>" nil end - + + # Characters that need to be escaped to HTML entities from user input + HTML_ESCAPE = { '&'=>'&', '<'=>'<', '>'=>'>', '"'=>'"', "'"=>''', } + + # Returns a copy of <tt>text</tt> with ampersands, angle brackets and quotes + # escaped into HTML entities. + def html_escape(text) + text.to_s.gsub(/[\"><&]/) { |s| HTML_ESCAPE[s] } + end + + # Escapes HTML entities in <tt>text</tt>, but without escaping an ampersand + # that is already part of an escaped entity. + def escape_once(text) + text.to_s.gsub(/[\"><]|&(?!([a-zA-Z]+|(#\d+));)/) { |s| HTML_ESCAPE[s] } + 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. + def is_haml? + !@haml_buffer.nil? && @haml_buffer.active? + end + private # Gets a reference to the current Haml::Buffer object. - def buffer - @haml_stack[-1] + def haml_buffer + @haml_buffer end - + # Gives a proc the same local "_hamlout" and "_erbout" variables # that the current template has. - def bind_proc(&proc) - _hamlout = buffer + def haml_bind_proc(&proc) + _hamlout = haml_buffer _erbout = _hamlout.buffer proc { |*args| proc.call(*args) } end - + # Performs the function of capture_haml, assuming <tt>local_buffer</tt> # is where the output of block goes. def capture_haml_with_buffer(local_buffer, *args, &block) position = local_buffer.length - + block.call *args - + captured = local_buffer.slice!(position..-1) - + min_tabs = nil captured.each do |line| tabs = line.index(/[^ ]/) min_tabs ||= tabs min_tabs = min_tabs > tabs ? tabs : min_tabs end - + result = captured.map do |line| line[min_tabs..-1] end result.to_s 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. - def is_haml? - @haml_is_haml - end - include ActionViewExtensions if self.const_defined? "ActionViewExtensions" end end -module ActionView - class Base # :nodoc: - def is_haml? - false - end +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 + vendor/plugins/haml/lib/haml/helpers.rb @@ -31,7 +31,7 @@ if defined?(ActionView) # # .entry # :color #00f - # + # def page_class controller.controller_name + " " + controller.action_name end vendor/plugins/haml/lib/haml/helpers/action_view_extensions.rb @@ -2,11 +2,8 @@ if defined?(ActionView) and not defined?(Merb::Plugins) module ActionView class Base # :nodoc: def render_with_haml(*args, &block) - was_haml = is_haml? - @haml_is_haml = false - res = render_without_haml(*args, &block) - @haml_is_haml = was_haml - res + return non_haml { render_without_haml(*args, &block) } if is_haml? + render_without_haml(*args, &block) end alias_method :render_without_haml, :render alias_method :render, :render_with_haml @@ -17,6 +14,16 @@ if defined?(ActionView) and not defined?(Merb::Plugins) module Helpers # :stopdoc: module CaptureHelper + def capture_with_haml(*args, &block) + if is_haml? + capture_haml(*args, &block) + else + capture_without_haml(*args, &block) + end + end + alias_method :capture_without_haml, :capture + alias_method :capture, :capture_with_haml + def capture_erb_with_buffer_with_haml(*args, &block) if is_haml? capture_haml_with_buffer(*args, &block) @@ -31,7 +38,7 @@ if defined?(ActionView) and not defined?(Merb::Plugins) module TextHelper def concat_with_haml(string, binding = nil) if is_haml? - buffer.buffer.concat(string) + haml_buffer.buffer.concat(string) else concat_without_haml(string, binding) end @@ -40,12 +47,41 @@ if defined?(ActionView) and not defined?(Merb::Plugins) alias_method :concat, :concat_with_haml end + module TagHelper + def content_tag_with_haml(name, *args, &block) + content = content_tag_without_haml(name, *args, &block) + + if is_haml? && haml_buffer.options[:preserve].include?(name.to_s) + content = Haml::Helpers.preserve content + end + + content + end + alias_method :content_tag_without_haml, :content_tag + alias_method :content_tag, :content_tag_with_haml + end + + class InstanceTag + # Includes TagHelper + + def haml_buffer + @template_object.send :haml_buffer + end + + def is_haml? + @template_object.send :is_haml? + end + + alias_method :content_tag_without_haml, :content_tag + alias_method :content_tag, :content_tag_with_haml + end + module FormTagHelper def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc) if is_haml? if block_given? oldproc = proc - proc = bind_proc do |*args| + proc = haml_bind_proc do |*args| concat "\n" tab_up oldproc.call(*args) @@ -66,8 +102,8 @@ if defined?(ActionView) and not defined?(Merb::Plugins) module FormHelper def form_for_with_haml(object_name, *args, &proc) if block_given? && is_haml? - oldproc = proc - proc = bind_proc do |*args| + oldproc = proc + proc = haml_bind_proc do |*args| tab_up oldproc.call(*args) tab_down vendor/plugins/haml/lib/haml/helpers/action_view_mods.rb @@ -59,7 +59,7 @@ module Haml String.new else lines = text.split("\n") - + lines.map do |line| line.strip! "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n" @@ -73,7 +73,7 @@ module Haml def self.options @@options end - + TEXT_REGEXP = /^(\s*).*$/ class ::Hpricot::Doc @@ -129,14 +129,14 @@ module Haml class ::Hpricot::Elem def to_haml(tabs = 0) - output = "#{tabulate(tabs)}" + output = "#{tabulate(tabs)}" if HTML.options[:rhtml] && name[0...5] == 'haml:' return output + HTML.send("haml_tag_#{name[5..-1]}", CGI.unescapeHTML(self.innerHTML)) end output += "%#{name}" unless name == 'div' && (attributes.include?('id') || attributes.include?('class')) - + if attributes output += "##{attributes['id']}" if attributes['id'] attributes['class'].split(' ').each { |c| output += ".#{c}" } if attributes['class'] @@ -144,10 +144,10 @@ module Haml remove_attribute('class') output += haml_attributes if attributes.length > 0 end - + output += "/" if children.length == 0 output += "\n" - + self.children.each do |child| output += child.to_haml(tabs + 1) end vendor/plugins/haml/lib/haml/html.rb @@ -14,12 +14,15 @@ module Haml # Designates an XHTML/XML comment. COMMENT = ?/ - # Designates an XHTML doctype. + # Designates an XHTML doctype or script that is never HTML-escaped. DOCTYPE = ?! # Designates script, the result of which is output. SCRIPT = ?= + # Designates script that is always HTML-escaped. + SANITIZE = ?& + # Designates script, the result of which is flattened and output. FLAT_SCRIPT = ?~ @@ -47,6 +50,7 @@ module Haml COMMENT, DOCTYPE, SCRIPT, + SANITIZE, FLAT_SCRIPT, SILENT_SCRIPT, ESCAPE, @@ -75,15 +79,9 @@ module Haml # is a member of this array. MID_BLOCK_KEYWORDS = ['else', 'elsif', 'rescue', 'ensure', 'when'] - # The Regex that matches an HTML comment command. - COMMENT_REGEX = /\/(\[[\w\s\.]*\])?(.*)/ - # The Regex that matches a Doctype command. DOCTYPE_REGEX = /(\d\.\d)?[\s]*([a-z]*)/i - # The Regex that matches an HTML tag command. - TAG_REGEX = /[%]([-:\w]+)([-\w\.\#]*)(\{.*\})?(\[.*\])?([=\/\~]?)?(.*)?/ - # The Regex that matches a literal string or symbol value LITERAL_VALUE_REGEX = /^\s*(:(\w*)|(('|")([^\\\#'"]*?)\4))\s*$/ @@ -93,15 +91,12 @@ module Haml def precompiled_with_ambles(local_names) preamble = <<END.gsub("\n", ";") extend Haml::Helpers -@haml_stack ||= Array.new -@haml_stack.push(Haml::Buffer.new(#{options_for_buffer.inspect})) -@haml_is_haml = true -_hamlout = @haml_stack[-1] +_hamlout = @haml_buffer = Haml::Buffer.new(@haml_buffer, #{options_for_buffer.inspect}) _erbout = _hamlout.buffer END postamble = <<END.gsub("\n", ";") -@haml_is_haml = false -@haml_stack.pop.buffer +@haml_buffer = @haml_buffer.upper +_erbout END preamble + locals_code(local_names) + @precompiled + postamble end @@ -122,12 +117,12 @@ END @tab_change = 0 old_line = Line.new - (@template + "\n-#").each_with_index do |text, index| + (@template + "\n-#\n-#").split(/\n?\r|\r?\n/).each_with_index do |text, index| line = Line.new text.strip, text.lstrip.chomp, index line.spaces, line.tabs = count_soft_tabs(text) if line.text.empty? - process_indent(old_line) unless !flat? || old_line.text.empty? + process_indent(old_line) if flat? && !old_line.text.empty? unless flat? newline @@ -144,6 +139,7 @@ END if old_line.text.nil? || suppress_render old_line = line + resolve_newlines newline next end @@ -158,15 +154,20 @@ END end if old_line.spaces != old_line.tabs * 2 - raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.") + raise SyntaxError.new(<<END.strip, 1 + old_line.index - @index) +#{old_line.spaces} space#{old_line.spaces == 1 ? ' was' : 's were'} used for indentation. Haml must be indented using two spaces. +END end unless old_line.text.empty? || @haml_comment process_line(old_line.text, old_line.index, line.tabs > old_line.tabs && !line.text.empty?) end + resolve_newlines if !flat? && line.tabs - old_line.tabs > 1 - raise SyntaxError.new("Illegal Indentation: Indenting more than once per line is illegal.") + raise SyntaxError.new(<<END.strip, 2 + old_line.index - @index) +#{line.spaces} spaces were used for indentation. Haml must be indented using two spaces. +END end old_line = line newline @@ -176,7 +177,7 @@ END close until @to_close_stack.empty? flush_merged_text end - + # Processes and deals with lowering indentation. def process_indent(line) return unless line.tabs <= @template_tabs && @template_tabs > 0 @@ -194,30 +195,37 @@ END @index = index + 1 case text[0] - when DIV_CLASS, DIV_ID: render_div(text) - when ELEMENT: render_tag(text) - when COMMENT: render_comment(text) + when DIV_CLASS, DIV_ID; render_div(text) + when ELEMENT; render_tag(text) + when COMMENT; render_comment(text[1..-1].strip) + when SANITIZE + return push_script(unescape_interpolation(text[3..-1].strip), false, false, false, true) if text[1..2] == "==" + return push_script(text[2..-1].strip, false, false, false, true) if text[1] == SCRIPT + push_plain text when SCRIPT return push_script(unescape_interpolation(text[2..-1].strip), false) if text[1] == SCRIPT + return push_script(text[1..-1], false, false, false, true) if options[:escape_html] push_script(text[1..-1], false) - when FLAT_SCRIPT: push_flat_script(text[1..-1]) + when FLAT_SCRIPT; push_flat_script(text[1..-1]) when SILENT_SCRIPT return start_haml_comment if text[1] == SILENT_COMMENT push_silent(text[1..-1], true) - newline true + newline_now if (@block_opened && !mid_block_keyword?(text)) || text[1..-1].split(' ', 2)[0] == "case" push_and_tabulate([:script]) end - when FILTER: start_filtered(text[1..-1].downcase) + when FILTER; start_filtered(text[1..-1].downcase) when DOCTYPE return render_doctype(text) if text[0...3] == '!!!' + return push_script(unescape_interpolation(text[3..-1].strip), false) if text[1..2] == "==" + return push_script(text[2..-1].strip, false) if text[1] == SCRIPT push_plain text - when ESCAPE: push_plain text[1..-1] + when ESCAPE; push_plain text[1..-1] else push_plain text end end - + # Returns whether or not the text is a silent script text with one # of Ruby's mid-block keywords. def mid_block_keyword?(text) @@ -237,7 +245,7 @@ END @multiline.text << text[0...-1] return true end - + # A multiline string has just been activated, start adding the lines if is_multiline?(text) && (MULTILINE_STARTERS.include? text[0]) @multiline = Line.new text[0...-1], nil, line.index, nil, line.tabs @@ -262,73 +270,91 @@ END # Evaluates <tt>text</tt> in the context of the scope object, but # does not output the result. def push_silent(text, can_suppress = false) - flush_merged_text + flush_merged_text return if can_suppress && options[:suppress_eval] @precompiled << "#{text};" end # Adds <tt>text</tt> to <tt>@buffer</tt> with appropriate tabulation # without parsing it. - def push_merged_text(text, tab_change = 0, try_one_liner = false) - @merged_text << "#{' ' * @output_tabs}#{text}" + def push_merged_text(text, tab_change = 0, indent = true) + @merged_text << (!indent || @dont_indent_next_line || @options[:ugly] ? text : "#{' ' * @output_tabs}#{text}") + @dont_indent_next_line = false @tab_change += tab_change - @try_one_liner = try_one_liner end - - def push_text(text, tab_change = 0, try_one_liner = false) - push_merged_text("#{text}\n", tab_change, try_one_liner) + + # Concatenate <tt>text</tt> to <tt>@buffer</tt> without tabulation. + def concat_merged_text(text) + @merged_text << text end - + + def push_text(text, tab_change = 0) + push_merged_text("#{text}\n", tab_change) + end + def flush_merged_text return if @merged_text.empty? @precompiled << "_hamlout.push_text(#{@merged_text.dump}" - @precompiled << ", #{@tab_change}" if @tab_change != 0 || @try_one_liner + @precompiled << ", #{@dont_tab_up_next_text.inspect}" if @dont_tab_up_next_text || @tab_change != 0 + @precompiled << ", #{@tab_change}" if @tab_change != 0 @precompiled << ");" @merged_text = '' + @dont_tab_up_next_text = false @tab_change = 0 - @try_one_liner = false - end + end # Renders a block of text as plain text. # Also checks for an illegally opened block. def push_plain(text) - raise SyntaxError.new("Illegal Nesting: Nesting within plain text is illegal.") if @block_opened + raise SyntaxError.new("Illegal nesting: nesting within plain text is illegal.", 1) if @block_opened push_text text end # Adds +text+ to <tt>@buffer</tt> while flattening text. def push_flat(line) - tabulation = line.spaces - @flat_spaces - tabulation = tabulation > -1 ? tabulation : 0 - @filter_buffer << "#{' ' * tabulation}#{line.unstripped}\n" + unless @options[:ugly] + tabulation = line.spaces - @flat_spaces + tabulation = tabulation > -1 ? tabulation : 0 + @filter_buffer << "#{' ' * tabulation}#{line.unstripped}\n" + else + @filter_buffer << "#{line.unstripped}\n" + end end # Causes <tt>text</tt> to be evaluated in the context of # the scope object and the result to be added to <tt>@buffer</tt>. # - # If <tt>flattened</tt> is true, Haml::Helpers#find_and_flatten is run on + # If <tt>preserve_script</tt> is true, Haml::Helpers#find_and_flatten is run on # the result before it is added to <tt>@buffer</tt> - def push_script(text, flattened, close_tag = nil) + def push_script(text, preserve_script, in_tag = false, preserve_tag = false, + escape_html = false, nuke_inner_whitespace = false) + # Prerender tabulation unless we're in a tag + push_merged_text '' unless in_tag + flush_merged_text return if options[:suppress_eval] + raise SyntaxError.new("There's no Ruby code for = to evaluate.") if text.empty? + push_silent "haml_temp = #{text}" - newline true - out = "haml_temp = _hamlout.push_script(haml_temp, #{flattened.inspect}, #{close_tag.inspect});" + newline_now + args = [preserve_script, in_tag, preserve_tag, + escape_html, nuke_inner_whitespace].map { |a| a.inspect }.join(', ') + out = "haml_temp = _hamlout.push_script(haml_temp, #{args});" if @block_opened push_and_tabulate([:loud, out]) else @precompiled << out end end - + # Causes <tt>text</tt> to be evaluated, and Haml::Helpers#find_and_flatten # to be run on it afterwards. def push_flat_script(text) flush_merged_text - - raise SyntaxError.new("Tag has no content.") if text.empty? + + raise SyntaxError.new("There's no Ruby code for ~ to evaluate.") if text.empty? push_script(text, true) end @@ -343,21 +369,25 @@ END def close tag, value = @to_close_stack.pop case tag - when :script: close_block - when :comment: close_comment value - when :element: close_tag value - when :loud: close_loud value - when :filtered: close_filtered value - when :haml_comment: close_haml_comment + when :script; close_block + when :comment; close_comment value + when :element; close_tag value + when :loud; close_loud value + when :filtered; close_filtered value + when :haml_comment; close_haml_comment end end # Puts a line in <tt>@precompiled</tt> that will add the closing tag of # the most recently opened tag. - def close_tag(tag) - @output_tabs -= 1 + def close_tag(value) + tag, nuke_outer_whitespace, nuke_inner_whitespace = value + @output_tabs -= 1 unless nuke_inner_whitespace @template_tabs -= 1 - push_text("</#{tag}>", -1) + rstrip_buffer! if nuke_inner_whitespace + push_merged_text("</#{tag}>" + (nuke_outer_whitespace ? "" : "\n"), + nuke_inner_whitespace ? 0 : -1, !nuke_inner_whitespace) + @dont_indent_next_line = nuke_outer_whitespace end # Closes a Ruby block. @@ -373,7 +403,7 @@ END close_tag = has_conditional ? "<![endif]-->" : "-->" push_text(close_tag, -1) end - + # Closes a loud Ruby block. def close_loud(command) push_silent 'end', true @@ -384,14 +414,7 @@ END # Closes a filtered block. def close_filtered(filter) @flat_spaces = -1 - filtered = filter.new(@filter_buffer).render - - if filter == Haml::Filters::Preserve - push_silent("_hamlout.buffer << #{filtered.dump} << \"\\n\";") - else - push_text(filtered.rstrip.gsub("\n", "\n#{' ' * @output_tabs}")) - end - + filter.internal_compile(self, @filter_buffer) @filter_buffer = nil @template_tabs -= 1 end @@ -400,7 +423,7 @@ END @haml_comment = false @template_tabs -= 1 end - + # Iterates through the classes and ids supplied through <tt>.</tt> # and <tt>#</tt> syntax, and returns a hash with them as attributes, # that can then be merged with another attributes hash. @@ -415,7 +438,7 @@ END attributes['class'] = "" end attributes['class'] += property - when '#': attributes['id'] = property + when '#'; attributes['id'] = property end end attributes @@ -429,16 +452,16 @@ END # $5 holds the value matched by a string $2 || $5 end - - def parse_static_hash(text) - return {} unless text && inner = text.scan(/^\{(.*)\}$/)[0] + + def parse_static_hash(text) + return {} unless text attributes = {} - inner[0].split(',').each do |attrib| + text.split(',').each do |attrib| key, value, more = attrib.split('=>') # Make sure the key and value and only the key and value exist - # Otherwise, it's too complicated and we'll defer it to the actual Ruby parser + # Otherwise, it's too complicated or dynamic and we'll defer it to the actual Ruby parser key = parse_literal_value key value = parse_literal_value value return nil if more || key.nil? || value.nil? @@ -449,14 +472,23 @@ END end # This is a class method so it can be accessed from Buffer. - def self.build_attributes(attr_wrapper, attributes = {}) + def self.build_attributes(is_html, attr_wrapper, attributes = {}) quote_escape = attr_wrapper == '"' ? """ : "'" other_quote_char = attr_wrapper == '"' ? "'" : '"' - + result = attributes.collect do |attr, value| next if value.nil? - value = value.to_s + if value == true + next " #{attr}" if is_html + next " #{attr}=#{attr_wrapper}#{attr}#{attr_wrapper}" + elsif value == false + next + end + + value = Haml::Helpers.escape_once(value.to_s) + # We want to decide whether or not to escape quotes + value.gsub!('"', '"') this_attr_wrapper = attr_wrapper if value.include? attr_wrapper if value.include? other_quote_char @@ -470,73 +502,129 @@ END result.compact.sort.join end - def prerender_tag(name, atomic, attributes) - "<#{name}#{Precompiler.build_attributes(@options[:attr_wrapper], attributes)}#{atomic ? ' />' : '>'}" + def prerender_tag(name, self_close, attributes) + attributes_string = Precompiler.build_attributes(html?, @options[:attr_wrapper], attributes) + "<#{name}#{attributes_string}#{self_close && xhtml? ? ' /' : ''}>" + end + + # Parses a line into tag_name, attributes, attributes_hash, object_ref, action, value + def parse_tag(line) + raise SyntaxError.new("Invalid tag: \"#{line}\".") unless match = line.scan(/%([-:\w]+)([-\w\.\#]*)(.*)/)[0] + tag_name, attributes, rest = match + attributes_hash, rest = parse_attributes(rest) if rest[0] == ?{ + if rest + object_ref, rest = balance(rest, ?[, ?]) if rest[0] == ?[ + attributes_hash, rest = parse_attributes(rest) if rest[0] == ?{ && attributes_hash.nil? + nuke_whitespace, action, value = rest.scan(/(<>|><|[><])?([=\/\~&!])?(.*)?/)[0] + nuke_whitespace ||= '' + nuke_outer_whitespace = nuke_whitespace.include? '>' + nuke_inner_whitespace = nuke_whitespace.include? '<' + end + value = value.to_s.strip + [tag_name, attributes, attributes_hash, object_ref, nuke_outer_whitespace, + nuke_inner_whitespace, action, value] + end + + def parse_attributes(line) + scanner = StringScanner.new(line) + attributes_hash, rest = balance(scanner, ?{, ?}) + attributes_hash = attributes_hash[1...-1] if attributes_hash + return attributes_hash, rest end # Parses a line that will render as an XHTML tag, and adds the code that will # render that tag to <tt>@precompiled</tt>. def render_tag(line) - raise SyntaxError.new("Invalid tag: \"#{line}\"") unless match = line.scan(TAG_REGEX)[0] - tag_name, attributes, attributes_hash, object_ref, action, value = match - value = value.to_s.strip + tag_name, attributes, attributes_hash, object_ref, nuke_outer_whitespace, + nuke_inner_whitespace, action, value = parse_tag(line) raise SyntaxError.new("Illegal element: classes and ids must have values.") if attributes =~ /[\.#](\.|#|\z)/ + # Get rid of whitespace outside of the tag if we need to + rstrip_buffer! if nuke_outer_whitespace + + preserve_tag = options[:preserve].include?(tag_name) + nuke_inner_whitespace ||= preserve_tag + case action - when '/': atomic = true - when '~': parse = flattened = true - when '=': + when '/'; self_closing = xhtml? + when '~'; parse = preserve_script = true + when '=' parse = true value = unescape_interpolation(value[1..-1].strip) if value[0] == ?= + when '&', '!' + if value[0] == ?= + parse = true + value = (value[1] == ?= ? unescape_interpolation(value[2..-1].strip) : value[1..-1].strip) + end end - + if parse && @options[:suppress_eval] parse = false value = '' end + escape_html = (action == '&' || (action != '!' && @options[:escape_html])) + object_ref = "nil" if object_ref.nil? || @options[:suppress_eval] static_attributes = parse_static_hash(attributes_hash) # Try pre-compiling a static attributes hash - attributes_hash = "{nil}" if attributes_hash.nil? || static_attributes || @options[:suppress_eval] + attributes_hash = nil if static_attributes || @options[:suppress_eval] attributes = parse_class_and_id(attributes) Buffer.merge_attrs(attributes, static_attributes) if static_attributes - raise SyntaxError.new("Illegal Nesting: Nesting within an atomic tag is illegal.") if @block_opened && atomic - raise SyntaxError.new("Illegal Nesting: Nesting within a tag that already has content is illegal.") if @block_opened && !value.empty? - raise SyntaxError.new("Tag has no content.") if parse && value.empty? - raise SyntaxError.new("Atomic tags can't have content.") if atomic && !value.empty? + raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", 1) if @block_opened && self_closing + raise SyntaxError.new("Illegal nesting: content can't be both given on the same line as %#{tag_name} and nested within it.", 1) if @block_opened && !value.empty? + raise SyntaxError.new("There's no Ruby code for #{action} to evaluate.") if parse && value.empty? + raise SyntaxError.new("Self-closing tags can't have content.") if self_closing && !value.empty? - atomic = true if !@block_opened && value.empty? && @options[:autoclose].include?(tag_name) - - if object_ref == "nil" && attributes_hash == "{nil}" && !flattened && (parse || Buffer.one_liner?(value)) - # This means that we can render the tag directly to text and not process it in the buffer - tag_closed = !value.empty? && Buffer.one_liner?(value) && !parse + self_closing ||= !!( !@block_opened && value.empty? && @options[:autoclose].include?(tag_name) ) - open_tag = prerender_tag(tag_name, atomic, attributes) - open_tag << "#{value}</#{tag_name}>" if tag_closed - open_tag << "\n" unless parse + dont_indent_next_line = + (nuke_outer_whitespace && !@block_opened) || + (nuke_inner_whitespace && @block_opened) - push_merged_text(open_tag, tag_closed || atomic ? 0 : 1, parse) + # Check if we can render the tag directly to text and not process it in the buffer + if object_ref == "nil" && attributes_hash.nil? && !preserve_script + tag_closed = !@block_opened && !self_closing && !parse + + open_tag = prerender_tag(tag_name, self_closing, attributes) + if tag_closed + open_tag << "#{value}</#{tag_name}>" + open_tag << "\n" unless nuke_outer_whitespace + else + open_tag << "\n" unless parse || nuke_inner_whitespace || (self_closing && nuke_outer_whitespace) + end + + push_merged_text(open_tag, tag_closed || self_closing || nuke_inner_whitespace ? 0 : 1, + !nuke_outer_whitespace) + + @dont_indent_next_line = dont_indent_next_line return if tag_closed else flush_merged_text content = value.empty? || parse ? 'nil' : value.dump - push_silent "_hamlout.open_tag(#{tag_name.inspect}, #{atomic.inspect}, #{(!value.empty?).inspect}, #{attributes.inspect}, #{object_ref}, #{content}, #{attributes_hash[1...-1]})" + attributes_hash = ', ' + attributes_hash if attributes_hash + args = [tag_name, self_closing, !@block_opened, preserve_tag, escape_html, + attributes, nuke_outer_whitespace, nuke_inner_whitespace + ].map { |v| v.inspect }.join(', ') + push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_hash})" + @dont_tab_up_next_text = @dont_indent_next_line = dont_indent_next_line end - - return if atomic + + return if self_closing if value.empty? - push_and_tabulate([:element, tag_name]) - @output_tabs += 1 + push_and_tabulate([:element, [tag_name, nuke_outer_whitespace, nuke_inner_whitespace]]) + @output_tabs += 1 unless nuke_inner_whitespace return end - + if parse flush_merged_text - push_script(value, flattened, tag_name) + push_script(value, preserve_script, true, preserve_tag, escape_html, nuke_inner_whitespace) + @dont_tab_up_next_text = true + concat_merged_text("</#{tag_name}>" + (nuke_outer_whitespace ? "" : "\n")) end end @@ -548,92 +636,119 @@ END # Renders an XHTML comment. def render_comment(line) - conditional, content = line.scan(COMMENT_REGEX)[0] - content.strip! + conditional, line = balance(line, ?[, ?]) if line[0] == ?[ + line.strip! conditional << ">" if conditional - - if @block_opened && !content.empty? - raise SyntaxError.new('Illegal Nesting: Nesting within a tag that already has content is illegal.') + + if @block_opened && !line.empty? + raise SyntaxError.new('Illegal nesting: nesting within a tag that already has content is illegal.', 1) end open = "" : "-->"}") + unless line.empty? + return push_text("#{open}#{line} #{conditional ? "<![endif]-->" : "-->"}") end push_text(open, 1) @output_tabs += 1 push_and_tabulate([:comment, !conditional.nil?]) - unless content.empty? - push_text(content) + unless line.empty? + push_text(line) close end end - + # Renders an XHTML doctype or XML shebang. def render_doctype(line) - raise SyntaxError.new("Illegal Nesting: Nesting within a header command is illegal.") if @block_opened - push_text text_for_doctype(line) + raise SyntaxError.new("Illegal nesting: nesting within a header command is illegal.", 1) if @block_opened + doctype = text_for_doctype(line) + push_text doctype if doctype end def text_for_doctype(text) text = text[3..-1].lstrip.downcase - if text[0...3] == "xml" + if text.index("xml") == 0 + return nil if html? wrapper = @options[:attr_wrapper] return "<?xml version=#{wrapper}1.0#{wrapper} encoding=#{wrapper}#{text.split(' ')[1] || "utf-8"}#{wrapper} ?>" end - version, type = text.scan(DOCTYPE_REGEX)[0] - if version == "1.1" - return '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">' - end + if html5? + '<!DOCTYPE html>' + else + version, type = text.scan(DOCTYPE_REGEX)[0] - case type - when "strict": return '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' - when "frameset": return '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">' - else return '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">' + if xhtml? + if version == "1.1" + '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">' + else + case type + when "strict"; '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' + when "frameset"; '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">' + else '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">' + end + end + + elsif html4? + case type + when "strict"; '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">' + when "frameset"; '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">' + else '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">' + end + end end end # Starts a filtered block. def start_filtered(name) - raise SyntaxError.new('Filters must have nested text.') unless @block_opened + raise Error.new("Invalid filter name \":#{name}\".") unless name =~ /^\w+$/ unless filter = options[:filters][name] if filter == 'redcloth' || filter == 'markdown' || filter == 'textile' - raise HamlError.new("You must have the RedCloth gem installed to use \"#{name}\" filter") + raise Error.new("You must have the RedCloth gem installed to use \"#{name}\" filter") end - raise HamlError.new("\"#{name}\" filter is not defined!") + raise Error.new("Filter \"#{name}\" is not defined.") end push_and_tabulate([:filtered, filter]) @flat_spaces = @template_tabs * 2 @filter_buffer = String.new + @block_opened = false + end + + def contains_interpolation?(str) + str.include?('#{') end def unescape_interpolation(str) scan = StringScanner.new(str.dump) str = '' - while scan.scan(/(.*?)\\\#\{/) - str << scan.matched[0...-3] - str << eval("\"\\\#{#{balance_brackets(scan)}}\"") + while scan.scan(/(.*?)(\\+)\#\{/) + escapes = (scan[2].size - 1) / 2 + str << scan.matched[0...-3 - escapes] + if escapes % 2 == 1 + str << '#{' + else + # Use eval to get rid of string escapes + str << '#{' + eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"') + "}" + end end str + scan.rest end - def balance_brackets(scanner) + def balance(scanner, start, finish, count = 0) str = '' - count = 1 - - while scanner.scan(/(.*?)[\{\}]/) + scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner + regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]") + while scanner.scan(regexp) str << scanner.matched - count += 1 if scanner.matched[-1] == ?{ - count -= 1 if scanner.matched[-1] == ?} - return str[0...-1] if count == 0 + count += 1 if scanner.matched[-1] == start + count -= 1 if scanner.matched[-1] == finish + return [str.strip, scanner.rest] if count == 0 end raise SyntaxError.new("Unbalanced brackets.") @@ -641,14 +756,17 @@ END # Counts the tabulation of a line. def count_soft_tabs(line) - spaces = line.index(/[^ ]/) + spaces = line.index(/([^ ]|$)/) if line[spaces] == ?\t return nil if line.strip.empty? - raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.") + raise SyntaxError.new(<<END.strip, 2) +A tab character was used for indentation. Haml must be indented using two spaces. +Are you sure you have soft tabs enabled in your editor? +END end [spaces, spaces/2] end - + # Pushes value onto <tt>@to_close_stack</tt> and increases # <tt>@template_tabs</tt>. def push_and_tabulate(value) @@ -660,10 +778,30 @@ END @flat_spaces != -1 end - def newline(skip_next = false) - return @skip_next_newline = false if @skip_next_newline - @skip_next_newline = true if skip_next + def newline + @newlines += 1 + end + + def newline_now @precompiled << "\n" + @newlines -= 1 + end + + def resolve_newlines + return unless @newlines > 0 + @precompiled << "\n" * @newlines + @newlines = 0 + end + + # Get rid of and whitespace at the end of the buffer + # or the merged text + def rstrip_buffer! + unless @merged_text.empty? + @merged_text.rstrip! + else + push_silent("_erbout.rstrip!", false) + @dont_tab_up_next_text = true + end end end end vendor/plugins/haml/lib/haml/precompiler.rb @@ -1,19 +1,16 @@ require 'haml/engine' -require 'rubygems' -require 'active_support' -require 'action_view' module Haml class Template class << self @@options = {} - # Gets various options for Haml. See README for details. + # Gets various options for Haml. See README.rdoc for details. def options @@options end - # Sets various options for Haml. See README for details. + # Sets various options for Haml. See README.rdoc for details. def options=(value) @@options = value end @@ -29,3 +26,18 @@ if defined?(ActionView::TemplateHandler) else require 'haml/template/patch' end + +if defined?(RAILS_ROOT) + # Update init.rb to the current version + # if it's out of date. + # + # We can probably remove this as of v1.9, + # because the new init file is sufficiently flexible + # to not need updating. + rails_init_file = File.join(RAILS_ROOT, 'vendor', 'plugins', 'haml', 'init.rb') + haml_init_file = Haml.scope('init.rb') + if File.exists?(rails_init_file) + require 'fileutils' + FileUtils.cp(haml_init_file, rails_init_file) unless FileUtils.cmp(rails_init_file, haml_init_file) + end +end vendor/plugins/haml/lib/haml/template.rb @@ -26,7 +26,7 @@ module ActionView def compile_haml(template, file_name, local_assigns) render_symbol = assign_method_name(:haml, template, file_name) locals = local_assigns.keys - + @@template_args[render_symbol] ||= {} locals_keys = @@template_args[render_symbol].keys | locals @@template_args[render_symbol] = locals_keys.inject({}) { |h, k| h[k] = true; h } @@ -42,7 +42,14 @@ module ActionView logger.debug "Backtrace: #{e.backtrace.join("\n")}" end - raise TemplateError.new(@base_path, file_name || template, @assigns, template, e) + base_path = if defined?(extract_base_path_from) + # Rails 2.0.x + extract_base_path_from(file_name) || view_paths.first + else + # Rails <=1.2.6 + @base_path + end + raise ActionView::TemplateError.new(base_path, file_name || template, @assigns, template, e) end @@compile_time[render_symbol] = Time.now vendor/plugins/haml/lib/haml/template/patch.rb @@ -1,21 +1,72 @@ +# :stopdoc: # This file makes Haml work with Rails # using the > 2.0.1 template handler API. module Haml - class Template - def self.line_offset - 1 - end - - def initialize(view) - @view = view - end + class Plugin < ActionView::TemplateHandler + include ActionView::TemplateHandlers::Compilable if defined?(ActionView::TemplateHandlers::Compilable) def compile(template) options = Haml::Template.options.dup - Haml::Engine.new(template, options).send(:precompiled_with_ambles, []) + + # template is a template object in Rails >=2.1.0, + # a source string previously + if template.respond_to? :source + options[:filename] = template.filename + source = template.source + else + source = template + end + + Haml::Engine.new(source, options).send(:precompiled_with_ambles, []) + end + + def cache_fragment(block, name = {}, options = nil) + @view.fragment_for(block, name, options) do + eval("_hamlout.buffer", block.binding) + end end end end -ActionView::Base.register_template_handler(:haml, Haml::Template) +if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler + ActionView::Template +else + ActionView::Base +end.register_template_handler(:haml, Haml::Plugin) + +# In Rails 2.0.2, ActionView::TemplateError took arguments +# that we can't fill in from the Haml::Plugin context. +# Thus, we've got to monkeypatch ActionView::Base to catch the error. +if ActionView::TemplateError.instance_method(:initialize).arity == 5 + class ActionView::Base + def compile_template(handler, template, file_name, local_assigns) + render_symbol = assign_method_name(handler, template, file_name) + + # Move begin up two lines so it captures compilation exceptions. + begin + render_source = create_template_source(handler, template, render_symbol, local_assigns.keys) + line_offset = @@template_args[render_symbol].size + handler.line_offset + + file_name = 'compiled-template' if file_name.blank? + CompiledTemplates.module_eval(render_source, file_name, -line_offset) + rescue Exception => e # errors from template code + if logger + logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}" + logger.debug "Function body: #{render_source}" + logger.debug "Backtrace: #{e.backtrace.join("\n")}" + end + + # There's no way to tell Haml about the filename, + # so we've got to insert it ourselves. + e.backtrace[0].gsub!('(haml)', file_name) if e.is_a?(Haml::Error) + + raise ActionView::TemplateError.new(extract_base_path_from(file_name) || view_paths.first, file_name || template, @assigns, template, e) + end + + @@compile_time[render_symbol] = Time.now + # logger.debug "Compiled template #{file_name || template}\n ==> #{render_symbol}" if logger + end + end +end +# :startdoc: vendor/plugins/haml/lib/haml/template/plugin.rb @@ -11,7 +11,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # and implements various features that are useful # for creating manageable stylesheets. # -# == Features +# == Features # # * Whitespace active # * Well-formatted output @@ -32,13 +32,13 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # # To enable it as a Rails plugin, # then run -# +# # haml --rails path/to/rails/app -# +# # To enable Sass in Merb, # add # -# dependency "haml" +# dependency "merb-haml" # # to config/dependencies.rb. # @@ -128,7 +128,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # # By default, either attribute syntax may be used. # If you want to force one or the other, -# see the :attribute_syntax option below. +# see the <tt>:attribute_syntax</tt> option below. # # === Nested Rules # @@ -157,12 +157,12 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # # #main # :width 97% -# +# # p, div # :font-size 2em # a # :font-weight bold -# +# # pre # :font-size 3em # @@ -363,6 +363,39 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # #main { # content: string(Hello, "Hubert" Bean.) } # +# === Optional Assignment +# +# You can assign Sass constants if they aren't already assigned +# using the ||= assignment operator. +# This means that if the constant has already been assigned to, +# it won't be re-assigned, +# but if it doesn't have a value yet, +# it will be given one. +# For example: +# +# !content = "First content" +# !content ||= "Second content?" +# +# #main +# content = content +# +# is compiled to: +# +# #main { +# content: First content; } +# +# However, +# +# !content ||= "Second content?" +# +# #main +# content = content +# +# is compiled to: +# +# #main { +# content: Second content?; } +# # === Default Concatenation # # All those plusses and quotes for concatenating strings @@ -453,6 +486,40 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # might compile to either, # depending on whether a file called "foo.sass" existed. # +# === @font-face, @media, etc. +# +# Sass behaves as you'd expect for normal CSS @-directives. +# For example: +# +# @font-face +# font-family: "Bitstream Vera Sans" +# src: url(http://foo.bar/bvs") +# +# compiles to: +# +# @font-face { +# font-family: "Bitstream Vera Sans"; +# src: url(http://foo.bar/bvs"); } +# +# and +# +# @media print +# #sidebar +# display: none +# +# #main +# background-color: white +# +# compiles to: +# +# @media print { +# #sidebar { +# display: none; } +# +# #main { +# background-color: white; } +# } +# # == Comments # # === Silent Comments @@ -528,6 +595,84 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # background-image: url(/images/pbj.png); # color: red; } # +# == Mixins +# +# Mixins enable you to define groups of CSS attributes and +# then include them inline in any number of selectors +# throughout the document. +# +# === Defining a Mixin +# +# To define a mixin you use a slightly modified form of selector syntax. +# For example the 'large-text' mixin is defined as follows: +# +# =large-text +# :font +# :family Arial +# :size 20px +# :weight bold +# :color #ff0000 +# +# The initial '=' marks this as a mixin rather than a standard selector. +# The CSS rules that follow won't be included until the mixin is referenced later on. +# Anything you can put into a standard selector, +# you can put into a mixin definition. e.g. +# +# =clearfix +# display: inline-block +# &:after +# content: "." +# display: block +# height: 0 +# clear: both +# visibility: hidden +# * html & +# height: 1px +# +# +# === Mixing it in +# +# Inlining a defined mixin is simple, +# just prepend a '+' symbol to the name of a mixin defined earlier in the document. +# So to inline the 'large-text' defined earlier, +# we include the statment '+large-text' in our selector definition thus: +# +# .page-title +# +large-text +# :padding 4px +# :margin +# :top 10px +# +# +# This will produce the following CSS output: +# +# .page-title { +# font-family: Arial; +# font-size: 20px; +# font-weight: bold; +# color: #ff0000; +# padding: 4px; +# margin-top: 10px; +# } +# +# Any number of mixins may be defined and there is no limit on +# the number that can be included in a particular selector. +# +# Mixin definitions can also include references to other mixins defined earlier in the file. +# E.g. +# +# =highlighted-background +# background: +# color: #fc0 +# =header-text +# font: +# size: 20px +# +# =compound +# +highlighted-background +# +header-text +# +# # == Output Style # # Although the default CSS style that Sass outputs is very nice, @@ -601,7 +746,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # #main { color: #fff; background-color: #000; } # #main p { width: 10em; } # -# .huge { font-size: 10em; font-weight: bold; text-decoration: underline; } +# .huge { font-size: 10em; font-weight: bold; text-decoration: underline; } # # === <tt>:compressed</tt> # @@ -611,7 +756,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # It's not meant to be human-readable. # For example: # -# #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline} +# #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline} # # == Sass Options # @@ -634,7 +779,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # For example: <tt>color: #0f3</tt> # or <tt>width = !main_width</tt>. # By default, either syntax is valid. -# +# # [<tt>:never_update</tt>] Whether the CSS files should never be updated, # even if the template file changes. # Setting this to true may give small performance gains. @@ -646,7 +791,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # as opposed to only when the template has been modified. # Defaults to false. # Only has meaning within Ruby on Rails or Merb. -# +# # [<tt>:always_check</tt>] Whether a Sass template should be checked for updates every # time a controller is accessed, # as opposed to only when the Rails server starts. @@ -681,7 +826,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir) # for Sass templates imported with the "@import" directive. # This defaults to the working directory and, in Rails or Merb, # whatever <tt>:template_location</tt> is. -# +# module Sass; end require 'sass/engine' vendor/plugins/haml/lib/sass.rb @@ -8,13 +8,13 @@ module Sass # Whitespace characters WHITESPACE = [?\ , ?\t, ?\n, ?\r] - + # The character used to escape values ESCAPE_CHAR = ?\\ # The character used to open and close strings STRING_CHAR = ?" - + # A mapping of syntactically-significant characters # to parsed symbols SYMBOLS = { @@ -31,14 +31,14 @@ module Sass } # The regular expression used to parse constants - MATCH = /^#{Regexp.escape(CONSTANT_CHAR.chr)}([^\s#{(SYMBOLS.keys + [ ?= ]).map {|c| Regexp.escape("#{c.chr}") }}]+)\s*=\s*(.+)/ - + MATCH = /^#{Regexp.escape(CONSTANT_CHAR.chr)}([^\s#{(SYMBOLS.keys + [ ?= ]).map {|c| Regexp.escape("#{c.chr}") }.join}]+)\s*((?:\|\|)?=)\s*(.+)/ + # First-order operations FIRST_ORDER = [:times, :div, :mod] - + # Second-order operations SECOND_ORDER = [:plus, :minus] - + class << self def parse(value, constants, line) begin @@ -46,28 +46,28 @@ module Sass rescue Sass::SyntaxError => e if e.message == "Constant arithmetic error" e.instance_eval do - @message += ": #{value.dump}" + @message += ": #{value.dump}." end end e.sass_line = line raise e end end - + private - + def tokenize(value) escaped = false is_string = false beginning_of_token = true str = '' to_return = [] - + reset_str = Proc.new do to_return << str unless str.empty? '' end - + value.each_byte do |byte| unless escaped if byte == ESCAPE_CHAR @@ -97,7 +97,7 @@ module Sass str = reset_str.call next end - + symbol = SYMBOLS[byte] # Adjacent values without an operator should be concatenated @@ -135,28 +135,28 @@ module Sass end end end - + escaped = false beginning_of_token = false str << byte.chr end - + if is_string - raise Sass::SyntaxError.new("Unterminated string: #{value.dump}") + raise Sass::SyntaxError.new("Unterminated string: #{value.dump}.") end str = reset_str.call to_return end - + def parenthesize(value) parenthesize_helper(0, value, value.length)[0] end - + def parenthesize_helper(i, value, value_len, return_after_expr = false) to_return = [] beginning = i token = value[i] - + while i < value_len && token != :close if token == :open to_return.push(*value[beginning...i]) @@ -194,13 +194,13 @@ module Sass else i += 1 end - + token = value[i] end to_return.push(*value[beginning...i]) return to_return, i + 1 end - + #-- # TODO: Don't pass around original value; # have Constant.parse automatically add it to exception. @@ -234,10 +234,10 @@ module Sass end end end - + def get_constant(value, constants) to_return = constants[value] - raise SyntaxError.new("Undefined constant: \"!#{value}\"") unless to_return + raise SyntaxError.new("Undefined constant: \"!#{value}\".") unless to_return to_return end end vendor/plugins/haml/lib/sass/constant.rb @@ -21,9 +21,9 @@ module Sass::Constant # :nodoc: 'teal' => 0x008080, 'aqua' => 0x00ffff } - + REGEXP = /\##{"([0-9a-fA-F]{1,2})" * 3}/ - + def parse(value) if (value =~ REGEXP) @value = value.scan(REGEXP)[0].map { |num| num.ljust(2, num).to_i(16) } @@ -32,7 +32,7 @@ module Sass::Constant # :nodoc: @value = (0..2).map{ |n| color >> (n << 3) & 0xff }.reverse end end - + def plus(other) if other.is_a? Sass::Constant::String Sass::Constant::String.from_value(self.to_s + other.to_s) @@ -40,7 +40,7 @@ module Sass::Constant # :nodoc: piecewise(other, :+) end end - + def minus(other) if other.is_a? Sass::Constant::String raise NoMethodError.new(nil, :minus) @@ -48,7 +48,7 @@ module Sass::Constant # :nodoc: piecewise(other, :-) end end - + def times(other) if other.is_a? Sass::Constant::String raise NoMethodError.new(nil, :times) @@ -56,7 +56,7 @@ module Sass::Constant # :nodoc: piecewise(other, :*) end end - + def div(other) if other.is_a? Sass::Constant::String raise NoMethodError.new(nil, :div) @@ -64,7 +64,7 @@ module Sass::Constant # :nodoc: piecewise(other, :/) end end - + def mod(other) if other.is_a? Sass::Constant::String raise NoMethodError.new(nil, :mod) @@ -72,24 +72,24 @@ module Sass::Constant # :nodoc: piecewise(other, :%) end end - + def to_s red, green, blue = @value.map { |num| num.to_s(16).rjust(2, '0') } "##{red}#{green}#{blue}" end - + protected - + def self.filter_value(value) value.map { |num| num.to_i } end - + private - + def piecewise(other, operation) other_num = other.is_a? Number other_val = other.value - + rgb = [] for i in (0...3) res = @value[i].send(operation, other_num ? other_val : other_val[i]) vendor/plugins/haml/lib/sass/constant/color.rb @@ -13,7 +13,7 @@ class Sass::Constant::Literal # :nodoc: # The regular expression matching colors. COLOR = /^\# (?: [\da-f]{3} | [\da-f]{6} ) | #{html_color_matcher}/ix - + def self.parse(value) case value when NUMBER @@ -24,11 +24,11 @@ class Sass::Constant::Literal # :nodoc: Sass::Constant::String.new(value) end end - + def initialize(value = nil) self.parse(value) if value end - + def perform self end @@ -36,15 +36,15 @@ class Sass::Constant::Literal # :nodoc: def concat(other) Sass::Constant::String.from_value("#{self.to_s} #{other.to_s}") end - + attr_reader :value - + protected - + def self.filter_value(value) value end - + def self.from_value(value) instance = self.new instance.instance_variable_set('@value', self.filter_value(value)) vendor/plugins/haml/lib/sass/constant/literal.rb @@ -10,7 +10,7 @@ module Sass::Constant # :nodoc: @value = first.empty? ? second.to_i : "#{first}#{second}".to_f @unit = unit unless unit.empty? end - + def plus(other) if other.is_a? Number operate(other, :+) @@ -20,7 +20,7 @@ module Sass::Constant # :nodoc: Sass::Constant::String.from_value(self.to_s + other.to_s) end end - + def minus(other) if other.is_a? Number operate(other, :-) @@ -28,7 +28,7 @@ module Sass::Constant # :nodoc: raise NoMethodError.new(nil, :minus) end end - + def times(other) if other.is_a? Number operate(other, :*) @@ -38,7 +38,7 @@ module Sass::Constant # :nodoc: raise NoMethodError.new(nil, :times) end end - + def div(other) if other.is_a? Number operate(other, :/) @@ -46,7 +46,7 @@ module Sass::Constant # :nodoc: raise NoMethodError.new(nil, :div) end end - + def mod(other) if other.is_a? Number operate(other, :%) @@ -54,13 +54,13 @@ module Sass::Constant # :nodoc: raise NoMethodError.new(nil, :mod) end end - + def to_s value = @value value = value.to_i if value % 1 == 0.0 "#{value}#{@unit}" end - + protected def self.from_value(value, unit=nil) @@ -68,7 +68,7 @@ module Sass::Constant # :nodoc: instance.instance_variable_set('@unit', unit) instance end - + def operate(other, operation) unit = nil if other.unit.nil? @@ -78,7 +78,7 @@ module Sass::Constant # :nodoc: elsif other.unit == self.unit unit = self.unit else - raise Sass::SyntaxError.new("Incompatible units: #{self.unit} and #{other.unit}") + raise Sass::SyntaxError.new("Incompatible units: #{self.unit} and #{other.unit}.") end Number.from_value(self.value.send(operation, other.value), unit) vendor/plugins/haml/lib/sass/constant/number.rb @@ -9,13 +9,13 @@ module Sass::Constant # :nodoc: @operand2 = operand2 @operator = operator end - + def to_s self.perform.to_s end - + protected - + def perform literal1 = @operand1.perform literal2 = @operand2.perform @@ -23,7 +23,7 @@ module Sass::Constant # :nodoc: literal1.send(@operator, literal2) rescue NoMethodError => e raise e unless e.name.to_s == @operator.to_s - raise Sass::SyntaxError.new("Undefined operation: \"#{literal1} #{@operator} #{literal2}\"") + raise Sass::SyntaxError.new("Undefined operation: \"#{literal1} #{@operator} #{literal2}\".") end end end vendor/plugins/haml/lib/sass/constant/operation.rb @@ -2,11 +2,11 @@ require 'sass/constant/literal' module Sass::Constant # :nodoc: class String < Literal # :nodoc: - + def parse(value) @value = value end - + def plus(other) Sass::Constant::String.from_value(self.to_s + other.to_s) end @@ -14,7 +14,7 @@ module Sass::Constant # :nodoc: def funcall(other) Sass::Constant::String.from_value("#{self.to_s}(#{other.to_s})") end - + def to_s @value end vendor/plugins/haml/lib/sass/constant/string.rb @@ -6,11 +6,11 @@ module Sass # :stopdoc: module Tree class Node - def to_sass + def to_sass(opts = {}) result = '' children.each do |child| - result << "#{child.to_sass(0)}\n" + result << "#{child.to_sass(0, opts)}\n" end result @@ -24,11 +24,11 @@ module Sass end class RuleNode - def to_sass(tabs) - str = "#{' ' * tabs}#{rule}\n" + def to_sass(tabs, opts = {}) + str = "\n#{' ' * tabs}#{rule}#{children.any? { |c| c.is_a? AttrNode } ? "\n" : ''}" children.each do |child| - str << "#{child.to_sass(tabs + 1)}" + str << "#{child.to_sass(tabs + 1, opts)}" end str @@ -36,8 +36,8 @@ module Sass end class AttrNode - def to_sass(tabs) - "#{' ' * tabs}:#{name} #{value}\n" + def to_sass(tabs, opts = {}) + "#{' ' * tabs}#{opts[:alternate] ? '' : ':'}#{name}#{opts[:alternate] ? ':' : ''} #{value}\n" end end end @@ -90,11 +90,12 @@ module Sass # Creates a new instance of Sass::CSS that will compile the given document # to a Sass string when +render+ is called. - def initialize(template) + def initialize(template, options = {}) if template.is_a? IO template = template.read end + @options = options @template = StringScanner.new(template) end @@ -102,10 +103,10 @@ module Sass # containing the CSS template. def render begin - build_tree.to_sass + build_tree.to_sass(@options).lstrip rescue Exception => err line = @template.string[0...@template.pos].split("\n").size - + err.backtrace.unshift "(css):#{line}" raise err end @@ -116,12 +117,13 @@ module Sass def build_tree root = Tree::Node.new(nil) whitespace - directives root - rules root - expand_commas root - nest_rules root - flatten_rules root - fold_commas root + directives root + rules root + expand_commas root + parent_ref_rules root + remove_parent_refs root + flatten_rules root + fold_commas root root end @@ -164,12 +166,12 @@ module Sass whitespace assert_match /:/ - + value = '' while @template.scan(/[^;\s\}]+/) value << @template[0] << whitespace end - + assert_match /(;|(?=\}))/ rule << Tree::AttrNode.new(name, value, nil) end @@ -191,7 +193,10 @@ module Sass def assert_match(re) if !@template.scan(re) - raise Exception.new("Invalid CSS!") + line = @template.string[0..@template.pos].count "\n" + # Display basic regexps as plain old strings + expected = re.source == Regexp.escape(re.source) ? "\"#{re.source}\"" : re.inspect + raise Exception.new("Invalid CSS on line #{line}: expected #{expected}") end whitespace end @@ -224,7 +229,22 @@ module Sass root.children.flatten! end - # Nest rules so that + # Make rules use parent refs so that + # + # foo + # color: green + # foo.bar + # color: blue + # + # becomes + # + # foo + # color: green + # &.bar + # color: blue + # + # This has the side effect of nesting rules, + # so that # # foo # color: green @@ -237,29 +257,50 @@ module Sass # # foo # color: green - # bar + # & bar # color: red - # baz + # & baz # color: blue - # - def nest_rules(root) + # + def parent_ref_rules(root) rules = OrderedHash.new root.children.select { |c| Tree::RuleNode === c }.each do |child| root.children.delete child - first, rest = child.rule.split(' ', 2) + first, rest = child.rule.scan(/^(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?$/).first rules[first] ||= Tree::RuleNode.new(first, nil) if rest - child.rule = rest + child.rule = "&" + rest rules[first] << child else rules[first].children += child.children end end - rules.values.each { |v| nest_rules(v) } + rules.values.each { |v| parent_ref_rules(v) } root.children += rules.values end + # Remove useless parent refs so that + # + # foo + # & bar + # color: blue + # + # becomes + # + # foo + # bar + # color: blue + # + def remove_parent_refs(root) + root.children.each do |child| + if child.is_a?(Tree::RuleNode) + child.rule.gsub! /^& /, '' + remove_parent_refs child + end + end + end + # Flatten rules so that # # foo @@ -271,7 +312,18 @@ module Sass # # foo bar baz # color: red - # + # + # and + # + # foo + # &.bar + # color: blue + # + # becomes + # + # foo.bar + # color: blue + # def flatten_rules(root) root.children.each { |child| flatten_rule(child) if child.is_a?(Tree::RuleNode) } end @@ -279,7 +331,13 @@ module Sass def flatten_rule(rule) while rule.children.size == 1 && rule.children.first.is_a?(Tree::RuleNode) child = rule.children.first - rule.rule = "#{rule.rule} #{child.rule}" + + if child.rule[0] == ?& + rule.rule = child.rule.gsub /^&/, rule.rule + else + rule.rule = "#{rule.rule} #{child.rule}" + end + rule.children = child.children end vendor/plugins/haml/lib/sass/css.rb @@ -6,7 +6,6 @@ require 'sass/tree/attr_node' require 'sass/tree/directive_node' require 'sass/constant' require 'sass/error' -require 'haml/util' module Sass # This is the class where all the parsing and processing of the Sass @@ -39,10 +38,16 @@ module Sass # The character used to denote a compiler directive. DIRECTIVE_CHAR = ?@ - + # Designates a non-parsed rule. ESCAPE_CHAR = ?\\ + # Designates block as mixin definition rather than CSS rules to output + MIXIN_DEFINITION_CHAR = ?= + + # Includes named mixin declared using MIXIN_DEFINITION_CHAR + MIXIN_INCLUDE_CHAR = ?+ + # The regex that matches and extracts data from # attributes of the form <tt>:name attr</tt>. ATTRIBUTE = /^:([^\s=:]+)\s*(=?)(?:\s+|$)(.*)/ @@ -56,14 +61,14 @@ module Sass # Creates a new instace of Sass::Engine that will compile the given # template string when <tt>render</tt> is called. - # See README for available options. + # See README.rdoc for available options. # #-- # # TODO: Add current options to REFRENCE. Remember :filename! # # When adding options, remember to add information about them - # to README! + # to README.rdoc! #++ # def initialize(template, options={}) @@ -71,9 +76,10 @@ module Sass :style => :nested, :load_paths => ['.'] }.merge! options - @template = template.split(/\n\r|\n/) + @template = template.split(/\n?\r|\r?\n/) @lines = [] @constants = {"important" => "!important"} + @mixins = {} end # Processes the template and returns the result as a string. @@ -96,6 +102,10 @@ module Sass @constants end + def mixins + @mixins + end + def render_to_tree split_lines @@ -113,7 +123,7 @@ module Sass end end end - @line = nil + @lines.clear root end @@ -136,7 +146,7 @@ module Sass if tabs # if line isn't blank if tabs - old_tabs > 1 - raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.", @line) + raise SyntaxError.new("#{tabs * 2} spaces were used for indentation. Sass must be indented using two spaces.", @line) end @lines << [line.strip, tabs] @@ -151,18 +161,20 @@ module Sass # Counts the tabulation of a line. def count_tabs(line) - spaces = line.index(/[^ ]/) - if spaces - if spaces % 2 == 1 || line[spaces] == ?\t - # Make sure a line with just tabs isn't an error - return nil if line.strip.empty? - - raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.", @line) - end - spaces / 2 - else - nil + return nil if line.strip.empty? + return nil unless spaces = line.index(/[^ ]/) + + if spaces % 2 == 1 + raise SyntaxError.new(<<END.strip, @line) +#{spaces} space#{spaces == 1 ? ' was' : 's were'} used for indentation. Sass must be indented using two spaces. +END + elsif line[spaces] == ?\t + raise SyntaxError.new(<<END.strip, @line) +A tab character was used for indentation. Sass must be indented using two spaces. +Are you sure you have soft tabs enabled in your editor? +END end + spaces / 2 end def build_tree(index) @@ -177,15 +189,23 @@ module Sass unless node.is_a? Tree::Node if has_children if node == :constant - raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath constants.", @line) + raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath constants.", @line + 1) elsif node.is_a? Array - raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.", @line) + # arrays can either be full of import statements + # or attributes from mixin includes + # in either case they shouldn't have children. + # Need to peek into the array in order to give meaningful errors + directive_type = (node.first.is_a?(Tree::DirectiveNode) ? "import" : "mixin") + raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath #{directive_type} directives.", @line + 1) end end + index = @line if node == :mixin return node, index end + node.line = @line + if node.is_a? Tree::CommentNode while has_children line, index = raw_next_line(index) @@ -193,26 +213,52 @@ module Sass has_children = has_children?(index, tabs) end - else - while has_children - child, index = build_tree(index) - if child == :constant - raise SyntaxError.new("Constants may only be declared at the root of a document.", @line) - elsif child.is_a? Array - raise SyntaxError.new("Import directives may only be used at the root of a document.", @line) - elsif child.is_a? Tree::Node - child.line = @line - node << child + return node, index + end + + # Resolve multiline rules + if node.is_a?(Tree::RuleNode) + if node.continued? + child, index = build_tree(index) if @lines[old_index = index] + if @lines[old_index].nil? || has_children?(old_index, tabs) || !child.is_a?(Tree::RuleNode) + raise SyntaxError.new("Rules can't end in commas.", @line) end - has_children = has_children?(index, tabs) + node.add_rules child end + node.children = child.children if child + end + + while has_children + child, index = build_tree(index) + + validate_and_append_child(node, child) + + has_children = has_children?(index, tabs) end return node, index end + def validate_and_append_child(parent, child) + case child + when :constant + raise SyntaxError.new("Constants may only be declared at the root of a document.", @line) + when :mixin + raise SyntaxError.new("Mixins may only be defined at the root of a document.", @line) + when Array + child.each do |c| + if c.is_a?(Tree::DirectiveNode) + raise SyntaxError.new("Import directives may only be used at the root of a document.", @line) + end + parent << c + end + when Tree::Node + parent << child + end + end + def has_children?(index, tabs) next_line = ['//', 0] while !next_line.nil? && next_line[0] == '//' && next_line[1] = 0 @@ -238,6 +284,10 @@ module Sass parse_directive(line) when ESCAPE_CHAR Tree::RuleNode.new(line[1..-1], @options[:style]) + when MIXIN_DEFINITION_CHAR + parse_mixin_definition(line) + when MIXIN_INCLUDE_CHAR + parse_mixin_include(line) else if line =~ ATTRIBUTE_ALTERNATE_MATCHER parse_attribute(line, ATTRIBUTE_ALTERNATE) @@ -259,7 +309,7 @@ module Sass name, eq, value = line.scan(attribute_regx)[0] if name.nil? || value.nil? - raise SyntaxError.new("Invalid attribute: \"#{line}\"", @line) + raise SyntaxError.new("Invalid attribute: \"#{line}\".", @line) end if eq.strip[0] == SCRIPT_CHAR @@ -270,11 +320,18 @@ module Sass end def parse_constant(line) - name, value = line.scan(Sass::Constant::MATCH)[0] + name, op, value = line.scan(Sass::Constant::MATCH)[0] unless name && value - raise SyntaxError.new("Invalid constant: \"#{line}\"", @line) + raise SyntaxError.new("Invalid constant: \"#{line}\".", @line) + end + + constant = Sass::Constant.parse(value, @constants, @line) + if op == '||=' + @constants[name] ||= constant + else + @constants[name] = constant end - @constants[name] = Sass::Constant.parse(value, @constants, @line) + :constant end @@ -291,14 +348,36 @@ module Sass def parse_directive(line) directive, value = line[1..-1].split(/\s+/, 2) - case directive - when "import" + # If value begins with url( or ", + # it's a CSS @import rule and we don't want to touch it. + if directive == "import" && value !~ /^(url\(|")/ import(value) else Tree::DirectiveNode.new(line, @options[:style]) end end + def parse_mixin_definition(line) + mixin_name = line[1..-1] + @mixins[mixin_name] = [] + index = @line + line, tabs = @lines[index] + while !line.nil? && tabs > 0 + child, index = build_tree(index) + validate_and_append_child(@mixins[mixin_name], child) + line, tabs = @lines[index] + end + :mixin + end + + def parse_mixin_include(line) + mixin_name = line[1..-1] + unless @mixins.has_key?(mixin_name) + raise SyntaxError.new("Undefined mixin '#{mixin_name}'.", @line) + end + @mixins[mixin_name] + end + def import(files) nodes = [] @@ -312,7 +391,7 @@ module Sass end if filename =~ /\.css$/ - nodes << Tree::ValueNode.new("@import url(#{filename});", @options[:style]) + nodes << Tree::DirectiveNode.new("@import url(#{filename})", @options[:style]) else File.open(filename) do |file| new_options = @options.dup @@ -321,6 +400,7 @@ module Sass end engine.constants.merge! @constants + engine.mixins.merge! @mixins begin root = engine.render_to_tree @@ -333,6 +413,7 @@ module Sass nodes << child end @constants = engine.constants + @mixins = engine.mixins end end @@ -354,7 +435,7 @@ module Sass if new_filename.nil? if was_sass - raise Exception.new("File to import not found or unreadable: #{original_filename}") + raise Exception.new("File to import not found or unreadable: #{original_filename}.") else return filename + '.css' end vendor/plugins/haml/lib/sass/engine.rb @@ -4,7 +4,7 @@ module Sass # and the Sass file that was being parsed (if applicable). # It also provides a handy way to rescue only exceptions raised # because of a faulty template. - class SyntaxError < StandardError + class SyntaxError < Exception # The line of the Sass template on which the exception was thrown. attr_accessor :sass_line vendor/plugins/haml/lib/sass/error.rb @@ -13,8 +13,15 @@ module Sass :always_check => true, :full_exception => true } + @@checked_for_updates = false - # Gets various options for Sass. See README for details. + # Whether or not Sass has *ever* checked if the stylesheets need updates + # (in this Ruby instance). + def checked_for_updates + @@checked_for_updates + end + + # Gets various options for Sass. See README.rdoc for details. #-- # TODO: *DOCUMENT OPTIONS* #++ @@ -35,6 +42,7 @@ module Sass def update_stylesheets return if options[:never_update] + @@checked_for_updates = true Dir.glob(File.join(options[:template_location], "**", "*.sass")).entries.each do |file| # Get the relative path to the file with no extension @@ -96,7 +104,18 @@ module Sass end end end - "/*\n#{e_string}\n\nBacktrace:\n#{e.backtrace.join("\n")}\n*/" + <<END +/* +#{e_string} + +Backtrace:\n#{e.backtrace.join("\n")} +*/ +body:before { + white-space: pre; + font-family: monospace; + content: "#{e_string.gsub('"', '\"').gsub("\n", '\\A ')}"; } +END + # Fix an emacs syntax-highlighting hiccup: ' else "/* Internal stylesheet error */" end @@ -111,7 +130,7 @@ module Sass end def forbid_update?(name) - name[0] == ?_ + name.sub(/^.*\//, '')[0] == ?_ end def stylesheet_needs_update?(name) vendor/plugins/haml/lib/sass/plugin.rb @@ -1,20 +1,56 @@ unless defined?(Sass::MERB_LOADED) Sass::MERB_LOADED = true - Sass::Plugin.options.merge!(:template_location => MERB_ROOT + '/public/stylesheets/sass', - :css_location => MERB_ROOT + '/public/stylesheets', - :always_check => MERB_ENV != "production", - :full_exception => MERB_ENV != "production") + version = Merb::VERSION.split('.').map { |n| n.to_i } + if version[0] <= 0 && version[1] < 5 + root = MERB_ROOT + env = MERB_ENV + else + root = Merb.root + env = Merb.environment + end + + Sass::Plugin.options.merge!(:template_location => root + '/public/stylesheets/sass', + :css_location => root + '/public/stylesheets', + :always_check => env != "production", + :full_exception => env != "production") config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {} - config.symbolize_keys! + + if defined? config.symbolize_keys! + config.symbolize_keys! + end + Sass::Plugin.options.merge!(config) - - class MerbHandler # :nodoc: - def process_with_sass(request, response) - Sass::Plugin.update_stylesheets if Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check] - process_without_sass(request, response) + + if version[0] > 0 || version[1] >= 9 + + class Merb::Rack::Application # :nodoc: + def call_with_sass(env) + if !Sass::Plugin.checked_for_updates || + Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check] + Sass::Plugin.update_stylesheets + end + + call_without_sass(env) + end + alias_method :call_without_sass, :call + alias_method :call, :call_with_sass + end + + else + + class MerbHandler # :nodoc: + def process_with_sass(request, response) + if !Sass::Plugin.checked_for_updates || + Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check] + Sass::Plugin.update_stylesheets + end + + process_without_sass(request, response) + end + alias_method :process_without_sass, :process + alias_method :process, :process_with_sass end - alias_method :process_without_sass, :process - alias_method :process, :process_with_sass + end end vendor/plugins/haml/lib/sass/plugin/merb.rb @@ -5,14 +5,20 @@ unless defined?(Sass::RAILS_LOADED) :css_location => RAILS_ROOT + '/public/stylesheets', :always_check => RAILS_ENV != "production", :full_exception => RAILS_ENV != "production") - - module ActionController # :nodoc: - class Base # :nodoc: + + # :stopdoc: + module ActionController + class Base alias_method :sass_old_process, :process def process(*args) - Sass::Plugin.update_stylesheets if Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check] + if !Sass::Plugin.checked_for_updates || + Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check] + Sass::Plugin.update_stylesheets + end + sass_old_process(*args) end end end + # :startdoc: end vendor/plugins/haml/lib/sass/plugin/rails.rb @@ -3,26 +3,26 @@ require 'sass/tree/node' module Sass::Tree class AttrNode < ValueNode attr_accessor :name - + def initialize(name, value, style) @name = name super(value, style) end - + def to_s(tabs, parent_name = nil) if value[-1] == ?; - raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump} (This isn't CSS!)", @line) + raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump} (This isn't CSS!).", @line) end real_name = name real_name = "#{parent_name}-#{real_name}" if parent_name if value.empty? && children.empty? - raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump}", @line) + raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump}.", @line) end join_string = case @style - when :compact: ' ' - when :compressed: '' + when :compact; ' ' + when :compressed; '' else "\n" end spaces = ' ' * (tabs - 1) @@ -34,7 +34,7 @@ module Sass::Tree children.each do |kid| to_return << "#{kid.to_s(tabs, real_name)}" << join_string end - + (@style == :compressed && parent_name) ? to_return : to_return[0...-1] end vendor/plugins/haml/lib/sass/tree/attr_node.rb @@ -15,11 +15,6 @@ module Sass::Tree was_attr = false first = true children.each do |child| - if child.is_a?(RuleNode) && child.continued? - check_multiline_rule(child) - continued_rule = true - end - if @style == :compact if child.is_a?(AttrNode) result << "#{child.to_s(first || was_attr ? 1 : tabs + 1)} " @@ -32,12 +27,12 @@ module Sass::Tree result << rendered end was_attr = child.is_a?(AttrNode) - first = continued_rule + first = false elsif @style == :compressed result << (was_attr ? ";#{child.to_s(1)}" : child.to_s(1)) was_attr = child.is_a?(AttrNode) else - result << child.to_s(tabs + 1) + (continued_rule ? '' : "\n") + result << child.to_s(tabs + 1) + "\n" end end result.rstrip + if @style == :compressed vendor/plugins/haml/lib/sass/tree/directive_node.rb @@ -16,15 +16,12 @@ module Sass end @children << child end - + def to_s result = String.new children.each do |child| if child.is_a? AttrNode raise SyntaxError.new('Attributes aren\'t allowed at the root of a document.', child.line) - elsif child.is_a?(RuleNode) && child.continued? - check_multiline_rule(child) - result << child.to_s(1) else result << "#{child.to_s(1)}" + (@style == :compressed ? '' : "\n") end @@ -32,14 +29,6 @@ module Sass @style == :compressed ? result+"\n" : result[0...-1] end - protected - - def check_multiline_rule(rule) - unless rule.children.empty? - raise SyntaxError.new('Rules can\'t end in commas.', rule.line) - end - end - private # This method should be overridden by subclasses to return an error message vendor/plugins/haml/lib/sass/tree/node.rb @@ -9,33 +9,50 @@ module Sass::Tree alias_method :rule, :value alias_method :rule=, :value= + def rules + Array(rule) + end + + def add_rules(node) + self.rule = rules + self.rule += node.rules + end + def continued? rule[-1] == ?, end - + def to_s(tabs, super_rules = nil) attributes = [] sub_rules = [] - # Save this because the comma's removed by the super_rule additions - was_continued = continued? - + rule_split = /\s*,\s*/ + rule_separator = @style == :compressed ? ',' : ', ' + line_separator = [:nested, :expanded].include?(@style) ? ",\n" : rule_separator + rule_indent = ' ' * (tabs - 1) total_rule = if super_rules - super_rules.split(/,\s*/).collect! do |s| - self.rule.split(/,\s*/).collect do |r| - if r.include?(PARENT) - r.gsub(PARENT, s) - else - "#{s} #{r}" - end - end.join(", ") - end.join(", ") + (was_continued ? ',' : '') - elsif self.rule.include?(PARENT) - raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'", line) + super_rules.split(",\n").map do |super_line| + super_line.strip.split(rule_split).map do |super_rule| + self.rules.map do |line| + rule_indent + line.gsub(/,$/, '').split(rule_split).map do |rule| + if rule.include?(PARENT) + rule.gsub(PARENT, super_rule) + else + "#{super_rule} #{rule}" + end + end.join(rule_separator) + end.join(line_separator) + end.join(rule_separator) + end.join(line_separator) + elsif self.rules.any? { |r| r.include?(PARENT) } + raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.", line) else - self.rule + per_rule_indent, total_indent = [:nested, :expanded].include?(@style) ? [rule_indent, ''] : ['', rule_indent] + total_indent + self.rules.map do |r| + per_rule_indent + r.gsub(/,$/, '').gsub(rule_split, rule_separator).rstrip + end.join(line_separator) end - + children.each do |child| if child.is_a? RuleNode sub_rules << child @@ -43,38 +60,29 @@ module Sass::Tree attributes << child end end - + to_return = '' if !attributes.empty? old_spaces = ' ' * (tabs - 1) spaces = ' ' * tabs if @style == :compact attributes = attributes.map { |a| a.to_s(1) }.join(' ') - to_return << "#{old_spaces}#{total_rule} { #{attributes} }\n" + to_return << "#{total_rule} { #{attributes} }\n" elsif @style == :compressed attributes = attributes.map { |a| a.to_s(1) }.join(';') to_return << "#{total_rule}{#{attributes}}" else attributes = attributes.map { |a| a.to_s(tabs + 1) }.join("\n") end_attrs = (@style == :expanded ? "\n" + old_spaces : ' ') - to_return << "#{old_spaces}#{total_rule} {\n#{attributes}#{end_attrs}}\n" + to_return << "#{total_rule} {\n#{attributes}#{end_attrs}}\n" end - elsif continued? - to_return << (' ' * (tabs - 1)) + total_rule + case @style - when :compressed: '' - when :compact: ' ' - else "\n" - end end - + tabs += 1 unless attributes.empty? || @style != :nested sub_rules.each do |sub| - if sub.continued? - check_multiline_rule(sub) - end - to_return << sub.to_s(tabs, total_rule) end + to_return end end vendor/plugins/haml/lib/sass/tree/rule_node.rb @@ -3,7 +3,7 @@ require 'sass/tree/node' module Sass::Tree class ValueNode < Node attr_accessor :value - + def initialize(value, style) @value = value super(style) vendor/plugins/haml/lib/sass/tree/value_node.rb @@ -1,95 +1,82 @@ -# There's a bizarre error where ActionController tries to load a benchmark file -# and ends up finding this. -# These declarations then cause it to break. -# This only happens when running rcov, though, so we can avoid it. -unless $0 =~ /rcov$/ - require File.dirname(__FILE__) + '/../lib/haml' - require 'haml' +#!/usr/bin/env ruby + +times = (ARGV.first || 1000).to_i + +if times == 0 # Invalid parameter + puts <<END +ruby #$0 [times=1000] + Benchmark Haml against various other templating languages and Sass + on its own. +END + exit 1 +end + +require File.dirname(__FILE__) + '/../lib/haml' +%w[sass rubygems erb erubis markaby active_support action_controller + action_view haml/template].each(&method(:require)) + +begin + require 'benchwarmer' +rescue LoadError + # Since it's not as simple as gem install at the time of writing, + # we need to direct folks to the benchwarmer gem. + raise "The Haml benchmarks require the benchwarmer gem, available from http://github.com/wycats/benchwarmer" end -require 'rubygems' -require 'erb' -require 'erubis' -require 'markaby' -require 'benchmark' -require 'stringio' -require 'open-uri' - -module Haml - # Benchmarks Haml against ERB, Erubis, and Markaby and Sass on its own. - def self.benchmark(runs = 100) - template_name = 'standard' - directory = File.dirname(__FILE__) + '/haml' - haml_template = File.read("#{directory}/templates/#{template_name}.haml") - erb_template = File.read("#{directory}/rhtml/#{template_name}.rhtml") - markaby_template = File.read("#{directory}/markaby/#{template_name}.mab") - - puts '-'*51, "Haml and Friends: No Caching", '-'*51 - - times = Benchmark.bmbm do |b| - b.report("haml:") { runs.times { Haml::Engine.new(haml_template).render } } - b.report("erb:") { runs.times { ERB.new(erb_template, nil, '-').render } } - b.report("erubis:") { runs.times { Erubis::Eruby.new(erb_template).result } } - b.report("mab:") { runs.times { Markaby::Template.new(markaby_template).render } } - end - - print_result = proc do |s, n| - printf "%1$*2$s %3$*4$g", - "Haml/#{s}:", -13, times[0].to_a[5] / times[n].to_a[5], -17 - printf "%1$*2$s %3$g\n", - "#{s}/Haml:", -13, times[n].to_a[5] / times[0].to_a[5] - end - - print_result["ERB", 1] - print_result["Erubis", 2] - print_result["Markaby", 3] - - puts '', '-' * 50, 'Haml and Friends: Cached', '-' * 50 +Benchmark.warmer(times) do + columns :haml, :erb, :erubis, :mab + titles :haml => "Haml", :erb => "ERB", :erubis => "Erubis", :mab => "Markaby" + template_name = 'standard' + directory = File.dirname(__FILE__) + '/haml' + haml_template = File.read("#{directory}/templates/#{template_name}.haml") + erb_template = File.read("#{directory}/rhtml/#{template_name}.rhtml") + markaby_template = File.read("#{directory}/markaby/#{template_name}.mab") + + report "Uncached" do + haml { Haml::Engine.new(haml_template).render } + erb { ERB.new(erb_template, nil, '-').result } + erubis { Erubis::Eruby.new(erb_template).result } + mab { Markaby::Template.new(markaby_template).render } + end + + report "Cached" do obj = Object.new + Haml::Engine.new(haml_template).def_method(obj, :haml) - erb = ERB.new(erb_template, nil, '-') - obj.instance_eval("def erb; #{erb.src}; end") Erubis::Eruby.new(erb_template).def_method(obj, :erubis) - times = Benchmark.bmbm do |b| - b.report("haml:") { runs.times { obj.haml } } - b.report("erb:") { runs.times { obj.erb } } - b.report("erubis:") { runs.times { obj.erubis } } - end + obj.instance_eval("def erb; #{ERB.new(erb_template, nil, '-').src}; end") - print_result["ERB", 1] - print_result["Erubis", 2] - - puts '', '-' * 50, 'Haml and ERB: Via ActionView', '-' * 50 - - require 'active_support' - require 'action_controller' - require 'action_view' - require 'haml/template' + haml { obj.haml } + erb { obj.erb } + erubis { obj.erubis } + end + report "ActionView" do @base = ActionView::Base.new(File.dirname(__FILE__)) - times = Benchmark.bmbm do |b| - b.report("haml:") { runs.times { @base.render 'haml/templates/standard' } } - b.report("erb:") { runs.times { @base.render 'haml/rhtml/standard' } } - end - print_result["ERB", 1] + # To cache the template + @base.render 'haml/templates/standard' + @base.render 'haml/rhtml/standard' - puts '', '-' * 50, 'Haml and ERB: Via ActionView with deep partials', '-' * 50 + haml { @base.render 'haml/templates/standard' } + erb { @base.render 'haml/rhtml/standard' } + end + report "ActionView with deep partials" do @base = ActionView::Base.new(File.dirname(__FILE__)) - times = Benchmark.bmbm do |b| - b.report("haml:") { runs.times { @base.render 'haml/templates/action_view' } } - b.report("erb:") { runs.times { @base.render 'haml/rhtml/action_view' } } - end - - print_result["ERB", 1] - - puts '', '-' * 50, 'Sass', '-' * 50 - sass_template = File.read("#{File.dirname(__FILE__)}/sass/templates/complex.sass") - - Benchmark.bmbm do |b| - b.report("sass:") { runs.times { Sass::Engine.new(sass_template).render } } - end + + # To cache the template + @base.render 'haml/templates/action_view' + @base.render 'haml/rhtml/action_view' + + haml { @base.render 'haml/templates/action_view' } + erb { @base.render 'haml/rhtml/action_view' } end end + +Benchmark.warmer(times) do + sass_template = File.read("#{File.dirname(__FILE__)}/sass/templates/complex.sass") + + report("Sass") { Sass::Engine.new(sass_template).render } +end vendor/plugins/haml/test/benchmark.rb @@ -1,15 +1,45 @@ #!/usr/bin/env ruby - -require 'rubygems' -require 'active_support' -require 'action_controller' -require 'action_view' - -require 'test/unit' -require File.dirname(__FILE__) + '/../../lib/haml' -require 'haml/engine' +require File.dirname(__FILE__) + '/test_helper' class EngineTest < Test::Unit::TestCase + # A map of erroneous Sass documents to the error messages they should produce. + # The error messages may be arrays; + # if so, the second element should be the line number that should be reported for the error. + # If this isn't provided, the tests will assume the line number should be the last line of the document. + EXCEPTION_MAP = { + "!!!\n a" => "Illegal nesting: nesting within a header command is illegal.", + "a\n b" => "Illegal nesting: nesting within plain text is illegal.", + "/ a\n b" => "Illegal nesting: nesting within a tag that already has content is illegal.", + "% a" => 'Invalid tag: "% a".', + "%p a\n b" => "Illegal nesting: content can't be both given on the same line as %p and nested within it.", + "%p=" => "There's no Ruby code for = to evaluate.", + "%p~" => "There's no Ruby code for ~ to evaluate.", + "~" => "There's no Ruby code for ~ to evaluate.", + "=" => "There's no Ruby code for = to evaluate.", + "%p/\n a" => "Illegal nesting: nesting within a self-closing tag is illegal.", + "%p\n\ta" => <<END.strip, +A tab character was used for indentation. Haml must be indented using two spaces. +Are you sure you have soft tabs enabled in your editor? +END + "%p\n a" => "1 space was used for indentation. Haml must be indented using two spaces.", + "%p\n a" => "3 spaces were used for indentation. Haml must be indented using two spaces.", + "%p\n a" => "4 spaces were used for indentation. Haml must be indented using two spaces.", + ":a\n b" => ['Filter "a" is not defined.', 1], + ":a= b" => 'Invalid filter name ":a= b".', + "." => "Illegal element: classes and ids must have values.", + ".#" => "Illegal element: classes and ids must have values.", + ".{} a" => "Illegal element: classes and ids must have values.", + ".= a" => "Illegal element: classes and ids must have values.", + "%p..a" => "Illegal element: classes and ids must have values.", + "%a/ b" => "Self-closing tags can't have content.", + + # Regression tests + "- raise 'foo'\n\n\n\nbar" => ["foo", 1], + "= 'foo'\n-raise 'foo'" => ["foo", 2], + "\n\n\n- raise 'foo'" => ["foo", 4], + } + + User = Struct.new('User', :id) def render(text, options = {}, &block) scope = options.delete(:scope) || Object.new @@ -22,7 +52,7 @@ class EngineTest < Test::Unit::TestCase end def test_attributes_should_render_correctly - assert_equal("<div class='atlantis' style='ugly'>\n</div>", render(".atlantis{:style => 'ugly'}").chomp) + assert_equal("<div class='atlantis' style='ugly'></div>", render(".atlantis{:style => 'ugly'}").chomp) end def test_ruby_code_should_work_inside_attributes @@ -31,7 +61,7 @@ class EngineTest < Test::Unit::TestCase end def test_nil_should_render_empty_tag - assert_equal("<div class='no_attributes'>\n</div>", + assert_equal("<div class='no_attributes'></div>", render(".no_attributes{:nil => nil}").chomp) end @@ -44,20 +74,8 @@ class EngineTest < Test::Unit::TestCase assert_equal("<p>Hello</p>", render('%p Hello').chomp) end - def test_long_liner_should_not_print_on_one_line - assert_equal("<div>\n #{'x' * 51}\n</div>", render("%div #{'x' * 51}").chomp) - end - - def test_non_prerendered_one_liner - assert_equal("<p class='awesome'>One line</p>\n", render("%p{:class => c} One line", :locals => {:c => 'awesome'})) - end - - def test_non_prerendered_script_one_liner - assert_equal("<p class='awesome'>One line</p>\n", render("%p{:class => c}= 'One line'", :locals => {:c => 'awesome'})) - end - - def test_non_prerendered_long_script_one_liner - assert_equal("<p class='awesome'>\n #{'x' * 60}\n</p>\n", render("%p{:class => c}= 'x' * 60", :locals => {:c => 'awesome'})) + def test_one_liner_with_newline_shouldnt_be_one_line + assert_equal("<p>\n foo\n bar\n</p>", render('%p= "foo\nbar"').chomp) end def test_multi_render @@ -93,8 +111,148 @@ class EngineTest < Test::Unit::TestCase assert_equal("<img alt='' src='/foo.png' />\n", render("%img{:width => nil, :src => '/foo.png', :alt => String.new}")) end + def test_end_of_file_multiline + assert_equal("<p>0</p>\n<p>1</p>\n<p>2</p>\n", render("- for i in (0...3)\n %p= |\n i |")) + end + + def test_cr_newline + assert_equal("<p>foo</p>\n<p>bar</p>\n<p>baz</p>\n<p>boom</p>\n", render("%p foo\r%p bar\r\n%p baz\n\r%p boom")) + end + + def test_textareas + assert_equal("<textarea>Foo
 bar
 baz</textarea>\n", + render('%textarea= "Foo\n bar\n baz"')) + + assert_equal("<pre>Foo
 bar
 baz</pre>\n", + render('%pre= "Foo\n bar\n baz"')) + + assert_equal("<textarea>#{'a' * 100}</textarea>\n", + render("%textarea #{'a' * 100}")) + + assert_equal("<p>\n <textarea>Foo\n Bar\n Baz</textarea>\n</p>\n", render(<<SOURCE)) +%p + %textarea + Foo + Bar + Baz +SOURCE + end + + def test_boolean_attributes + assert_equal("<p bar baz='true' foo='bar'></p>\n", + render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :html4)) + assert_equal("<p bar='bar' baz='true' foo='bar'></p>\n", + render("%p{:foo => 'bar', :bar => true, :baz => 'true'}", :format => :xhtml)) + + assert_equal("<p baz='false' foo='bar'></p>\n", + render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :html4)) + assert_equal("<p baz='false' foo='bar'></p>\n", + render("%p{:foo => 'bar', :bar => false, :baz => 'false'}", :format => :xhtml)) + end + + def test_both_whitespace_nukes_work_together + assert_equal(<<RESULT, render(<<SOURCE)) +<p><q>Foo + Bar</q></p> +RESULT +%p + %q><= "Foo\\nBar" +SOURCE + end + + # HTML escaping tests + + def test_ampersand_equals_should_escape + assert_equal("<p>\n foo & bar\n</p>\n", render("%p\n &= 'foo & bar'", :escape_html => false)) + end + + def test_ampersand_equals_inline_should_escape + assert_equal("<p>foo & bar</p>\n", render("%p&= 'foo & bar'", :escape_html => false)) + end + + def test_bang_equals_should_not_escape + assert_equal("<p>\n foo & bar\n</p>\n", render("%p\n != 'foo & bar'", :escape_html => true)) + end + + def test_bang_equals_inline_should_not_escape + assert_equal("<p>foo & bar</p>\n", render("%p!= 'foo & bar'", :escape_html => true)) + end + + def test_static_attributes_should_be_escaped + assert_equal("<img class='atlantis' style='ugly&stupid' />\n", + render("%img.atlantis{:style => 'ugly&stupid'}", :escape_html => true)) + assert_equal("<div class='atlantis' style='ugly&stupid'>foo</div>\n", + render(".atlantis{:style => 'ugly&stupid'} foo", :escape_html => true)) + assert_equal("<p class='atlantis' style='ugly&stupid'>foo</p>\n", + render("%p.atlantis{:style => 'ugly&stupid'}= 'foo'", :escape_html => true)) + end + + def test_dynamic_attributes_should_be_escaped + assert_equal("<img alt='' src='/foo.png' />\n", + render("%img{:width => nil, :src => '/foo.png', :alt => String.new}", :escape_html => true)) + assert_equal("<p alt='' src='/foo.png'>foo</p>\n", + render("%p{:width => nil, :src => '/foo.png', :alt => String.new} foo", :escape_html => true)) + assert_equal("<div alt='' src='/foo.png'>foo</div>\n", + render("%div{:width => nil, :src => '/foo.png', :alt => String.new}= 'foo'", :escape_html => true)) + end + + def test_string_interpolation_should_be_esaped + assert_equal("<p>4&3</p>\n", render("%p== #{2+2}&#{2+1}", :escape_html => true)) + assert_equal("<p>4&3</p>\n", render("%p== #{2+2}&#{2+1}", :escape_html => false)) + end + + def test_escaped_inline_string_interpolation + assert_equal("<p>4&3</p>\n", render("%p&== #{2+2}&#{2+1}", :escape_html => true)) + assert_equal("<p>4&3</p>\n", render("%p&== #{2+2}&#{2+1}", :escape_html => false)) + end + + def test_unescaped_inline_string_interpolation + assert_equal("<p>4&3</p>\n", render("%p!== #{2+2}&#{2+1}", :escape_html => true)) + assert_equal("<p>4&3</p>\n", render("%p!== #{2+2}&#{2+1}", :escape_html => false)) + end + + def test_escaped_string_interpolation + assert_equal("<p>\n 4&3\n</p>\n", render("%p\n &== #{2+2}&#{2+1}", :escape_html => true)) + assert_equal("<p>\n 4&3\n</p>\n", render("%p\n &== #{2+2}&#{2+1}", :escape_html => false)) + end + + def test_unescaped_string_interpolation + assert_equal("<p>\n 4&3\n</p>\n", render("%p\n !== #{2+2}&#{2+1}", :escape_html => true)) + assert_equal("<p>\n 4&3\n</p>\n", render("%p\n !== #{2+2}&#{2+1}", :escape_html => false)) + end + + def test_scripts_should_respect_escape_html_option + assert_equal("<p>\n foo & bar\n</p>\n", render("%p\n = 'foo & bar'", :escape_html => true)) + assert_equal("<p>\n foo & bar\n</p>\n", render("%p\n = 'foo & bar'", :escape_html => false)) + end + + def test_inline_scripts_should_respect_escape_html_option + assert_equal("<p>foo & bar</p>\n", render("%p= 'foo & bar'", :escape_html => true)) + assert_equal("<p>foo & bar</p>\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 + # Options tests + def test_filename_and_line + begin + render("\n\n = abc", :filename => 'test', :line => 2) + rescue Exception => e + assert_kind_of Haml::SyntaxError, e + assert_match /test:4/, e.backtrace.first + end + + begin + render("\n\n= 123\n\n= nil[]", :filename => 'test', :line => 2) + rescue Exception => e + assert_kind_of NoMethodError, e + assert_match /test:6/, e.backtrace.first + end + end + def test_stop_eval assert_equal("", render("= 'Hello'", :suppress_eval => true)) assert_equal("", render("- puts 'foo'", :suppress_eval => true)) @@ -104,25 +262,46 @@ class EngineTest < Test::Unit::TestCase begin assert_equal("", render(":ruby\n puts 'hello'", :suppress_eval => true)) - rescue Haml::HamlError => err + rescue Haml::Error => err caught = true - assert_equal('"ruby" filter is not defined!', err.message) + assert_equal('Filter "ruby" is not defined.', err.message) end assert(caught, "Rendering a ruby filter without evaluating didn't throw an error!") end def test_attr_wrapper - assert_equal("<p strange=*attrs*>\n</p>\n", render("%p{ :strange => 'attrs'}", :attr_wrapper => '*')) - assert_equal("<p escaped='quo\"te'>\n</p>\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"')) - assert_equal("<p escaped=\"q'uo"te\">\n</p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"')) + assert_equal("<p strange=*attrs*></p>\n", render("%p{ :strange => 'attrs'}", :attr_wrapper => '*')) + assert_equal("<p escaped='quo\"te'></p>\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"')) + assert_equal("<p escaped=\"quo'te\"></p>\n", render("%p{ :escaped => 'quo\\'te'}", :attr_wrapper => '"')) + assert_equal("<p escaped=\"q'uo"te\"></p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"')) assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n", render("!!! XML", :attr_wrapper => '"')) end def test_attrs_parsed_correctly - assert_equal("<p boom=>biddly='bar => baz'>\n</p>\n", render("%p{'boom=>biddly' => 'bar => baz'}")) - assert_equal("<p foo,bar='baz, qux'>\n</p>\n", render("%p{'foo,bar' => 'baz, qux'}")) - assert_equal("<p escaped='quo\nte'>\n</p>\n", render("%p{ :escaped => \"quo\\nte\"}")) - assert_equal("<p escaped='quo4te'>\n</p>\n", render("%p{ :escaped => \"quo\#{2 + 2}te\"}")) + assert_equal("<p boom=>biddly='bar => baz'></p>\n", render("%p{'boom=>biddly' => 'bar => baz'}")) + assert_equal("<p foo,bar='baz, qux'></p>\n", render("%p{'foo,bar' => 'baz, qux'}")) + assert_equal("<p escaped='quo\nte'></p>\n", render("%p{ :escaped => \"quo\\nte\"}")) + assert_equal("<p escaped='quo4te'></p>\n", render("%p{ :escaped => \"quo\#{2 + 2}te\"}")) + end + + def test_correct_parsing_with_brackets + assert_equal("<p class='foo'>{tada} foo</p>\n", render("%p{:class => 'foo'} {tada} foo")) + assert_equal("<p class='foo'>deep {nested { things }}</p>\n", render("%p{:class => 'foo'} deep {nested { things }}")) + assert_equal("<p class='bar foo'>{a { d</p>\n", render("%p{{:class => 'foo'}, :class => 'bar'} {a { d")) + assert_equal("<p foo='bar'>a}</p>\n", render("%p{:foo => 'bar'} a}")) + + foo = [] + foo[0] = Struct.new('Foo', :id).new + assert_equal("<p class='struct_foo' id='struct_foo_new'>New User]</p>\n", + render("%p[foo[0]] New User]", :locals => {:foo => foo})) + assert_equal("<p class='prefix_struct_foo' id='prefix_struct_foo_new'>New User]</p>\n", + render("%p[foo[0], :prefix] New User]", :locals => {:foo => foo})) + + foo[0].id = 1 + assert_equal("<p class='struct_foo' id='struct_foo_1'>New User]</p>\n", + render("%p[foo[0]] New User]", :locals => {:foo => foo})) + assert_equal("<p class='prefix_struct_foo' id='prefix_struct_foo_1'>New User]</p>\n", + render("%p[foo[0], :prefix] New User]", :locals => {:foo => foo})) end def test_empty_attrs @@ -135,6 +314,19 @@ class EngineTest < Test::Unit::TestCase assert_equal("<p>nil</p>\n", render("%p{ :attr => x } nil", :locals => {:x => nil})) end + def test_nil_id_with_syntactic_id + assert_equal("<p id='foo'>nil</p>\n", render("%p#foo{:id => nil} nil")) + assert_equal("<p id='foo_bar'>nil</p>\n", render("%p#foo{{:id => 'bar'}, :id => nil} nil")) + assert_equal("<p id='foo_bar'>nil</p>\n", render("%p#foo{{:id => nil}, :id => 'bar'} nil")) + end + + def test_nil_class_with_syntactic_class + assert_equal("<p class='foo'>nil</p>\n", render("%p.foo{:class => nil} nil")) + assert_equal("<p class='bar foo'>nil</p>\n", render("%p.bar.foo{:class => nil} nil")) + assert_equal("<p class='bar foo'>nil</p>\n", render("%p.foo{{:class => 'bar'}, :class => nil} nil")) + assert_equal("<p class='bar foo'>nil</p>\n", render("%p.foo{{:class => nil}, :class => 'bar'} nil")) + end + def test_locals assert_equal("<p>Paragraph!</p>\n", render("%p= text", :locals => { :text => "Paragraph!" })) end @@ -152,44 +344,33 @@ class EngineTest < Test::Unit::TestCase end def test_dynamic_attrs_shouldnt_register_as_literal_values - assert_equal("<p a='b2c'>\n</p>\n", render('%p{:a => "b#{1 + 1}c"}')) - assert_equal("<p a='b2c'>\n</p>\n", render("%p{:a => 'b' + (1 + 1).to_s + 'c'}")) + assert_equal("<p a='b2c'></p>\n", render('%p{:a => "b#{1 + 1}c"}')) + assert_equal("<p a='b2c'></p>\n", render("%p{:a => 'b' + (1 + 1).to_s + 'c'}")) end - def test_rec_merge - hash1 = {1=>2, 3=>{5=>7, 8=>9}} - hash2 = {4=>5, 3=>{5=>2, 16=>12}} - hash3 = {1=>2, 4=>5, 3=>{5=>2, 8=>9, 16=>12}} - - hash1.rec_merge!(hash2) - assert_equal(hash3, hash1) + def test_dynamic_attrs_with_self_closed_tag + assert_equal("<a b='2' />\nc\n", render("%a{'b' => 1 + 1}/\n= 'c'\n")) end - def test_syntax_errors - errs = [ "!!!\n a", "a\n b", "a\n:foo\nb", "/ a\n b", - "% a", "%p a\n b", "a\n%p=\nb", "%p=\n a", - "a\n%p~\nb", "a\n~\nb", "a\n~\n b", "%p~\n b", "%p/\n a", - "%p\n \t%a b", "%a\n b\nc", "%a\n b\nc", - ":notafilter\n This isn't\n a filter!", - ".{} a", "\#{} a", ".= 'foo'", "%a/ b", "%p..class", "%p..#." ] - errs.each do |err| + def test_exceptions + EXCEPTION_MAP.each do |key, value| begin - render(err) - rescue Exception => e - assert(e.is_a?(Haml::Error), "#{err.dump} doesn't produce Haml::SyntaxError") + render(key) + rescue Exception => err + value = [value] unless value.is_a?(Array) + + assert_equal(value.first, err.message, "Line: #{key}") + assert_equal(value[1] || key.split("\n").length, err.backtrace[0].gsub('(haml):', '').to_i, "Line: #{key}") else - assert(false, "#{err.dump} doesn't produce an exception") + assert(false, "Exception not raised for\n#{key}") end end end - def test_syntax_error + def test_exception_line render("a\nb\n!!!\n c\nd") rescue Haml::SyntaxError => e - assert_equal(e.message, "Illegal Nesting: Nesting within a header command is illegal.") - assert_equal("(haml):3", e.backtrace[0]) - rescue Exception => e - assert(false, '"a\nb\n!!!\n c\nd" doesn\'t produce a Haml::SyntaxError') + assert_equal("(haml):4", e.backtrace[0]) else assert(false, '"a\nb\n!!!\n c\nd" doesn\'t produce an exception') end @@ -218,6 +399,11 @@ class EngineTest < Test::Unit::TestCase assert_equal("Unbalanced brackets.", e.message) end + def test_balanced_conditional_comments + assert_equal("\n", + render("/[if !(IE 6)|(IE 7)] Bracket: ]")) + end + def test_no_bluecloth Kernel.module_eval do def gem_original_require_with_bluecloth(file) @@ -231,7 +417,7 @@ class EngineTest < Test::Unit::TestCase begin assert_equal("<h1>Foo</h1>\t<p>- a\n- b</p>\n", Haml::Engine.new(":markdown\n Foo\n ===\n - a\n - b").to_html) - rescue Haml::HamlError => e + rescue Haml::Error => e if e.message == "Can't run Markdown filter; required 'bluecloth' or 'redcloth', but none were found" puts "\nCouldn't require 'bluecloth' or 'redcloth'; skipping a test." else @@ -256,7 +442,7 @@ class EngineTest < Test::Unit::TestCase begin Haml::Engine.new(":redcloth\n _foo_").to_html - rescue Haml::HamlError + rescue Haml::Error else assert(false, "No exception raised!") end @@ -278,7 +464,7 @@ class EngineTest < Test::Unit::TestCase begin Haml::Engine.new(":markdown\n _foo_").to_html - rescue Haml::HamlError + rescue Haml::Error else assert(false, "No exception raised!") end @@ -288,17 +474,39 @@ class EngineTest < Test::Unit::TestCase end end + def test_empty_filter + assert_equal(<<END, render(':javascript')) +<script type='text/javascript'> + //<![CDATA[ + + //]]> +</script> +END + end + def test_local_assigns_dont_modify_class assert_equal("bar\n", render("= foo", :locals => {:foo => 'bar'})) assert_equal(nil, defined?(foo)) end def test_object_ref_with_nil_id - user = Struct.new('User', :id).new + user = User.new assert_equal("<p class='struct_user' id='struct_user_new'>New User</p>\n", render("%p[user] New User", :locals => {:user => user})) end + def test_object_ref_before_attrs + user = User.new 42 + assert_equal("<p class='struct_user' id='struct_user_42' style='width: 100px;'>New User</p>\n", + render("%p[user]{:style => 'width: 100px;'} New User", :locals => {:user => user})) + end + + def test_non_literal_attributes + assert_equal("<p a1='foo' a2='bar' a3='baz' />\n", + render("%p{a2, a1, :a3 => 'baz'}/", + :locals => {:a1 => {:a1 => 'foo'}, :a2 => {:a2 => 'bar'}})) + end + def test_render_should_accept_a_binding_as_scope string = "This is a string!" string.instance_variable_set("@var", "Instance variable") @@ -340,4 +548,58 @@ class EngineTest < Test::Unit::TestCase def test_render_proc_with_binding assert_equal("FOO\n", Haml::Engine.new("= upcase").render_proc("foo".instance_eval{binding}).call) end + + def test_ugly_true + assert_equal("<div id='outer'>\n<div id='inner'>\n<p>hello world</p>\n</div>\n</div>\n", + render("#outer\n #inner\n %p hello world", :ugly => true)) + + assert_equal("<p>#{'s' * 75}</p>\n", + render("%p #{'s' * 75}", :ugly => true)) + + assert_equal("<p>#{'s' * 75}</p>\n", + render("%p= 's' * 75", :ugly => true)) + end + + def test_xhtml_output_option + assert_equal "<p>\n <br />\n</p>\n", render("%p\n %br", :format => :xhtml) + assert_equal "<a />\n", render("%a/", :format => :xhtml) + end + + def test_arbitrary_output_option + assert_raise(Haml::Error, "Invalid output format :html1") { Haml::Engine.new("%br", :format => :html1) } + end + + # HTML 4.0 + + def test_html_has_no_self_closing_tags + assert_equal "<p>\n <br>\n</p>\n", render("%p\n %br", :format => :html4) + assert_equal "<br>\n", render("%br/", :format => :html4) + end + + def test_html_renders_empty_node_with_closing_tag + assert_equal "<div class='foo'></div>\n", render(".foo", :format => :html4) + end + + def test_html_ignores_explicit_self_closing_declaration + assert_equal "<a></a>\n", render("%a/", :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 %{<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">\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 + assert_no_match /^\s+/, render("!!! xml\n!!!", :format => :html4) + end + + # HTML5 + def test_html5_doctype + assert_equal %{<!DOCTYPE html>\n}, render('!!!', :format => :html5) + end end vendor/plugins/haml/test/haml/engine_test.rb @@ -1,20 +1,15 @@ #!/usr/bin/env ruby - -require 'rubygems' -require 'active_support' -require 'action_controller' -require 'action_view' - -require 'test/unit' -require File.dirname(__FILE__) + '/../../lib/haml' +require File.dirname(__FILE__) + '/test_helper' require 'haml/template' class HelperTest < Test::Unit::TestCase include Haml::Helpers + Post = Struct.new('Post', :body) def setup @base = ActionView::Base.new @base.controller = ActionController::Base.new + @base.instance_variable_set('@post', Post.new("Foo bar\nbaz")) end def render(text, options = {}) @@ -27,14 +22,14 @@ class HelperTest < Test::Unit::TestCase end def test_flatten - assert_equal(flatten("FooBar"), "FooBar") + assert_equal("FooBar", flatten("FooBar")) - assert_equal(flatten("Foo\rBar"), "FooBar") + assert_equal("FooBar", flatten("Foo\rBar")) - assert_equal(flatten("Foo\nBar"), "Foo
Bar") + assert_equal("Foo
Bar", flatten("Foo\nBar")) - assert_equal(flatten("Hello\nWorld!\nYOU ARE \rFLAT?\n\rOMGZ!"), - "Hello
World!
YOU ARE FLAT?
OMGZ!") + assert_equal("Hello
World!
YOU ARE FLAT?
OMGZ!", + flatten("Hello\nWorld!\nYOU ARE \rFLAT?\n\rOMGZ!")) end def test_list_of_should_render_correctly @@ -85,10 +80,33 @@ class HelperTest < Test::Unit::TestCase should_be = "<form action=\"foo\" method=\"post\">\n <p>bar</p>\n <strong>baz</strong>\n</form>\n" assert_equal(should_be, result) end + + def test_text_area + assert_equal(%(<textarea id="body" name="body">Foo
Bar
 Baz
 Boom</textarea>\n), + render('= text_area_tag "body", "Foo\nBar\n Baz\n Boom"', :action_view)) + + assert_equal(%(<textarea cols="40" id="post_body" name="post[body]" rows="20">Foo bar
baz</textarea>\n), + render('= text_area :post, :body', :action_view)) + + assert_equal(%(<pre>Foo bar
 baz</pre>\n), + render('= content_tag "pre", "Foo bar\n baz"', :action_view)) + end def test_capture_haml assert_equal("\"<p>13</p>\\n\"\n", render("- foo = capture_haml(13) do |a|\n %p= a\n= foo.dump")) end + + def test_haml_tag_attribute_html_escaping + assert_equal("<p id='foo&bar'>baz</p>\n", render("%p{:id => 'foo&bar'} baz", :escape_html => true)) + end + + def test_haml_tag_autoclosed_tags_are_closed + assert_equal("<br class='foo' />\n", render("- haml_tag :br, :class => 'foo'")) + end + + def test_haml_tag_non_autoclosed_tags_arent_closed + assert_equal("<p>\n</p>\n", render("- haml_tag :p")) + end def test_is_haml assert(!ActionView::Base.new.is_haml?) @@ -122,6 +140,16 @@ class HelperTest < Test::Unit::TestCase assert_equal("1\n\n2\n\n3\n\n", render("- trc([1, 2, 3]) do |i|\n = i.inspect")) end + def test_find_and_preserve_with_block + assert_equal("<pre>Foo
Bar</pre>\nFoo\nBar\n", + render("= find_and_preserve do\n %pre\n Foo\n Bar\n Foo\n Bar")) + end + + def test_preserve_with_block + assert_equal("<pre>Foo
Bar</pre>
Foo
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 @@ -130,12 +158,30 @@ class HelperTest < Test::Unit::TestCase context.init_haml_helpers result = context.capture_haml do - context.open :p, :attr => "val" do + context.haml_tag :p, :attr => "val" do context.puts "Blah" end end assert_equal("<p attr='val'>\n Blah\n</p>\n", result) end + + def test_non_haml + assert_equal("false\n", render("= non_haml { is_haml? }")) + end + + class ActsLikeTag + # We want to be able to have people include monkeypatched ActionView helpers + # without redefining is_haml?. + # This is accomplished via Object#is_haml?, and this is a test for it. + include ActionView::Helpers::TagHelper + def to_s + content_tag :p, 'some tag content' + end + end + + def test_random_class_includes_tag_helper + assert_equal "<p>some tag content</p>", ActsLikeTag.new.to_s + end end vendor/plugins/haml/test/haml/helper_test.rb @@ -1,7 +1,6 @@ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> - <head> - </head> + <head></head> <body> <div id='content'> Lorem ipsum dolor sit amet vendor/plugins/haml/test/haml/results/content_for_layout.xhtml @@ -1,7 +1,5 @@ -<p> -</p> -<p> -</p> +<p></p> +<p></p> <h1>Me!</h1> <div id='foo'> <p id='bar'>All</p> vendor/plugins/haml/test/haml/results/eval_suppressed.xhtml @@ -1,7 +1,7 @@ <style> p { border-style: dotted; - border-width: 10px; + border-width: 22px; border-color: #ff00ff; } h1 { @@ -21,31 +21,54 @@ Wowie-zowie!</code></pre> <p><em>pretty much the same as above</em></p> +<p> + <script type='text/javascript'> + //<![CDATA[ + function newline(str) { + return "\n" + str; + } + //]]> + </script> +</p> This Is Plain Text %strong right? + #{not interpolated} + \3 + \#{also not} + \\ +<p> + <pre>This pre is pretty deeply
 nested.
 Does interpolation work? + This one is, too.
Nested, that is.
</pre> +</p> +<ul> + + <li>a</li> + + <li>b</li> - a + <li>c</li> - b + <li>d</li> - c + <li>e</li> - d + <li>f</li> - e + <li>g</li> - f + <li>h</li> - g + <li>i</li> - h + <li>j</li> - i - j + +</ul> +<div class='res'>178</div> <ul> <li>Foo</li> <li>Bar</li> @@ -54,4 +77,6 @@ This Text! Hello, World! How are you doing today? - +<div class="foo"> + <p>I think &mdash; or do I?</p> +</div> vendor/plugins/haml/test/haml/results/filters.xhtml @@ -24,9 +24,7 @@ </p> </div> <p>foo</p> - <p> - reeeeeeeeeeeeeeeeeeeeeeeeeeeeeeally loooooooooooooooooong - </p> + <p>reeeeeeeeeeeeeeeeeeeeeeeeeeeeeeally loooooooooooooooooong</p> <div class='woah'> <div id='funky'> <div> @@ -56,6 +54,7 @@ foo @foo = value one </p> + Toplevel? false <p> @foo = value three vendor/plugins/haml/test/haml/results/helpers.xhtml @@ -28,9 +28,6 @@ stuff followed by whitespace </p>   -<!-- This is a block comment cool, huh? <strong>there can even be sub-tags!</strong> @@ -62,6 +59,5 @@ testtest <p class='article foo' id='article_1'>Blah</p> <p class='article quux qux' id='article_1'>Blump</p> Woah inner quotes -<p class='dynamic_quote' dyn='3' quotes="single '"> -</p> -<p class='dynamic_atomic' dyn='3' /> +<p class='dynamic_quote' dyn='3' quotes="single '"></p> +<p class='dynamic_self_closing' dyn='3' /> vendor/plugins/haml/test/haml/results/just_stuff.xhtml @@ -4,9 +4,7 @@ <title>Stop. haml time</title> <div id='content'> <h1>This is a title!</h1> - <p> - Lorem ipsum dolor sit amet, consectetur adipisicing elit - </p> + <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit</p> <p class='foo'>Cigarettes!</p> <h2>Man alive!</h2> <ul class='things'> @@ -15,10 +13,8 @@ <li>Bathrobe</li> <li>Coffee</li> </ul> - <pre> - 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? - </pre> + <pre>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?</pre> </div> </head> </html> vendor/plugins/haml/test/haml/results/original_engine.xhtml @@ -10,6 +10,7 @@ @foo = value two </p> +Toplevel? false <p> @foo = value three vendor/plugins/haml/test/haml/results/partials.xhtml @@ -12,8 +12,7 @@ <foo2u>11</foo2u> </div> <div class='classes'> - <p class='foo bar' id='boom'> - </p> + <p class='foo bar' id='boom'></p> <div class='fooBar'>a</div> <div class='foo-bar'>b</div> <div class='foo_bar'>c</div> @@ -22,7 +21,3 @@ <div class='123'>f</div> <div class='foo2u'>g</div> </div> -<div class='broken'> - <foo><{ :a => :b }</foo> - <div class='foo'>>{ :c => :d }</div> -</div> vendor/plugins/haml/test/haml/results/tag_parsing.xhtml @@ -1,7 +1,5 @@ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> - <head> - </head> - <body> - </body> + <head></head> + <body></body> </html> vendor/plugins/haml/test/haml/results/very_basic.xhtml @@ -12,16 +12,16 @@ <div class='text_area_test_area'> <textarea>Oneline</textarea> </div> - <textarea>BLAH
</textarea> + <textarea>BLAH</textarea> <div class='text_area_test_area'> <textarea>Two
lines</textarea> </div> - <textarea>BLAH
</textarea> + <textarea>BLAH</textarea> <div id='flattened'> <div class='text_area_test_area'> <textarea>Two
lines</textarea> </div> - <textarea>BLAH
</textarea> + <textarea>BLAH</textarea> </div> </div> <div class='hithere'> @@ -36,7 +36,7 @@ </div> <div class='foo'> 13 - <textarea>
a
</textarea><textarea>
b
</textarea><textarea>
c
</textarea> + <textarea>
a</textarea><textarea>
b</textarea><textarea>
c</textarea> </div> <div id='whitespace_test'> <div class='text_area_test_area'> @@ -52,16 +52,16 @@ <div class='text_area_test_area'> <textarea>Oneline</textarea> </div> - <textarea>BLAH
</textarea> + <textarea>BLAH</textarea> <div class='text_area_test_area'> <textarea>Two
lines</textarea> </div> - <textarea>BLAH
</textarea> + <textarea>BLAH</textarea> <div id='flattened'> <div class='text_area_test_area'> <textarea>Two
lines</textarea> </div> - <textarea>BLAH
</textarea> + <textarea>BLAH</textarea> </div> </div> <div class='hithere'> @@ -73,22 +73,14 @@ foo bar </p> - <pre> - ___
 ,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!
 - </pre> + <pre> ___
 ,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!</pre> <strong>This should!</strong> - <textarea> - ___ ___ ___ ___ 
 /\__\ /\ \ /\__\ /\__\
 /:/ / /::\ \ /::| | /:/ /
 /:/__/ /:/\:\ \ /:|:| | /:/ / 
 /::\ \ ___ /::\~\:\ \ /:/|:|__|__ /:/ / 
 /:/\:\ /\__\ /:/\:\ \:\__\ /:/ |::::\__\ /:/__/ 
 \/__\:\/:/ / \/__\:\/:/ / \/__/~~/:/ / \:\ \ 
 \::/ / \::/ / /:/ / \:\ \ 
 /:/ / /:/ / /:/ / \:\ \ 
 /:/ / /:/ / /:/ / \:\__\
 \/__/ \/__/ \/__/ \/__/

 Many
 thanks
 to
 http://www.network-science.de/ascii/
 - <strong>indeed!</strong> - </textarea> + <textarea> ___ ___ ___ ___ 
 /\__\ /\ \ /\__\ /\__\
 /:/ / /::\ \ /::| | /:/ /
 /:/__/ /:/\:\ \ /:|:| | /:/ / 
 /::\ \ ___ /::\~\:\ \ /:/|:|__|__ /:/ / 
 /:/\:\ /\__\ /:/\:\ \:\__\ /:/ |::::\__\ /:/__/ 
 \/__\:\/:/ / \/__\:\/:/ / \/__/~~/:/ / \:\ \ 
 \::/ / \::/ / /:/ / \:\ \ 
 /:/ / /:/ / /:/ / \:\ \ 
 /:/ / /:/ / /:/ / \:\__\
 \/__/ \/__/ \/__/ \/__/

 Many
 thanks
 to
 http://www.network-science.de/ascii/ + <strong>indeed!</strong></textarea> </div> <div class='foo'> 13 </div> -<pre> - __ ______ __ ______
.----.| |--.|__ |.----.| |--..--------.| __ |
| __|| ||__ || __|| < | || __ |
|____||__|__||______||____||__|__||__|__|__||______|
 -</pre> -<pre> -foo
 - bar -</pre> +<pre> __ ______ __ ______
.----.| |--.|__ |.----.| |--..--------.| __ |
| __|| ||__ || __|| < | || __ |
|____||__|__||______||____||__|__||__|__|__||______|</pre> +<pre>foo +bar</pre> vendor/plugins/haml/test/haml/results/whitespace_handling.xhtml @@ -1,19 +1,12 @@ #!/usr/bin/env ruby - -require 'test/unit' -require 'rubygems' -require 'action_pack' - -require File.dirname(__FILE__) + '/../../lib/haml' +require File.dirname(__FILE__) + '/test_helper' require 'haml/template' require File.dirname(__FILE__) + '/mocks/article' -class TestFilter - def initialize(text) - @text = text - end +module TestFilter + include Haml::Filters::Base - def render + def render(text) "TESTING HAHAHAHA!" end end @@ -22,7 +15,7 @@ class TemplateTest < Test::Unit::TestCase @@templates = %w{ very_basic standard helpers whitespace_handling original_engine list helpful silent_script tag_parsing just_stuff partials - filters } + filters nuke_outer_whitespace nuke_inner_whitespace } def setup Haml::Template.options = { :filters => { 'test'=>TestFilter } } vendor/plugins/haml/test/haml/template_test.rb @@ -2,6 +2,7 @@ @foo = = @foo - @foo = 'value three' +== Toplevel? #{haml_buffer.toplevel?} %p @foo = = @foo vendor/plugins/haml/test/haml/templates/_partial.haml @@ -1,9 +1,10 @@ %style + - width = 5 + 17 :sass p :border :style dotted - :width 10px + :width #{width}px :color #ff00ff h1 :font-weight normal @@ -29,17 +30,43 @@ _pretty much the same as above_ +%p + :javascript + function newline(str) { + return "\n" + str; + } + :plain This Is Plain Text %strong right? + \#{not interpolated} + \\#{1 + 2} + \\\#{also not} + \\ + +- last = "noitalo" +%p + %pre + :preserve + This pre is pretty deeply + nested. + Does #{"interp" + last.reverse} work? + :preserve + This one is, too. + Nested, that is. -:erb - <% 10.times do |c| %> - <%= (c+97).chr %> - <% end %> +- num = 10 +%ul + :erb + <% num.times do |c| %> + <li><%= (c+97).chr %></li> + <% end %> + <% res = 178 %> + +.res= res :markdown * Foo @@ -48,6 +75,12 @@ = "Text!" +- var = "Hello" :ruby - puts "Hello, World!" - puts "How are you doing today?" + printf "%s, World!\n", var + print "How are you doing today?\n" + +:escaped + <div class="foo"> + <p>I think — or do I?</p> + </div> vendor/plugins/haml/test/haml/templates/filters.haml @@ -31,10 +31,10 @@ click = succeed '.' do %a{:href=>"thing"} here %p baz -- buffer.tabulation = 10 +- haml_buffer.tabulation = 10 %p boom - concat "foo\n" -- buffer.tabulation = 0 +- haml_buffer.tabulation = 0 - def url_for(*stuff); stuff.join(' '); end -# The form URLs must be empty -# because of a weird bug that causes url_for to misbehave. @@ -58,12 +58,12 @@ click - puts "boom" baz - puts "boom, again" -- open :table do - - open :tr do - - open :td, {:class => 'cell'} do - - open :strong, "strong!" +- haml_tag :table do + - haml_tag :tr do + - haml_tag :td, {:class => 'cell'} do + - haml_tag :strong, "strong!" - puts "data" - - open :td do + - haml_tag :td do - puts "more_data" -- open :hr -- open :div, '' +- haml_tag :hr +- haml_tag :div, '' vendor/plugins/haml/test/haml/templates/helpers.haml @@ -31,7 +31,6 @@ \%p foo \yee\ha / Short comment -/ This is a really long comment look how long it is it should be on a line of its own don't you think? / This is a block comment cool, huh? @@ -75,4 +74,4 @@ %p.qux{:class => 'quux'}[@article] Blump == #{"Woah inner quotes"} %p.dynamic_quote{:quotes => "single '", :dyn => 1 + 2} -%p.dynamic_atomic{:dyn => 1 + 2}/ +%p.dynamic_self_closing{:dyn => 1 + 2}/ vendor/plugins/haml/test/haml/templates/just_stuff.haml @@ -19,6 +19,3 @@ .foo16 e .123 f .foo2u g -%div.broken - %foo<{ :a => :b } - .foo>{ :c => :d } vendor/plugins/haml/test/haml/templates/tag_parsing.haml @@ -5,53 +5,73 @@ require File.dirname(__FILE__) + '/../../lib/sass' require 'sass/engine' class SassEngineTest < Test::Unit::TestCase + # A map of erroneous Sass documents to the error messages they should produce. + # The error messages may be arrays; + # if so, the second element should be the line number that should be reported for the error. + # If this isn't provided, the tests will assume the line number should be the last line of the document. EXCEPTION_MAP = { - "!a = 1 + " => 'Constant arithmetic error: "1 +"', - "!a = 1 + 2 +" => 'Constant arithmetic error: "1 + 2 +"', - "!a = \"b" => 'Unterminated string: "\\"b"', - "!a = #aaa - a" => 'Undefined operation: "#aaaaaa minus a"', - "!a = #aaa / a" => 'Undefined operation: "#aaaaaa div a"', - "!a = #aaa * a" => 'Undefined operation: "#aaaaaa times a"', - "!a = #aaa % a" => 'Undefined operation: "#aaaaaa mod a"', - "!a = 1 - a" => 'Undefined operation: "1 minus a"', - "!a = 1 * a" => 'Undefined operation: "1 times a"', - "!a = 1 / a" => 'Undefined operation: "1 div a"', - "!a = 1 % a" => 'Undefined operation: "1 mod a"', - ":" => 'Invalid attribute: ":"', - ": a" => 'Invalid attribute: ": a"', - ":= a" => 'Invalid attribute: ":= a"', - "a\n :b" => 'Invalid attribute: ":b "', - "a\n :b: c" => 'Invalid attribute: ":b: c"', - "a\n :b:c d" => 'Invalid attribute: ":b:c d"', - "a\n :b=c d" => 'Invalid attribute: ":b=c d"', - "a\n :b c;" => 'Invalid attribute: ":b c;" (This isn\'t CSS!)', - "a\n b : c" => 'Invalid attribute: "b : c"', - "a\n b=c: d" => 'Invalid attribute: "b=c: d"', + "!a = 1 + " => 'Constant arithmetic error: "1 +".', + "!a = 1 + 2 +" => 'Constant arithmetic error: "1 + 2 +".', + "!a = \"b" => 'Unterminated string: "\\"b".', + "!a = #aaa - a" => 'Undefined operation: "#aaaaaa minus a".', + "!a = #aaa / a" => 'Undefined operation: "#aaaaaa div a".', + "!a = #aaa * a" => 'Undefined operation: "#aaaaaa times a".', + "!a = #aaa % a" => 'Undefined operation: "#aaaaaa mod a".', + "!a = 1 - a" => 'Undefined operation: "1 minus a".', + "!a = 1 * a" => 'Undefined operation: "1 times a".', + "!a = 1 / a" => 'Undefined operation: "1 div a".', + "!a = 1 % a" => 'Undefined operation: "1 mod a".', + ":" => 'Invalid attribute: ":".', + ": a" => 'Invalid attribute: ": a".', + ":= a" => 'Invalid attribute: ":= a".', + "a\n :b" => 'Invalid attribute: ":b ".', + "a\n :b: c" => 'Invalid attribute: ":b: c".', + "a\n :b:c d" => 'Invalid attribute: ":b:c d".', + "a\n :b=c d" => 'Invalid attribute: ":b=c d".', + "a\n :b c;" => 'Invalid attribute: ":b c;" (This isn\'t CSS!).', + "a\n b : c" => 'Invalid attribute: "b : c".', + "a\n b=c: d" => 'Invalid attribute: "b=c: d".', ":a" => 'Attributes aren\'t allowed at the root of a document.', - "!" => 'Invalid constant: "!"', - "!a" => 'Invalid constant: "!a"', - "! a" => 'Invalid constant: "! a"', - "!a b" => 'Invalid constant: "!a b"', - "a\n\t:b c" => "Illegal Indentation: Only two space characters are allowed as tabulation.", - "a\n :b c" => "Illegal Indentation: Only two space characters are allowed as tabulation.", - "a\n :b c" => "Illegal Indentation: Only two space characters are allowed as tabulation.", + "!" => 'Invalid constant: "!".', + "!a" => 'Invalid constant: "!a".', + "! a" => 'Invalid constant: "! a".', + "!a b" => 'Invalid constant: "!a b".', + "a\n\t:b c" => <<END.strip, +A tab character was used for indentation. Sass must be indented using two spaces. +Are you sure you have soft tabs enabled in your editor? +END + "a\n :b c" => "1 space was used for indentation. Sass must be indented using two spaces.", + "a\n :b c" => "4 spaces were used for indentation. Sass must be indented using two spaces.", "a\n :b c\n !d = 3" => "Constants may only be declared at the root of a document.", - "!a = 1b + 2c" => "Incompatible units: b and c", - "& a\n :b c" => "Base-level rules cannot contain the parent-selector-referencing character '&'", + "!a = 1b + 2c" => "Incompatible units: b and c.", + "& a\n :b c" => "Base-level rules cannot contain the parent-selector-referencing character '&'.", "a\n :b\n c" => "Illegal nesting: Only attributes may be nested beneath attributes.", "a,\n :b c" => "Rules can\'t end in commas.", + "a," => "Rules can\'t end in commas.", + "a,\n!b = c" => "Rules can\'t end in commas.", "!a = b\n :c d\n" => "Illegal nesting: Nothing may be nested beneath constants.", - "@import foo.sass" => "File to import not found or unreadable: foo.sass", + "@import foo.sass" => "File to import not found or unreadable: foo.sass.", "@import templates/basic\n foo" => "Illegal nesting: Nothing may be nested beneath import directives.", "foo\n @import templates/basic" => "Import directives may only be used at the root of a document.", "!foo = bar baz !" => "Unterminated constant.", "!foo = !(foo)" => "Invalid constant.", + "=foo\n :color red\n.bar\n +bang" => "Undefined mixin 'bang'.", + ".bar\n =foo\n :color red\n" => "Mixins may only be defined at the root of a document.", + "=foo\n :color red\n.bar\n +foo\n :color red" => "Illegal nesting: Nothing may be nested beneath mixin directives.", + + # Regression tests + "a\n b:\n c\n d" => ["Illegal nesting: Only attributes may be nested beneath attributes.", 3] } def test_basic_render renders_correctly "basic", { :style => :compact } end + def test_multiple_calls_to_render + sass = Sass::Engine.new("a\n b: c") + assert_equal sass.render, sass.render + end + def test_alternate_styles renders_correctly "expanded", { :style => :expanded } renders_correctly "compact", { :style => :compact } @@ -64,8 +84,10 @@ class SassEngineTest < Test::Unit::TestCase begin Sass::Engine.new(key).render rescue Sass::SyntaxError => err - assert_equal(value, err.message) - assert(err.sass_line, "Line: #{key}") + value = [value] unless value.is_a?(Array) + + assert_equal(value.first, err.message, "Line: #{key}") + assert_equal(value[1] || key.split("\n").length, err.sass_line, "Line: #{key}") assert_match(/$sass$:[0-9]+/, err.backtrace[0], "Line: #{key}") else assert(false, "Exception not raised for\n#{key}") @@ -98,16 +120,27 @@ class SassEngineTest < Test::Unit::TestCase end end + def test_css_import + assert_equal("@import url(./fonts.css) screen;", render("@import url(./fonts.css) screen")) + assert_equal("@import \"./fonts.css\" screen;", render("@import \"./fonts.css\" screen")) + end + + def test_sass_import + renders_correctly "import", { :style => :compact, :load_paths => [File.dirname(__FILE__) + "/templates"] } + end + def test_default_function assert_equal("foo {\n bar: url(foo.png); }\n", render("foo\n bar = url(foo.png)\n")); end - def test_multiline_selector + def test_basic_multiline_selector assert_equal("#foo #bar,\n#baz #boom {\n foo: bar; }\n", render("#foo #bar,\n#baz #boom\n :foo bar")) assert_equal("#foo #bar,\n#foo #baz {\n foo: bar; }\n", render("#foo\n #bar,\n #baz\n :foo bar")) + assert_equal("#foo,\n#bar {\n foo: bar; }\n #foo #baz,\n #bar #baz {\n foo: bar; }\n", + render("#foo,\n#bar\n :foo bar\n #baz\n :foo bar")) assert_equal("#foo #bar, #baz #boom { foo: bar; }\n", render("#foo #bar,\n#baz #boom\n :foo bar", :style => :compact)) @@ -115,6 +148,10 @@ class SassEngineTest < Test::Unit::TestCase render("#foo #bar,\n#baz #boom\n :foo bar", :style => :compressed)) end + def test_complex_multiline_selector + renders_correctly "multiline" + end + def test_colon_only begin render("a\n b: c", :attribute_syntax => :normal) @@ -204,7 +241,20 @@ END assert_equal(":focus {\n a: b; }\n", render("\\:focus\n a: b")) assert_equal("a {\n b: c; }\n a :focus {\n d: e; }\n", render("\\a\n b: c\n \\:focus\n d: e")) end + + def test_cr_newline + assert_equal("foo {\n a: b;\n c: d;\n e: f; }\n", render("foo\r a: b\r\n c: d\n\r e: f")) + end + + def test_or_eq + assert_equal("foo {\n a: b; }\n", render("!foo = b\n!foo ||= c\nfoo\n a = !foo")) + assert_equal("foo {\n a: b; }\n", render("!foo ||= b\nfoo\n a = !foo")) + end + def test_mixins + renders_correctly "mixins", { :style => :expanded } + end + private def render(sass, options = {}) vendor/plugins/haml/test/sass/engine_test.rb @@ -58,7 +58,7 @@ class SassPluginTest < Test::Unit::TestCase File.delete(tempfile_loc('bork')) Sass::Plugin.update_stylesheets File.open(tempfile_loc('bork')) do |file| - assert_equal("/*\nSass::SyntaxError: Undefined constant: \"!bork\"\non line 2 of #{File.dirname(__FILE__) + '/templates/bork.sass'}\n\n1: bork\n2: :bork= !bork", file.read.split("\n")[0...6].join("\n")) + assert_equal("/*\nSass::SyntaxError: Undefined constant: \"!bork\".\non line 2 of #{File.dirname(__FILE__) + '/templates/bork.sass'}\n\n1: bork\n2: :bork= !bork", file.read.split("\n")[0...6].join("\n")) end File.delete(tempfile_loc('bork')) end vendor/plugins/haml/test/sass/plugin_test.rb @@ -1,4 +1,4 @@ -imported { otherconst: hello; myconst: goodbye; } +imported { otherconst: hello; myconst: goodbye; pre-mixin: here; } body { font: Arial; background: blue; } @@ -26,4 +26,4 @@ body { font: Arial; background: blue; } @import url(../results/complex.css); #foo { background-color: #baf; } -nonimported { myconst: hello; otherconst: goodbye; } +nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; } vendor/plugins/haml/test/sass/results/import.css @@ -1,8 +1,11 @@ !preconst = hello +=premixin + pre-mixin: here + @import importee, basic, basic.css, ../results/complex.css, partial nonimported :myconst = !preconst :otherconst = !postconst - + +postmixin vendor/plugins/haml/test/sass/templates/import.sass @@ -1,8 +1,12 @@ !postconst = goodbye +=postmixin + post-mixin: here + imported :otherconst = !preconst :myconst = !postconst + +premixin @import basic vendor/plugins/haml/test/sass/templates/importee.sass vendor/plugins/haml/README vendor/plugins/haml/lib/haml/util.rb vendor/plugins/haml/test/haml/runner.rb 589aa4ce34bcd337652dd9d9cb035188ef428461 Nathan Weizenbaum nex342@gmail.com http://github.com/nex3/nex3-s-blog-engine/commit/cd0b1fe8646bb00a0f628505fa6a891712e28b85 cd0b1fe8646bb00a0f628505fa6a891712e28b85

2008-05-11T17:00:53-07:00

Update to the latest Haml release. 0cbafc5795a27daefc8752c43734b820d90c43b6 Nathan Weizenbaum nex342@gmail.com