haml-edge 2.3.179 → 2.3.180

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.179
+2.3.180

data/README.md

@@ -21,7 +21,7 @@ After you convert some HTML to Haml or some CSS to Sass,
 you can run
 
     haml document.haml
-    sass style.sass
+    sass style.scss
 
 to compile them.
 For more information on these commands, check out
@@ -131,169 +131,107 @@ like `if` and `while`:
 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:
+#### Indentation
 
-    #main
-      background-color: #f00
-      width: 98%
+Haml's 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.
 
-becomes:
+### Sass
 
-    #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%;
+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://sass-lang.org/docs/yardoc/file.SASS_REFERENCE.md#variables_
+[nested]:  http://sass-lang.org/docs/yardoc/file.SASS_REFERENCE.md#nested_rules_
+[mixins]:  http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#mixins
+[imports]: http://sass-lang.org/docs/yardoc/file.SASS_REFERENCE.md#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://sass-lang.org/docs/yardoc/file.SASS_REFERENCE.md#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; }
     }
-    #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
+    li {
+      font: {
+        family: serif;
+        weight: bold;
+        size: 1.2em;
+      }
+    }
 
-becomes:
+#### Variables
 
-    #main {
-      background-color: #46a312;
-      width: 40em; }
-      #main .sidebar {
-        background-color: #79d645;
-        width: 15em; }
+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.
 
-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: #3bbfce;
+    $margin: 16px;
 
-    =blue-border
-      border:
-        color: blue
-        width: 2px
-        style: dotted
+    .content_navigation {
+      border-color: $blue;
+      color: darken($blue, 10%);
+    }
 
-    .comment
-      +blue-border
-      padding: 2px
-      margin: 10px 0
+    .border {
+      padding: $margin / 2;
+      margin: $margin / 2;
+      border-color: $blue;
+    }
 
-    .reply
-      +blue-border
+#### Mixins
 
-becomes:
+Even more powerful than variables,
+mixins allow you to re-use whole chunks of CSS,
+properties or selectors.
+You can even give them arguments. 
 
