haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/test/haml/templates/filters.haml

@@ -1,66 +0,0 @@
-%style
-  - width = 5 + 17
-  :sass
-    p
-      :border
-        :style dotted
-        :width #{width}px
-        :color #ff00ff
-    h1
-      :font-weight normal
-
-:test
-  This
-  Should
-  Not
-  Print
-
-%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.
-
-- num = 10
-%ul
-  :erb
-    <% num.times do |c| %>
-      <li><%= (c+97).chr %></li>
-    <% end %>
-    <% res = 178 %>
-
-.res= res
-
-= "Text!"
-
-- var = "Hello"
-:ruby
-  printf "%s, World!\n", var
-  print "How are you doing today?\n"
-
-:escaped
-  <div class="foo">
-    <p>I think &mdash; or do I?</p>
-  </div>

data/test/haml/templates/partial_layout.haml

@@ -1,10 +0,0 @@
-%h1 Partial layout used with for block:
-- if Haml::Util.ap_geq?("3.2.0.alpha1")
-  = render :layout => 'layout_for_partial' do
-    %p Some content within a layout
-- elsif Haml::Util.ap_geq_3?
-  = render :layout => 'layout_for_partial.haml' do
-    %p Some content within a layout
-- else
-  - render :layout => 'layout_for_partial.haml' do
-    %p Some content within a layout

data/test/haml/util_test.rb

