singularitygs 1.0.alpha.2 → 1.0.0

data/stylesheets/singularitygs/helpers/_box-sizing.scss

@@ -0,0 +1,25 @@
+@import "compass/css3/shared";
+
+@mixin box-sizing($bs) {
+  $bs: unquote($bs);
+  @include experimental(box-sizing, $bs,
+    -moz, -webkit, not -o, not -ms, not -khtml, official
+  );
+
+  @if $bs == 'border-box' {
+    @if $legacy-support-for-ie6 or $legacy-support-for-ie7 {
+      *behavior: url("../behaviors/box-sizing/boxsizing.php");
+    }
+  }
+  @else {
+    *behavior: none;
+  }
+}
+
+%border-box {
+  @include box-sizing('border-box');
+}
+
+%content-box {
+  @include box-sizing('content-box');
+}

data/stylesheets/singularitygs/helpers/_clearfix.scss

@@ -0,0 +1,51 @@
+$legacy-support-for-ie6: false !default;
+$legacy-support-for-ie7: false !default;
+$legacy-support-for-mozilla: false !default;
+
+@mixin clearfix {
+  @if $legacy-support-for-ie6 and $legacy-support-for-ie7 and not $legacy-support-for-mozilla {
+    /* for IE 6/7 */
+    *zoom: expression(this.runtimeStyle.zoom="1", this.appendChild(document.createElement("br")).style.cssText="clear:both;font:0/0 serif");
+    /* non-JS fallback */
+    *zoom: 1;
+
+    &:before,
+    &:after {
+      content: "";
+      display: table;
+    }
+
+    &:after {
+      clear: both;
+    }
+  }
+  @else if $legacy-support-for-ie6 and $legacy-support-for-ie7 and $legacy-support-for-mozilla {
+    /* for IE 6/7 */
+    *zoom: expression(this.runtimeStyle.zoom="1", this.appendChild(document.createElement("br")).style.cssText="clear:both;font:0/0 serif");
+    /* non-JS fallback */
+    *zoom: 1;
+
+    &:before,
+    &:after {
+      content: ".";
+      display: block;
+      height: 0;
+      overflow: hidden;
+    }
+
+    &:after {
+      clear: both;
+    }
+  }
+  @else {
+    &:after {
+      content: "";
+      display: table;
+      clear: both;
+    }
+  }
+}
+
+%clearfix {
+  @include clearfix;
+}

data/stylesheets/singularitygs/helpers/_columns.scss

@@ -0,0 +1,15 @@
+@function end-row($span, $location, $columns) {
+  $columns: find-grid($columns);
+
+  @if $location == 'last' or $location == 'omega' {
+    @return true;
+  }
+  @else {
+    @if $location + ($span - 1) == column-count($columns) {
+      @return true;
+    }
+    @else {
+      @return false;
+    }
+  }
+}

data/stylesheets/singularitygs/helpers/_directions.scss

@@ -0,0 +1,37 @@
+//////////////////////////////
+// Find Opposite Direction
+//////////////////////////////
+@function opposite-direction($dir) {
+  @if $dir == 'left' {
+    @return right;
+  }
+  @else if  $dir == 'right' {
+    @return left;
+  }
+  @else if $dir == 'ltr' {
+    @return rtl;
+  }
+  @else if $dir == 'rtl' {
+    @return ltr;
+  }
+  @else {
+    @warn "#{$dir} is not a direction! Make sure your direction is all lowercase!";
+    @return false;
+  }
+}
+
+//////////////////////////////
+// Find Direction Name
+//////////////////////////////
+@function named-direction($dir) {
+  @if $dir == 'ltr' {
+    @return left;
+  }
+  @else if $dir == 'rtl' {
+    @return right;
+  }
+  @else {
+    @warn "#{$dir} is not a valid HTML direction! Make sure you are using a valid HTML direction";
+    @return false;
+  }
+}

data/stylesheets/singularitygs/helpers/_find.scss