-    .comment {
-      border-color: blue;
-      border-width: 2px;
-      border-style: dotted;
-      padding: 2px;
-      margin: 10px 0;
+    @mixin table-scaffolding {
+      th {
+        text-align: center;
+        font-weight: bold;
+      }
+      td, th { padding: 2px; }
     }
 
-    .reply {
-      border-color: blue;
-      border-width: 2px;
-      border-style: dotted;
+    @mixin left($dist) {
+      float: left;
+      margin-left: $dist;
     }
 
-A comprehensive list of features is in
-the documentation for the Sass module.
-
-## Indentation
+    #data {
+      @include left(10px);
+      @include table-scaffolding;
+    }
 
-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.
+A comprehensive list of features is available
+in the [Sass reference](http://sass-lang.org/docs/yardoc/file.SASS_REFERENCE.md).
 
 ## Executables
 
@@ -318,10 +256,11 @@ 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`
+### `sass-convert`
 
-The `css2sass` executable attempts to transform CSS into Sass code.
-This transformation attempts to use Sass nesting where possible.
+The `sass-convert` executable converts between CSS, Sass, and SCSS.
+When converting from CSS to Sass or SCSS,
+nesting is applied where appropriate.
 See `css2sass --help` for further information and options.
 
 ## Authors

data/VERSION

@@ -1 +1 @@
-2.3.179
+2.3.180

data/bin/css2sass

@@ -3,5 +3,11 @@
 require File.dirname(__FILE__) + '/../lib/haml'
 require 'haml/exec'
 
-opts = Haml::Exec::CSS2Sass.new(ARGV)
+warn <<END
+DEPRECATION WARNING:
+The css2sass tool is deprecated and will be removed in Sass 3.2.
+Use the sass-convert tool instead.
+END
+
+opts = Haml::Exec::SassConvert.new(%w[--from css --to sass] + ARGV)
 opts.parse!

data/bin/sass-convert

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

data/lib/haml/exec.rb

@@ -93,17 +93,14 @@ module Haml
       # so they can run their respective programs.
       def process_result
         input, output = @options[:input], @options[:output]
-        input_file, output_file = if input
-                                    [nil, open_file(@args[0], 'w')]
-                                  else
-                                    @options[:filename] = @args[0]
-                                    [open_file(@args[0]), open_file(@args[1], 'w')]
-                                  end
-
-        input  ||= input_file
-        output ||= output_file
-        input  ||= $stdin
-        output ||= $stdout
+        args = @args.dup
+        input ||=
+          begin
+            filename = args.shift
+            @options[:filename] = filename
+            open_file(filename) || $stdin
+          end
+        output ||= open_file(args.shift, 'w') || $stdout
 
         @options[:input], @options[:output] = input, output
       end
@@ -218,6 +215,10 @@ END
       def set_opts(opts)
         super
 
+        opts.on('--scss',
+                'Use the CSS-superset SCSS syntax.') do
+          @options[:for_engine][:syntax] = :scss
+        end
         opts.on('--watch', 'Watch files or directories for changes.',
                            'The location of the generated CSS can be set using a colon:',
                            '  sass --watch input.sass:output.css',
@@ -275,6 +276,7 @@ END
           input = @options[:input]
           output = @options[:output]
 
+          @options[:syntax] ||= :scss if input.is_a?(File) && input.path =~ /\.scss$/
           tree =
             if input.is_a?(File) && !@options[:check_syntax]
               ::Sass::Files.tree_for(input.path, @options[:for_engine])
@@ -533,12 +535,13 @@ END
       end
     end
 
-    # The `css2sass` executable.
-    class CSS2Sass < Generic
+    # The `sass-convert` executable.
+    class SassConvert < Generic
       # @param args [Array<String>] The command-line arguments
       def initialize(args)
         super
-        @module_opts = {}
+        @options[:for_tree] = {}
+        @options[:for_engine] = {}
       end
 
       # Tells optparse how to parse the arguments.
@@ -546,18 +549,45 @@ END
       # @param opts [OptionParser]
       def set_opts(opts)
         opts.banner = <<END
-Usage: css2sass [options] [INPUT] [OUTPUT]
+Usage: sass-convert [options] [INPUT] [OUTPUT]
 
-Description: Transforms a CSS file into corresponding Sass code.
+Description:
+  Converts between CSS, Sass, and SCSS files.
+  E.g. converts from SCSS to Sass,
+  or converts from CSS to SCSS (adding appropriate nesting).
 
 Options:
 END
 
-        opts.on('--old', 'Output the old-style ":prop val" property syntax') do
-          @module_opts[:old] = true
+        opts.on('-F', '--from FORMAT',
+          'The format to convert from. Can be css, scss, sass, or sass2.',
+          'sass2 is the same as sass, but updates more old syntax to new.',
+          'By default, this is inferred from the input filename.',
+          'If there is none, defaults to css.') do |name|
+          @options[:from] = name.downcase.to_sym
+        end
+
+        opts.on('-T', '--to FORMAT',
+          'The format to convert to. Can be scss or sass.',
+          'By default, this is inferred from the output filename.',
+          'If there is none, defaults to sass.') do |name|
+          @options[:to] = name.downcase.to_sym
         end
 
-        opts.on_tail('-a', '--alternate', 'Ignored') {}
+        opts.on('-i', '--in-place',
+          'Convert a file to its own syntax.',
+          'This can be used to update some deprecated syntax.') do
+          @options[:in_place] = true
+        end
+
+        opts.on('--old', 'Output the old-style ":prop val" property syntax.',
+                         'Only meaningful when generating Sass.') do
+          @options[:for_tree][:old] = true
+        end
+
+        opts.on('-C', '--no-cache', "Don't cache to sassc files.") do
+          @options[:for_engine][:cache] = false
+        end
 
         super
       end
@@ -565,14 +595,57 @@ END
       # Processes the options set by the command-line arguments,
       # and runs the CSS compiler appropriately.
       def process_result
+        require 'sass'
         super
 
-        require 'sass/css'
-
         input = @options[:input]
         output = @options[:output]
+        output = input if @options[:in_place]
+
+        if input.is_a?(File)
+          @options[:from] ||=
+            case input.path
+            when /\.scss$/; :scss
+            when /\.sass$/; :sass
+            when /\.css$/; :css
+            end
+        elsif @options[:in_place]
+          raise "Error: the --in-place option requires a filename."
+        end
+
+        if output.is_a?(File)
+          @options[:to] ||=
+            case output.path
+            when /\.scss$/; :scss
+            when /\.sass$/; :sass
+            end
+        end
+
+        if @options[:from] == :sass2
+          @options[:from] = :sass
+          @options[:for_engine][:sass2] = true
+        end
+
+        @options[:from] ||= :css
+        @options[:to] ||= :sass
+        @options[:for_engine][:syntax] = @options[:from]
+
+        out =
+          ::Haml::Util.silence_haml_warnings do
+            if @options[:from] == :css
+              require 'sass/css'
+              ::Sass::CSS.new(input.read, @options[:for_tree]).render(@options[:to])
+            else
+              if input.is_a?(File)
+                ::Sass::Files.tree_for(input.path, @options[:for_engine])
+              else
+                ::Sass::Engine.new(input.read, @options[:for_engine]).to_tree
+              end.send("to_#{@options[:to]}", @options[:for_tree])
+            end
+          end
 
-        output.write(::Sass::CSS.new(input, @module_opts).render)
+        output = File.open(input.path, 'w') if @options[:in_place]
+        output.write(out)
       rescue ::Sass::SyntaxError => e
         raise e if @options[:trace]
         raise "Syntax error on line #{get_line e}: #{e.message}\n  Use --trace for backtrace"