flint-gs 2.0.3 → 2.0.4

data/tests/bootcamp/matchers/_be.scss

@@ -0,0 +1,3 @@
+@function be($value) {
+  @return should("be", $value, bc-util-equal( actual(), $value ) );
+}

data/tests/bootcamp/matchers/_equal.scss

@@ -0,0 +1,3 @@
+@function equal($value) {
+  @return should("equal", $value, actual() == $value);
+}

data/tests/bootcamp/matchers/lists/_be-empty.scss

@@ -0,0 +1,3 @@
+@function be-empty() {
+  @return should("be", "empty", actual() == ());
+}

data/tests/bootcamp/matchers/lists/_be-longer-than.scss

@@ -0,0 +1,3 @@
+@function be-longer-than($this) {
+  @return should("be longer than", $this, length(actual()) > $this);
+}

data/tests/bootcamp/matchers/lists/_be-shorter-than.scss

@@ -0,0 +1,3 @@
+@function be-shorter-than($this) {
+  @return should("be shorter than", $this, length(actual()) < $this);
+}

data/tests/bootcamp/matchers/lists/_contain.scss

@@ -0,0 +1,3 @@
+@function contain($value) {
+  @return should("deep contain", $value, bc-util-contain( actual(), $value ));
+}

data/tests/bootcamp/matchers/lists/_deep-contain.scss

@@ -0,0 +1,3 @@
+@function deep-contain($value) {
+  @return should("deep contain", $value, bc-util-contain( actual(), $value, $recursive: true ));
+}

data/tests/bootcamp/matchers/lists/_deep-equal.scss

@@ -0,0 +1,47 @@
+@function deep-equal($expected) {
+  $when: true;
+  $actual: actual();
+
+  $contains-list: true;
+  $temp-1: $actual;
+  $temp-2: $expected;
+
+  @while $contains-list {
+    $contains-list: false;
+
+    @if length($temp-1) == length($temp-2) {
+      @for $n from 1 through length($temp-1) {
+        $temp-1-item: nth($temp-1, $n);
+        $temp-2-item: nth($temp-2, $n);
+
+        @if type-of($temp-1-item) == "list" and type-of($temp-2-item) == "list" {
+          @if length($temp-1-item) == length($temp-2-item) {
+            @for $_n from 1 through length($temp-1-item) {
+              $_temp-1-item: nth($temp-1-item, $_n);
+              $_temp-2-item: nth($temp-2-item, $_n);
+
+              @if type-of($_temp-1-item) == "list" and type-of($_temp-2-item) == "list" {
+                $contains-list: true;
+              } @else if $_temp-1-item != $_temp-2-item {
+                $when: false;
+              }
+
+              $temp-1: $_temp-1-item;
+              $temp-2: $_temp-2-item;
+            }
+          } @else {
+            $when: false;
+          }
+        } @else if $temp-1-item != $temp-2-item {
+          $when: false;
+        }
+      }
+    } @else {
+      $when: false;
+    }
+  }
+
+  $throw: error("dep", "The `deep-equal` matcher has been deprecated, please use the `be` matcher for the same functionality");
+
+  @return should("deep equal", $expected, $when);
+}

data/tests/bootcamp/matchers/lists/_have-length-of.scss

@@ -0,0 +1,3 @@
+@function have-length-of($this) {
+  @return should("have length of", $this, length(actual()) == $this );
+}

data/tests/bootcamp/matchers/numbers/_be-close-to.scss

@@ -0,0 +1,12 @@
+@function be-close-to($this, $precision) {
+  $actual: actual();
+  $when: false;
+
+  @if type-of($actual) == "number" {
+    $when: abs($this - $actual) < (bc-util-power(10, -$precision) / 2);
+  } @else {
+    $when: error("type", "The `be-close-to` matcher is only for numbers");
+  }
+
+  @return should("be close to", $this, $when);
+}

data/tests/bootcamp/matchers/numbers/_be-greater-than.scss

@@ -0,0 +1,12 @@
+@function be-greater-than($this) {
+  $actual: actual();
+  $when: false;
+
+  @if type-of($actual) == "number" {
+    $when: $actual > $this;
+  } @else {
+    $when: error("type", "The `be-greater-than` matcher is only for numbers");
+  }
+
+  @return should("be greater than", $this, $when);
+}

data/tests/bootcamp/matchers/numbers/_be-less-than.scss

@@ -0,0 +1,12 @@
+@function be-less-than($this) {
+  $actual: actual();
+  $when: false;
+
+  @if type-of($actual) == "number" {
+    $when: $actual < $this;
+  } @else {
+    $when: error("type", "The `be-less-than` matcher is only for numbers");
+  }
+
+  @return should("be less than", $this, $when);
+}