@@ -1,300 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/../test_helper'
-require 'pathname'
-
-class UtilTest < Test::Unit::TestCase
-  include Haml::Util
-
-  class Dumpable
-    attr_reader :arr
-    def initialize; @arr = []; end
-    def _before_dump; @arr << :before; end
-    def _after_dump; @arr << :after; end
-    def _around_dump
-      @arr << :around_before
-      yield
-      @arr << :around_after
-    end
-    def _after_load; @arr << :loaded; end
-  end
-
-  def test_scope
-    assert(File.exist?(scope("Rakefile")))
-  end
-
-  def test_to_hash
-    assert_equal({
-        :foo => 1,
-        :bar => 2,
-        :baz => 3
-      }, to_hash([[:foo, 1], [:bar, 2], [:baz, 3]]))
-  end
-
-  def test_map_keys
-    assert_equal({
-        "foo" => 1,
-        "bar" => 2,
-        "baz" => 3
-      }, map_keys({:foo => 1, :bar => 2, :baz => 3}) {|k| k.to_s})
-  end
-
-  def test_map_vals
-    assert_equal({
-        :foo => "1",
-        :bar => "2",
-        :baz => "3"
-      }, map_vals({:foo => 1, :bar => 2, :baz => 3}) {|k| k.to_s})
-  end
-
-  def test_map_hash
-    assert_equal({
-        "foo" => "1",
-        "bar" => "2",
-        "baz" => "3"
-      }, map_hash({:foo => 1, :bar => 2, :baz => 3}) {|k, v| [k.to_s, v.to_s]})
-  end
-
-  def test_powerset
-    return unless Set[Set[]] == Set[Set[]] # There's a bug in Ruby 1.8.6 that breaks nested set equality
-    assert_equal([[].to_set].to_set,
-      powerset([]))
-    assert_equal([[].to_set, [1].to_set].to_set,
-      powerset([1]))
-    assert_equal([[].to_set, [1].to_set, [2].to_set, [1, 2].to_set].to_set,
-      powerset([1, 2]))
-    assert_equal([[].to_set, [1].to_set, [2].to_set, [3].to_set,
-        [1, 2].to_set, [2, 3].to_set, [1, 3].to_set, [1, 2, 3].to_set].to_set,
-      powerset([1, 2, 3]))
-  end
-
-  def test_restrict
-    assert_equal(0.5, restrict(0.5, 0..1))
-    assert_equal(1, restrict(2, 0..1))
-    assert_equal(1.3, restrict(2, 0..1.3))
-    assert_equal(0, restrict(-1, 0..1))
-  end
-
-  def test_merge_adjacent_strings
-    assert_equal(["foo bar baz", :bang, "biz bop", 12],
-      merge_adjacent_strings(["foo ", "bar ", "baz", :bang, "biz", " bop", 12]))
-    str = "foo"
-    assert_equal(["foo foo foo", :bang, "foo foo", 12],
-      merge_adjacent_strings([str, " ", str, " ", str, :bang, str, " ", str, 12]))
-  end
-
-  def test_intersperse
-    assert_equal(["foo", " ", "bar", " ", "baz"],
-      intersperse(%w[foo bar baz], " "))
-    assert_equal([], intersperse([], " "))
-  end
-
-  def test_substitute
-    assert_equal(["foo", "bar", "baz", 3, 4],
-      substitute([1, 2, 3, 4], [1, 2], ["foo", "bar", "baz"]))
-    assert_equal([1, "foo", "bar", "baz", 4],
-      substitute([1, 2, 3, 4], [2, 3], ["foo", "bar", "baz"]))
-    assert_equal([1, 2, "foo", "bar", "baz"],
-      substitute([1, 2, 3, 4], [3, 4], ["foo", "bar", "baz"]))
-
-    assert_equal([1, "foo", "bar", "baz", 2, 3, 4],
-      substitute([1, 2, 2, 2, 3, 4], [2, 2], ["foo", "bar", "baz"]))
-  end
-
-  def test_strip_string_array
-    assert_equal(["foo ", " bar ", " baz"],
-      strip_string_array([" foo ", " bar ", " baz "]))
-    assert_equal([:foo, " bar ", " baz"],
-      strip_string_array([:foo, " bar ", " baz "]))
-    assert_equal(["foo ", " bar ", :baz],
-      strip_string_array([" foo ", " bar ", :baz]))
-  end
-
-  def test_paths
-    assert_equal([[1, 3, 5], [2, 3, 5], [1, 4, 5], [2, 4, 5]],
-      paths([[1, 2], [3, 4], [5]]))
-    assert_equal([[]], paths([]))
-    assert_equal([[1, 2, 3]], paths([[1], [2], [3]]))
-  end
-
-  def test_lcs
-    assert_equal([1, 2, 3], lcs([1, 2, 3], [1, 2, 3]))
-    assert_equal([], lcs([], [1, 2, 3]))
-    assert_equal([], lcs([1, 2, 3], []))
-    assert_equal([1, 2, 3], lcs([5, 1, 4, 2, 3, 17], [0, 0, 1, 2, 6, 3]))
-
-    assert_equal([1], lcs([1, 2, 3, 4], [4, 3, 2, 1]))
-    assert_equal([1, 2], lcs([1, 2, 3, 4], [3, 4, 1, 2]))
-  end
-
-  def test_lcs_with_block
-    assert_equal(["1", "2", "3"],
-      lcs([1, 4, 2, 5, 3], [1, 2, 3]) {|a, b| a == b && a.to_s})
-    assert_equal([-4, 2, 8],
-      lcs([-5, 3, 2, 8], [-4, 1, 8]) {|a, b| (a - b).abs <= 1 && [a, b].max})
-  end
-
-  def test_silence_warnings
-    old_stderr, $stderr = $stderr, StringIO.new
-    warn "Out"
-    assert_equal("Out\n", $stderr.string)
-    silence_warnings {warn "In"}
-    assert_equal("Out\n", $stderr.string)
-  ensure
-    $stderr = old_stderr
-  end
-
-  def test_haml_warn
-    assert_warning("Foo!") {haml_warn "Foo!"}
-  end
-
-  def test_silence_haml_warnings
-    old_stderr, $stderr = $stderr, StringIO.new
-    silence_haml_warnings {warn "Out"}
-    assert_equal("Out\n", $stderr.string)
-    silence_haml_warnings {haml_warn "In"}
-    assert_equal("Out\n", $stderr.string)
-  ensure
-    $stderr = old_stderr
-  end
-
-  def test_has
-    assert(has?(:instance_method, String, :chomp!))
-    assert(has?(:private_instance_method, Haml::Engine, :set_locals))
-  end
-
-  def test_enum_with_index
-    assert_equal(%w[foo0 bar1 baz2],
-      enum_with_index(%w[foo bar baz]).map {|s, i| "#{s}#{i}"})
-  end
-
-  def test_enum_cons
-    assert_equal(%w[foobar barbaz],
-      enum_cons(%w[foo bar baz], 2).map {|s1, s2| "#{s1}#{s2}"})
-  end
-
-  def test_ord
-    assert_equal(102, ord("f"))
-    assert_equal(98, ord("bar"))
-  end
-
-  def test_flatten
-    assert_equal([1, 2, 3], flatten([1, 2, 3], 0))
-    assert_equal([1, 2, 3], flatten([1, 2, 3], 1))
-    assert_equal([1, 2, 3], flatten([1, 2, 3], 2))
-
-    assert_equal([[1, 2], 3], flatten([[1, 2], 3], 0))
-    assert_equal([1, 2, 3], flatten([[1, 2], 3], 1))
-    assert_equal([1, 2, 3], flatten([[1, 2], 3], 2))
-
-    assert_equal([[[1], 2], [3], 4], flatten([[[1], 2], [3], 4], 0))
-    assert_equal([[1], 2, 3, 4], flatten([[[1], 2], [3], 4], 1))
-    assert_equal([1, 2, 3, 4], flatten([[[1], 2], [3], 4], 2))
-  end
-
-  def test_set_hash
-    assert(set_hash(Set[1, 2, 3]) == set_hash(Set[3, 2, 1]))
-    assert(set_hash(Set[1, 2, 3]) == set_hash(Set[1, 2, 3]))
-
-    s1 = Set[]
-    s1 << 1
-    s1 << 2
-    s1 << 3
-    s2 = Set[]
-    s2 << 3
-    s2 << 2
-    s2 << 1
-    assert(set_hash(s1) == set_hash(s2))
-  end
-
-  def test_set_eql
-    assert(set_eql?(Set[1, 2, 3], Set[3, 2, 1]))
-    assert(set_eql?(Set[1, 2, 3], Set[1, 2, 3]))
-
-    s1 = Set[]
-    s1 << 1
-    s1 << 2
-    s1 << 3
-    s2 = Set[]
-    s2 << 3
-    s2 << 2
-    s2 << 1
-    assert(set_eql?(s1, s2))
-  end
-
-  def test_caller_info
-    assert_equal(["/tmp/foo.rb", 12, "fizzle"], caller_info("/tmp/foo.rb:12: in `fizzle'"))
-    assert_equal(["/tmp/foo.rb", 12, nil], caller_info("/tmp/foo.rb:12"))
-    assert_equal(["(haml)", 12, "blah"], caller_info("(haml):12: in `blah'"))
-    assert_equal(["", 12, "boop"], caller_info(":12: in `boop'"))
-    assert_equal(["/tmp/foo.rb", -12, "fizzle"], caller_info("/tmp/foo.rb:-12: in `fizzle'"))
-    assert_equal(["/tmp/foo.rb", 12, "fizzle"], caller_info("/tmp/foo.rb:12: in `fizzle {}'"))
-  end
-
-  def test_version_gt
-    assert_version_gt("2.0.0", "1.0.0")
-    assert_version_gt("1.1.0", "1.0.0")
-    assert_version_gt("1.0.1", "1.0.0")
-    assert_version_gt("1.0.0", "1.0.0.rc")
-    assert_version_gt("1.0.0.1", "1.0.0.rc")
-    assert_version_gt("1.0.0.rc", "0.9.9")
-    assert_version_gt("1.0.0.beta", "1.0.0.alpha")
-
-    assert_version_eq("1.0.0", "1.0.0")
-    assert_version_eq("1.0.0", "1.0.0.0")
-  end
-
-  def assert_version_gt(v1, v2)
-    #assert(version_gt(v1, v2), "Expected #{v1} > #{v2}")
-    assert(!version_gt(v2, v1), "Expected #{v2} < #{v1}")
-  end
-
-  def assert_version_eq(v1, v2)
-    assert(!version_gt(v1, v2), "Expected #{v1} = #{v2}")
-    assert(!version_gt(v2, v1), "Expected #{v2} = #{v1}")
-  end
-
-  def test_dump_and_load
-    obj = Dumpable.new
-    data = dump(obj)
-    assert_equal([:before, :around_before, :around_after, :after], obj.arr)
-    obj2 = load(data)
-    assert_equal([:before, :around_before, :loaded], obj2.arr)
-  end
-
-  class FooBar
-    def foo
-      Haml::Util.abstract(self)
-    end
-  end
-
-  def test_abstract
-    assert_raise_message(NotImplementedError,
-      "UtilTest::FooBar must implement #foo") {FooBar.new.foo}
-  end
-
-  def test_def_static_method
-    klass = Class.new
-    def_static_method(klass, :static_method, [:arg1, :arg2],
-      :sarg1, :sarg2, <<RUBY)
-      s = "Always " + arg1
-      s << " <% if sarg1 %>and<% else %>but never<% end %> " << arg2
-
-      <% if sarg2 %>
-        s << "."
-      <% end %>
-RUBY
-    c = klass.new
-    assert_equal("Always brush your teeth and comb your hair.",
-      c.send(static_method_name(:static_method, true, true),
-        "brush your teeth", "comb your hair"))
-    assert_equal("Always brush your teeth and comb your hair",
-      c.send(static_method_name(:static_method, true, false),
-        "brush your teeth", "comb your hair"))
-    assert_equal("Always brush your teeth but never play with fire.",
-      c.send(static_method_name(:static_method, false, true),
-        "brush your teeth", "play with fire"))
-    assert_equal("Always brush your teeth but never play with fire",
-      c.send(static_method_name(:static_method, false, false),
-        "brush your teeth", "play with fire"))
-  end
-end

