css_validator 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c88186e16bb12ede012f688d59039d59db05c6d8
-  data.tar.gz: bb0e22aa6502c3215c613fb1e2a6894e634ca884
+  metadata.gz: 83e10ea1409d636a1382fc3ed6f0cefc2a3ca0f9
+  data.tar.gz: 55e55e35822eee80c90bbc7f977dab219fac6b4e
 SHA512:
-  metadata.gz: 4fe2a790534678405e67758bfa2ece9766daea3287b4dc7963499ab8151c4f74edd8155d73a9350fc2672631d07bd8a73aa551c2aa216e4c7fb8a517ae6516dd
-  data.tar.gz: e90a399cb3016be36165b3da679a170776ce1207a6574eb0e92cf46b698980e681c52ecbcefecb65d8cdd6ebf39b16ac8c9d92e8e1414f71cf881c4f5f43f412
+  metadata.gz: 5d06e5642343d23de0da4f18eb6c24df55c2339f7ffe7ca11c16affb9104233ed59a0510c3d5fd176e380bcb814db3c5bd7e615515051b2422599c181f679489
+  data.tar.gz: f5b3323fcde00f4aa0e63c3a2f9dcf1bd2336a431568be064c4e8c130cecb0262051ff606325ffc35d183e0b487f06a7262aed90acee07e422e59f17be70f1ec

data/.gitignore