data/tests/bootcamp/matchers/types/_be-falsy.scss

@@ -0,0 +1,3 @@
+@function be-falsy() {
+  @return should("be", "falsy", not actual());
+}

data/tests/bootcamp/matchers/types/_be-null.scss

@@ -0,0 +1,3 @@
+@function be-null() {
+  @return should("be", "null", actual() == null);
+}

data/tests/bootcamp/matchers/types/_be-truthy.scss

@@ -0,0 +1,3 @@
+@function be-truthy() {
+  @return should("be", "truthy", not not actual());
+}

data/tests/bootcamp/matchers/types/_have-type-of.scss

@@ -0,0 +1,3 @@
+@function have-type-of($type) {
+  @return should("have type of", $type, type-of(actual()) == $type);
+}

data/tests/bootcamp/utils/_contain.scss

@@ -0,0 +1,15 @@
+@function bc-util-contain($list, $value, $recursive: false) {
+  @each $item in $list {
+    @if type-of( $item ) == list and $recursive {
+      @if bc-util-contain($item, $value, $recursive) {
+        @return true;
+      }
+    }
+
+    @if $item == $value {
+      @return true;
+    }
+  }
+
+  @return false;
+}

data/tests/bootcamp/utils/_equal.scss

@@ -0,0 +1,23 @@
+@function bc-util-equal($value-1, $value-2, $recursive: true) {
+  @if length($value-1) != length($value-2) {
+    @return false;
+  }
+
+  @for $i from 1 through length($value-1) {
+
+    @if $recursive
+    and type-of( nth($value-1, $i) ) == list
+    and type-of( nth($value-2, $i) ) == list {
+
+      @if not bc-util-equal(nth($value-1, $i), nth($value-2, $i)) {
+        @return false;
+      }
+    }
+
+    @else if nth($value-1, $i) != nth($value-2, $i){
+      @return false;
+    }
+  }
+
+  @return true;
+}

data/tests/bootcamp/utils/_list-join.scss

@@ -0,0 +1,35 @@
+@function bc-util-list-join($list, $separator, $slice-start: 1, $slice-end: 0) {
+  $result: "";
+
+  @if type-of($list) == list {
+    $length: length($list);
+
+    @if $slice-end == false {
+      $slice-end: length($list);
+    }
+
+    @if $slice-start < 0 {
+      $slice-start: length($list) + $slice-start + 1;
+    }
+
+    @if $slice-end < 0 {
+      $slice-end: length($list) + $slice-end + 1;
+    }
+
+    @for $i from $slice-start through $length - $slice-end {
+      @if $result == "" {
+        $result: nth($list, $i);
+      }
+
+      @else {
+        $result: $result + "#{$separator}" + nth($list, $i);
+      }
+    }
+  }
+
+  @else {
+    $result: $list;
+  }
+
+  @return $result;
+}

data/tests/bootcamp/utils/_power.scss

@@ -0,0 +1,15 @@
+@function bc-util-power($x, $n) {
+  $ret: 1;
+
+  @if $n >= 0 {
+    @for $i from 1 through $n {
+      $ret: $ret * $x;
+    }
+  } @else {
+    @for $i from $n to 0 {
+      $ret: $ret / $x;
+    }
+  }
+
+  @return $ret;
+}

data/tests/config.rb

@@ -0,0 +1,52 @@
+require '../lib/flint.rb'
+require 'rubygems'
+require 'bundler'
+
+# Require dependencies through bundler
+Bundler.require(:default, :test) if defined?(Bundler)
+
+# Define paths
+css_dir = "output"
+sass_dir = "input"
+
+# Output style will change based on environment
+output_style = :expanded
+
+# Disable line comments
+line_comments = false
+
+# Disable Sass warnings
+# disable_warnings = true
+
+# Options
+sass_options = {
+	# For when working on Windows machines
+	:unix_newlines => true
+}
+
+module Sass::Script::Functions
+    @@timeStart = Time.now
+    @@timeLast  = Time.now
+
+    def profileRender(timeLast)
+        diff = Time.now - timeLast
+        return Sass::Script::String.new(diff * 1)
+    end
+
+    def timing_total()
+        return self.profileRender(@@timeStart)
+    end
+
+    def timing_interval()
+        str = profileRender(@@timeLast)
+        @@timeLast = Time.now
+        return str
+    end
+end
+
+class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
+	# Removes all comments completely
+	def visit_comment(node)
+		return []
+	end
+end

