kotovalexarian-likes-github
/
haml--haml
mirror of https://github.com/haml/haml.git
1
0
Fork 0
Code Releases Activity

Get rid of trailing whitespace.

This commit is contained in:
Nathan Weizenbaum 2008-04-07 23:09:17 -07:00
parent d4d176b138
commit 84fdde13a5
30 changed files with 301 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
README.rdoc
View File

@ -67,7 +67,7 @@ a tag without a name defaults to a div. So
becomes
<div id='foo'>Hello!</div>
Haml uses indentation
to bring the individual elements to represent the HTML structure.
A tag's children are indented two spaces more than the parent tag.
@ -235,8 +235,8 @@ the documentation for the Sass module.
Haml and Sass are designed by Hampton Catlin (hcatlin) and he is the author
of the original implementation. However, Hampton doesn't even know his way
around the code anymore and mostly just concentrates on the language issues.
Hampton lives in Toronto, Ontario (though he's an American by birth) and
around the code anymore and mostly just concentrates on the language issues.
Hampton lives in Toronto, Ontario (though he's an American by birth) and
is a partner at Unspace Interactive.
Nathan Weizenbaum is the primary maintainer and architect of the "modern" Ruby

12
Rakefile
View File

@ -68,7 +68,7 @@ END
but it can function as a stand-alone templating engine.
END
#'
readmes = FileList.new('*') do |list|
list.exclude(/(^|[^.a-z])[a-z]+/)
list.exclude('TODO')
@ -133,7 +133,7 @@ END
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')
@ -167,17 +167,17 @@ END
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

4
extra/haml-mode.el
View File

@ -7,10 +7,10 @@
;;; 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)
;;;
;;;
;;; Code:

278
lib/haml.rb
View File

@ -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,13 +132,13 @@ $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>
@ -200,7 +200,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
#
# 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.
@ -211,9 +211,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
# 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
@ -222,40 +222,40 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
# Because the id of an object is normally an obscure implementation detail,
# this is most useful for elements that represent instances of Models.
# For example:
#
#
# # file: app/controllers/users_controller.rb
#
#
# def show
# @user = CrazyUser.find(15)
# end
#
#
# -# file: app/views/users/show.haml
#
#
# %div[@user]
# %bar[290]/
# Hello!
#
#
# is compiled to:
#
#
# <div class="crazy_user" id="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' />
#
@ -271,9 +271,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.
@ -281,22 +281,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
@ -305,9 +305,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>
@ -317,34 +317,34 @@ $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>
#
#
# ==== =
#
#
# <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.
@ -353,45 +353,45 @@ $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>
#
#
# === 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
@ -400,9 +400,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>
@ -414,112 +414,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>
# <!-- This is the peanutbutterjelly element -->
# 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:
#
#
# <!--
# <p>This doesn't render...</p>
# <div>
# <h1>Because it's commented out!</h1>
# </div>
# -->
#
#
# 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:
#
#
# <!--[if IE]>
# <a href='http://www.mozilla.com/en-US/firefox/'>
# <h1>Get Firefox</h1>
# </a>
# <![endif]-->
#
#
# ==== \
#
#
# 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 |
@ -527,9 +527,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.
@ -613,21 +613,21 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
# (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
@ -642,29 +642,29 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
# would be compiled to
#
# &lt;script&gt;alert(&quot;I'm evil!&quot;);&lt;/script&gt;
#
#
# ==== -
#
#
# 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,
@ -729,7 +729,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
# 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
@ -737,13 +737,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>
@ -759,9 +759,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
# <p>
# 46
# </p>
#
#
# Another example:
#
#
# %p
# - case 2
# - when 1
@ -770,9 +770,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
# = "2?"
# - when 3
# = "3."
#
#
# is compiled to:
#
#
# <p>
# 2?
# </p>
@ -783,7 +783,7 @@ $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
@ -809,7 +809,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
#
# <p>foo</p>
# <p>bar</p>
#
#
# == Other Useful Things
#
# === Helpers
@ -819,9 +819,9 @@ $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.
@ -842,7 +842,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
# 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

12
lib/haml/buffer.rb
View File

@ -71,7 +71,7 @@ module Haml
# Have to push every line in by the extra user set tabulation
text.gsub!(/^/m, ' ' * @tabulation)
end
@buffer << text
@real_tabs += tab_change
end
@ -86,13 +86,13 @@ module Haml
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
result = html_escape(result) if escape_html
if close_tag && (@options[:ugly] || Buffer.one_liner?(result) || preserve_tag)
@ -102,10 +102,10 @@ module Haml
if close_tag
@buffer << "\n"
end
result = result.gsub(/^/m, tabs(tabulation)) unless @options[:ugly]
@buffer << "#{result}\n"
if close_tag
# We never get here if @options[:ugly] is true
@buffer << "#{tabs(tabulation-1)}</#{close_tag}>\n"
@ -119,7 +119,7 @@ module Haml
# element, formats it, and adds it to the buffer.
def open_tag(name, atomic, try_one_line, preserve_tag, escape_html, class_id, obj_ref, content, *attributes_hashes)
tabulation = @real_tabs
attributes = class_id
attributes_hashes.each do |attributes_hash|
attributes_hash.keys.each { |key| attributes_hash[key.to_s] = attributes_hash.delete(key) }

6
lib/haml/engine.rb
View File

@ -116,7 +116,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
@ -225,7 +225,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.
@ -241,7 +241,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

8
lib/haml/exec.rb
View File

@ -21,7 +21,7 @@ module Haml
@opts.parse!(@args)
process_result
@options
rescue Exception => e
raise e if e.is_a? SystemExit
@ -45,7 +45,7 @@ module Haml
def get_line(exception)
exception.backtrace[0].scan(/:(\d+)/)[0]
end
private
def set_opts(opts)
@ -110,7 +110,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
@ -218,7 +218,7 @@ END
'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

8
lib/haml/filters.rb
View File

@ -93,7 +93,7 @@ module Haml
#
# ...
# end
#
#
def lazy_require(*reqs)
@lazy_requires = reqs
end
@ -110,7 +110,7 @@ module Haml
return
rescue LoadError; end # RCov doesn't see this, but it is run
end
begin
@required = @lazy_requires[-1]
require @required
@ -210,7 +210,7 @@ END
precompiler.send(:push_silent, src)
end
end
module RedCloth
include Base
lazy_require 'redcloth'
@ -219,7 +219,7 @@ END
::RedCloth.new(text).to_html
end
end
# Uses RedCloth to provide only Textile (not Markdown) parsing
module Textile
include Base

36
lib/haml/helpers.rb
View File

@ -35,7 +35,7 @@ module Haml
# end
# context.init_haml_helpers
# context.haml_tag :p, "Stuff"
#
#
def init_haml_helpers
@haml_is_haml = true
@haml_stack = [Haml::Buffer.new(Haml::Engine.new('').send(:options_for_buffer))]
@ -45,7 +45,7 @@ module Haml
# 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 = '', &block)
@ -107,14 +107,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")
@ -163,7 +163,7 @@ module Haml
def tab_down(i = 1)
haml_buffer.tabulation -= i
end
# Surrounds the given block of Haml code with the given characters,
# with no whitespace in between.
# For example:
@ -187,10 +187,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:
@ -205,7 +205,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:
@ -222,7 +222,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.
@ -254,7 +254,7 @@ module Haml
# 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,
#
# haml_tag :table do
@ -331,7 +331,7 @@ END
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)
@ -344,7 +344,7 @@ END
def haml_buffer
@haml_stack[-1]
end
# Gives a proc the same local "_hamlout" and "_erbout" variables
# that the current template has.
def haml_bind_proc(&proc)
@ -352,23 +352,23 @@ END
_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
@ -376,7 +376,7 @@ END
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.

