brakeman 3.2.1 → 3.3.0

data/bundle/ruby/2.3.0/gems/sass-3.4.22/lib/sass/exec/sass_convert.rb

@@ -0,0 +1,283 @@
+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('-q', '--quiet', 'Silence warnings and status messages during conversion.') do |bool|
+        @options[:for_engine][:quiet] = bool
+      end
+
+      opts.on('--trace', :NONE, 'Show a full Ruby stack trace on error') do
+        @options[:trace] = true
+      end
+    end
+
+    def process_directory
+      @options[:input] = @args.shift
+      unless @options[:input]
+        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
+
+        process_file(f, output)
+      end
+    end
+
+    def process_file(input, output)
+      input_path, output_path = path_for(input), path_for(output)
+      if input_path
+        @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_path
+        @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(read(input), @options[:for_tree]).render(@options[:to])
+          else
+            if input_path
+              Sass::Engine.for_file(input_path, @options[:for_engine])
+            else
+              Sass::Engine.new(read(input), @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
+
+    def path_for(file)
+      return file.path if file.is_a?(File)
+      return file if file.is_a?(String)
+    end
+
+    def read(file)
+      if file.respond_to?(:read)
+        file.read
+      else
+        open(file, 'rb') {|f| f.read}
+      end
+    end
+  end
+end

data/bundle/ruby/2.3.0/gems/sass-3.4.22/lib/sass/exec/sass_scss.rb

@@ -0,0 +1,440 @@
+module Sass::Exec
+  # The `sass` and `scss` executables.
+  class SassScss < Base
+    attr_reader :default_syntax
+
+    # @param args [Array<String>] The command-line arguments
+    def initialize(args, default_syntax)
+      super(args)
+      @options[:sourcemap] = :auto
+      @options[:for_engine] = {
+        :load_paths => default_sass_path
+      }
+      @default_syntax = default_syntax
+    end
+
+    protected
+
+    # Tells optparse how to parse the arguments.
+    #
+    # @param opts [OptionParser]
+    def set_opts(opts)
+      opts.banner = <<END
+Usage: #{default_syntax} [options] [INPUT] [OUTPUT]
+
+Description:
+  Converts SCSS or Sass files to CSS.
+END
+
+      common_options(opts)
+      watching_and_updating(opts)
+      input_and_output(opts)
+      miscellaneous(opts)
+    end
+
+    # Processes the options set by the command-line arguments,
+    # and runs the Sass compiler appropriately.
+    def process_result
+      require 'sass'
+
+      if !@options[:update] && !@options[:watch] &&
+          @args.first && colon_path?(@args.first)
+        if @args.size == 1
+          @args = split_colon_path(@args.first)
+        else
+          @fake_update = true
+          @options[:update] = true
+        end
+      end
+      load_compass if @options[:compass]
+      return interactive if @options[:interactive]
+      return watch_or_update if @options[:watch] || @options[:update]
+      super
+
+      if @options[:sourcemap] != :none && @options[:output_filename]
+        @options[:sourcemap_filename] = Sass::Util.sourcemap_name(@options[:output_filename])
+      end
+
+      @options[:for_engine][:filename] = @options[:filename]
+      @options[:for_engine][:css_filename] = @options[:output] if @options[:output].is_a?(String)
+      @options[:for_engine][:sourcemap_filename] = @options[:sourcemap_filename]
+      @options[:for_engine][:sourcemap] = @options[:sourcemap]
+
+      run
+    end
+
+    private
+
+    def common_options(opts)
+      opts.separator ''
+      opts.separator 'Common Options:'
+
+      opts.on('-I', '--load-path PATH', 'Specify a Sass import path.') do |path|
+        (@options[:for_engine][:load_paths] ||= []) << path
+      end
+
+      opts.on('-r', '--require LIB', 'Require a Ruby library before running Sass.') do |lib|
+        require lib
+      end
+
+      opts.on('--compass', 'Make Compass imports available and load project configuration.') do
+        @options[:compass] = true
+      end
+
+      opts.on('-t', '--style NAME', 'Output style. Can be nested (default), compact, ' \
+                                    'compressed, or expanded.') do |name|
+        @options[:for_engine][:style] = name.to_sym
+      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 watching_and_updating(opts)
+      opts.separator ''
+      opts.separator 'Watching and Updating:'
+
+      opts.on('--watch', 'Watch files or directories for changes.',
+                         'The location of the generated CSS can be set using a colon:',
+                         "  #{@default_syntax} --watch input.#{@default_syntax}:output.css",
+                         "  #{@default_syntax} --watch input-dir:output-dir") do
+        @options[:watch] = true
+      end
+
+      # Polling is used by default on Windows.
+      unless Sass::Util.windows?
+        opts.on('--poll', 'Check for file changes manually, rather than relying on the OS.',
+                          'Only meaningful for --watch.') do
+          @options[:poll] = true
+        end
+      end
+
+      opts.on('--update', 'Compile files or directories to CSS.',
+                          'Locations are set like --watch.') do
+        @options[:update] = true
+      end
+
+      opts.on('-f', '--force', 'Recompile every Sass file, even if the CSS file is newer.',
+                               'Only meaningful for --update.') do
+        @options[:force] = true
+      end
+
+      opts.on('--stop-on-error', 'If a file fails to compile, exit immediately.',
+                                 'Only meaningful for --watch and --update.') do
+        @options[:stop_on_error] = true
+      end
+    end
+
+    def input_and_output(opts)
+      opts.separator ''
+      opts.separator 'Input and Output:'
+
+      if @default_syntax == :sass
+        opts.on('--scss',
+                'Use the CSS-superset SCSS syntax.') do
+          @options[:for_engine][:syntax] = :scss
+        end
+      else
+        opts.on('--sass',
+                'Use the indented Sass syntax.') do
+          @options[:for_engine][:syntax] = :sass
+        end
+      end
+
+      # This is optional for backwards-compatibility with Sass 3.3, which didn't
+      # enable sourcemaps by default and instead used "--sourcemap" to do so.
+      opts.on(:OPTIONAL, '--sourcemap=TYPE',
+          'How to link generated output to the source files.',
+          '  auto (default): relative paths where possible, file URIs elsewhere',
+          '  file: always absolute file URIs',
+          '  inline: include the source text in the sourcemap',
+          '  none: no sourcemaps') do |type|
+        if type && !%w(auto file inline none).include?(type)
+          $stderr.puts "Unknown sourcemap type #{type}.\n\n"
+          $stderr.puts opts
+          exit
+        elsif type.nil?
+          Sass::Util.sass_warn <<MESSAGE.rstrip
+DEPRECATION WARNING: Passing --sourcemap without a value is deprecated.
+Sourcemaps are now generated by default, so this flag has no effect.
+MESSAGE
+        end
+
+        @options[:sourcemap] = (type || :auto).to_sym
+      end
+
+      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.') 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
+
+      opts.on('-g', '--debug-info',
+              'Emit output that can be used by the FireSass Firebug plugin.') do
+        @options[:for_engine][:debug_info] = true
+      end
+
+      opts.on('-l', '--line-numbers', '--line-comments',
+              'Emit comments in the generated CSS indicating the corresponding source line.') do
+        @options[:for_engine][:line_numbers] = true
+      end
+    end
+
+    def miscellaneous(opts)
+      opts.separator ''
+      opts.separator 'Miscellaneous:'
+
+      opts.on('-i', '--interactive',
+              'Run an interactive SassScript shell.') do
+        @options[:interactive] = true
+      end
+
+      opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
+        require 'stringio'
+        @options[:check_syntax] = true
+        @options[:output] = StringIO.new
+      end
+
+      opts.on('--precision NUMBER_OF_DIGITS', Integer,
+              "How many digits of precision to use when outputting decimal numbers.",
+              "Defaults to #{Sass::Script::Value::Number.precision}.") do |precision|
+        Sass::Script::Value::Number.precision = precision
+      end
+
+      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 parsed Sass files.") do
+        @options[:for_engine][:cache] = false
+      end
+
+      opts.on('--trace', :NONE, 'Show a full Ruby stack trace on error.') do
+        @options[:trace] = true
+      end
+
+      opts.on('-q', '--quiet', 'Silence warnings and status messages during compilation.') do
+        @options[:for_engine][:quiet] = true
+      end
+    end
+
+    def load_compass
+      begin
+        require 'compass'
+      rescue LoadError
+        require 'rubygems'
+        begin
+          require 'compass'
+        rescue LoadError
+          puts "ERROR: Cannot load compass."
+          exit 1
+        end
+      end
+      Compass.add_project_configuration
+      Compass.configuration.project_path ||= Dir.pwd
+      @options[:for_engine][:load_paths] ||= []
+      @options[:for_engine][:load_paths] += Compass.configuration.sass_load_paths
+    end
+
+    def interactive
+      require 'sass/repl'
+      Sass::Repl.new(@options).run
+    end
+
+    # @comment
+    #   rubocop:disable MethodLength
+    def watch_or_update
+      require 'sass/plugin'
+      Sass::Plugin.options.merge! @options[:for_engine]
+      Sass::Plugin.options[:unix_newlines] = @options[:unix_newlines]
+      Sass::Plugin.options[:poll] = @options[:poll]
+      Sass::Plugin.options[:sourcemap] = @options[:sourcemap]
+
+      if @options[:force]
+        raise "The --force flag may only be used with --update." unless @options[:update]
+        Sass::Plugin.options[:always_update] = true
+      end
+
+      raise <<MSG if @args.empty?
+What files should I watch? Did you mean something like:
+    #{@default_syntax} --watch input.#{@default_syntax}:output.css
+    #{@default_syntax} --watch input-dir:output-dir
+MSG
+
+      if !colon_path?(@args[0]) && probably_dest_dir?(@args[1])
+        flag = @options[:update] ? "--update" : "--watch"
+        err =
+          if !File.exist?(@args[1])
+            "doesn't exist"
+          elsif @args[1] =~ /\.css$/
+            "is a CSS file"
+          end
+        raise <<MSG if err
+File #{@args[1]} #{err}.
+    Did you mean: #{@default_syntax} #{flag} #{@args[0]}:#{@args[1]}
+MSG
+      end
+
+      dirs, files = @args.map {|name| split_colon_path(name)}.
+        partition {|i, _| File.directory? i}
+
+      if @fake_update && !dirs.empty?
+        # Issue 1602.
+        Sass::Util.sass_warn <<WARNING.strip
+DEPRECATION WARNING: Compiling directories without --update or --watch is
+deprecated and won't work in future versions of Sass. Instead use:
+  #{@default_syntax} --update #{@args}
+WARNING
+      end
+
+      files.map! do |from, to|
+        to ||= from.gsub(/\.[^.]*?$/, '.css')
+        sourcemap = Sass::Util.sourcemap_name(to) if @options[:sourcemap]
+        [from, to, sourcemap]
+      end
+      dirs.map! {|from, to| [from, to || from]}
+      Sass::Plugin.options[:template_location] = dirs
+
+      Sass::Plugin.on_updated_stylesheet do |_, css, sourcemap|
+        [css, sourcemap].each do |file|
+          next unless file
+          puts_action :write, :green, file
+        end
+      end
+
+      had_error = false
+      Sass::Plugin.on_creating_directory {|dirname| puts_action :directory, :green, dirname}
+      Sass::Plugin.on_deleting_css {|filename| puts_action :delete, :yellow, filename}
+      Sass::Plugin.on_deleting_sourcemap {|filename| puts_action :delete, :yellow, filename}
+      Sass::Plugin.on_compilation_error do |error, _, _|
+        if error.is_a?(SystemCallError) && !@options[:stop_on_error]
+          had_error = true
+          puts_action :error, :red, error.message
+          STDOUT.flush
+          next
+        end
+
+        raise error unless error.is_a?(Sass::SyntaxError) && !@options[:stop_on_error]
+        had_error = true
+        puts_action :error, :red,
+          "#{error.sass_filename} (Line #{error.sass_line}: #{error.message})"
+        STDOUT.flush
+      end
+
+      if @options[:update]
+        Sass::Plugin.update_stylesheets(files)
+        exit 1 if had_error
+        return
+      end
+
+      puts ">>> Sass is watching for changes. Press Ctrl-C to stop."
+
+      Sass::Plugin.on_template_modified do |template|
+        puts ">>> Change detected to: #{template}"
+        STDOUT.flush
+      end
+      Sass::Plugin.on_template_created do |template|
+        puts ">>> New template detected: #{template}"
+        STDOUT.flush
+      end
+      Sass::Plugin.on_template_deleted do |template|
+        puts ">>> Deleted template detected: #{template}"
+        STDOUT.flush
+      end
+
+      Sass::Plugin.watch(files)
+    end
+    # @comment
+    #   rubocop:enable MethodLength
+
+    def run
+      input = @options[:input]
+      output = @options[:output]
+
+      if input == $stdin
+        # See issue 1745
+        (@options[:for_engine][:load_paths] ||= []) << ::Sass::Importers::DeprecatedPath.new(".")
+      end
+
+      @options[:for_engine][:syntax] ||= :scss if input.is_a?(File) && input.path =~ /\.scss$/
+      @options[:for_engine][:syntax] ||= @default_syntax
+      engine =
+        if input.is_a?(File) && !@options[:check_syntax]
+          Sass::Engine.for_file(input.path, @options[:for_engine])
+        else
+          # We don't need to do any special handling of @options[:check_syntax] here,
+          # because the Sass syntax checking happens alongside evaluation
+          # and evaluation doesn't actually evaluate any code anyway.
+          Sass::Engine.new(input.read, @options[:for_engine])
+        end
+
+      input.close if input.is_a?(File)
+
+      if @options[:sourcemap] != :none && @options[:sourcemap_filename]
+        relative_sourcemap_path = Sass::Util.relative_path_from(
+          @options[:sourcemap_filename], Sass::Util.pathname(@options[:output_filename]).dirname)
+        rendered, mapping = engine.render_with_sourcemap(relative_sourcemap_path.to_s)
+        write_output(rendered, output)
+        write_output(
+          mapping.to_json(
+            :type => @options[:sourcemap],
+            :css_path => @options[:output_filename],
+            :sourcemap_path => @options[:sourcemap_filename]) + "\n",
+          @options[:sourcemap_filename])
+      else
+        write_output(engine.render, output)
+      end
+    rescue Sass::SyntaxError => e
+      write_output(Sass::SyntaxError.exception_to_css(e), output) if output.is_a?(String)
+      raise e
+    ensure
+      output.close if output.is_a? File
+    end
+
+    def colon_path?(path)
+      !split_colon_path(path)[1].nil?
+    end
+
+    def split_colon_path(path)
+      one, two = path.split(':', 2)
+      if one && two && Sass::Util.windows? &&
+          one =~ /\A[A-Za-z]\Z/ && two =~ %r{\A[/\\]}
+        # If we're on Windows and we were passed a drive letter path,
+        # don't split on that colon.
+        one2, two = two.split(':', 2)
+        one = one + ':' + one2
+      end
+      return one, two
+    end
+
+    # Whether path is likely to be meant as the destination
+    # in a source:dest pair.
+    def probably_dest_dir?(path)
+      return false unless path
+      return false if colon_path?(path)
+      Sass::Util.glob(File.join(path, "*.s[ca]ss")).empty?
+    end
+
+    def default_sass_path
+      return unless ENV['SASS_PATH']
+      # The select here prevents errors when the environment's
+      # load paths specified do not exist.
+      ENV['SASS_PATH'].split(File::PATH_SEPARATOR).select {|d| File.directory?(d)}
+    end
+  end
+end