JavaScript gulp-sass-lint format Examples

Example #1

File: gulpfile.babel.js Project: reactsuper/webcube

gulp.task('check:scss', [], () => {
  return gulp.src([
    'app/**/*.scss',
    'staticweb/**/*.scss',
  ], { cwd: rootPath })
    .pipe(gulpif(!process.env.APP_DISABLE_SASSLINT,
      sassLint({
        configFile: path.join(rootPath, '.sass-lint.yml'),
      })
    ))
    .pipe(gulpif(!process.env.APP_DISABLE_SASSLINT,
      sassLint.format()
    ))
    .pipe(gulpif(!process.env.APP_DISABLE_SASSLINT,
      sassLint.failOnError()
    ))
    .pipe(gulpif(!process.env.APP_DISABLE_STYLELINT,
      styleLint({
        configFile: path.join(rootPath, '.stylelintrc'),
        failAfterError: true,
        reporters: [
           { formatter: 'string', console: true },
        ],
      })
    ));
});

Example #2

File: sass.js Project: P71/foundation

 .on('finish', function() {
   gulp.src(CONFIG.SASS_LINT_FILES)
     .pipe(sassLint({
         config: './.sass-lint.yml'
       }))
     .pipe(sassLint.format());
 });

Example #3

File: gulpfile.js Project: splintercode/psi-dashboard

 let tasks = CONFIGS.map(config => {
     return gulp.src(config.sass.lintSrc)
     .pipe(sassLint())
     .pipe(sassLint.format())
     .pipe(sassLint.failOnError())
     .on('error', swallowError);
 });

Example #4

File: gulpfile.js Project: thisisbliss/bliss-go

gulp.task('lint-sass', function () {
  return gulp
    .src(styleInput)
    .pipe(sassLint())
    .pipe(sassLint.format())
    .pipe(sassLint.failOnError())
})

Example #5

File: lint-css.js Project: UKTradeInvestment/govstrap

gulp.task('lint-css', () => {
  const sassLint = require('gulp-sass-lint');
  return gulp.src(`${paths.sourceStyles}/**/*.s+(a|c)ss`)
    .pipe(sassLint())
    .pipe(sassLint.format())
    .pipe(sassLint.failOnError());
});

Example #6

File: scss.js Project: arillo/gulp-plate

function scss() {
  const isProd = global.env === 'prod';
  if (isProd) {
    procesors.push(nano(config.compression));
  }

  return (
    src(config.src)
      // Linting
      .pipe(sassLint())
      .pipe(sassLint.format())
      .pipe(sassLint.failOnError())
      .on('error', handleErrors)

      // Sourcemaps if not prod
      .pipe(gulpif(!isProd, sourcemaps.init()))

      // Copilation
      .pipe(sass(config.options))
      .on('error', handleErrors)

      // Post processing
      .pipe(postcss(procesors))

      // Sourcemaps if not prod
      .pipe(gulpif(!isProd, sourcemaps.write()))

      // Dest & reloading
      .pipe(dest(config.dest))
      .pipe(gulpif(!isProd, browserSync.reload({ stream: true })))
  );
}

Example #7

File: lint-scss.js Project: WillsB3/Grow-Closure-Angular-Scaffold

 return function() {
   return gulp.src(PATHS.CSS_SOURCES)
     // .pipe(debug({'title': 'scss-lint'}))
     .pipe(sassLint())
     .pipe(sassLint.format())
     .pipe(sassLint.failOnError());
 };

Example #8

File: gulpfile.js Project: thijskok/bootstrap-solarized-theme

gulp.task('lint', function () {
    return gulp
      .src('sass/**/*.s+(a|c)ss')
      .pipe(sasslint())
      .pipe(sasslint.format())
      .pipe(sasslint.failOnError())
});

Example #9

File: Gulpfile.babel.js Project: Chronoes/ttu-webpage-prax3

gulp.task('lint:sass', function() {
  return gulp.src(directories.source.css + '/**/*.scss')
    .pipe(remember('style'))
    .pipe(sasslint())
    .pipe(sasslint.format())
    .pipe(sasslint.failOnError());
});

