flint-gs 1.6.5 → 1.7.0

data/stylesheets/flint/functions/lib/_calc-width.scss

@@ -6,36 +6,45 @@
 // -------------------------------------------------------------------------------
 // @return calculated value | false
 
-@function calc-width($key, $span, $context: null) {
-	@if get-value("settings", "grid") == "fluid" {
+@function flint-calc-width($key, $span, $context: null) {
+	$result: false;
 
+	// Check to see if value has been cached
+	@if map-has-key($flint__cached-values, "#{$key, $span, $context}::width") and $context != "auto" {
+		@return map-get($flint__cached-values, "#{$key, $span, $context}::width");
+	}
+
+	@if flint-get-value("settings", "grid") == "fluid" {
 		@if $key == "container" or $span == "container" {
 
-			@return fluid-width(get-value($key, "breakpoint"), get-value($key, "breakpoint"));
+			$result: flint-fluid-width(flint-get-value($key, "breakpoint"), flint-get-value($key, "breakpoint"));
 
 		} @else if $context == null {
 
-			@return fluid-width((get-value($key, "breakpoint") / get-value($key, "columns") * $span), get-value($key, "breakpoint"));
+			$result: flint-fluid-width((flint-get-value($key, "breakpoint") / flint-get-value($key, "columns") * $span), flint-get-value($key, "breakpoint"));
 
 		} @else {
 
-			@return fluid-width((get-value($key, "breakpoint") / get-value($key, "columns") * $span), ((get-value($key, "breakpoint") / get-value($key, "columns") * $context)));
+			$result: flint-fluid-width((flint-get-value($key, "breakpoint") / flint-get-value($key, "columns") * $span), ((flint-get-value($key, "breakpoint") / flint-get-value($key, "columns") * $context)));
 
 		}
-
-	} @if get-value("settings", "grid") == "fixed" {
-
+	} @if flint-get-value("settings", "grid") == "fixed" {
 		@if $key == "container" or $span == "container" {
 
-			@return get-value($key, "breakpoint");
+			$result: flint-get-value($key, "breakpoint");
 
 		} @else {
 
-			@return get-value($key, "breakpoint") / get-value($key, "columns") * $span;
+			$result: flint-get-value($key, "breakpoint") / flint-get-value($key, "columns") * $span;
 
 		}
+	}
 
-	} @else {
-		@return false;
+	// Save result to cache
+	@if $context != "auto" {
+		$flint__cached-values: map-merge($flint__cached-values, ("#{$key, $span, $context}::width": $result));
 	}
+
+	// Return result
+	@return $result;
 }

data/stylesheets/flint/functions/lib/_exists.scss

@@ -5,18 +5,18 @@
 // -------------------------------------------------------------------------------
 // @return [bool]
 
-@function exists($map, $value){
-	
-	@if is-map($map) {
+@function flint-exists($map, $value){
+
+	@if flint-is-map($map) {
 		@if map-has-key($map, $value) {
 			@return true;
 		}
 		@each $key, $i in $map {
-			@if exists($i, $value) {
+			@if flint-exists($i, $value) {
 				@return true;
 			}
 		}
-	} 
+	}
 
 	@return false;
-}
+}

data/stylesheets/flint/functions/lib/_fluid-width.scss

@@ -5,6 +5,6 @@
 // -------------------------------------------------------------------------------
 // @return [number]
 
-@function fluid-width($target, $context) {
+@function flint-fluid-width($target, $context) {
 	@return ($target / $context) * 100%;
-}
+}

data/stylesheets/flint/functions/lib/_get-index.scss

@@ -4,9 +4,9 @@
 // -------------------------------------------------------------------------------
 // @return [number]
 
-@function get-index($key) {
-  	@for $i from 1 through (length(map-fetch($flint, "config")) - 1) {
-		@if steal-key($i) == $key {
+@function flint-get-index($key) {
+  	@for $i from 1 through (length(flint-map-fetch($flint, "config")) - 1) {
+		@if flint-steal-key($i) == $key {
 			@return $i;
 		}
 	}

data/stylesheets/flint/functions/lib/_get-instance-value.scss

@@ -1,6 +1,6 @@
 // Get single value from key in instance map based on $selector::$key
 // -------------------------------------------------------------------------------
-// @warning : all values @returned are strings and must be converted with `to-number()`
+// @warning : all values returned are strings and must be converted with `flint-to-number()`
 // -------------------------------------------------------------------------------
 // @param $key [string] : key
 // @param $value [number] : value
@@ -8,10 +8,10 @@
 // -------------------------------------------------------------------------------
 // @return [string]
 
-@function get-instance-value($key, $value, $deep: null) {
+@function flint-get-instance-value($key, $value, $deep: null) {
 	@if $deep == null {
-		@return map-fetch($flint__instances, get-family-instance($key) $value);
+		@return flint-map-fetch($flint__instances, flint-has-family-instance($key) $value);
 	} @else {
-		@return map-fetch($flint__instances, get-family-instance($key) $value $deep);
+		@return flint-map-fetch($flint__instances, flint-has-family-instance($key) $value $deep);
 	}
 }

data/stylesheets/flint/functions/lib/_get-value.scss

@@ -5,10 +5,10 @@
 // -------------------------------------------------------------------------------
 // @return [literal]
 
-@function get-value($key, $value: null) {
+@function flint-get-value($key, $value: null) {
 	@if $value == null {
-		@return map-fetch($flint, "config" $key);
+		@return flint-map-fetch($flint, "config" $key);
 	} @else {
-		@return map-fetch($flint, "config" $key $value);
+		@return flint-map-fetch($flint, "config" $key $value);
 	}
 }

data/stylesheets/flint/functions/lib/_has-family-instance.scss

@@ -0,0 +1,74 @@
+// Checks if instance flint-exists in selector familiy tree, falls back from current selector
+// -------------------------------------------------------------------------------
+// @param $key [string] : breakpoint key to search for matching instance
+// @param $syntax [string | null] : searches for instance using passed syntax
+// -------------------------------------------------------------------------------
+// @return matching instance | false
+
+@function flint-has-family-instance($key: flint-get-value("settings", "default"), $syntax: $flint__support-syntax) {
+	$selector-string: selector_string();
+
+	// Check if instance result had been cached
+	@if map-has-key($flint__cached-instances, "#{$selector-string}") {
+		// Get cached instance
+		$cached-instance: map-get($flint__cached-instances, "#{$selector-string}");
+		// Return with current key
+		@return "#{$cached-instance}::#{$key}";
+	}
+
+	// Check for syntax support, try to find instance using it
+	@if $syntax {
+
+		$selector-list: flint-use-syntax($selector-string);
+		$length: length($selector-list);
+
+		// Loop through transformed selectors
+		@for $i from 1 through $length {
+
+			// Check flint-last selector in list
+			@if flint-exists($flint__instances, "#{flint-last($selector-list)}::#{$key}") {
+
+				// Cache result
+				$flint__cached-instances: map-merge($flint__cached-instances, ("#{$selector-string}": "#{flint-last($selector-list)}"));
+
+				// Return the matching instance key
+				@return "#{flint-last($selector-list)}::#{$key}";
+
+			} @else {
+
+				// Else, flint-remove the flint-last selector and loop again
+				$selector-list: flint-remove($selector-list, flint-last($selector-list));
+
+			}
+		}
+
+		// Search for a parent instance normally
+		@return flint-has-family-instance($key, null);
+
+	} @else {
+		$selector-list: flint-string-to-list($selector-string);
+		$length: length($selector-list);
+
+		// Loop through length of list of selectors
+		@for $i from 1 through $length {
+
+			// Make sure that we're not counting the current selector string
+			@if flint-exists($flint__instances, "#{flint-list-to-string($selector-list, ' ')}::#{$key}") and $selector-string != flint-list-to-string($selector-list, " ") {
+
+				// Cache result
+				$flint__cached-instances: map-merge($flint__cached-instances, ("#{$selector-string}": "#{flint-list-to-string($selector-list, ' ')}"));
+
+				// Return the matching instance key
+				@return "#{flint-list-to-string($selector-list, ' ')}::#{$key}";
+
+			} @else {
+
+				// Else, flint-remove the flint-last selector and loop again
+				$selector-list: flint-remove($selector-list, flint-last($selector-list));
+
+			}
+		}
+
+		@return false;
+	}
+}

data/stylesheets/flint/functions/lib/_instance.scss

@@ -1,41 +1,43 @@
 // Keeps count of all instances with arguments, stores in global var
 // -------------------------------------------------------------------------------
-// @dependence `get-value()`
+// @dependence `flint-get-value()`
 // -------------------------------------------------------------------------------
 // @param $key [string] : computed breakpoint of instance
 // @param $span [number] : computed span of instance
 // @param $context [number] : computed context of instance
 // @param $gutter [number] : computed gutter of instance
 // @param $shift [number] : computed shift of instance
-// @param $outputWidth [number] : computed width of instance
-// @param $outputMarginRight [number] : computed right margin of instance
-// @param $outputMarginLeft [number] : computed left margin of instance
+// @param $output-width [number] : computed width of instance
+// @param $output-margin-right [number] : computed right margin of instance
+// @param $output-margin-left [number] : computed left margin of instance
 // -------------------------------------------------------------------------------
 // @return instance map
 
-@function instance($key, $span, $context, $gutter, $shift, $outputWidth, $outputMarginRight, $outputMarginLeft) {
-	  // Increase the instance count
+@function flint-instance($key, $span, $context, $gutter, $shift, $output-width, $output-margin-right, $output-margin-left) {
+
+    // Increase the instance count
     $flint__instance-count: $flint__instance-count + 1 !global;
+
     // Lets clean up the selector a bit...
     $selector-string: selector_string();
-    $selector-list: string-to-list($selector-string);
-    $selector-cleaned: list-to-string($selector-list, " ");
+    $selector-list: flint-string-to-list($selector-string);
+    $selector-cleaned: flint-list-to-string($selector-list, " ");
 
     $flint__instance: (
 		"#{$selector-cleaned}::#{$key}": (
 			"instance-count": #{$flint__instance-count},
-			"parent-selector": #{if(get-family-instance($key) != false, get-family-instance($key), none)},
+			"parent-selector": #{if(flint-has-family-instance($key) != false, flint-has-family-instance($key), none)},
 			"key": #{$key},
-			"breakpoint": #{get-value($key, breakpoint)},
-			"columns": #{get-value($key, columns)},
+			"breakpoint": #{flint-get-value($key, "breakpoint")},
+			"columns": #{flint-get-value($key, "columns")},
 			"span": #{$span},
-			"context": #{if($context == "auto", get-instance-value($key, "span"), $context)},
+			"context": #{if($context == "auto", flint-get-instance-value($key, "span"), $context)},
 			"gutter": #{$gutter},
 			"shift": #{$shift},
 			"output": (
-				"width": #{$outputWidth},
-				"margin-right": #{$outputMarginRight},
-				"margin-left": #{$outputMarginLeft}
+				"width": #{$output-width},
+				"margin-right": #{$output-margin-right},
+				"margin-left": #{$output-margin-left}
 			)
 		)
     );

data/stylesheets/flint/functions/lib/_last.scss

@@ -4,6 +4,6 @@
 // -------------------------------------------------------------------------------
 // @return [list]
 
-@function last($list) {
+@function flint-last($list) {
 	@return nth($list, length($list));
-}
+}

data/stylesheets/flint/functions/lib/_list-to-string.scss

@@ -7,19 +7,19 @@
 // -------------------------------------------------------------------------------
 // @return [string]
 
-@function list-to-string($list, $glue: "", $is-nested: false) {
+@function flint-list-to-string($list, $glue: "", $is-nested: false) {
 	$result: null;
 	$length: length($list);
 
 	@for $i from 1 through $length {
 		$n: nth($list, $i);
 
-		@if is-list($n) {
-			$result: $result#{list-to-string($n, $glue, true)};
+		@if flint-is-list($n) {
+			$result: $result#{flint-list-to-string($n, $glue, true)};
 		} @else {
 			$result: if($i != length($list) or $is-nested, $result#{$n}#{$glue}, $result#{$n});
 		}
 	}
 
 	@return $result;
-}
+}

data/stylesheets/flint/functions/lib/_map-fetch.scss

@@ -5,18 +5,12 @@
 // -------------------------------------------------------------------------------
 // @return fetched literal | false
 
-@function map-fetch($map, $keys) {
+@function flint-map-fetch($map, $keys) {
 	$key: nth($keys, 1);
 	$length: length($keys);
 	$value: map-get($map, $key);
 
-	// check if the key was incorrect, meaning the map doesn't exist
-	@if $value == null {
-		@warn "Invalid arguments passed to function: map-fetch(#{$map}, #{$keys}). One or more of the keys do not exist.";
-		@return false;
-	}
-
-	@else {
+	@if $value != null {
 		@if $length > 1 {
 			$rest: ();
 
@@ -24,10 +18,13 @@
 				$rest: append($rest, nth($keys, $i))
 			}
 
-			@return map-fetch($value, $rest);
+			@return flint-map-fetch($value, $rest);
 
 		} @else {
 			@return $value;
 		}
+	} @else {
+		@warn "Invalid arguments passed to function: flint-map-fetch(#{$map}, #{$keys}). One or more of the keys do not exist.";
+		@return false;
 	}
 }

data/stylesheets/flint/functions/lib/_next-index.scss

@@ -4,12 +4,12 @@
 // -------------------------------------------------------------------------------
 // @return [string] | null
 
-@function next-index($index) { 
-	@if $index != (length(map-fetch($flint, "config")) - 1) {
+@function flint-next-index($index) { 
+	@if $index != (length(flint-map-fetch($flint, "config")) - 1) {
 		@each $key in nth(map-get($flint, "config"), $index + 1) {
 			@return $key;
 		}
 	} @else {
 		@return null;
 	}
-}
+}

data/stylesheets/flint/functions/lib/_purge.scss

@@ -6,11 +6,11 @@
 // -------------------------------------------------------------------------------
 // @return [list]
 
-@function purge($list) {
+@function flint-purge($list) {
 	$result: ();
 
 	@each $item in $list {
-		@if is-true($item) {
+		@if flint-is-true($item) {
 			$result: append($result, $item, list-separator($list));
 		}
 	}

data/stylesheets/flint/functions/lib/_remove.scss

@@ -1,13 +1,13 @@
-// Removes value(s) $value from $list
+// Remove $value from $list
 // -------------------------------------------------------------------------------
 // @documentation http://sassylists.com/documentation/#remove
 // -------------------------------------------------------------------------------
 // @param $list [list] : list
-// @param $value [literal] : value to remove
+// @param $value [literal] : value to flint-remove
 // @param $recursive [bool] : enable / disable recursivity
 // -------------------------------------------------------------------------------
 // @return [list]
 
-@function remove($list, $value) {
-	@return replace($list, $value, null);
+@function flint-remove($list, $value) {
+	@return flint-replace($list, $value, null);
 }

data/stylesheets/flint/functions/lib/_replace-substring.scss

@@ -6,23 +6,29 @@
 // -------------------------------------------------------------------------------
 // @return [string]
 
-@function replace-substring($string, $substring, $new-substring: " ") {
-	// Loop through length of string
-	@for $i from 1 through str-length($string) {
-		// Get index and length of substring
-		$sub-index: str-index($string, $substring);
-		$sub-length: str-length($substring);
+@function flint-replace-substring($string, $substring, $new-substring: " ") {
+
+	// Use Ruby function if available
+	@if $flint__use-ruby-functions {
+		@return replace_substring($string, $substring, $new-substring);
+	} @else {
+		// Loop through length of string
+		@for $i from 1 through str-length($string) {
+			// Get index and length of substring
+			$sub-index: str-index($string, $substring);
+			$sub-length: str-length($substring);
+
+			// If count is index of substring
+			@if $i == $sub-index {
+				// Slice string to exclude substring
+				$string-before: str-slice($string, 1, $i - 1);
+				$string-after: str-slice($string, $i + $sub-length, str-length($string));
+				// Create new string
+				$string: $string-before + $new-substring + $string-after;
+			}
 
-		// If count is index of substring
-		@if $i == $sub-index {
-			// Slice string to exclude substring
-			$string-before: str-slice($string, 1, $i - 1);
-			$string-after: str-slice($string, $i + $sub-length, str-length($string));
-			// Create new string
-			$string: $string-before + $new-substring + $string-after;
 		}
 
+		@return $string;
 	}
-
-	@return $string;
 }