data/test/linked_rails.rb

@@ -1,42 +0,0 @@
-# allows testing with edge Rails by creating a test/rails symlink
-linked_rails = File.dirname(__FILE__) + '/rails'
-
-if File.exists?(linked_rails) && !$:.include?(linked_rails + '/activesupport/lib')
-  puts "[ using linked Rails ]"
-  $:.unshift linked_rails + '/activesupport/lib'
-  $:.unshift linked_rails + '/actionpack/lib'
-  $:.unshift linked_rails + '/railties/lib'
-end
-require 'rubygems'
-require 'action_pack'
-require 'action_controller'
-require 'action_view'
-
-if ActionPack::VERSION::MAJOR >= 3
-  # Necessary for Rails 3
-  require 'rails'
-else
-  # Necessary for Rails 2.3.*
-  require 'initializer'
-end
-
-if defined?(Rails::Application) # Rails 3
-  class TestApp < Rails::Application
-    config.root = File.join(File.dirname(__FILE__), "../..")
-  end
-  Rails.application = TestApp
-elsif defined?(RAILS_ROOT)
-  RAILS_ROOT.replace(File.join(File.dirname(__FILE__), "../.."))
-else
-  RAILS_ROOT = File.join(File.dirname(__FILE__), "../..")
-end
-
-ActionController::Base.logger = Logger.new(nil)
-
-# Load plugins from test/plugins.
-# This will only work with very basic plugins,
-# since we don't want to load the entirety of Rails.
-Dir[File.dirname(__FILE__) + '/plugins/*'].each do |plugin|
-  $: << plugin + '/lib'
-  eval(File.read(plugin + '/init.rb'))
-end