Example #10

File: linting.js Project: andymantell/andymantell.com

  gulp.task('sass-lint', () => {
    var sassFiles = [
      '**/*.s+(a|c)ss',
      '!' + path.join(config.sourcePath, 'scss/vendor/**'),
      '!' + path.join(config.destinationPath, '**'),
      '!node_modules/**'
    ]

    if (config.lintingPaths) {
      sassFiles = sassFiles.concat(config.lintingPaths)
    }

    return gulp.src(sassFiles)
      .pipe(sassLint({
        rules: {
          'property-sort-order': 0,
          'force-element-nesting': 0,
          'force-attribute-nesting': 0,
          'no-color-literals': 0,
          'force-pseudo-nesting': 0,
          'shorthand-values': 0,
          'mixins-before-declarations': 0,
          'no-qualifying-elements': {
            'allow-element-with-attribute': 0
          },
          'class-name-format': 0
        }
      }))
      .pipe(sassLint.format())
      .pipe(sassLint.failOnError())
  })

Example #11

File: build.js Project: rmadhuram/berea

gulp.task('sass-lint', function () {
  var sassLint = require('gulp-sass-lint');
  return gulp.src(path.join(conf.paths.src, '/app/**/*.scss'))
    .pipe(sassLint())
    .pipe(sassLint.format())
    .pipe(sassLint.failOnError())
});

Example #12

File: styles-lint.js Project: francishogue/starter

 return function () {
   gulp.src([
     `${config.paths.src.baseDir}${config.paths.src.css}**/*.scss`,
   ])
     .pipe(sassLint(config.sassLint))
     .pipe(sassLint.format());
     // .pipe(sassLint.failOnError());
 };

Example #13

File: gulp.sass.js Project: bogdandorca/angular2_gulp

 lint() {
     return GULP.src(this._input)
         // Catch all the errors so the script will not crash on error
         .pipe(PLUMBER())
         // Lint the Sass files
         .pipe(SASSLINT(SASS_CONFIG.sassLint))
         .pipe(SASSLINT.format());
 }

Example #14

File: gulpfile.js Project: unit9/gae-secure-scaffold-python

gulp.task('sass', function () {
  return gulp.src([config.paths.src + '/**/*.scss', '!' + config.paths.src + '/styles/**/_assets.scss'])
    .pipe(sassLint())
    .pipe(sassLint.format())
    .pipe(sassLint.failOnError())
    .pipe(sass())
    .pipe(gulp.dest(config.paths.dist + '/'));
});

Example #15

File: csslint.js Project: jitendrathakur/ng-pioneer

gulp.task('csslint', function() {
  return gulp.src('src/**/*.s+(a|c)ss')
    .pipe(sassLint({
      'config': 'lint.yml'
    }))
    .pipe(sassLint.format())
    .pipe(sassLint.failOnError())
});

Example #16

File: lint.js Project: Deilusia/champions

gulp.task('lint:style', () => gulp.src([
    './src/**/*.scss',
])
    .pipe(sassLint({
        'maxBuffer': 1228800,
    }))
    .pipe(sassLint.format())
    .pipe(sassLint.failOnError()));

Example #17

File: sass.js Project: cyrale/gulpfile.js

  lint(done, funcName) {
    this.lintError = false;

    return gulp
      .src(this.options.src, { cwd: this.options.cwd })
      .pipe(sassLint({ configFile: path.join(this.options.cwd, ".sass-lint.yml") }))
      .pipe(sassLint.format())
      .pipe(this.failOnError(funcName));
  }

Example #18

File: style.js Project: n-sikka/insta-map

gulp.task('check:sass', function(){
  return gulp.src(['assets/sass/**/*.scss'])
  .pipe(sassLint(
    {
      'endless' : true
    }
  ))
  .pipe(sassLint.format())
})

Example #19

File: ci.js Project: OsvaldoFernandez/witty-web

gulp.task('ci:sass', () => {
  return gulp.src(localConfig.sassFiles)
    .pipe(plumber({ errorHandler: localConfig.errorHandler }))
    .pipe(sasslint({
      config: '.sass-lint.yml'
    }))
    .pipe(sasslint.format())
    .pipe(sasslint.failOnError());
});