@@ -0,0 +1,75 @@
+//////////////////////////////
+// Find Object
+//
+// Finds relevant object
+// Must be using Breakpoint to work properly
+//////////////////////////////
+@function find-object($haystack, $user-object: false) {
+  $length: length($haystack);
+
+  @if $user-object != false {
+    @return $user-object;
+  }
+  @else if $length > 1 {
+    $query-min: breakpoint-get-context('min-width');
+    $query-max: breakpoint-get-context('max-width');
+
+    // If we've got a min-width or max-width
+    @if $query-min or $query-max {
+      // Reverse the grid so we can step through it
+      $reverse-haystack: ();
+      @for $i from 2 through $length {
+        $reverse-haystack: append($reverse-haystack, nth($haystack, $i), comma);
+      }
+      $reverse-haystack: reverse($reverse-haystack);
+      $rg-length: $length - 1;
+
+      // Grab the largest and smallest MQs
+      $smallest: nth(nth($haystack, 2), 2);
+      $largest: nth(nth($reverse-haystack, 1), 2);
+      $context: $query-min;
+
+      @if not ($mobile-first) {
+        $context: $query-max;
+      }
+
+
+      // If it's smallest than the smallest MQ, use the 1st grid
+      @if $context < $smallest {
+        @return nth($haystack, 1);
+      }
+      // If it's larger than or equal to the largest MQ, use the last grid
+      @else if $context >= $largest {
+        @return nth(nth($reverse-haystack, 1), 1);
+      }
+      // If it's in between the smallest and largest, go run a check.
+      @else {
+        // Loop through each MQ.
+        @for $j from 1 through $rg-length {
+          $query: nth(nth($reverse-haystack, $j), 2);
+
+          // If the MQ is greather than or equal to the the MQ in question, use it! (mobile first)
+          @if ($mobile-first) {
+            @if $context >= $query {
+              @return nth(nth($reverse-haystack, $j), 1);
+            }
+          }
+          // If the MQ is less than or equal to the the MQ in question, use it! (not mobile first)
+          @else {
+            @if $context <= $query {
+              @return nth(nth($reverse-haystack, $j), 1);
+            }
+          }
+        }
+      }
+    }
+    // All else fails, return the first grid
+    @else {
+      @return nth($haystack, 1);
+    }
+  }
+  // All else fails, return the first grid
+  @else {
+    @return nth($haystack, 1);
+  }
+}

data/stylesheets/singularitygs/helpers/_sass-lists.scss

@@ -0,0 +1,71 @@
+// ---------------------------------------------------------------------------
+// Sass List Helpers
+//
+// - list-sum()
+// - query-list()
+
+// ---------------------------------------------------------------------------
+// Functions
+
+// Return the sum of all items in a list.
+//
+// list-sum($list)
+// - $list  : <list>
+@function list-sum($list) {
+  $sum: 0;
+  @each $item in $list {
+    $sum: $sum + $item;
+  }
+  @return $sum;
+}
+
+// Return list of index locations where a query appears in a list,
+// including unit queries.
+//
+// query-list($list, $query [, $mode])
+// - $list    : <list>
+// - $query   : <anything>
+// - $mode    : none | unit
+//            - "none" (default) runs a standard query.
+//            - "unit" finds all items with the same unit.
+@function query-list(
+  $list,
+  $query,
+  $mode: none
+) {
+  $return: ();
+
+  // loop through $list
+  @for $i from 1 through length($list) {
+    @if $mode == unit {
+      // if the list item matches the query, write where it is to the list.
+      @if unit(nth($list, $i)) == $query {
+        $return: append($return, $i);
+      }
+    }
+    @else {
+      // if the list item matches the query, write where it is to the list.
+      @if nth(nth($list, $i), 1) == $query {
+        $return: append($return, $i);
+      }
+    }
+  }
+
+  // if nothing matches then return false.
+  @if $return == () {
+    $return: false;
+  }
+
+  // return list.
+  @return $return;
+}
+
+// Reverses direction of a list
+@function reverse($list) {
+  $length: length($list);
+  $return: ();
+  @for $i from 0 to $length {
+    $return: append($return, nth($list, $length - $i), comma);
+  }
+  @return $return;
+}

data/stylesheets/singularitygs/helpers/_span-shared.scss

@@ -0,0 +1,9 @@
+@mixin span-shared {
+  @if $include-border-box {
+    @include box-sizing('border-box');
+  }
+
+  @if $include-clearfix {
+    @include clearfix;
+  }
+}

data/stylesheets/singularitygs/language/_parse-add.scss

@@ -0,0 +1,19 @@
+@function parse-add($definition) {
+  $grid: ();
+  $mq: false;
+  $mq-find: false;
+
+  @each $item in $definition {
+    @if $item != 'at' and $mq-find != true {
+      $grid: append($grid, $item, 'space');
+    }
+    @else if $item == 'at' {
+      $mq-find: true;
+    }
+    @else {
+      $mq: $item;
+    }
+  }
+
+  @return ($grid $mq);
+}

data/stylesheets/singularitygs/language/_parse-list.scss

