gohanlonllc-haml 2.1.0

data/README.rdoc

@@ -0,0 +1,332 @@
+= 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
+
+There are several ways to use Haml and Sass.
+They can be used as a plugin for Rails or Merb,
+or embedded on their own in other applications.
+The first step of all of these is to install the Haml gem:
+
+  gem install haml
+
+To install Haml and Sass as a Rails plugin,
+just run <tt>haml --rails path/to/rails/app</tt>
+and both Haml and Sass will be installed.
+Views with the <tt>.haml</tt> (or <tt>.html.haml</tt> for edge)
+extension will automatically use Haml.
+Sass is a little more complicated;
+<tt>.sass</tt> 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 module docs for details).
+
+For Merb, <tt>.html.haml</tt> 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 RDocs for the Haml and Sass modules.
+
+== Formatting
+
+=== Haml
+
+The most basic element of Haml
+is a shorthand for creating HTML tags:
+
+  %tagname{:attr1 => 'value1', :attr2 => 'value2'} Contents
+
+No end-tag is needed; Haml handles that automatically.
+Adding <tt>class</tt> and <tt>id</tt> 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 <tt><div></tt> tag,
+it becomes <em>even easier</em>.
+Because <tt><div></tt> 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, <tt>=</tt>, will output the result of the code.
+A hyphen, <tt>-</tt>, will run the code but not output the result.
+You can even use control statements
+like <tt>if</tt> and <tt>while</tt>:
+
+  %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:
+tabulation indicates the attributes in a rule,
+rather than non-DRY brackets;
+and newlines indicate the end of an attribute,
+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 attribute 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 swathes of CSS attributes 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 <tt>haml --help</tt> for further information and options.
+
+=== +sass+
+
+The +sass+ executable transforms a source Sass file into CSS.
+See <tt>sass --help</tt> for further information and options.
+
+=== <tt>html2haml</tt>
+
+The <tt>html2haml</tt> 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 <tt>html2haml --help</tt> for further information and options.
+
+=== <tt>css2sass</tt>
+
+The <tt>css2sass</tt> executable attempts to transform CSS into Sass code.
+This transformation attempts to use Sass nesting where possible.
+See <tt>css2sass --help</tt> for further information and options.
+
+== Authors
+
+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
+is a partner at Unspace Interactive.
+
+Nathan Weizenbaum is the primary maintainer 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 University of Washington he consults for
+Unspace Interactive and Microsoft.
+
+Chris Eppstein 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, CA with his wife and daughter. He is the Software Architect for 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.
+Ok, fine, I guess that means compliments aren't *required*.

data/Rakefile