@@ -5,4 +5,5 @@ Gemfile.lock
 pkg/*
 
 Vagrantfile
-.vagrant
+.vagrant
+.DS_Store

data/README.md

@@ -1,7 +1,7 @@
 # CSS Validator
 
-This uses the `csslint.js` with `js.jar` from [CSSLint](https://github.com/CSSLint/csslint) to validate CSS in ActiveModel.
-So, your system requires `java` to use this gem.  And, it also works fine on Heroku.
+This uses the `csslint-node.js` from [CSSLint](https://github.com/CSSLint/csslint) to validate CSS in ActiveModel.
+So, your system requires `node.js` to use this gem.  It should work fine on Heroku.
 
 ## Usage
 

data/benchmark.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path('../lib',__FILE__)
+require 'css_validator'
+require 'active_model'
+require 'benchmark'
+
+class WebPage
+  include ActiveModel::Validations
+  attr_accessor :css
+
+  validates :css, presence: true, css: true
+end
+
+p = WebPage.new
+p.css = <<-eos
+  #valid {
+    margin: 10px;
+  }
+eos
+
+n = 10
+Benchmark.bm do |x|
+  x.report do
+    n.times do
+      p.valid? # => true
+    end
+  end
+end

data/css_validator.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = "css_validator"
-  s.version       = "2.0.0"
+  s.version       = "3.0.0"
   s.authors       = ["Teng Siong Ong"]
   s.email         = ["siong1987@gmail.com"]
   s.homepage      = "https://github.com/siong1987/css_validator"

data/lib/css_validator.rb

@@ -6,8 +6,8 @@ class CssValidator < ActiveModel::EachValidator
   VENDOR_DIR = File.join(File.expand_path('../..', __FILE__), 'vendor')
 
   def validate_each(record, attribute, value)
-    java_path = `which java`.rstrip
-    raise 'You do not have a Java installed, but it is required.' unless java_path && !java_path.empty?
+    node_path = `which node`.rstrip
+    raise 'You do not have a Node.js installed, but it is required.' unless node_path && !node_path.empty?
 
     return if options[:allow_nil] && value.nil?
     return if options[:allow_blank] && value.blank?
@@ -16,7 +16,7 @@ class CssValidator < ActiveModel::EachValidator
     css_file.write(value)
     css_file.close
 
-    cmd = "#{java_path} -jar #{VENDOR_DIR}/js.jar #{VENDOR_DIR}/csslint-rhino.js --quiet #{css_file.path}"
+    cmd = "#{node_path} #{VENDOR_DIR}/cli.js #{css_file.path}"
     Open3.popen3(cmd) do |stdin, stdout, stderr|
       result = stdout.read
       if result =~ /error/

data/vendor/cli.js

@@ -0,0 +1,441 @@
+#!/usr/bin/env node
+/*!
+CSSLint
+Copyright (c) 2013 Nicole Sullivan and Nicholas C. Zakas. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+/* Build: v0.10.0 15-August-2013 01:07:22 *//*
+ * Encapsulates all of the CLI functionality. The api argument simply
+ * provides environment-specific functionality.
+ */
+/*global CSSLint*/
+function cli(api){
+
+    var globalOptions = {
+        "help"        : { "format" : "",                       "description" : "Displays this information."},
+        "format"      : { "format" : "<format>",               "description" : "Indicate which format to use for output."},
+        "list-rules"  : { "format" : "",                       "description" : "Outputs all of the rules available."},
+        "quiet"       : { "format" : "",                       "description" : "Only output when errors are present."},
+        "errors"      : { "format" : "<rule[,rule]+>",         "description" : "Indicate which rules to include as errors."},
+        "warnings"    : { "format" : "<rule[,rule]+>",         "description" : "Indicate which rules to include as warnings."},
+        "ignore"      : { "format" : "<rule[,rule]+>",         "description" : "Indicate which rules to ignore completely."},
+        "exclude-list": { "format" : "<file|dir[,file|dir]+>", "description" : "Indicate which files/directories to exclude from being linted."},
+        "version"     : { "format" : "",                       "description" : "Outputs the current version number."}
+    };
+
+    //-------------------------------------------------------------------------
+    // Helper functions
+    //-------------------------------------------------------------------------
+
+    /**
+     * Returns an array of messages for a particular type.
+     * @param messages {Array} Array of CSS Lint messages.
+     * @param type {String} The type of message to filter on.
+     * @return {Array} An array of matching messages.
+     */
+    function pluckByType(messages, type){
+        return messages.filter(function(message) {
+            return message.type === type;
+        });
+    }
+
+    /**
+     * Returns a ruleset object based on the CLI options.
+     * @param options {Object} The CLI options.
+     * @return {Object} A ruleset object.
+     */
+    function gatherRules(options, ruleset){
+        var warnings = options.rules || options.warnings,
+            errors = options.errors;
+
+        if (warnings){
+            ruleset = ruleset || {};
+            warnings.split(",").forEach(function(value){
+                ruleset[value] = 1;
+            });
+        }
+
+        if (errors){
+            ruleset = ruleset || {};
+            errors.split(",").forEach(function(value){
+                ruleset[value] = 2;
+            });
+        }
+
+        return ruleset;
+    }
+
+    /**
+     * Filters out rules using the ignore command line option.
+     * @param options {Object} the CLI options
+     * @return {Object} A ruleset object.
+     */
+    function filterRules(options) {
+        var ignore = options.ignore,
+            ruleset = null;
+
+        if (ignore) {
+            ruleset = CSSLint.getRuleset();
+            ignore.split(",").forEach(function(value){
+                ruleset[value] = 0;
+            });
+        }
+
+        return ruleset;
+    }
+
+
+    /**
+     * Filters out files using the exclude-list command line option.
+     * @param files   {Array}  the list of files to check for exclusions
+     * @param options {Object} the CLI options
+     * @return {Array} A list of files
+     */
+    function filterFiles(files, options) {
+        var excludeList = options["exclude-list"],
+            excludeFiles = [],
+            filesToLint = files.map(api.getFullPath),
+            fullPath;
+
+
+        if (excludeList) {
+            // Build up the exclude list, expanding any directory exclusions that were passed in
+            excludeList.split(",").forEach(function(value){
+                if (api.isDirectory(value)) {
+                    excludeFiles = excludeFiles.concat(api.getFiles(value));
+                } else {
+                    excludeFiles.push(value);
+                }
+            });
+
+            // Remove the excluded files from the list of files to lint
+            excludeFiles.forEach(function(value){
+                fullPath = api.getFullPath(value);
+                if (filesToLint.indexOf(fullPath) > -1) {
+                    filesToLint.splice(filesToLint.indexOf(fullPath),1);
+                }
+            });
+        }
+
+        return filesToLint;
+    }
+
+    /**
+     * Outputs all available rules to the CLI.
+     * @return {void}
+     */
+    function printRules(){
+        api.print("");
+        var rules = CSSLint.getRules();
+        rules.forEach(function(rule){
+            api.print(rule.id + "\n  " + rule.desc + "\n");
+        });
+    }
+
+    /**
+     * Given a file name and options, run verification and print formatted output.
+     * @param {String} relativeFilePath absolute file location
+     * @param {Object} options for processing
+     * @return {Number} exit code
+     */
+    function processFile(relativeFilePath, options) {
+        var input = api.readFile(relativeFilePath),
+            ruleset = filterRules(options),
+            result = CSSLint.verify(input, gatherRules(options, ruleset)),
+            formatter = CSSLint.getFormatter(options.format || "text"),
+            messages = result.messages || [],
+            output,
+            exitCode = 0;
+
+        if (!input) {
+            if (formatter.readError) {
+                api.print(formatter.readError(relativeFilePath, "Could not read file data. Is the file empty?"));
+            } else {
+                api.print("csslint: Could not read file data in " + relativeFilePath + ". Is the file empty?");
+            }
+            exitCode = 1;
+        } else {
+            //var relativeFilePath = getRelativePath(api.getWorkingDirectory(), fullFilePath);
+            options.fullPath = api.getFullPath(relativeFilePath);
+            output = formatter.formatResults(result, relativeFilePath, options);
+            if (output){
+                api.print(output);
+            }
+
+            if (messages.length > 0 && pluckByType(messages, "error").length > 0) {
+                exitCode = 1;
+            }
+        }
+
+        return exitCode;
+    }
+
+
+    /**
+     * Outputs the help screen to the CLI.
+     * @return {void}
+     */
+    function outputHelp(){
+        var lenToPad = 40,
+            toPrint = '',
+            formatString = '';
+
+        api.print([
+            "\nUsage: csslint-rhino.js [options]* [file|dir]*",
+            " ",
+            "Global Options"
+        ].join("\n"));
+
+        for (var optionName in globalOptions) {
+            if (globalOptions.hasOwnProperty(optionName)) {
+                // Print the option name and the format if present
+                toPrint += "  --" + optionName;
+                if (globalOptions[optionName].format !== "") {
+                    formatString = '=' + globalOptions[optionName].format;
+                    toPrint += formatString;
+                } else {
+                    formatString = '';
+                }
+
+                // Pad out with the appropriate number of spaces
+                toPrint += new Array(lenToPad - (optionName.length + formatString.length)).join(' ');
+
+                // Print the description
+                toPrint += globalOptions[optionName].description + "\n";
+            }
+        }
+        api.print(toPrint);
+    }
+
+    /**
+     * Given an Array of filenames, print wrapping output and process them.
+     * @param files {Array} filenames list
+     * @param options {Object} options object
+     * @return {Number} exit code
+     */
+    function processFiles(fileArray, options){
+        var exitCode = 0,
+            formatId = options.format || "text",
+            formatter,
+            files = filterFiles(fileArray,options),
+            output;
+
+        if (!files.length) {
+            api.print("csslint: No files specified.");
+            exitCode = 1;
+        } else {
+            if (!CSSLint.hasFormat(formatId)){
+                api.print("csslint: Unknown format '" + formatId + "'. Cannot proceed.");
+                exitCode = 1;
+            } else {
+                formatter = CSSLint.getFormatter(formatId);
+
+                output = formatter.startFormat();
+                if (output){
+                    api.print(output);
+                }
+
+
+                files.forEach(function(file){
+                    if (exitCode === 0) {
+                        exitCode = processFile(file,options);
+                    } else {
+                        processFile(file,options);
+                    }
+                });
+
+                output = formatter.endFormat();
+                if (output){
+                    api.print(output);
+                }
+            }
+        }
+        return exitCode;
+    }
+
+
+    function processArguments(args, options) {
+        var arg = args.shift(),
+            argName,
+            parts,
+            files = [];
+
+        while(arg){
+            if (arg.indexOf("--") === 0){
+                argName = arg.substring(2);
+
+                if (argName.indexOf("=") > -1){
+                    parts = argName.split("=");
+                    options[parts[0]] = parts[1];
+                } else {
+                    options[argName] = true;
+                }
+
+            } else {
+
+                //see if it's a directory or a file
+                if (api.isDirectory(arg)){
+                    files = files.concat(api.getFiles(arg));
+                } else {
+                    files.push(arg);
+                }
+            }
+            arg = args.shift();
+        }
+
+        options.files = files;
+        return options;
+    }
+
+    function validateOptions(options) {
+        for (var option_key in options) {
+            if (!globalOptions.hasOwnProperty(option_key) && option_key !== 'files') {
+                api.print(option_key + ' is not a valid option. Exiting...');
+                outputHelp();
+                api.quit(0);
+            }
+        }
+    }
+
+    function readConfigFile(options) {
+        var data = api.readFile(api.getFullPath(".csslintrc"));
+        if (data) {
+            options = processArguments(data.split(/[\s\n\r]+/m), options);
+        }
+
+        return options;
+    }
+
+
+
+    //-----------------------------------------------------------------------------
+    // Process command line
+    //-----------------------------------------------------------------------------
+
+    var args     = api.args,
+        argCount = args.length,
+        options  = {};
+
+    // first look for config file .csslintrc
+    options = readConfigFile(options);
+
+    // Command line arguments override config file
+    options = processArguments(args, options);
+
+    if (options.help || argCount === 0){
+        outputHelp();
+        api.quit(0);
+    }
+
+    // Validate options
+    validateOptions(options);
+
+    if (options.version){
+        api.print("v" + CSSLint.version);
+        api.quit(0);
+    }
+
+    if (options["list-rules"]){
+        printRules();
+        api.quit(0);
+    }
+
+    api.quit(processFiles(options.files,options));
+}
+
+/*
+ * CSSLint Node.js Command Line Interface
+ */
+
+/*jshint node:true*/
+/*global cli*/
+
+var fs      = require("fs"),
+    path    = require("path"),
+    CSSLint = require("./lib/csslint-node").CSSLint;
+    
+cli({
+    args: process.argv.slice(2),
+
+    print: function(message){
+        fs.writeSync(1, message + "\n");
+    },
+    
+    quit: function(code){
+        process.exit(code || 0);
+    },
+    
+    isDirectory: function(name){
+        try {
+            return fs.statSync(name).isDirectory();
+        } catch (ex) {
+            return false;
+        }
+    },
+
+    getFiles: function(dir){
+        var files = [];
+
+        try {
+            fs.statSync(dir);
+        } catch (ex){
+            return [];
+        }
+
+        function traverse(dir, stack){
+            stack.push(dir);
+            fs.readdirSync(stack.join("/")).forEach(function(file){
+                var path = stack.concat([file]).join("/"),
+                    stat = fs.statSync(path);
+                
+                if (file[0] == ".") {
+                    return;
+                } else if (stat.isFile() && /\.css$/.test(file)){
+                    files.push(path);
+                } else if (stat.isDirectory()){
+                    traverse(file, stack);
+                }
+            });
+            stack.pop();
+        }
+
+        traverse(dir, []);
+
+        return files;
+    },    
+
+    getWorkingDirectory: function() {
+        return process.cwd();
+    },
+    
+    getFullPath: function(filename){
+        return path.resolve(process.cwd(), filename);
+    },
+
+    readFile: function(filename){
+        try {
+            return fs.readFileSync(filename, "utf-8");    
+        } catch (ex) {
+            return "";
+        }
+    }
+});
+