2
lib/haml/helpers/action_view_extensions.rb
View File

@ -31,7 +31,7 @@ if defined?(ActionView)
#
# .entry
# :color #00f
#
#
def page_class
controller.controller_name + " " + controller.action_name
end

4
lib/haml/helpers/action_view_mods.rb
View File

@ -50,7 +50,7 @@ if defined?(ActionView) and not defined?(Merb::Plugins)
alias_method :concat, :concat_with_haml
end
module TagHelper
module TagHelper
def content_tag_with_haml(name, *args, &block)
content = content_tag_without_haml(name, *args, &block)
@ -105,7 +105,7 @@ 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
oldproc = proc
proc = haml_bind_proc do |*args|
tab_up
oldproc.call(*args)

12
lib/haml/html.rb
View File

@ -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

46
lib/haml/precompiler.rb
View File

@ -180,7 +180,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
@ -228,7 +228,7 @@ END
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)
@ -248,7 +248,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
@ -273,7 +273,7 @@ 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
@ -291,11 +291,11 @@ END
@merged_text << text
@try_one_liner = false
end
def push_text(text, tab_change = 0, try_one_liner = false)
push_merged_text("#{text}\n", tab_change, try_one_liner)
end
def flush_merged_text
return if @merged_text.empty?
@ -305,7 +305,7 @@ END
@merged_text = ''
@tab_change = 0
@try_one_liner = false
end
end
# Renders a block of text as plain text.
# Also checks for an illegally opened block.
@ -343,12 +343,12 @@ END
@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?
push_script(text, true)
end
@ -394,7 +394,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
@ -414,7 +414,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.
@ -443,8 +443,8 @@ END
# $5 holds the value matched by a string
$2 || $5
end
def parse_static_hash(text)
def parse_static_hash(text)
return {} unless text
attributes = {}
@ -466,7 +466,7 @@ END
def self.build_attributes(is_html, attr_wrapper, attributes = {})
quote_escape = attr_wrapper == '"' ? "&quot;" : "&apos;"
other_quote_char = attr_wrapper == '"' ? "'" : '"'
result = attributes.collect do |attr, value|
next if value.nil?
@ -495,7 +495,7 @@ END
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]
@ -517,7 +517,7 @@ END
# render that tag to <tt>@precompiled</tt>.
def render_tag(line)
tag_name, attributes, attributes_hash, object_ref, action, value = parse_tag(line)
raise SyntaxError.new("Illegal element: classes and ids must have values.") if attributes =~ /[\.#](\.|#|\z)/
preserve_tag = options[:preserve].include?(tag_name)
@ -581,7 +581,7 @@ END
@output_tabs += 1
return
end
if parse
flush_merged_text
push_script(value, preserve_script, tag_name, preserve_tag, escape_html)
@ -599,13 +599,13 @@ END
conditional, content = line.scan(COMMENT_REGEX)[0]
content.strip!
conditional << ">" if conditional
if @block_opened && !content.empty?
raise SyntaxError.new('Illegal Nesting: Nesting within a tag that already has content is illegal.')
end
open = "<!--#{conditional} "
# Render it statically if possible
if !content.empty? && Buffer.one_liner?(content)
return push_text("#{open}#{content} #{conditional ? "<![endif]-->" : "-->"}")
@ -619,7 +619,7 @@ END
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
@ -639,7 +639,7 @@ END
'<!DOCTYPE html>'
else
version, type = text.scan(DOCTYPE_REGEX)[0]
if xhtml?
if version == "1.1"
'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
@ -660,7 +660,7 @@ END
end
end
end
# Starts a filtered block.
def start_filtered(name)
raise SyntaxError.new('Filters must have nested text.') unless @block_opened
@ -723,7 +723,7 @@ 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)