Example #20

File: gulpfile.js Project: rutgers/RutgersIEEE-Website

gulp.task("lint:scss", function() {
    return gulp
        .src(path.scss)
        .pipe(sassLint({
            configFile: "./config/.sass-lint.yml"
        }))
        .pipe(sassLint.format())
        .pipe(sassLint.failOnError());
});

Example #21

File: lint.js Project: 8simsim8/crisp-studio---new-version

gulp.task('lint_sass', () => {
    return gulp.src(global.paths.sass)
        .pipe(cache('lint_sass'))
        .pipe(sassLint().on('error', function(error) {
            gutil.log(error.toString());
            this.emit('end');
        }))
        .pipe(sassLint.format());
});

Example #22

File: Gulpfile.js Project: smark73/gcmaz

gulp.task('sass:lint', ['cssnano'], function() {
	gulp.src([
		'sass/**/*.scss',
		'!sass/defaults/_sprites.scss'
	])
	.pipe(sassLint())
	.pipe(sassLint.format())
	.pipe(sassLint.failOnError());
});

Example #23

File: gulpfile.js Project: ackmann-dickenson/ad-wp-starter-theme

// run SCSS lint on theme styles
function stylesLint() {
  return (
    gulp
      .src(PATHS.sass)
      .pipe(sassLint())
      .pipe(sassLint.format())
      .pipe(sassLint.failOnError())
  );
}

Example #24

File: styles.js Project: danielddb/hayley-tennis

gulp.task('styles:lint', function(cb) {
    return gulp.src([
            config.paths.styles.all,
            '!' + config.paths.styles.src + '/base/_normalize.scss'
        ])
        .pipe(sassLint())
        .pipe(sassLint.format())
        .pipe(gulpif(!config.isDev, sassLint.failOnError()))
});

Example #25

File: gulpfile.js Project: jeffeoff/frontstyle

gulp.task('lint', function () {
	return gulp.src( sassSrc )
		.pipe( sassGlob() )
		.pipe( sassLint({
				maxBuffer: 1228800,
        configFile: './.sass-lint.yml'
		}) )
		.pipe( sassLint.format() )
});

Example #26

File: gulpfile.js Project: sielay/lackey-cms

gulp.task('sass:lint', function () {
    gulp.src([
        '**/*.s+(a|c)ss',
        '!node_modules/**'
        ])
        .pipe(sassLint())
        .pipe(sassLint.format())
        .pipe(sassLint.failOnError());
});

Example #27

File: lint.js Project: P71/foundation

gulp.task('lint:sass', function() {
  return gulp.src(CONFIG.SASS_LINT_FILES)
    .pipe(plumber())
    .pipe(sassLint({
      config: './.sass-lint.yml'
    }))
    .pipe(sassLint.format())
    .pipe(sassLint.failOnError())
});

Example #28

File: gulpfile.js Project: johngruen/testpilot

gulp.task('sass-lint', function sassLintTask() {
  const files = [
    SRC_PATH + '/styles/**/*.scss',
    '!' + SRC_PATH + '/styles/_hidpi-mixin.scss'
  ];
  return gulp.src(files)
    .pipe(sassLint())
    .pipe(sassLint.format())
    .pipe(sassLint.failOnError());
});

Example #29

File: Gulpfile.js Project: cofetti/gulp_config

gulp.task('sasslint', function() {
    return gulp.src('./dev/scss/**/*.scss')
        .pipe(sasslint({
            "options": {
                "config-file": ".sass-lint.yml"
            }
        }))
        .pipe(sasslint.format())
        .pipe(sasslint.failOnError())
});

Example #30

File: gulpfile.js Project: PinpointDesigns/GulpBoilerplate

gulp.task('styles_deploy', function () {
    gulp.src('web/css/*.scss')
        .pipe(sasslint())
        .pipe(sasslint.format())
        .pipe(sasslint.failOnError())
        .pipe(plumber())
        .pipe(sass())
        .pipe(postcss(post))
        .pipe(gulp.dest('web/css'));
});