haml 2.0.10 → 2.2.0

data/.yardopts

@@ -0,0 +1,5 @@
+--readme          README.md
+--markup          markdown
+--markup-provider maruku
+--protected
+--no-highlight

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2006-2008 Hampton Catlin
+Copyright (c) 2006-2009 Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,347 @@
+# Haml and Sass
+
+Haml and Sass are templating engines
+for the two most common types of documents on the web:
+HTML and CSS, respectively.
+They are designed to make it both easier and more pleasant
+to code HTML and CSS documents,
+by eliminating redundancy,
+reflecting the underlying structure that the document represents,
+and providing elegant, easily understandable, and powerful syntax.
+
+## Using
+
+Haml and Sass can be used from the command line
+or as part of a Ruby web framework.
+The first step is to install the gem:
+
+    gem install haml
+
+After you convert some HTML to Haml or some CSS to Sass,
+you can run
+
+    haml document.haml
+    sass style.sass
+
+to compile them.
+For more information on these commands, check out
+
+    haml --help
+    sass --help
+
+To install Haml and Sass as a Rails plugin,
+just run `haml --rails path/to/rails/app`
+and both Haml and Sass will be installed.
+Views with the `.html.haml` extension will automatically use Haml.
+Sass is a little more complicated;
+`.sass` files should be placed in `public/stylesheets/sass`,
+where they'll be automatically compiled
+to corresponding CSS files in `public/stylesheets` when needed
+(the Sass template directory is customizable...
+see [the Sass reference](http://sass-lang.com/docs/yardoc/SASS_REFERENCE.md.html#template_location-option) for details).
+
+For Merb, `.html.haml` views will work without any further modification.
+To enable Sass, you also need to add a dependency.
+To do so, just add
+
+    dependency "merb-haml"
+
+to `config/dependencies.rb` (or `config/init.rb` in a flat/very flat Merb application).
+Then it'll work just like it does in Rails.
+
+To use Haml and Sass programatically,
+check out the [YARD documentation](http://haml-lang.com/docs/yardoc).
+
+## Formatting
+
+### Haml
+
+The most basic element of Haml
+is a shorthand for creating HTML:
+
+    %tagname{:attr1 => 'value1', :attr2 => 'value2'} Contents
+
+No end-tag is needed; Haml handles that automatically.
+If you prefer HTML-style attributes, you can also use:
+
+    %tagname(attr1='value1' attr2='value2') Contents
+
+Adding `class` and `id` attributes is even easier.
+Haml uses the same syntax as the CSS that styles the document:
+
+    %tagname#id.class
+
+In fact, when you're using the `<div>` tag,
+it becomes _even easier_.
+Because `<div>` is such a common element,
+a tag without a name defaults to a div. So
+
+    #foo Hello!
+
+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 beneath than the parent tag.
+Again, a closing tag is automatically added.
+For example:
+
+    %ul
+      %li Salt
+      %li Pepper
+
+becomes:
+
+    <ul>
+      <li>Salt</li>
+      <li>Pepper</li>
+    </ul>
+
+You can also put plain text as a child of an element:
+
+    %p
+      Hello,
+      World!
+
+It's also possible to embed Ruby code into Haml documents.
+An equals sign, `=`, will output the result of the code.
+A hyphen, `-`, will run the code but not output the result.
+You can even use control statements
+like `if` and `while`:
+
+    %p
+      Date/Time:
+      - now = DateTime.now
+      %strong= now
+      - if now > DateTime.parse("December 31, 2006")
+        = "Happy new " + "year!"
+
+Haml provides far more tools than those presented here.
+Check out the reference documentation in the Haml module.
+
+### Sass
+
+At its most basic,
+Sass is just another way of writing CSS.
+Although it's very much like normal CSS,
+the basic syntax offers a few helpful features:
+indentation indicates the properties in a rule,
+rather than non-DRY brackets;
+and newlines indicate the end of a properties,
+rather than a semicolon.
+For example:
+
+    #main
+      background-color: #f00
+      width: 98%
+
+becomes:
+
+    #main {
+      background-color: #f00;
+      width: 98% }
+
+However, Sass provides much more than a way to make CSS look nice.
+In CSS, it's important to have accurate selectors,
+so your styles don't just apply to everything.
+However, in order to do this,
+you need to use nested element selectors.
+These get very ugly very quickly.
+I'm sure everyone's had to write something like
+"#main .sidebar .top p h1 a",
+followed by
+"#main .sidebar .top p h1 a:visited" and
+"#main .sidebar .top p h1 a:hover".
+Well, Sass gets rid of that.
+Like Haml, it uses indentation to indicate the structure of the document.
+So, what was:
+
+    #main {
+      width: 90%;
+    }
+    #main p {
+      border-style: solid;
+      border-width: 1px;
+      border-color: #00f;
+    }
+    #main p a {
+      text-decoration: none;
+      font-weight: bold;
+    }
+    #main p a:hover {
+      text-decoration: underline;
+    }
+
+becomes:
+
+    #main
+      width: 90%
+      p
+        border-style: solid
+        border-width: 1px
+        border-color: #00f
+        a
+          text-decoration: none
+          font-weight: bold
+        a:hover
+          text-decoration: underline
+
+Pretty nice, no? Well, it gets better.
+One of the main complaints against CSS is that it doesn't allow variables.
+What if have a color or a width you re-use all the time?
+In CSS, you just have to re-type it each time,
+which is a nightmare when you decide to change it later.
+Not so for Sass!
+You can use the `!` character to set variables.
+Then, if you put `=` after your property name,
+you can set it to a variable.
+For example:
+
+    !note_bg= #55aaff
+
+    #main
+      width: 70%
+      .note
+        background-color = !note_bg
+      p
+        width: 5em
+        background-color = !note_bg
+
+becomes:
+
+    #main {
+      width: 70%; }
+      #main .note {
+        background-color: #55aaff; }
+      #main p {
+        width: 5em;
+        background-color: #55aaff; }
+
+You can even do simple arithmetic operations with variables,
+adding numbers and even colors together:
+
+    !main_bg= #46ar12
+    !main_width= 40em
+
+    #main
+      background-color = !main_bg
+      width = !main_width
+      .sidebar
+        background-color = !main_bg + #333333
+        width = !main_width - 25em
+
+becomes:
+
+    #main {
+      background-color: #46a312;
+      width: 40em; }
+      #main .sidebar {
+        background-color: #79d645;
+        width: 15em; }
+
+Taking the idea of variables a bit further are mixins.
+These let you group whole bunches of CSS properties into a single
+directive and then include those anywhere you want:
+
+    =blue-border
+      border:
+        color: blue
+        width: 2px
+        style: dotted
+
+    .comment
+      +blue-border
+      padding: 2px
+      margin: 10px 0
+
+    .reply
+      +blue-border
+
+becomes:
+
+    .comment {
+      border-color: blue;
+      border-width: 2px;
+      border-style: dotted;
+      padding: 2px;
+      margin: 10px 0;
+    }
+
+    .reply {
+      border-color: blue;
+      border-width: 2px;
+      border-style: dotted;
+    }
+
+A comprehensive list of features is in
+the documentation for the Sass module.
+
+## Indentation
+
+Indentation can be made up of one or more tabs or spaces.
+However, indentation must be consistent within a given document.
+Hard tabs and spaces can't be mixed,
+and the same number of tabs or spaces must be used throughout.
+
+## Executables
+
+The Haml gem includes several executables that are useful
+for dealing with Haml and Sass from the command line.
+
+### `haml`
+
+The `haml` executable transforms a source Haml file into HTML.
+See `haml --help` for further information and options.
+
+### `sass`
+
+The `sass` executable transforms a source Sass file into CSS.
+See `sass --help` for further information and options.
+
+### `html2haml`
+
+The `html2haml` executable attempts to transform HTML,
+optionally with ERB markup, into Haml code.
+Since HTML is so variable, this transformation is not always perfect;
+it's a good idea to have a human check the output of this tool.
+See `html2haml --help` for further information and options.
+
+### `css2sass`
+
+The `css2sass` executable attempts to transform CSS into Sass code.
+This transformation attempts to use Sass nesting where possible.
+See `css2sass --help` for further information and options.
+
+## Authors
+
+Haml and Sass were created by [Hampton Catlin](http://hamptoncatlin.com)
+(hcatlin) and he is the author of the original implementation. However, Hampton
+doesn't even know his way around the code anymore and now occasionally consults
+on the language issues.  Hampton lives in Jacksonville, Florida and is the lead
+mobile developer for Wikimedia.
+
+[Nathan Weizenbaum](http://nex-3.com) is the primary developer and architect of
+the "modern" Ruby implementation of Haml. His hard work has kept the project
+alive by endlessly answering forum posts, fixing bugs, refactoring, finding
+speed improvements, writing documentation, implementing new features, and
+getting Hampton coffee (a fitting task for a boy-genius). Nathan lives in
+Seattle, Washington and while not being a student at the University of
+Washington or working at an internship, he consults for Unspace Interactive.
+
+[Chris Eppstein](http://acts-as-architect.blogspot.com) is a core contributor to
+Sass and the creator of Compass, the first Sass-based framework. Chris focuses
+on making Sass more powerful, easy to use, and on ways to speed its adoption
+through the web development community. Chris lives in San Jose, California with
+his wife and daughter. He is the Software Architect for
+[Caring.com](http://caring.com), a website devoted to the 34 Million caregivers
+whose parents are sick or elderly, that uses Haml and Sass.
+
+If you use this software, you must pay Hampton a compliment. And
+buy Nathan some jelly beans. Maybe pet a kitten. Yeah. Pet that kitty.
+
+Some of the work on Haml was supported by Unspace Interactive.
+
+Beyond that, the implementation is licensed under the MIT License.
+Okay, fine, I guess that means compliments aren't __required__.

data/Rakefile

@@ -48,9 +48,10 @@ end
 task :revision_file do
   require 'lib/haml'
 
-  if Haml.version[:rev] && !Rake.application.top_level_tasks.include?('release')
+  release = Rake.application.top_level_tasks.include?('release') || File.exist?('EDGE_GEM_VERSION')
+  if Haml.version[:rev] && !release
     File.open('REVISION', 'w') { |f| f.puts Haml.version[:rev] }
-  elsif Rake.application.top_level_tasks.include?('release')
+  elsif release
     File.open('REVISION', 'w') { |f| f.puts "(release)" }
   else
     File.open('REVISION', 'w') { |f| f.puts "(unknown)" }
@@ -70,8 +71,9 @@ end
 
 desc "Release a new Haml package to Rubyforge. Requires the NAME and VERSION flags."
 task :release => [:package] do
-  name, version = ENV['NAME'], ENV['VERSION']
-  raise "Must supply NAME and VERSION for release task." unless name && version
+  name = File.read("VERSION_NAME").strip
+  version = File.read("VERSION").strip
+  raise "VERSION_NAME must not be 'Bleeding Edge'" if name == "Bleeding Edge"
   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}
@@ -79,27 +81,92 @@ task :release => [:package] do
   sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.zip}
 end
 
+task :release_edge do
+  ensure_git_cleanup do
+    puts "#{'=' * 50} Running rake release_edge"
+
+    sh %{git checkout edge-gem}
+    sh %{git reset --hard origin/edge-gem}
+    sh %{git merge origin/master}
+
+    # Get the current master branch version
+    version = File.read('VERSION').strip.split('.').map {|n| n.to_i}
+    unless version[1] % 2 == 1 && version[2] == 0
+      raise "#{version.join('.')} is not a development version" 
+    end
+
+    # Bump the edge gem version
+    edge_version = File.read('EDGE_GEM_VERSION').strip.split('.').map {|n| n.to_i}
+    if edge_version[0..1] != version[0..1]
+      # A new master branch version was released, reset the edge gem version
+      edge_version[0..1] = version[0..1]
+      edge_version[2] = 0
+    else
+      # Just bump the teeny version
+      edge_version[2] += 1
+    end
+    edge_version = edge_version.join('.')
+    File.open('EDGE_GEM_VERSION', 'w') {|f| f.puts(edge_version)}
+    sh %{git commit -m "Bump edge gem version to #{edge_version}." EDGE_GEM_VERSION}
+    sh %{git push origin edge-gem}
+
+    # Package the edge gem with the proper version
+    File.open('VERSION', 'w') {|f| f.puts(edge_version)}
+    sh %{rake package}
+    sh %{git checkout VERSION}
+
+    sh %{rubyforge login}
+    sh %{rubyforge add_release haml haml-edge "Bleeding Edge (v#{edge_version})" pkg/haml-edge-#{edge_version}.gem}
+  end
+end
+
+task :watch_for_update do
+  sh %{ruby extra/update_watch.rb}
+end
+
 # ----- Documentation -----
 
+task :rdoc do
+  puts '=' * 100, <<END, '=' * 100
+Haml uses the YARD documentation system (http://github.com/lsegal/yard).
+Install the yard gem and then run "rake doc".
+END
+end
+
 begin
-  require 'hanna/rdoctask'
+  require 'yard'
+
+  YARD::Rake::YardocTask.new do |t|
+    t.files = FileList.new('lib/**/*.rb') do |list|
+      list.exclude('lib/haml/template/*.rb')
+      list.exclude('lib/haml/helpers/action_view_mods.rb')
+    end.to_a
+    t.options << '--use-cache' if Rake.application.top_level_tasks.include?('redoc')
+    t.options += FileList.new('yard/*.rb').to_a.map {|f| ['-e', f]}.flatten
+    files = FileList.new('doc-src/*').to_a.sort_by {|s| s.size} + %w[MIT-LICENSE VERSION]
+    t.options << '--files' << files.join(',')
+  end
+  Rake::Task['yardoc'].instance_variable_set('@comment', nil)
+
+  desc "Generate Documentation"
+  task :doc => :yardoc
+  task :redoc => :yardoc
 rescue LoadError
-  require 'rake/rdoctask'
+  desc "Generate Documentation"
+  task :doc => :rdoc
+  task :yardoc => :rdoc
 end
 
-Rake::RDocTask.new do |rdoc|
-  rdoc.title    = 'Haml/Sass'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include(*FileList.new('*') do |list|
-                            list.exclude(/(^|[^.a-z])[a-z]+/)
-                            list.exclude('TODO')
-                          end.to_a)
-  rdoc.rdoc_files.include('lib/**/*.rb')
-  rdoc.rdoc_files.exclude('TODO')
-  rdoc.rdoc_files.exclude('lib/haml/buffer.rb')
-  rdoc.rdoc_files.exclude('lib/sass/tree/*')
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.main = 'README.rdoc'
+task :pages do
+  ensure_git_cleanup do
+    puts "#{'=' * 50} Running rake pages PROJ=#{ENV["PROJ"].inspect}"
+    raise 'No ENV["PROJ"]!' unless proj = ENV["PROJ"]
+    sh %{git checkout #{proj}-pages}
+    sh %{git reset --hard origin/#{proj}-pages}
+
+    sh %{rake build --trace}
+    sh %{rsync -av --delete site/ /var/www/#{proj}-pages}
+  end
 end
 
 # ----- Coverage -----
@@ -183,3 +250,41 @@ namespace :test do
     end
   end
 end
+
+# ----- Handling Updates -----
+
+def ensure_git_cleanup
+  yield
+ensure
+  sh %{git reset --hard HEAD}
+  sh %{git clean -xdf}
+  sh %{git checkout master}
+end
+
+task :handle_update do
+  unless ENV["REF"] =~ %r{^refs/heads/(master|(?:haml|sass)-pages)$}
+    puts "#{'=' * 20} Ignoring rake handle_update REF=#{ENV["REF"].inspect}"
+    next
+  end
+  branch = $1
+
+  puts
+  puts
+  puts '=' * 150
+  puts "Running rake handle_update REF=#{ENV["REF"].inspect}"
+
+  sh %{git checkout master}
+  sh %{git fetch origin}
+  sh %{git reset --hard origin/master}
+
+  if branch == "master"
+    sh %{rake release_edge --trace}
+    sh %{rake pages --trace PROJ=haml}
+    sh %{rake pages --trace PROJ=sass}
+  elsif branch =~ /^(haml|sass)-pages$/
+    sh %{rake pages --trace PROJ=#{$1}}
+  end
+
+  puts 'Done running handle_update'
+  puts '=' * 150
+end