2
lib/haml/template/patch.rb
View File

@ -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 }

6
lib/haml/template/plugin.rb
View File

@ -13,7 +13,7 @@ module Haml
def compilable?
true
end
def line_offset
self.class.line_offset
end
@ -26,13 +26,13 @@ module Haml
options = Haml::Template.options.dup
Haml::Engine.new(template, 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
def read_template_file(template_path, extension)
File.read(template_path)
end

20
lib/sass.rb
View File

@ -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,9 +32,9 @@ $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
#
@ -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
#
@ -668,7 +668,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>
#
@ -678,7 +678,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
#
@ -701,7 +701,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.
@ -713,7 +713,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.
@ -748,7 +748,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'

36
lib/sass/constant.rb
View File

@ -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 = {
@ -32,13 +32,13 @@ module Sass
# The regular expression used to parse constants
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
@ -53,21 +53,21 @@ module Sass
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}")
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,7 +234,7 @@ module Sass
end
end
end
def get_constant(value, constants)
to_return = constants[value]
raise SyntaxError.new("Undefined constant: \"!#{value}\"") unless to_return

26
lib/sass/constant/color.rb
View File

@ -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])

14
lib/sass/constant/literal.rb
View File

@ -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))

16
lib/sass/constant/number.rb
View File

@ -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?

