sass 3.3.0 → 3.4.0

data/lib/sass/exec/base.rb

@@ -0,0 +1,187 @@
+require 'optparse'
+
+module Sass::Exec
+  # The abstract base class for Sass executables.
+  class Base
+    # @param args [Array<String>] The command-line arguments
+    def initialize(args)
+      @args = args
+      @options = {}
+    end
+
+    # Parses the command-line arguments and runs the executable.
+    # Calls `Kernel#exit` at the end, so it never returns.
+    #
+    # @see #parse
+    def parse!
+      # rubocop:disable RescueException
+      begin
+        parse
+      rescue Exception => e
+        raise e if @options[:trace] || e.is_a?(SystemExit)
+
+        $stderr.print "#{e.class}: " unless e.class == RuntimeError
+        $stderr.puts "#{e.message}"
+        $stderr.puts "  Use --trace for backtrace."
+        exit 1
+      end
+      exit 0
+      # rubocop:enable RescueException
+    end
+
+    # Parses the command-line arguments and runs the executable.
+    # This does not handle exceptions or exit the program.
+    #
+    # @see #parse!
+    def parse
+      @opts = OptionParser.new(&method(:set_opts))
+      @opts.parse!(@args)
+
+      process_result
+
+      @options
+    end
+
+    # @return [String] A description of the executable
+    def to_s
+      @opts.to_s
+    end
+
+    protected
+
+    # Finds the line of the source template
+    # on which an exception was raised.
+    #
+    # @param exception [Exception] The exception
+    # @return [String] The line number
+    def get_line(exception)
+      # SyntaxErrors have weird line reporting
+      # when there's trailing whitespace
+      if exception.is_a?(::SyntaxError)
+        return (exception.message.scan(/:(\d+)/).first || ["??"]).first
+      end
+      (exception.backtrace[0].scan(/:(\d+)/).first || ["??"]).first
+    end
+
+    # Tells optparse how to parse the arguments
+    # available for all executables.
+    #
+    # This is meant to be overridden by subclasses
+    # so they can add their own options.
+    #
+    # @param opts [OptionParser]
+    def set_opts(opts)
+      Sass::Util.abstract(this)
+    end
+
+    # Set an option for specifying `Encoding.default_external`.
+    #
+    # @param opts [OptionParser]
+    def encoding_option(opts)
+      encoding_desc = if Sass::Util.ruby1_8?
+                        'Does not work in Ruby 1.8.'
+                      else
+                        'Specify the default encoding for input files.'
+                      end
+      opts.on('-E', '--default-encoding ENCODING', encoding_desc) do |encoding|
+        if Sass::Util.ruby1_8?
+          $stderr.puts "Specifying the encoding is not supported in ruby 1.8."
+          exit 1
+        else
+          Encoding.default_external = encoding
+        end
+      end
+    end
+
+    # Processes the options set by the command-line arguments. In particular,
+    # sets `@options[:input]` and `@options[:output]` to appropriate IO streams.
+    #
+    # This is meant to be overridden by subclasses
+    # so they can run their respective programs.
+    def process_result
+      input, output = @options[:input], @options[:output]
+      args = @args.dup
+      input ||=
+        begin
+          filename = args.shift
+          @options[:filename] = filename
+          open_file(filename) || $stdin
+        end
+      @options[:output_filename] = args.shift
+      output ||= @options[:output_filename] || $stdout
+      @options[:input], @options[:output] = input, output
+    end
+
+    COLORS = {:red => 31, :green => 32, :yellow => 33}
+
+    # Prints a status message about performing the given action,
+    # colored using the given color (via terminal escapes) if possible.
+    #
+    # @param name [#to_s] A short name for the action being performed.
+    #   Shouldn't be longer than 11 characters.
+    # @param color [Symbol] The name of the color to use for this action.
+    #   Can be `:red`, `:green`, or `:yellow`.
+    def puts_action(name, color, arg)
+      return if @options[:for_engine][:quiet]
+      printf color(color, "%11s %s\n"), name, arg
+      STDOUT.flush
+    end
+
+    # Same as `Kernel.puts`, but doesn't print anything if the `--quiet` option is set.
+    #
+    # @param args [Array] Passed on to `Kernel.puts`
+    def puts(*args)
+      return if @options[:for_engine][:quiet]
+      Kernel.puts(*args)
+    end
+
+    # Wraps the given string in terminal escapes
+    # causing it to have the given color.
+    # If terminal esapes aren't supported on this platform,
+    # just returns the string instead.
+    #
+    # @param color [Symbol] The name of the color to use.
+    #   Can be `:red`, `:green`, or `:yellow`.
+    # @param str [String] The string to wrap in the given color.
+    # @return [String] The wrapped string.
+    def color(color, str)
+      raise "[BUG] Unrecognized color #{color}" unless COLORS[color]
+
+      # Almost any real Unix terminal will support color,
+      # so we just filter for Windows terms (which don't set TERM)
+      # and not-real terminals, which aren't ttys.
+      return str if ENV["TERM"].nil? || ENV["TERM"].empty? || !STDOUT.tty?
+      "\e[#{COLORS[color]}m#{str}\e[0m"
+    end
+
+    def write_output(text, destination)
+      if destination.is_a?(String)
+        open_file(destination, 'w') {|file| file.write(text)}
+      else
+        destination.write(text)
+      end
+    end
+
+    private
+
+    def open_file(filename, flag = 'r')
+      return if filename.nil?
+      flag = 'wb' if @options[:unix_newlines] && flag == 'w'
+      file = File.open(filename, flag)
+      return file unless block_given?
+      yield file
+      file.close
+    end
+
+    def handle_load_error(err)
+      dep = err.message[/^no such file to load -- (.*)/, 1]
+      raise err if @options[:trace] || dep.nil? || dep.empty?
+      $stderr.puts <<MESSAGE
+Required dependency #{dep} not found!
+    Run "gem install #{dep}" to get it.
+  Use --trace for backtrace.
+MESSAGE
+      exit 1
+    end
+  end
+end

