prettier javascript

Author: thet

Diff for: .gitignore

@@ -1,22 +1,19 @@
-*.log
 *.css.map
+*.log
 *.swo
 *.swp
 *~
+.DS_Store
 .bundle
 .sass-cache
-coverage/
-node_modules/
 /paternslib.sublime-project
 /paternslib.sublime-workspace
 /stamp-yarn
 Gemfile.lock
 cache/
-webpack/cache/
+coverage/
 dist/
-stats.json
-stats.html
-test-reports
+node_modules/
 src/pat/auto-scale/auto-scale.css
 src/pat/auto-submit/auto-submit.css
 src/pat/auto-suggest/auto-suggest.css
@@ -57,4 +54,7 @@ src/pat/toggle/toggle.css
 src/pat/tooltip/tooltip.css
 src/pat/validate/validate.css
 src/pat/zoom/zoom.css
-.DS_Store
+stats.html
+stats.json
+test-reports
+webpack/cache/

Diff for: .travis.yml

@@ -1,7 +1,7 @@
 dist: xenial
 language: node_js
 node_js:
-- lts/*
+    - lts/*
 before_script: travis_retry make stamp-yarn
 script: make check
 sudo: required

Diff for: src/core/base.js

@@ -1,27 +1,26 @@
 /**
-* A Base pattern for creating scoped patterns. It's similar to Backbone's
-* Model class. The advantage of this approach is that each instance of a
-* pattern has its own local scope (closure).
-*
-* A new instance is created for each DOM element on which a pattern applies.
-*
-* You can assign values, such as $el, to `this` for an instance and they
-* will remain unique to that instance.
-*
-* Older Patternslib patterns on the other hand have a single global scope for
-* all DOM elements.
-*/
+ * A Base pattern for creating scoped patterns. It's similar to Backbone's
+ * Model class. The advantage of this approach is that each instance of a
+ * pattern has its own local scope (closure).
+ *
+ * A new instance is created for each DOM element on which a pattern applies.
+ *
+ * You can assign values, such as $el, to `this` for an instance and they
+ * will remain unique to that instance.
+ *
+ * Older Patternslib patterns on the other hand have a single global scope for
+ * all DOM elements.
+ */
 
 import $ from "jquery";
 import Registry from "./registry";
 import logging from "./logging";
 import mockupParser from "./mockup-parser";
 
-
 var log = logging.getLogger("Patternslib Base");
 
