chore: some refactoriing not finished

Author: lee-chase

.DS_Store

@@ -0,0 +1,13 @@
+# editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false

.editorconfig

@@ -1 +1,5 @@
-node_modules
+node_modules
+dist
+*.log
+.coverage
+.ignore

.gitignore

@@ -0,0 +1,2 @@
+package.json
+package-lock.json

index.js .old/index.jsindex.js renamed to .old/index.js

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) 2016 Waqar Ali
+Copyright (c) 2016 Krister Kari
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

test/index.js .old/test/index.jstest/index.js renamed to .old/test/index.js

@@ -0,0 +1,133 @@
+"use strict"; // eslint-disable-line strict
+
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ *
+ */
+
+const crypto = require("crypto");
+const fs = require("fs");
+const jestPreset = require("babel-preset-jest");
+const path = require("path");
+
+const BABELRC_FILENAME = ".babelrc";
+const BABELRC_JS_FILENAME = ".babelrc.js";
+const BABEL_CONFIG_KEY = "babel";
+const PACKAGE_JSON = "package.json";
+const THIS_FILE = fs.readFileSync(__filename);
+
+let babel;
+
+const createTransformer = (options) => {
+  const cache = Object.create(null);
+
+  const getBabelRC = (filename) => {
+    const paths = [];
+    let directory = filename;
+
+    while (directory !== (directory = path.dirname(directory))) {
+      if (cache[directory]) {
+        break;
+      }
+
+      paths.push(directory);
+      const configFilePath = path.join(directory, BABELRC_FILENAME);
+
+      if (fs.existsSync(configFilePath)) {
+        cache[directory] = fs.readFileSync(configFilePath, "utf8");
+        break;
+      }
+
+      const configJsFilePath = path.join(directory, BABELRC_JS_FILENAME);
+
+      if (fs.existsSync(configJsFilePath)) {
+        // $FlowFixMe
+        cache[directory] = JSON.stringify(require(configJsFilePath));
+        break;
+      }
+
+      const packageJsonFilePath = path.join(directory, PACKAGE_JSON);
+
+      if (fs.existsSync(packageJsonFilePath)) {
+        // $FlowFixMe
+        const packageJsonFileContents = require(packageJsonFilePath);
+
+        if (packageJsonFileContents[BABEL_CONFIG_KEY]) {
+          cache[directory] = JSON.stringify(
+            packageJsonFileContents[BABEL_CONFIG_KEY]
+          );
+
+          break;
+        }
+      }
+    }
+    paths.forEach((directoryPath) => (cache[directoryPath] = cache[directory]));
+
+    return cache[directory] || "";
+  };
+
+  options = Object.assign({}, options, {
+    plugins: (options && options.plugins) || [],
+    presets: ((options && options.presets) || []).concat([jestPreset]),
+    retainLines: true,
+  });
+
+  delete options.cacheDirectory;
+  delete options.filename;
+
+  return {
+    canInstrument: true,
+    getCacheKey(fileData, filename, configString, _ref) {
+      const instrument = _ref.instrument;
+
+      return crypto
+        .createHash("md5")
+        .update(THIS_FILE)
+        .update("\0", "utf8")
+        .update(fileData)
+        .update("\0", "utf8")
+        .update(configString)
+        .update("\0", "utf8")
+        .update(getBabelRC(filename))
+        .update("\0", "utf8")
+        .update(instrument ? "instrument" : "")
+        .digest("hex");
+    },
+    process(src, filename, config, transformOptions) {
+      if (!babel) {
+        babel = require("@babel/core");
+      }
+
+      if (babel.util && !babel.util.canCompile(filename)) {
+        return src;
+      }
+
+      const theseOptions = Object.assign({ filename }, options);
+
+      if (transformOptions && transformOptions.instrument) {
+        // theseOptions.auxiliaryCommentBefore = ' istanbul ignore next ';
+        // Copied from jest-runtime transform.js
+        theseOptions.plugins = theseOptions.plugins.concat([
+          [
+            require("babel-plugin-istanbul").default,
+            {
+              // files outside `cwd` will not be instrumented
+              cwd: config.rootDir,
+              exclude: [],
+            },
+          ],
+        ]);
+      }
+
+      return babel.transform(src, theseOptions).code;
+    },
+  };
+};
+
+module.exports = createTransformer();
+module.exports.createTransformer = createTransformer;