@@ -0,0 +1,53 @@
+//////////////////////////////
+// Parse natural language string
+//
+// Retrieve values from the natural language string.
+// parse-string($var, $list)
+//  $var  : <string>
+//        - at/span/of or any other keywords.
+//        - 'span' queries the unprefixed span declaration.
+//        - 'at' can also query first, last, alpha, and omega.
+//  $list : <list>
+//        - A list like this: last 2 of (1 1 2) push 1
+//
+//////////////////////////////
+@function parse-span-list($var, $list) {
+
+  $found: false;
+
+  $grid: ();
+
+  // Loop through list.
+  @each $item in $list {
+
+    // if 'span' - return the first numeric.
+    // if keyword was found - return the following item.
+    @if (type-of($item) == number and $var == span and $found != 'grid') or $found == true {
+
+      // @if $found == true
+      @return $item;
+    }
+
+    // Special handling for Grids
+    @else if $item == $var and $var == 'of' {
+      $found: 'grid';
+    }
+
+    @else if $found == 'grid' {
+      @if type-of($item) == number {
+        $grid: append($grid, $item, 'space');
+      }
+      @else {
+        @return $grid;
+      }
+    }
+
+    // Any keyword - return the following value.
+    @else if $item == $var {
+      $found: true;
+    }
+  }
+
+  // Wasn't found.
+  @return false;
+}

data/stylesheets/singularitygs/language/_span.scss

@@ -0,0 +1,20 @@
+//////////////////////////////
+// "Natural Language" Parsing
+//
+// Keywords:
+//  span:     Column Span
+//  at:       Column Location
+//  of:       Context
+//  gutters:  Gutters
+//  output:   Output
+//////////////////////////////
+@mixin span($input) {
+  $span:      nth($input, 1);
+
+  $location:  parse-span-list('at', $input);
+  $context:   parse-span-list('of', $input);
+  $gutter:    parse-span-list('gutters', $input);
+  $output:    parse-span-list('output', $input);
+
+  @include grid-span($span, $location, $context, $gutter, $output)
+}

data/stylesheets/singularitygs/math/_columns.scss

@@ -0,0 +1,70 @@
+//////////////////////////////
+// Find width, in percentages, of the column span
+//////////////////////////////
+@function column-span($span, $location, $columns: false, $gutter: false) {
+
+  // Find the columns and gutters
+  $columns: find-grid($columns);
+  $gutter: find-gutter($gutter);
+
+  // Combine the columns and gutters
+  $columns-and-gutters: column-sum($columns, $gutter);
+
+  // Equal width columns are easy! Deal with them!
+  @if type-of($columns) == 'number' or length($columns) == 1 {
+    $span-and-gutters: $span + (($span - 1) * nth($gutter, 1));
+    @return $span-and-gutters / $columns-and-gutters * 100%;
+  }
+  // Asymmetric lists are harder, so we're going to treat them as their own columns
+  @else if type-of($columns) == 'list' or length($columns) > 1 {
+    // Build a fake column set
+    $sum: 0;
+    $holder: ();
+
+    @for $i from $location to ($location + $span) {
+      $holder: append($holder, nth(nth($columns, $i), 1), comma);
+    }
+
+    // Get sub-column sum
+    $span-and-gutters: column-sum($holder, $gutter);
+    @return $span-and-gutters / $columns-and-gutters * 100%;
+  }
+  @else {
+    @warn "Can't find a working set of columns! That's terrible!";
+    @return false;
+  }
+}
+
+//////////////////////////////
+// Find the total sum of the columns
+//////////////////////////////
+@function column-sum($columns, $gutter) {
+  @if type-of($columns) == 'number' or length($columns) == 1 {
+    @return nth($columns, 1) + ((column-count(nth($columns, 1)) - 1) * nth($gutter, 1));
+  }
+  @else if type-of($columns) == 'list' {
+    $sum: 0;
+    @each $column in $columns {
+      $sum: $sum + nth($column, 1);
+    }
+    $sum: $sum + (column-count($columns) - 1) * nth($gutter, 1);
+    @return $sum;
+  }
+}
+
+//////////////////////////////
+// Find the number of columns
+//////////////////////////////
+@function column-count($columns) {
+  @if type-of($columns) == 'number' {
+    @return $columns;
+  }
+  @if type-of($columns) == 'list' {
+    @if length($columns) == 1 {
+      @return nth($columns, 1);
+    }
+    @else {
+      @return length($columns);
+    }
+  }
+}