data/lib/sass/exec/sass_convert.rb

@@ -0,0 +1,264 @@
+require 'optparse'
+require 'fileutils'
+
+module Sass::Exec
+  # The `sass-convert` executable.
+  class SassConvert < Base
+    # @param args [Array<String>] The command-line arguments
+    def initialize(args)
+      super
+      require 'sass'
+      @options[:for_tree] = {}
+      @options[:for_engine] = {:cache => false, :read_cache => true}
+    end
+
+    # Tells optparse how to parse the arguments.
+    #
+    # @param opts [OptionParser]
+    def set_opts(opts)
+      opts.banner = <<END
+Usage: sass-convert [options] [INPUT] [OUTPUT]
+
+Description:
+  Converts between CSS, indented syntax, and SCSS files. For example,
+  this can convert from the indented syntax to SCSS, or from CSS to
+  SCSS (adding appropriate nesting).
+END
+
+      common_options(opts)
+      style(opts)
+      input_and_output(opts)
+      miscellaneous(opts)
+    end
+
+    # Processes the options set by the command-line arguments,
+    # and runs the CSS compiler appropriately.
+    def process_result
+      require 'sass'
+
+      if @options[:recursive]
+        process_directory
+        return
+      end
+
+      super
+      input = @options[:input]
+      if File.directory?(input)
+        raise "Error: '#{input.path}' is a directory (did you mean to use --recursive?)"
+      end
+      output = @options[:output]
+      output = input if @options[:in_place]
+      process_file(input, output)
+    end
+
+    private
+
+    def common_options(opts)
+      opts.separator ''
+      opts.separator 'Common Options:'
+
+      opts.on('-F', '--from FORMAT',
+        'The format to convert from. Can be css, scss, sass.',
+        'By default, this is inferred from the input filename.',
+        'If there is none, defaults to css.') do |name|
+        @options[:from] = name.downcase.to_sym
+        raise "sass-convert no longer supports LessCSS." if @options[:from] == :less
+        unless [:css, :scss, :sass].include?(@options[:from])
+          raise "Unknown format for sass-convert --from: #{name}"
+        end
+      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
+        unless [:scss, :sass].include?(@options[:to])
+          raise "Unknown format for sass-convert --to: #{name}"
+        end
+      end
+
+      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('-R', '--recursive',
+          'Convert all the files in a directory. Requires --from and --to.') do
+        @options[:recursive] = true
+      end
+
+      opts.on("-?", "-h", "--help", "Show this help message.") do
+        puts opts
+        exit
+      end
+
+      opts.on("-v", "--version", "Print the Sass version.") do
+        puts("Sass #{Sass.version[:string]}")
+        exit
+      end
+    end
+
+    def style(opts)
+      opts.separator ''
+      opts.separator 'Style:'
+
+      opts.on('--dasherize', 'Convert underscores to dashes.') do
+        @options[:for_tree][:dasherize] = true
+      end
+
+      opts.on('--indent NUM',
+        'How many spaces to use for each level of indentation. Defaults to 2.',
+        '"t" means use hard tabs.') do |indent|
+
+        if indent == 't'
+          @options[:for_tree][:indent] = "\t"
+        else
+          @options[:for_tree][:indent] = " " * indent.to_i
+        end
+      end
+
+      opts.on('--old', 'Output the old-style ":prop val" property syntax.',
+                       'Only meaningful when generating Sass.') do
+        @options[:for_tree][:old] = true
+      end
+    end
+
+    def input_and_output(opts)
+      opts.separator ''
+      opts.separator 'Input and Output:'
+
+      opts.on('-s', '--stdin', :NONE,
+              'Read input from standard input instead of an input file.',
+              'This is the default if no input file is specified. Requires --from.') do
+        @options[:input] = $stdin
+      end
+
+      encoding_option(opts)
+
+      opts.on('--unix-newlines', 'Use Unix-style newlines in written files.',
+                                 ('Always true on Unix.' unless Sass::Util.windows?)) do
+        @options[:unix_newlines] = true if Sass::Util.windows?
+      end
+    end
+
+    def miscellaneous(opts)
+      opts.separator ''
+      opts.separator 'Miscellaneous:'
+
+        opts.on('--cache-location PATH',
+                'The path to save parsed Sass files. Defaults to .sass-cache.') do |loc|
+          @options[:for_engine][:cache_location] = loc
+        end
+
+      opts.on('-C', '--no-cache', "Don't cache to sassc files.") do
+        @options[:for_engine][:read_cache] = false
+      end
+
+      opts.on('--trace', :NONE, 'Show a full Ruby stack trace on error') do
+        @options[:trace] = true
+      end
+    end
+
+    def process_directory
+      unless (input = @options[:input] = @args.shift)
+        raise "Error: directory required when using --recursive."
+      end
+
+      output = @options[:output] = @args.shift
+      raise "Error: --from required when using --recursive." unless @options[:from]
+      raise "Error: --to required when using --recursive." unless @options[:to]
+      unless File.directory?(@options[:input])
+        raise "Error: '#{@options[:input]}' is not a directory"
+      end
+      if @options[:output] && File.exist?(@options[:output]) &&
+        !File.directory?(@options[:output])
+        raise "Error: '#{@options[:output]}' is not a directory"
+      end
+      @options[:output] ||= @options[:input]
+
+      if @options[:to] == @options[:from] && !@options[:in_place]
+        fmt = @options[:from]
+        raise "Error: converting from #{fmt} to #{fmt} without --in-place"
+      end
+
+      ext = @options[:from]
+      Sass::Util.glob("#{@options[:input]}/**/*.#{ext}") do |f|
+        output =
+          if @options[:in_place]
+            f
+          elsif @options[:output]
+            output_name = f.gsub(/\.(c|sa|sc|le)ss$/, ".#{@options[:to]}")
+            output_name[0...@options[:input].size] = @options[:output]
+            output_name
+          else
+            f.gsub(/\.(c|sa|sc|le)ss$/, ".#{@options[:to]}")
+          end
+
+        unless File.directory?(File.dirname(output))
+          puts_action :directory, :green, File.dirname(output)
+          FileUtils.mkdir_p(File.dirname(output))
+        end
+        puts_action :convert, :green, f
+        if File.exist?(output)
+          puts_action :overwrite, :yellow, output
+        else
+          puts_action :create, :green, output
+        end
+
+        input = open_file(f)
+        process_file(input, output)
+      end
+    end
+
+    def process_file(input, output)
+      if input.is_a?(File)
+        @options[:from] ||=
+          case input.path
+          when /\.scss$/; :scss
+          when /\.sass$/; :sass
+          when /\.less$/; raise "sass-convert no longer supports LessCSS."
+          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
+
+      @options[:from] ||= :css
+      @options[:to] ||= :sass
+      @options[:for_engine][:syntax] = @options[:from]
+
+      out =
+        Sass::Util.silence_sass_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::Engine.for_file(input.path, @options[:for_engine])
+            else
+              Sass::Engine.new(input.read, @options[:for_engine])
+            end.to_tree.send("to_#{@options[:to]}", @options[:for_tree])
+          end
+        end
+
+      output = input.path if @options[:in_place]
+      write_output(out, output)
+    rescue Sass::SyntaxError => e
+      raise e if @options[:trace]
+      file = " of #{e.sass_filename}" if e.sass_filename
+      raise "Error on line #{e.sass_line}#{file}: #{e.message}\n  Use --trace for backtrace"
+    rescue LoadError => err
+      handle_load_error(err)
+    end
+  end
+end