-var initBasePattern = function($el, options, trigger) {
-    if(!$el.jquery) {
+var initBasePattern = function ($el, options, trigger) {
+    if (!$el.jquery) {
         $el = $($el);
     }
     var name = this.prototype.name;
@@ -35,18 +34,15 @@ var initBasePattern = function($el, options, trigger) {
                     : options;
             pattern = new Registry.patterns[name]($el, options, trigger);
         } catch (e) {
-            log.error(
-                "Failed while initializing '" + name + "' pattern.",
-                e
-            );
+            log.error("Failed while initializing '" + name + "' pattern.", e);
         }
         $el.data("pattern-" + name, pattern);
     }
     return pattern;
 };
 
-var Base = function($el, options, trigger) {
-    if(!$el.jquery) {
+var Base = function ($el, options, trigger) {
+    if (!$el.jquery) {
         $el = $($el);
     }
     this.$el = $el;
@@ -57,22 +53,19 @@ var Base = function($el, options, trigger) {
 
 Base.prototype = {
     constructor: Base,
-    on: function(eventName, eventCallback) {
-        this.$el.on(
-            eventName + "." + this.name + ".patterns",
-            eventCallback
-        );
+    on: function (eventName, eventCallback) {
+        this.$el.on(eventName + "." + this.name + ".patterns", eventCallback);
     },
-    emit: function(eventName, args) {
+    emit: function (eventName, args) {
         // args should be a list
         if (args === undefined) {
             args = [];
         }
         this.$el.trigger(eventName + "." + this.name + ".patterns", args);
-    }
+    },
 };
 
-Base.extend = function(patternProps) {
+Base.extend = function (patternProps) {
     /* Helper function to correctly set up the prototype chain for new patterns.
      */
     var parent = this;
@@ -91,7 +84,7 @@ Base.extend = function(patternProps) {
     if (patternProps.hasOwnProperty("constructor")) {
         child = patternProps.constructor;
     } else {
-        child = function() {
+        child = function () {
             parent.apply(this, arguments);
         };
     }
@@ -106,7 +99,7 @@ Base.extend = function(patternProps) {
 
     // Set the prototype chain to inherit from `parent`, without calling
     // `parent`'s constructor function.
-    var Surrogate = function() {
+    var Surrogate = function () {
         this.constructor = child;
     };
     Surrogate.prototype = parent.prototype;

Diff for: src/core/base.test.js

@@ -3,7 +3,7 @@ import $ from "jquery";
 import Base from "./base";
 import _ from "underscore";
 
-describe("pat-base: The Base class for patterns", function() {
+describe("pat-base: The Base class for patterns", function () {
     var patterns = registry.patterns;
 
     beforeEach(function () {
@@ -14,21 +14,21 @@ describe("pat-base: The Base class for patterns", function() {
         registry.patterns = patterns;
     });
 
-    it("can be extended and used in similar way as classes", function() {
+    it("can be extended and used in similar way as classes", function () {
         var Tmp = Base.extend({
             name: "example",
             trigger: "pat-example",
             some: "thing",
-            init: function() {
+            init: function () {
                 expect(this.$el.hasClass("pat-example")).toEqual(true);
                 expect(_.includes(_.keys(this.options), "option")).toBeTruthy();
                 this.extra();
             },
-            extra: function() {
+            extra: function () {
                 expect(this.some).toEqual("thing");
-            }
+            },
         });
-        var tmp = new Tmp($("<div class=\"pat-example\"/>"), {option: "value"});
+        var tmp = new Tmp($('<div class="pat-example"/>'), { option: "value" });
         expect(tmp instanceof Tmp).toBeTruthy();
     });
 
@@ -54,11 +54,11 @@ describe("pat-base: The Base class for patterns", function() {
         expect(tmp instanceof Tmp).toBeTruthy();
     });
 
-    it("will automatically register a pattern in the registry when extended", function() {
+    it("will automatically register a pattern in the registry when extended", function () {
         spyOn(registry, "register").and.callThrough();
         var NewPattern = Base.extend({
             name: "example",
-            trigger: ".pat-example"
+            trigger: ".pat-example",
         });
         expect(NewPattern.prototype.trigger).toEqual(".pat-example");
         expect(NewPattern.prototype.name).toEqual("example");
@@ -67,86 +67,87 @@ describe("pat-base: The Base class for patterns", function() {
         expect(_.includes(_.keys(registry.patterns), "example")).toBeTruthy();
     });
 
-    it("will not automatically register a pattern without a \"name\" attribute", function() {
+    it('will not automatically register a pattern without a "name" attribute', function () {
         spyOn(registry, "register").and.callThrough();
-        var NewPattern = Base.extend({trigger: ".pat-example"});
+        var NewPattern = Base.extend({ trigger: ".pat-example" });
         expect(NewPattern.prototype.trigger).toEqual(".pat-example");
         expect(registry.register).not.toHaveBeenCalled();
     });
 
-    it("will not automatically register a pattern without a \"trigger\" attribute", function() {
+    it('will not automatically register a pattern without a "trigger" attribute', function () {
         spyOn(registry, "register").and.callThrough();
-        var NewPattern = Base.extend({name: "example"});
+        var NewPattern = Base.extend({ name: "example" });
         expect(registry.register).not.toHaveBeenCalled();
         expect(NewPattern.prototype.name).toEqual("example");
     });
 
-    it("will instantiate new instances of a pattern when the DOM is scanned", function() {
+    it("will instantiate new instances of a pattern when the DOM is scanned", function () {
         var NewPattern = Base.extend({
             name: "example",
             trigger: ".pat-example",
-            init: function() {
+            init: function () {
                 expect(this.$el.attr("class")).toEqual("pat-example");
-            }
+            },
         });
         spyOn(NewPattern, "init").and.callThrough();
-        registry.scan($("<div class=\"pat-example\"/>"));
+        registry.scan($('<div class="pat-example"/>'));
         expect(NewPattern.init).toHaveBeenCalled();
     });
 
-    it("requires that patterns that extend it provide an object of properties", function() {
-        expect(Base.extend)
-            .toThrowError(
-                "Pattern configuration properties required when calling Base.extend"
-            );
+    it("requires that patterns that extend it provide an object of properties", function () {
+        expect(Base.extend).toThrowError(
+            "Pattern configuration properties required when calling Base.extend"
+        );
     });
 
-    it("can be extended multiple times", function() {
+    it("can be extended multiple times", function () {
         var Tmp1 = Base.extend({
             name: "thing",
             trigger: "pat-thing",
             something: "else",
-            init: function() {
+            init: function () {
                 expect(this.some).toEqual("thing3");
                 expect(this.something).toEqual("else");
-            }
+            },
         });
         var Tmp2 = Tmp1.extend({
             name: "thing",
             trigger: "pat-thing",
             some: "thing2",
-            init: function() {
+            init: function () {
                 expect(this.some).toEqual("thing3");
                 expect(this.something).toEqual("else");
-                this.constructor.__super__.constructor.__super__.init.call(this);
-            }
+                this.constructor.__super__.constructor.__super__.init.call(
+                    this
+                );
+            },
         });
         var Tmp3 = Tmp2.extend({
             name: "thing",
             trigger: "pat-thing",
             some: "thing3",
-            init: function() {
+            init: function () {
                 expect(this.some).toEqual("thing3");
                 expect(this.something).toEqual("else");
                 this.constructor.__super__.init.call(this);
-            }
+            },
         });
-        new Tmp3($("<div>"), {option: "value"});
+        new Tmp3($("<div>"), { option: "value" });
     });
 
-    it("has on/emit helpers to prefix events", function() {
+    it("has on/emit helpers to prefix events", function () {
         var Tmp = Base.extend({
             name: "tmp",
             trigger: ".pat-tmp",
-            init: function() {
-                this.on("something", function(e, arg1) {
+            init: function () {
+                this.on("something", function (e, arg1) {
                     expect(arg1).toEqual("yaay!");
                 });
                 this.emit("somethingelse", ["yaay!"]);
-            }
+            },
         });
         new Tmp(
-            $("<div/>").on("somethingelse.tmp.patterns", function(e, arg1) {
+            $("<div/>").on("somethingelse.tmp.patterns", function (e, arg1) {
                 $(this).trigger("something.tmp.patterns", [arg1]);
             })
         );