6
lib/sass/constant/operation.rb
View File

@ -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

6
lib/sass/constant/string.rb
View File

@ -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

10
lib/sass/css.rb
View File

@ -105,7 +105,7 @@ module Sass
build_tree.to_sass
rescue Exception => err
line = @template.string[0...@template.pos].split("\n").size
err.backtrace.unshift "(css):#{line}"
raise err
end
@ -164,12 +164,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
@ -244,7 +244,7 @@ module Sass
# color: red
# baz
# color: blue
#
#
def nest_rules(root)
rules = OrderedHash.new
root.children.select { |c| Tree::RuleNode === c }.each do |child|
@ -274,7 +274,7 @@ module Sass
#
# foo bar baz
# color: red
#
#
def flatten_rules(root)
root.children.each { |child| flatten_rule(child) if child.is_a?(Tree::RuleNode) }
end

2
lib/sass/engine.rb
View File

@ -39,7 +39,7 @@ module Sass
# The character used to denote a compiler directive.
DIRECTIVE_CHAR = ?@
# Designates a non-parsed rule.
ESCAPE_CHAR = ?\\

4
lib/sass/plugin/merb.rb
View File

@ -15,13 +15,13 @@ unless defined?(Sass::MERB_LOADED)
:always_check => env != "production",
:full_exception => env != "production")
config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
if defined? config.symbolize_keys!
config.symbolize_keys!
end
Sass::Plugin.options.merge!(config)
if version[0] > 0 || version[1] >= 9
class Merb::Rack::Application # :nodoc:

2
lib/sass/plugin/rails.rb
View File

@ -5,7 +5,7 @@ unless defined?(Sass::RAILS_LOADED)
:css_location => RAILS_ROOT + '/public/stylesheets',
:always_check => RAILS_ENV != "production",
:full_exception => RAILS_ENV != "production")
# :stopdoc:
module ActionController
class Base

6
lib/sass/tree/attr_node.rb
View File

@ -3,12 +3,12 @@ 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)
@ -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

2
lib/sass/tree/node.rb
View File

@ -16,7 +16,7 @@ module Sass
end
@children << child
end
def to_s
result = String.new
children.each do |child|

8
lib/sass/tree/rule_node.rb
View File

@ -21,7 +21,7 @@ module Sass::Tree
def continued?
rule[-1] == ?,
end
def to_s(tabs, super_rules = nil)
attributes = []
sub_rules = []
@ -52,7 +52,7 @@ module Sass::Tree
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
@ -60,7 +60,7 @@ module Sass::Tree
attributes << child
end
end
to_return = ''
if !attributes.empty?
old_spaces = ' ' * (tabs - 1)
@ -77,7 +77,7 @@ module Sass::Tree
to_return << "#{total_rule} {\n#{attributes}#{end_attrs}}\n"
end
end
tabs += 1 unless attributes.empty? || @style != :nested
sub_rules.each do |sub|
to_return << sub.to_s(tabs, total_rule)

2
lib/sass/tree/value_node.rb
View File

@ -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)