Class: Haml::Exec::SassConvert

Inherits:

Generic

Object
Generic
Haml::Exec::SassConvert

show all

Defined in:: lib/haml/exec.rb

Overview

The sass-convert executable.

Instance Method Summary collapse

#initialize(args) ⇒ SassConvert constructor
A new instance of SassConvert.
#process_directory
#process_file(input, output)
#process_result
Processes the options set by the command-line arguments, and runs the CSS compiler appropriately.
#set_opts(opts)
Tells optparse how to parse the arguments.

Methods inherited from Generic

#color, #get_line, #parse!, #puts_action, #to_s

Constructor Details

#initialize(args) ⇒ `SassConvert`

Returns a new instance of SassConvert.

Parameters:

args (Array<String>) —
The command-line arguments

# File 'lib/haml/exec.rb', line 557

def initialize(args)
  super
  @options[:for_tree] = {}
  @options[:for_engine] = {}
end

Instance Method Details

#process_directory

# File 'lib/haml/exec.rb', line 638

def process_directory
  input = @options[:input] = @args.shift
  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]
  raise "Error: '#{@options[:input]}' is not a directory" unless File.directory?(@options[:input])
  if @options[:output] && File.exists?(@options[:output]) && !File.directory?(@options[:output])
    raise "Error: '#{@options[:output]}' is not a directory"
  end
  @options[:output] ||= @options[:input]

  ext = @options[:from]
  ext = :sass if ext == :sass2
  Dir.glob("#{@options[:input]}/**/*.#{ext}") do |f|
    output =
      if @options[:in_place]
        f
      elsif @options[:output]
        output_name = f.gsub(/\.(c|sa|sc)ss$/, ".#{@options[:to]}")
        output_name[0...@options[:input].size] = @options[:output]
        output_name
      else
        f.gsub(/\.(c|sa|sc)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.exists?(output)
      puts_action :overwrite, :yellow, output
    else
      puts_action :create, :green, output
    end

    input = open_file(f)
    output = @options[:in_place] ? input : open_file(output, "w")
    process_file(input, output)
  end
end

#process_file(input, output)

# File 'lib/haml/exec.rb', line 680

def process_file(input, output)
  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 = 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"
end

#process_result

Processes the options set by the command-line arguments, and runs the CSS compiler appropriately.

# File 'lib/haml/exec.rb', line 622

def process_result
  require 'sass'

  if @options[:recursive]
    process_directory
    return
  end

  super
  input = @options[:input]
  raise "Error: '#{input}' is a directory (did you mean to use --recursive?)" if File.directory?(input)
  output = @options[:output]
  output = input if @options[:in_place]
  process_file(input, output)
end

#set_opts(opts)

Tells optparse how to parse the arguments.