hypery2k/nativescript-fabric

View on GitHub
src/lib/postinstall.js

Summary

Maintainability
F
1 mo
Test Coverage

File postinstall.js has 2310 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/******/ (function(modules) { // webpackBootstrap
/******/     // The module cache
/******/     var installedModules = {};
/******/
/******/     // The require function
Severity: Major
Found in src/lib/postinstall.js - About 6 days to fix

    Function getInput has 140 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    prompt.getInput = function (prop, callback) {
      var schema = prop.schema || prop,
          propName = prop.path && prop.path.join(':') || prop,
          storedSchema = prompt.properties[propName.toLowerCase()],
          delim = prompt.delimiter,
    Severity: Major
    Found in src/lib/postinstall.js - About 5 hrs to fix

      Function validateProperty has 117 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        function validateProperty(object, value, property, schema, options, errors) {
          var format,
              valid,
              spec,
              type;
      Severity: Major
      Found in src/lib/postinstall.js - About 4 hrs to fix

        Function writeFabricServiceGradleHook has 107 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        function writeFabricServiceGradleHook(config) {
            console.log("Install Fabric-build-gradle hook.");
            try {
                if (!fs.existsSync(path.join(appRoot, "hooks"))) {
                    fs.mkdirSync(path.join(appRoot, "hooks"));
        Severity: Major
        Found in src/lib/postinstall.js - About 4 hrs to fix

          Function get has 99 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          prompt.get = function (schema, callback) {
            //
            // Transforms a full JSON-schema into an array describing path and sub-schemas.
            // Used for iteration purposes.
            //
          Severity: Major
          Found in src/lib/postinstall.js - About 3 hrs to fix

            Function zalgo has 94 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            function zalgo(text, options) {
              var soul = {
                "up" : [
                  '̍', '̎', '̄', '̅',
                  '̿', '̑', '̆', '̐',
            Severity: Major
            Found in src/lib/postinstall.js - About 3 hrs to fix

              Function read has 89 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              function read (opts, cb) {
                if (opts.num) {
                  throw new Error('read() no longer accepts a char number limit')
                }
              
              
              Severity: Major
              Found in src/lib/postinstall.js - About 3 hrs to fix

                Function iterate has 75 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  function iterate(schema, get, done) {
                    var iterator = [],
                        result = {};
                
                    if (typeof schema === 'string') {
                Severity: Major
                Found in src/lib/postinstall.js - About 3 hrs to fix

                  Function writeXcodeData has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  function writeXcodeData(config) {
                  
                      console.log("Install Fabric-build-xcode hook.");
                  
                      try {
                  Severity: Major
                  Found in src/lib/postinstall.js - About 2 hrs to fix

                    Function auto has 64 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        async.auto = function (tasks, callback) {
                            callback = callback || function () {};
                            var keys = _keys(tasks);
                            if (!keys.length) {
                                return callback(null);
                    Severity: Major
                    Found in src/lib/postinstall.js - About 2 hrs to fix

                      Function stylize has 59 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      function stylize(str, style) {
                      
                        var styles;
                      
                        if (exports.mode === 'console') {
                      Severity: Major
                      Found in src/lib/postinstall.js - About 2 hrs to fix

                        Function queue has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            async.queue = function (worker, concurrency) {
                                var workers = 0;
                                var q = {
                                    tasks: [],
                                    concurrency: concurrency,
                        Severity: Minor
                        Found in src/lib/postinstall.js - About 1 hr to fix

                          Function validateObject has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                            function validateObject(object, schema, options, errors) {
                              var props, allProps = Object.keys(object),
                                  visitedProps = [];
                          
                              // see 5.2
                          Severity: Minor
                          Found in src/lib/postinstall.js - About 1 hr to fix

                            Function heComes has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                              function heComes(text, options) {
                                var result = '', counts, l;
                                options = options || {};
                                options["up"] = options["up"] || true;
                                options["mid"] = options["mid"] || true;
                            Severity: Minor
                            Found in src/lib/postinstall.js - About 1 hr to fix

                              Function writeGradleFile has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                              function writeGradleFile() {
                                  if (!fs.existsSync(directories.android)) {
                                      fs.mkdirSync(directories.android);
                                  }
                                  try {
                              Severity: Minor
                              Found in src/lib/postinstall.js - About 1 hr to fix

                                Function forEachLimit has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                    async.forEachLimit = function (arr, limit, iterator, callback) {
                                        callback = callback || function () {};
                                        if (!arr.length || limit <= 0) {
                                            return callback();
                                        }
                                Severity: Minor
                                Found in src/lib/postinstall.js - About 1 hr to fix

                                  Function addProperties has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  prompt.addProperties = function (obj, properties, callback) {
                                    properties = properties.filter(function (prop) {
                                      return typeof obj[prop] === 'undefined';
                                    });
                                  
                                  
                                  Severity: Minor
                                  Found in src/lib/postinstall.js - About 1 hr to fix

                                    Function parallel has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                        async.parallel = function (tasks, callback) {
                                            callback = callback || function () {};
                                            if (tasks.constructor === Array) {
                                                async.map(tasks, function (fn, callback) {
                                                    if (fn) {
                                    Severity: Minor
                                    Found in src/lib/postinstall.js - About 1 hr to fix

                                      Function memoize has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                          async.memoize = function (fn, hasher) {
                                              var memo = {};
                                              var queues = {};
                                              hasher = hasher || function (x) {
                                                  return x;
                                      Severity: Minor
                                      Found in src/lib/postinstall.js - About 1 hr to fix

                                        Function series has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            async.series = function (tasks, callback) {
                                                callback = callback || function () {};
                                                if (tasks.constructor === Array) {
                                                    async.mapSeries(tasks, function (fn, callback) {
                                                        if (fn) {
                                        Severity: Minor
                                        Found in src/lib/postinstall.js - About 1 hr to fix

                                          Function assembler has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                                get(branch, function assembler(err, line) {
                                                  if (err) {
                                                    return next(err);
                                                  }
                                          
                                          
                                          Severity: Minor
                                          Found in src/lib/postinstall.js - About 1 hr to fix

                                            Function applyTheme has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                            function applyTheme(theme) {
                                            
                                              //
                                              // Remark: This is a list of methods that exist
                                              // on String that you should not overwrite.
                                            Severity: Minor
                                            Found in src/lib/postinstall.js - About 1 hr to fix

                                              Function convert has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                              function convert(schema) {
                                                var newProps = Object.keys(validate.messages),
                                                    newSchema = false,
                                                    key;
                                              
                                              
                                              Severity: Minor
                                              Found in src/lib/postinstall.js - About 1 hr to fix

                                                Function waterfall has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                    async.waterfall = function (tasks, callback) {
                                                        callback = callback || function () {};
                                                        if (!tasks.length) {
                                                            return callback();
                                                        }
                                                Severity: Minor
                                                Found in src/lib/postinstall.js - About 1 hr to fix

                                                  Avoid deeply nested control flow statements.
                                                  Open

                                                              if (err.message == 'canceled') {
                                                                wait = false;
                                                                stdout.write('\n');
                                                              }
                                                  Severity: Major
                                                  Found in src/lib/postinstall.js - About 45 mins to fix

                                                    Function _performValidation has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                    Open

                                                    prompt._performValidation = function (name, prop, against, schema, line, callback) {
                                                    Severity: Minor
                                                    Found in src/lib/postinstall.js - About 45 mins to fix

                                                      Function validateProperty has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                      Open

                                                        function validateProperty(object, value, property, schema, options, errors) {
                                                      Severity: Minor
                                                      Found in src/lib/postinstall.js - About 45 mins to fix

                                                        Avoid deeply nested control flow statements.
                                                        Open

                                                                    if (length) {
                                                                      if (tmp.length + 1 < length) {
                                                                        isValid = false;
                                                                        wait = true;
                                                                      }
                                                        Severity: Major
                                                        Found in src/lib/postinstall.js - About 45 mins to fix

                                                          Avoid deeply nested control flow statements.
                                                          Open

                                                                      if (object.hasOwnProperty(k)) {
                                                                        visitedProps.push(k);
                                                                        if (re.exec(k) !== null) {
                                                                          validateProperty(object, object[k], p, props[p], options, errors);
                                                                        }
                                                          Severity: Major
                                                          Found in src/lib/postinstall.js - About 45 mins to fix

                                                            Function error has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                            Open

                                                              function error(attribute, property, actual, schema, errors) {
                                                            Severity: Minor
                                                            Found in src/lib/postinstall.js - About 35 mins to fix

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              if (process.argv.indexOf("config") === -1 && fs.existsSync(pluginConfigPath)) {
                                                                  readConfig();
                                                                  if (config.apiKey) {
                                                                      config.api_key = config.apiKey;
                                                                      delete config.apiKey;
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 2 days to fix
                                                              publish/scripts/postinstall.js on lines 68..99

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 358.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                  async.series = function (tasks, callback) {
                                                                      callback = callback || function () {};
                                                                      if (tasks.constructor === Array) {
                                                                          async.mapSeries(tasks, function (fn, callback) {
                                                                              if (fn) {
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 day to fix
                                                              src/lib/postinstall.js on lines 1388..1418

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 287.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                  async.parallel = function (tasks, callback) {
                                                                      callback = callback || function () {};
                                                                      if (tasks.constructor === Array) {
                                                                          async.map(tasks, function (fn, callback) {
                                                                              if (fn) {
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 day to fix
                                                              src/lib/postinstall.js on lines 1420..1450

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 287.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function writeFabricServiceGradleHook(config) {
                                                                  console.log("Install Fabric-build-gradle hook.");
                                                                  try {
                                                                      if (!fs.existsSync(path.join(appRoot, "hooks"))) {
                                                                          fs.mkdirSync(path.join(appRoot, "hooks"));
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 day to fix
                                                              publish/scripts/postinstall.js on lines 365..493

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 238.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function writeXcodeData(config) {
                                                              
                                                                  console.log("Install Fabric-build-xcode hook.");
                                                              
                                                                  try {
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 day to fix
                                                              publish/scripts/postinstall.js on lines 187..269

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 230.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                } else if (exports.mode === 'browser') {
                                                                  styles = {
                                                                    //styles
                                                                    'bold'      : ['<b>',  '</b>'],
                                                                    'italic'    : ['<i>',  '</i>'],
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 day to fix
                                                              src/lib/postinstall.js on lines 1718..1788

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 208.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                if (exports.mode === 'console') {
                                                                  styles = {
                                                                    //styles
                                                                    'bold'      : ['\x1B[1m',  '\x1B[22m'],
                                                                    'italic'    : ['\x1B[3m',  '\x1B[23m'],
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 day to fix
                                                              src/lib/postinstall.js on lines 1751..1788

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 208.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function writePodFile(result) {
                                                                  if (!fs.existsSync(directories.ios)) {
                                                                      fs.mkdirSync(directories.ios);
                                                                  }
                                                                  try {
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 4 hrs to fix
                                                              publish/scripts/postinstall.js on lines 291..315

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 132.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function writeGradleFile() {
                                                                  if (!fs.existsSync(directories.android)) {
                                                                      fs.mkdirSync(directories.android);
                                                                  }
                                                                  try {
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 4 hrs to fix
                                                              publish/scripts/postinstall.js on lines 322..360

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 131.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function askAndroidPrompt() {
                                                                  prompt.get({
                                                                      name: 'using_android',
                                                                      description: 'Are you using Android (y/n)',
                                                                      default: 'y'
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 3 hrs to fix
                                                              publish/scripts/postinstall.js on lines 128..145

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 104.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function promptQuestions() {
                                                                  prompt.get([{
                                                                      name: 'api_key',
                                                                      description: 'Your Fabric API Key',
                                                                      default: ''
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 3 hrs to fix
                                                              publish/scripts/postinstall.js on lines 156..173

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 102.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function askSaveConfigPrompt() {
                                                                  prompt.get({
                                                                      name: 'save_config',
                                                                      description: 'Do you want to save the selected configuration. Reinstalling the dependency will reuse the setup from: ' + pluginConfigFile + '. CI will be easier. (y/n)',
                                                                      default: 'y'
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 2 hrs to fix
                                                              publish/scripts/postinstall.js on lines 271..284

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 92.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function askiOSPrompt() {
                                                                  prompt.get({
                                                                      name: 'using_ios',
                                                                      description: 'Are you using iOS (y/n)',
                                                                      default: 'y'
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 2 hrs to fix
                                                              publish/scripts/postinstall.js on lines 104..117

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 83.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function readConfig() {
                                                                  try {
                                                                      config = JSON.parse(fs.readFileSync(pluginConfigPath));
                                                                  } catch (e) {
                                                                      console.log("Failed reading " + pluginConfigFile);
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 2 hrs to fix
                                                              publish/scripts/postinstall.js on lines 42..50

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 79.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              Object.defineProperty(MuteStream.prototype, 'rows', {
                                                                get: function () {
                                                                  return( this._dest ? this._dest.rows
                                                                        : this._src ? this._src.rows
                                                                        : undefined )
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 2 hrs to fix
                                                              src/lib/postinstall.js on lines 2092..2097

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 77.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              Object.defineProperty(MuteStream.prototype, 'columns', {
                                                                get: function () {
                                                                  return( this._dest ? this._dest.columns
                                                                        : this._src ? this._src.columns
                                                                        : undefined )
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 2 hrs to fix
                                                              src/lib/postinstall.js on lines 2085..2090

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 77.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                  var doParallel = function (fn) {
                                                                      return function () {
                                                                          var args = Array.prototype.slice.call(arguments);
                                                                          return fn.apply(null, [async.forEach].concat(args));
                                                                      };
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 hr to fix
                                                              src/lib/postinstall.js on lines 1110..1115

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 70.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                  var doSeries = function (fn) {
                                                                      return function () {
                                                                          var args = Array.prototype.slice.call(arguments);
                                                                          return fn.apply(null, [async.forEachSeries].concat(args));
                                                                      };
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 hr to fix
                                                              src/lib/postinstall.js on lines 1104..1109

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 70.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                      }, function (err) {
                                                                          callback(_map(results.sort(function (a, b) {
                                                                              return a.index - b.index;
                                                                          }), function (x) {
                                                                              return x.value;
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 hr to fix
                                                              src/lib/postinstall.js on lines 1174..1180

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 62.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                      }, function (err) {
                                                                          callback(_map(results.sort(function (a, b) {
                                                                              return a.index - b.index;
                                                                          }), function (x) {
                                                                              return x.value;
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 hr to fix
                                                              src/lib/postinstall.js on lines 1200..1206

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 62.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function promptQuestionsResult(result) {
                                                                  if (usingiOS) {
                                                                      writePodFile(result);
                                                                      writeXcodeData(result);
                                                                  }
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 hr to fix
                                                              publish/scripts/postinstall.js on lines 175..185

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 61.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                    case 'maxi':
                                                                      counts.up = randomNumber(16) + 3;
                                                                      counts.min = randomNumber(4) + 1;
                                                                      counts.down = randomNumber(64) + 3;
                                                                      break;
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 hr to fix
                                                              src/lib/postinstall.js on lines 1976..1980

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 59.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                    default:
                                                                      counts.up = randomNumber(8) + 1;
                                                                      counts.mid = randomNumber(6) / 2;
                                                                      counts.down = randomNumber(8) + 1;
                                                                      break;
                                                              Severity: Major
                                                              Found in src/lib/postinstall.js and 1 other location - About 1 hr to fix
                                                              src/lib/postinstall.js on lines 1971..1975

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 59.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Identical blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                              function isInteractive() {
                                                                  return process.stdin && process.stdin.isTTY && process.stdout && process.stdout.isTTY;
                                                              }
                                                              Severity: Minor
                                                              Found in src/lib/postinstall.js and 1 other location - About 40 mins to fix
                                                              publish/scripts/postinstall.js on lines 52..54

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 49.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                      if ('true' === value || '1' === value || 1 === value) {
                                                                        value = true;
                                                                        object[property] = value;
                                                                      }
                                                              Severity: Minor
                                                              Found in src/lib/postinstall.js and 1 other location - About 30 mins to fix
                                                              src/lib/postinstall.js on lines 2546..2549

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 45.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              Similar blocks of code found in 2 locations. Consider refactoring.
                                                              Open

                                                                      if ('false' === value || '0' === value || 0 === value) {
                                                                        value = false;
                                                                        object[property] = value;
                                                                      }
                                                              Severity: Minor
                                                              Found in src/lib/postinstall.js and 1 other location - About 30 mins to fix
                                                              src/lib/postinstall.js on lines 2541..2544

                                                              Duplicated Code

                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                              Tuning

                                                              This issue has a mass of 45.

                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                              Refactorings

                                                              Further Reading

                                                              There are no issues that match your filters.

                                                              Category
                                                              Status