Find all CSS files or compile.

 Uses sprockets if Rails; Sass engine otherwise.
 Compass is supported
 @return [#compile_scss_rails, #compile_scss, Array] CSS files
968588
def compile_scss
        puts "\nCompiling assets for stylestats...".color(:blue)
        if is_rails?

          # Get rake tasks
          Rails.application.load_tasks unless @config.is_dev?
          compile_scss_rails
        else

          load_compass

          compile_scss
        end
      end
94333
def run_all
      Compat::UI.info 'Guard::Less: compiling all files'
      files = Dir.glob('**/*.*')
      paths = Compat.matching_files(self, files).uniq
      run(paths)
    end
144260
protected function getFiles() {
        $dir_iterator = new RecursiveDirectoryIterator($this->entryPath);
        $iterator = new RecursiveIteratorIterator($dir_iterator, RecursiveIteratorIterator::CHILD_FIRST);
        $files = new RegexIterator($iterator, '/^.+\.scss$/i');
        return $files;
    }
95490
def get_templates
      hash = []
      current_theme = Setting.get('theme_folder')

      Dir.glob("#{Rails.root}/app/views/themes/#{current_theme}/template-*.html.erb") do |my_text_file|
        opt = my_text_file.split('/').last
        opt['template-'] = ''
        opt['.html.erb'] = ''
        # strips out the template- and .html.erb extention and returns the middle as the template name for the admin
        hash << opt.titleize
      end

      hash
    end
911282
def compile
      compiled_assets = {}
      machined.sprockets.each do |sprocket|
        next unless sprocket.compile?
        sprocket.each_logical_path do |logical_path|
          url = File.join(sprocket.config.url, logical_path)
          next unless compiled_assets[url].nil? && compile?(url)

          if asset = sprocket.find_asset(logical_path)
            compiled_assets[url] = write_asset(sprocket, asset)
          end
        end
      end
      compiled_assets
    end
195121
def make_css
      template = ERB.new TEMPLATE
      result = template.result binding
      (0..3).each { result.gsub!(/\n;\n/m, ";\n") }
      @result = result.gsub /^$\n/, ''
    end
888309
function compileAllFiles (src, isDebug, options)
{
    glob(src,
        function (err, files)
        {
            if (err) throw err;

            for (var i = 0, l = files.length; i < l; i++)
            {
                // only start compilation at root files
                if (sassHelpers.isRootFile(files[i]))
                {
                    compileSingleFile(files[i], isDebug, options);
                }
            }
        }
    );
}
1026128
function getDefaultModules() {
  return {
    preLoaders: [
      {
        test: /\.(js|jsx)$/,
        include: srcPath,
        loader: 'eslint-loader'
      }
    ],
    loaders: [
      {
        test: /\.css$/,
        loader: 'style-loader!css-loader'
      },
      {
        test: /\.sass/,
        loader: 'style-loader!css-loader!sass-loader?outputStyle=expanded&indentedSyntax'
      },
      {
        test: /\.scss/,
        loader: 'style-loader!css-loader!sass-loader?outputStyle=expanded'
      },
      {
        test: /\.less/,
        loader: 'style-loader!css-loader!less-loader'
      },
      {
        test: /\.styl/,
        loader: 'style-loader!css-loader!stylus-loader'
      },
      {
        test: /\.(png|jpg|gif|woff|woff2)$/,
        loader: 'url-loader?limit=8192'
      },
      {
        test: /\.(mp4|ogg|svg)$/,
        loader: 'file-loader'
      }
    ]
  };
}
622267
def find_stylesheet!(name)
      errors = []
      @providers.each do |provider|
        begin
          return provider.find_stylesheet!(name)
        rescue CssNotFound => error
          errors << error
        end
      end
      raise ProvidersFailed.new(name, self, errors)
    end
1239028
def source_files
      return @source_files if @source_files

      old_dir = Dir.pwd
      Dir.chdir @rakefile_path
      @source_files = Rake::Path.find_files(@source_search_paths, source_file_extension).uniq.sort
      Dir.chdir old_dir
      @source_files
    end
729960
function sassWatch() {
    return gulp
    // ... and compile if necessary
    .watch(sassSrcFiles, ['sass-compile'])
    .on('change', (event) => {
        gutil.log(`File ${event.path} was ${event.type}, running tasks...`);
    });
}
901088
def cleanup(sprocket_assets = [:javascripts, :stylesheets])
      # Remove previous dist path
      FileUtils.rm_r build_path if File.exists?(build_path)
      # Clean compass project
      Compass::Exec::SubCommandUI.new(["clean", project_root]).run!
      # Don't initialize Compass assets, the config will take care of it
      sprocket_assets.each do |asset|
        FileUtils.mkdir_p File.join(build_path, asset.to_s)
      end
      if mustaches_config_file_exists?
        mustaches_yaml.each_key do |dir|
          FileUtils.mkdir_p File.join(build_path, dir.to_s)
        end
      end
    end
260940
def get_files
        return @dir.values.map do |dir|
          next get_files_recursively_from dir
        end .reject { |x| !x } .flatten
      end
509632
def find(patterns)
      if patterns.empty?
        raise SCSSLint::Exceptions::NoFilesError,
              'No files, paths, or patterns were specified'
      end

      matched_files = extract_files_from(patterns)
      if matched_files.empty?
        raise SCSSLint::Exceptions::NoFilesError,
              "No SCSS files matched by the patterns: #{patterns.join(' ')}"
      end

      matched_files.reject { |file| @config.excluded_file?(file) }
    end
896078
def all_stylesheet_paths
      all_paths = []
      all_paths += @stylesheets
      all_paths += @content_scripts.map { |cs| cs.stylesheets }.compact
      all_paths.flatten.uniq
    end
1257651
def find_file(pattern = params[:splat].first, source_path: build_path)
      finder = Compiler::FileFinders::Normal.new(source_path)
      finder.find_files(pattern).first
    end
417476
def get_theme_options

      hash = []
      Dir.glob("#{Rails.root}/app/views/themes/*/") do |themes|
        opt = themes.split('/').last
        if File.exists?("#{themes}theme.yml")
          info = YAML.load(File.read("#{themes}theme.yml"))
          hash << info if !info['name'].blank? && !info['author'].blank? && !info['foldername'].blank? && !info['view_extension'].blank?
        end
      end

      hash
    end