data/tests/input/functions/_functions.scss

@@ -0,0 +1,48 @@
+/*
+ * Helpers
+ */
+@import "helpers/helpers";
+
+/*
+ * Functions
+ */
+@import "lib/exists";
+
+// Getters
+@import "lib/map-fetch";
+@import "lib/get-value";
+@import "lib/get-index";
+@import "lib/steal-key";
+@import "lib/steal-values";
+
+// Calculations
+@import "lib/fluid-width";
+@import "lib/calc-width";
+@import "lib/calc-breakpoint";
+
+// Instance functions
+@import "lib/instance";
+@import "lib/has-family-instance";
+@import "lib/get-instance-value";
+
+// List functions
+@import "lib/list-to-string";
+@import "lib/types-in-list";
+@import "lib/next-index";
+@import "lib/purge";
+@import "lib/replace";
+@import "lib/remove";
+@import "lib/last";
+
+// String functions
+@import "lib/replace-substring";
+@import "lib/string-to-list";
+
+/*
+ * Support syntax
+ */
+@import "lib/use-syntax";
+@import "lib/support-syntax";
+
+// Syntaxes
+@import "lib/support-syntax-bem"

data/tests/input/functions/helpers/_helpers.scss

@@ -0,0 +1,416 @@
+/*
+ * Returns truthiness of a value
+ */
+@include describe("[function] is-true") {
+
+	@include it("should expect values to be truthy") {
+		@include should(expect(
+			flint-is-true(true)),
+			to(be(true))
+		);
+		@include should(expect(
+			flint-is-true("true")),
+			to(be(true))
+		);
+	}
+
+	@include it("should expect values to return false") {
+		@include should(expect(
+			flint-is-true(null)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-true(false)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-true(())),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-true("")),
+			to(be(false))
+		);
+	}
+}
+
+/*
+ * Checks if item is map
+ */
+@include describe("[function] is-map") {
+
+	$map: ("key": "value");
+	$list: ("one", "two", "three");
+	$string: "string";
+	$number: 1;
+	$bool: true;
+	$null: null;
+
+	@include it("should expect variable to be a map and return true") {
+		@include should(expect(
+			flint-is-map($map)),
+			to(be(true))
+		);
+	}
+
+	@include it("should expect variable to be a map and return false") {
+		@include should(expect(
+			flint-is-map($list)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-map($string)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-map($number)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-map($bool)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-map($null)),
+			to(be(false))
+		);
+	}
+}
+
+/*
+ * Checks if item is list
+ */
+@include describe("[function] is-list") {
+
+	$map: ("key": "value");
+	$list: ("one", "two", "three");
+	$string: "string";
+	$number: 1;
+	$bool: true;
+	$null: null;
+
+	@include it("should expect variable to be a list and return true") {
+		@include should(expect(
+			flint-is-list($list)),
+			to(be(true))
+		);
+	}
+
+	@include it("should expect variable to be a list and return false") {
+		@include should(expect(
+			flint-is-list($map)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-list($string)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-list($number)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-list($bool)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-list($null)),
+			to(be(false))
+		);
+	}
+}
+
+/*
+ * Checks if item is number
+ */
+@include describe("[function] is-number") {
+
+	$map: ("key": "value");
+	$list: ("one", "two", "three");
+	$string: "string";
+	$number: 1;
+	$bool: true;
+	$null: null;
+
+	@include it("should expect variable to be a number and return true") {
+		@include should(expect(
+			flint-is-number($number)),
+			to(be(true))
+		);
+	}
+
+	@include it("should expect variable to be a number and return false") {
+		@include should(expect(
+			flint-is-number($map)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-number($list)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-number($string)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-number($bool)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-number($null)),
+			to(be(false))
+		);
+	}
+}
+
+/*
+ * Checks if item is string
+ */
+@include describe("[function] is-string") {
+
+	$map: ("key": "value");
+	$list: ("one", "two", "three");
+	$string: "string";
+	$number: 1;
+	$bool: true;
+	$null: null;
+
+	@include it("should expect variable to be a string and return true") {
+		@include should(expect(
+			flint-is-string($string)),
+			to(be(true))
+		);
+	}
+
+	@include it("should expect variable to be a string and return false") {
+		@include should(expect(
+			flint-is-string($map)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-string($list)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-string($number)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-string($bool)),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-string($null)),
+			to(be(false))
+		);
+	}
+}
+
+/*
+ * Checks if item is not string
+ */
+@include describe("[function] is-not-string") {
+
+	$map: ("key": "value");
+	$list: ("one", "two", "three");
+	$string: "string";
+	$number: 1;
+	$bool: true;
+	$null: null;
+
+	@include it("should expect variable not to be a string") {
+		@include should(expect(
+			flint-is-not-string($string)),
+			not-to(be(true))
+		);
+		@include should(expect(
+			flint-is-not-string($map)),
+			to(be(true))
+		);
+		@include should(expect(
+			flint-is-not-string($list)),
+			to(be(true))
+		);
+		@include should(expect(
+			flint-is-not-string($number)),
+			to(be(true))
+		);
+		@include should(expect(
+			flint-is-not-string($bool)),
+			to(be(true))
+		);
+		@include should(expect(
+			flint-is-not-string($null)),
+			to(be(true))
+		);
+	}
+}
+
+/*
+ * Get gutter value from config map
+ */
+@include describe("[function] get-gutter") {
+
+	@include it("should expect gutter value from config") {
+		@include should(expect(
+			flint-get-gutter()),
+			to(be((0.625em)))
+		);
+	}
+}
+
+/*
+ * Gets list of each breakpoint's key
+ */
+@include describe("[function] get-all-keys") {
+
+	@include it("should expect a list of all breakpoint keys") {
+		@include should(expect(
+			flint-get-all-keys()),
+			to(be(("desktop", "laptop", "tablet", "mobile")))
+		);
+	}
+}
+
+/*
+ * Gets list of all breakpoints
+ */
+@include describe("[function] get-all-breakpoints") {
+
+	@include it("should expect a list of all breakpoint values") {
+		@include should(expect(
+			flint-get-all-breakpoints()),
+			to(be((80em, 60em, 40em, 20em)))
+		);
+	}
+}
+
+/*
+ * Checks if passed $key is the highest breakpoint
+ */
+@include describe("[function] is-highest-breakpoint") {
+
+	@include it("should expect to be highest breakpoint") {
+		@include should(expect(
+			flint-is-highest-breakpoint("desktop")),
+			to(be(true))
+		);
+	}
+
+	@include it("should expect not to be highest breakpoint") {
+		@include should(expect(
+			flint-is-highest-breakpoint("laptop")),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-highest-breakpoint("tablet")),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-highest-breakpoint("mobile")),
+			to(be(false))
+		);
+	}
+}
+
+/*
+ * Checks if passed $key is the lowest breakpoint
+ */
+@include describe("[function] is-lowest-breakpoint") {
+
+	@include it("should expect to be lowest breakpoint") {
+		@include should(expect(
+			flint-is-lowest-breakpoint("mobile")),
+			to(be(true))
+		);
+	}
+
+	@include it("should expect not to be lowest breakpoint") {
+		@include should(expect(
+			flint-is-lowest-breakpoint("desktop")),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-lowest-breakpoint("laptop")),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-lowest-breakpoint("tablet")),
+			to(be(false))
+		);
+	}
+}
+
+/*
+ * Checks if $key is grid default
+ */
+@include describe("[function] is-default") {
+
+	@include it("should expect to be default breakpoint") {
+		@include should(expect(
+			flint-is-default("mobile")),
+			to(be(true))
+		);
+	}
+
+	@include it("should expect not to be default breakpoint") {
+		@include should(expect(
+			flint-is-default("desktop")),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-default("laptop")),
+			to(be(false))
+		);
+		@include should(expect(
+			flint-is-default("tablet")),
+			to(be(false))
+		);
+	}
+}
+
+/*
+ * Gets all breakpoint column values
+ */
+@include describe("[function] get-all-columns") {
+
+	@include it("should expect a list of all breakpoint column values") {
+		@include should(expect(
+			flint-get-all-columns()),
+			to(be((16, 12, 8, 4)))
+		);
+	}
+}
+
+/*
+ * Returns the unit used in config
+ */
+@include describe("[function] get-config-unit") {
+	@include it("should expect configuration unit to be ems") {
+		@include should(expect(
+			flint-get-config-unit()),
+			to(be("em"))
+		);
+	}
+}
+
+/*
+ * Convert pixel value to em
+ */
+@include describe("[function] to-em") {
+
+	@include it("should expect passed pixel value to be converted to ems") {
+		@include should(expect(
+			flint-to-em(16px)),
+			to(be(1em))
+		);
+		@include should(expect(
+			flint-to-em(32px)),
+			to(be(2em))
+		);
+		@include should(expect(
+			flint-to-em(16px, 32px)),
+			to(be(0.5em))
+		);
+	}
+}