RubyGems - magic_carpet - Versions diffs - 0.5.0 - Mend

magic_carpet 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (225) hide show

data/spec/dummy/public/404.html ADDED Viewed

@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The page you were looking for doesn't exist (404)</title>
+  <style>
+  body {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+  }
+  div.dialog {
+    width: 25em;
+    margin: 4em auto 0 auto;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 4em 0 4em;
+  }
+  h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+  body > p {
+    width: 33em;
+    margin: 0 auto 1em;
+    padding: 1em 0;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow:0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/404.html -->
+  <div class="dialog">
+    <h1>The page you were looking for doesn't exist.</h1>
+    <p>You may have mistyped the address or the page may have moved.</p>
+  </div>
+  <p>If you are the application owner check the logs for more information.</p>
+</body>
+</html>

data/spec/dummy/public/422.html ADDED Viewed

@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The change you wanted was rejected (422)</title>
+  <style>
+  body {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+  }
+  div.dialog {
+    width: 25em;
+    margin: 4em auto 0 auto;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 4em 0 4em;
+  }
+  h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+  body > p {
+    width: 33em;
+    margin: 0 auto 1em;
+    padding: 1em 0;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow:0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/422.html -->
+  <div class="dialog">
+    <h1>The change you wanted was rejected.</h1>
+    <p>Maybe you tried to change something you didn't have access to.</p>
+  </div>
+  <p>If you are the application owner check the logs for more information.</p>
+</body>
+</html>

data/spec/dummy/public/500.html ADDED Viewed

@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <style>
+  body {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+  }
+  div.dialog {
+    width: 25em;
+    margin: 4em auto 0 auto;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 4em 0 4em;
+  }
+  h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+  body > p {
+    width: 33em;
+    margin: 0 auto 1em;
+    padding: 1em 0;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow:0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <h1>We're sorry, but something went wrong.</h1>
+  </div>
+  <p>If you are the application owner check the logs for more information.</p>
+</body>
+</html>

data/spec/dummy/public/favicon.ico ADDED Viewed

File without changes

data/spec/dummy/spec/javascripts/helpers/spec_helper.js ADDED Viewed

@@ -0,0 +1,367 @@
+//= require magic_carpet/application
+// Stub agent string for testing agent detection code
+function stubAgent(agentString) {
+  var __originalNavigator = navigator;
+  navigator = new Object();
+  navigator.__proto__ = __originalNavigator;
+  navigator.__defineGetter__('userAgent', function () { return agentString; });
+}
+// Stub event object for testing DOM events
+var eventStub;
+// Stub promise object for testing asynchronous code
+var promiseStub;
+// Stub an event object with a few basic spies
+// for assertions.
+eventStub = {
+  preventDefault: jasmine.createSpy("preventDefault"),
+  stopPropagation: jasmine.createSpy("stopPropagation"),
+  target: jasmine.createSpy("target"),
+  keyCode: 13 // Send enter keyCode by default
+};
+// The promise stub requres a bit more setup to
+// enable assertions. Since promises are chainable
+// every spy must return the promise stub
+promiseStub = jasmine.createSpy("promiseStub");
+promiseStub.abort = jasmine.createSpy("abort").and.returnValue(promiseStub);
+promiseStub.fail = jasmine.createSpy("fail").and.returnValue(promiseStub);
+promiseStub.done = jasmine.createSpy("done").and.returnValue(promiseStub);
+promiseStub.always = jasmine.createSpy("always").and.returnValue(promiseStub);
+beforeEach(function() {
+  jasmine.addMatchers({
+    toBeTrue: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: actual === true,
+            message: "Expected " + actual + " to be true"
+          };
+        }
+      };
+    },
+    toBeFalse: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: actual === false,
+            message: "Expected " + actual + " to be false"
+          };
+        }
+      };
+    },
+    toBeEmpty: function() {
+      return {
+        compare: function(actual) {
+          var pass;
+          if ((/Array/).test(Object.prototype.toString.call(actual))) {
+            pass = actual.length === 0;
+          } else {
+            for (var prop in actual) {
+              pass = false;
+            }
+            pass = (pass === undefined) ? true : false;
+          }
+          return {
+            pass: pass,
+            message: "Expected " + actual + " to be empty"
+          };
+        }
+      };
+    },
+    toBeObject: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: compareConstructor(actual, Object),
+            message: "Expected " + actual + " to be an Object"
+          };
+        }
+      };
+    },
+    toBeArray: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: compareConstructor(actual, Array),
+            message: "Expected " + actual + " to be an Array"
+          };
+        }
+      };
+    },
+    toBeNumber: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: compareConstructor(actual, Number),
+            message: "Expected " + actual + " to be a Number"
+          };
+        }
+      };
+    },
+    toBeString: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: compareConstructor(actual, String),
+            message: "Expected " + actual + " to be a String"
+          };
+        }
+      };
+    },
+    toBeFunction: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: compareConstructor(actual, Function),
+            message: "Expected " + actual + " to be a Function"
+          };
+        }
+      };
+    },
+    toBeTypeof: function() {
+      return {
+        compare: function(actual, b) {
+          return {
+            pass: compareConstructor(actual, b),
+            message: "Expected " + actual + " to be a typeof " + b
+          };
+        }
+      };
+    },
+    toDeepEqual: function() {
+      var eq = function(a, b, aStack, bStack) {
+        // Identical objects are equal. `0 === -0`, but they aren't identical.
+        // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
+        if (a === b) return a !== 0 || 1 / a == 1 / b;
+        // A strict comparison is necessary because `null == undefined`.
+        if (a == null || b == null) return a === b;
+        // Compare `[[Class]]` names.
+        var className = toString.call(a);
+        if (className != toString.call(b)) return false;
+        switch (className) {
+          // Strings, numbers, dates, and booleans are compared by value.
+          case '[object String]':
+            // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+            // equivalent to `new String("5")`.
+            return a == String(b);
+          case '[object Number]':
+            // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+            // other numeric values.
+            return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+          case '[object Date]':
+          case '[object Boolean]':
+            // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+            // millisecond representations. Note that invalid dates with millisecond representations
+            // of `NaN` are not equivalent.
+            return +a == +b;
+          // RegExps are compared by their source patterns and flags.
+          case '[object RegExp]':
+            return a.source == b.source &&
+                   a.global == b.global &&
+                   a.multiline == b.multiline &&
+                   a.ignoreCase == b.ignoreCase;
+        }
+        if (typeof a != 'object' || typeof b != 'object') return false;
+        // Assume equality for cyclic structures. The algorithm for detecting cyclic
+        // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+        var length = aStack.length;
+        while (length--) {
+          // Linear search. Performance is inversely proportional to the number of
+          // unique nested structures.
+          if (aStack[length] == a) return bStack[length] == b;
+        }
+        // Objects with different constructors are not equivalent, but `Object`s
+        // from different frames are.
+        var aCtor = a.constructor, bCtor = b.constructor;
+        if (aCtor !== bCtor && !(aCtor == Function && (aCtor instanceof aCtor) &&
+                                 bCtor == Function && (bCtor instanceof bCtor))
+                            && ('constructor' in a && 'constructor' in b)) {
+          return false;
+        }
+        // Add the first object to the stack of traversed objects.
+        aStack.push(a);
+        bStack.push(b);
+        var size = 0, result = true;
+        // Recursively compare objects and arrays.
+        if (className == '[object Array]') {
+          // Compare array lengths to determine if a deep comparison is necessary.
+          size = a.length;
+          result = size == b.length;
+          if (result) {
+            // Deep compare the contents, ignoring non-numeric properties.
+            while (size--) {
+              if (!(result = eq(a[size], b[size], aStack, bStack))) break;
+            }
+          }
+        } else {
+          // Deep compare objects.
+          for (var key in a) {
+            if (a.hasOwnProperty(key)) {
+              // Count the expected number of properties.
+              size++;
+              // Deep compare each member.
+              if (!(result = b.hasOwnProperty(key) && eq(a[key], b[key], aStack, bStack))) break;
+            }
+          }
+          // Ensure that both objects contain the same number of properties.
+          if (result) {
+            for (key in b) {
+              if (b.hasOwnProperty(key) && !(size--)) break;
+            }
+            result = !size;
+          }
+        }
+        // Remove the first object from the stack of traversed objects.
+        aStack.pop();
+        bStack.pop();
+        return result;
+      };
+      return {
+        compare: function(actual, expected) {
+          return {
+            pass: eq(actual, expected, [], []),
+            message: "Expected " + actual + " to deep equal " + expected
+          };
+        }
+      };
+    },
+    // jQuery matchers
+    toBeJqueryWrapped: function() {
+      return {
+        compare: function(actual, selector) {
+          return {
+            pass: (selector && actual && actual.selector !== selector) ? false : checkElementExistence(actual),
+            message: "Expected " + actual + " to be a jQuery wrapped element"
+          };
+        }
+      };
+    },
+    toHaveClass: function() {
+      return {
+        compare: function(actual, className) {
+          return {
+            pass: actual.hasClass(className),
+            message: "Expected " + actual + " to have class " + className
+          };
+        }
+      };
+    },
+    toBeHidden: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: !actual.is(":visible"),
+            message: "Expected " + actual + " to be hidden"
+          };
+        }
+      };
+    },
+    toBeVisible: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: actual.is(":visible"),
+            message: "Expected " + actual + " to be visible"
+          };
+        }
+      };
+    },
+    toExist: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: actual.length > 0,
+            message: "Expected " + actual + " to exist in the DOM"
+          };
+        }
+      };
+    },
+    toHaveText: function() {
+      return {
+        compare: function(actual, text) {
+          return {
+            pass: actual.text().trim() === text,
+            message: "Expected " + actual + " to have text " + '"' + text + '"'
+          };
+        }
+      };
+    },
+    toHaveHTML: function() {
+      return {
+        compare: function(actual, html) {
+          return {
+            pass: actual.html().trim() === html,
+            message: "Expected " + actual + " to have HTML " + '"' + html + '"'
+          };
+        }
+      };
+    },
+    toBeChecked: function() {
+      return {
+        compare: function(actual) {
+          return {
+            pass: actual.prop("checked"),
+            message: "Expected " + actual + " to be checked"
+          };
+        }
+      };
+    },
+    toHaveAttribute: function(attr, value) {
+      return {
+        compare: function(actual, attr, value) {
+          var pass;
+          var message;
+          if (value) {
+            pass = (actual.attr(attr) === value);
+            message = "Expected " + actual + ' to have the "' + attr + '" attribute with a value of "' + value + '"';
+          } else {
+            pass = !!actual.attr(attr);
+            message = "Expected " + actual + ' to have the "' + attr + '" attribute';
+          }
+          return {
+            pass: pass,
+            message: message
+          };
+        }
+      };
+    }
+  });
+  // compareConstructor checks an object against a specific type
+  function compareConstructor(a, b) {
+    if (typeof a === "undefined") return false;
+    return a.constructor == b; // double equals is important here, ignore the linter
+  }
+  // This function is an exhaustive check for the existence
+  // of a jQuery wrapped element. It requires an element to
+  // be in the DOM and to be jQuery wrapped
+  function checkElementExistence(element) {
+    if (typeof element === "undefined") return false;
+    if (typeof element.selector === "undefined") return false;
+    if (!element.length) return false;
+    return compareConstructor(element, jQuery);
+  }
+});