data/vendor/sass/CONTRIBUTING

@@ -1,3 +0,0 @@
-Contributions are welcomed. Please see the following sites for guidelines:
-
-  http://sass-lang.com/development.html#contributing

data/vendor/sass/MIT-LICENSE

@@ -1,20 +0,0 @@
-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
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/sass/README.md

@@ -1,201 +0,0 @@
-# Sass
-
-**Sass makes CSS fun again**. Sass is an extension of CSS3,
-adding nested rules, variables, mixins, selector inheritance, and more.
-It's translated to well-formatted, standard CSS
-using the command line tool or a web-framework plugin.
-
-Sass has two syntaxes. The new main syntax (as of Sass 3)
-is known as "SCSS" (for "Sassy CSS"),
-and is a superset of CSS3's syntax.
-This means that every valid CSS3 stylesheet is valid SCSS as well.
-SCSS files use the extension `.scss`.
-
-The second, older syntax is known as the indented syntax (or just "Sass").
-Inspired by Haml's terseness, it's intended for people
-who prefer conciseness over similarity to CSS.
-Instead of brackets and semicolons,
-it uses the indentation of lines to specify blocks.
-Although no longer the primary syntax,
-the indented syntax will continue to be supported.
-Files in the indented syntax use the extension `.sass`.
-
-## Using
-
-Sass can be used from the command line
-or as part of a web framework.
-The first step is to install the gem:
-
-    gem install sass
-
-After you convert some CSS to Sass, you can run
-
-    sass style.scss
-
-to compile it back to CSS.
-For more information on these commands, check out
-
-    sass --help
-
-To install Sass in Rails 2,
-just add `config.gem "sass"` to `config/environment.rb`.
-In Rails 3, add `gem "sass"` to your Gemfile instead.
-`.sass` or `.scss` 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/file.SASS_REFERENCE.html#template_location-option) for details).
-
-Sass can also be used with any Rack-enabled web framework.
-To do so, just add
-
-    require 'sass/plugin/rack'
-    use Sass::Plugin::Rack
-
-to `config.ru`.
-Then any Sass files in `public/stylesheets/sass`
-will be compiled CSS files in `public/stylesheets` on every request.
-
-To use Sass programatically,
-check out the [YARD documentation](http://sass-lang.com/docs/yardoc/).
-
-## Formatting
-
-Sass is an extension of CSS
-that adds power and elegance to the basic language.
-It allows you to use [variables][vars], [nested rules][nested],
-[mixins][mixins], [inline imports][imports],
-and more, all with a fully CSS-compatible syntax.
-Sass helps keep large stylesheets well-organized,
-and get small stylesheets up and running quickly,
-particularly with the help of
-[the Compass style library](http://compass-style.org).
-
-[vars]:    http://beta.sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#variables_
-[nested]:  http://beta.sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#nested_rules_
-[mixins]:  http://beta.sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#mixins
-[imports]: http://beta.sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#import
-
-Sass has two syntaxes.
-The one presented here, known as "SCSS" (for "Sassy CSS"),
-is fully CSS-compatible.
-The other (older) syntax, known as the indented syntax or just "Sass",
-is whitespace-sensitive and indentation-based.
-For more information, see the [reference documentation][syntax].
-
-[syntax]: http://beta.sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#syntax
-
-To run the following examples and see the CSS they produce,
-put them in a file called `test.scss` and run `sass test.scss`.
-
-### Nesting
-
-Sass avoids repetition by nesting selectors within one another.
-The same thing works for properties.
-
-    table.hl {
-      margin: 2em 0;
-      td.ln { text-align: right; }
-    }
-
-    li {
-      font: {
-        family: serif;
-        weight: bold;
-        size: 1.2em;
-      }
-    }
-
-### Variables
-
-Use the same color all over the place?
-Need to do some math with height and width and text size?
-Sass supports variables, math operations, and many useful functions.
-
-    $blue: #3bbfce;
-    $margin: 16px;
-
-    .content_navigation {
-      border-color: $blue;
-      color: darken($blue, 10%);
-    }
-
-    .border {
-      padding: $margin / 2;
-      margin: $margin / 2;
-      border-color: $blue;
-    }
-
-### Mixins
-
-Even more powerful than variables,
-mixins allow you to re-use whole chunks of CSS,
-properties or selectors.
-You can even give them arguments. 
-
-    @mixin table-scaffolding {
-      th {
-        text-align: center;
-        font-weight: bold;
-      }
-      td, th { padding: 2px; }
-    }
-
-    @mixin left($dist) {
-      float: left;
-      margin-left: $dist;
-    }
-
-    #data {
-      @include left(10px);
-      @include table-scaffolding;
-    }
-
-A comprehensive list of features is available
-in the [Sass reference](http://beta.sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html).
-
-## Executables
-
-The Sass gem includes several executables that are useful
-for dealing with Sass from the command line.
-
-### `sass`
-
-The `sass` executable transforms a source Sass file into CSS.
-See `sass --help` for further information and options.
-
-### `sass-convert`
-
-The `sass-convert` executable converts between CSS, Sass, and SCSS.
-When converting from CSS to Sass or SCSS,
-nesting is applied where appropriate.
-See `sass-convert --help` for further information and options.
-
-## Authors
-
-Sass was envisioned by [Hampton Catlin](http://hamptoncatlin.com) (hcatlin).
-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
-Sass. 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.
-
-Beyond that, the implementation is licensed under the MIT License.
-Okay, fine, I guess that means compliments aren't __required__.