.prettierignore

@@ -0,0 +1,163 @@
+"use strict"; // eslint-disable-line strict
+
+const _ = require("lodash");
+const stylelint = require("stylelint");
+
+global.testRule = (rule, schema) => {
+  expect.extend({
+    toHaveMessage(testCase) {
+      if (testCase.message === undefined) {
+        return {
+          message: () =>
+            'Expected "reject" test case to have a "message" property',
+          pass: false,
+        };
+      }
+
+      return {
+        pass: true,
+      };
+    },
+  });
+
+  // eslint-disable-next-line jest/valid-describe
+  describe(`${schema.ruleName}`, () => {
+    const stylelintConfig = {
+      plugins: ["./src"],
+      rules: {
+        [schema.ruleName]: schema.config,
+      },
+    };
+
+    if (schema.accept && schema.accept.length) {
+      describe("accept", () => {
+        schema.accept.forEach((testCase) => {
+          const spec = testCase.only ? it.only : it;
+
+          spec(testCase.description || "no description", () => {
+            const options = {
+              code: testCase.code,
+              config: stylelintConfig,
+              syntax: schema.syntax,
+            };
+
+            return stylelint.lint(options).then((output) => {
+              expect(output.results[0].warnings).toEqual([]);
+
+              if (!schema.fix) {
+                return;
+              }
+
+              // Check the fix
+              return stylelint
+                .lint(Object.assign({ fix: true }, options))
+                .then((output2) => {
+                  const fixedCode = getOutputCss(output2);
+
+                  expect(fixedCode).toBe(testCase.code);
+                });
+            });
+          });
+        });
+      });
+    }
+
+    if (schema.reject && schema.reject.length) {
+      describe("reject", () => {
+        schema.reject.forEach((testCase) => {
+          const spec = testCase.only ? it.only : it;
+
+          spec(testCase.description || "no description", () => {
+            const options = {
+              code: testCase.code,
+              config: stylelintConfig,
+              syntax: schema.syntax,
+            };
+
+            return stylelint.lint(options).then((output) => {
+              const warnings = output.results[0].warnings;
+              const warning = warnings[0];
+
+              expect(warnings.length).toBeGreaterThanOrEqual(1);
+              // expect(testCase).toHaveMessage();
+
+              if (testCase.message !== undefined) {
+                expect(_.get(warning, "text")).toBe(testCase.message);
+              }
+
+              if (testCase.line !== undefined) {
+                expect(_.get(warning, "line")).toBe(testCase.line);
+              }
+
+              if (testCase.column !== undefined) {
+                expect(_.get(warning, "column")).toBe(testCase.column);
+              }
+
+              if (!schema.fix) {
+                return;
+              }
+
+              if (!testCase.fixed) {
+                throw new Error(
+                  "If using { fix: true } in test schema, all reject cases must have { fixed: .. }"
+                );
+              }
+
+              // Check the fix
+              return stylelint
+                .lint(Object.assign({ fix: true }, options))
+                .then((output2) => {
+                  const fixedCode = getOutputCss(output2);
+
+                  expect(fixedCode).toBe(testCase.fixed);
+                });
+            });
+          });
+        });
+      });
+    }
+  });
+};
+
+function getOutputCss(output) {
+  const result = output.results[0]._postcssResult;
+  const css = result.root.toString(result.opts.syntax);
+
+  return css;
+}
+
+global.testConfig = (input) => {
+  let testFn;
+
+  if (input.only) {
+    testFn = test.only;
+  } else if (input.skip) {
+    testFn = test.skip;
+  } else {
+    testFn = test;
+  }
+
+  testFn(input.description, () => {
+    const config = {
+      plugins: ["./"],
+      rules: {
+        [input.ruleName]: input.config,
+      },
+    };
+
+    return stylelint
+      .lint({
+        code: "",
+        config,
+      })
+      .then((data) => {
+        const invalidOptionWarnings = data.results[0].invalidOptionWarnings;
+
+        if (input.valid) {
+          expect(invalidOptionWarnings).toHaveLength(0);
+        } else {
+          expect(invalidOptionWarnings[0].text).toBe(input.message);
+        }
+      });
+  });
+};