@@ -0,0 +1,250 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |spec|
+    spec.name = 'haml'
+    spec.summary = "An elegant, structured XHTML/XML templating engine.\nComes with Sass, a similar CSS templating engine."
+    spec.authors = ['Nathan Weizenbaum', '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
+
+    spec.executables = ['haml', 'html2haml', 'sass', 'css2sass']
+    spec.homepage = 'http://haml.hamptoncatlin.com/'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+# ----- Benchmarking -----
+
+desc <<END
+Benchmark haml against ERb.
+  TIMES=n sets the number of runs. Defaults to 1000.
+END
+task :benchmark do
+  sh "ruby test/benchmark.rb #{ENV['TIMES']}"
+end
+
+# ----- Default: Testing ------
+
+if ENV["RUN_CODE_RUN"] == "true"
+  task :default => :"test:rails_compatibility"
+else
+  task :default => :test
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  test_files = FileList['test/**/*_test.rb']
+  test_files.exclude('test/rails/*')
+  t.test_files = test_files
+  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
+
+# ----- Packaging -----
+
+# require 'rake/gempackagetask'
+# load    'haml.gemspec'
+# 
+# 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 :revision_file do
+#   require 'lib/haml'
+# 
+#   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 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.
+at_exit { File.delete('REVISION') rescue nil }
+
+desc "Install Haml as a gem."
+task :install => [:package] do
+  sudo = RUBY_PLATFORM =~ /win32/ ? '' : 'sudo'
+  gem  = RUBY_PLATFORM =~ /java/  ? 'jgem' : 'gem' 
+  sh %{#{sudo} #{gem} install --no-ri pkg/haml-#{File.read('VERSION').strip}}
+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
+  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
+
+task :release_edge do
+  sh %{git checkout edge-gem}
+  sh %{git fetch origin}
+  sh %{git merge 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." 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
+
+task :watch_for_edge_update do
+  sh %{ruby extra/edge_gem_watch.rb}
+end
+
+# ----- Documentation -----
+
+begin
+  require 'hanna/rdoctask'
+rescue LoadError
+  require 'rake/rdoctask'
+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'
+end
+
+# ----- Coverage -----
+
+begin
+  require '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
+rescue LoadError; end
+
+# ----- Profiling -----
+
+begin
+  require 'ruby-prof'
+
+  desc <<END
+Run a profile of haml.
+  ENGINE=str sets the engine to be profiled. Defaults to Haml.
+  TIMES=n sets the number of runs. Defaults to 1000.
+  FILE=str sets the file to profile.
+    Defaults to 'standard' for Haml and 'complex' for Sass.
+  OUTPUT=str sets the ruby-prof output format.
+    Can be Flat, CallInfo, or Graph. Defaults to Flat. Defaults to Flat.
+END
+  task :profile do
+    engine = (ENV['ENGINE'] || 'haml').downcase
+    times  = (ENV['TIMES'] || '1000').to_i
+    file   = ENV['FILE']
+
+    if engine == 'sass'
+      require 'lib/sass'
+
+      file = File.read("#{File.dirname(__FILE__)}/test/sass/templates/#{file || 'complex'}.sass")
+      result = RubyProf.profile { times.times { Sass::Engine.new(file).render } }
+    else
+      require 'lib/haml'
+
+      file = File.read("#{File.dirname(__FILE__)}/test/haml/templates/#{file || 'standard'}.haml")
+      obj = Object.new
+      Haml::Engine.new(file).def_method(obj, :render)
+      result = RubyProf.profile { times.times { obj.render } }
+    end
+
+    RubyProf.const_get("#{(ENV['OUTPUT'] || 'Flat').capitalize}Printer").new(result).print 
+  end
+rescue LoadError; end
+
+# ----- Testing Multiple Rails Versions -----
+
+rails_versions = [
+  "v2.3.0",
+  "v2.2.2",
+  "v2.1.2",
+  "v2.0.5"
+]
+
+namespace :test do
+  desc "Test all supported versions of rails. This takes a while."
+  task :rails_compatibility do
+    `rm -rf test/rails`
+    puts "Checking out rails. Please wait."
+    `git clone git://github.com/rails/rails.git test/rails` rescue nil
+    begin
+      rails_versions.each do |version|
+        Dir.chdir "test/rails" do
+          `git checkout #{version}`
+        end
+        puts "Testing Rails #{version}"
+        Rake::Task['test'].reenable
+        Rake::Task['test'].execute
+      end
+    ensure
+      `rm -rf test/rails`
+    end
+  end
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 2
+:minor: 1
+:patch: 0

data/bin/css2sass

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/haml'
+require 'haml/exec'
+
+opts = Haml::Exec::CSS2Sass.new(ARGV)
+opts.parse!

data/bin/haml

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# The command line Haml parser.
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'haml'
+require 'haml/exec'
+
+opts = Haml::Exec::Haml.new(ARGV)
+opts.parse!

data/bin/html2haml

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/haml'
+require 'haml/exec'
+
+opts = Haml::Exec::HTML2Haml.new(ARGV)
+opts.parse!

data/bin/sass

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# The command line Sass parser.
+
+require File.dirname(__FILE__) + '/../lib/haml'
+require 'haml/exec'
+
+opts = Haml::Exec::Sass.new(ARGV)
+opts.parse!