modular-scale 0.0.5 → 1.0.rc.1

data/README.mdown

@@ -12,47 +12,69 @@ Usage requires Sass. Visit [sass-lang.com](http://sass-lang.com) to learn more a
 
 `gem install modular-scale`
 
-Then add `require 'modular-scale'` to your Compass config file.
+Add `require 'modular-scale'` to your Compass config file.
 
-## Alternative installation (without Compass)
+Import the file into your stylesheets: `@import 'modular-scale';`
 
-Compass provides a way for Sass mixins to be easily required into a project, but we also support the following:
+## Usage
 
-* Copy either `stylesheets/_modular-scale.sass` or `stylesheets/_modular-scale.scss` into your project's Sass directory
-* Import the file into your Sass stylesheet to access the mixins and functions. For example, `@import vendor/modular-scale`
+Modular-scale is used as a function. Simply pass it through in place of any value to generate a value based on a modular scale.
 
-## Usage
+```scss
+width: modular-scale(2); // two up the modular scale
+width: ms(2); // Shorthand for the line above
+width: modular-scale(2, 1em); // two up the modular scale with a base size of 1em
+width: modular-scale(2, 1em, $octave); // Same as above but on an octave scale
+```
+
+You can output a list to your terminal to help you find out what values are on your scale.
+
+```scss
+@include modular-scale-list($start, $end, $base-size, $ratio);
+```
+
+By default, it writes 0-20 on the scale. You can also use shorthand to make things more efficient.
+
+```scss
+@include ms-list; // shorthand without attributes
+@include ms-list($start, $end, $base-size, $ratio); // shorthand with attributes
+```
+
+As a side effect of the modular-scale functions a `exponent` function is also available.
+
+```scss
+@include exponent($base, $exponent);
+```
 
-Sassy Modular Scale can be used as a function, mixin or a mixin that generates a range of classes to `@extend`.
+Sassy Modular Scale can be used as a function, like so:
 
 ```scss
 // Use as a function. Fill in the multiple, base-size, and ratio
 height: modular-scale(7, 16px, $golden);
+```
 
-// Use as a mixin. Fill in the property, multiple, base-size, and ratio
-@include modular-scale(line-height, 1, 16px, $golden);
 
-// This method will generate a range of classes to `@extend`
-@include modular-scale-classes(6);
 
-h1 { @extend .ms-2; }
-h2 { @extend .ms-1; }
-h3 { @extend .ms-0; }
+You can also 'lace' multiple ratios together by passing them in as a list (space-separated)
 
-// You can also 'lace' multiple ratios together by 
-// passing them in as a list (space-separated)
+```scss
 .lace {
   width: ms(7, 16px, $golden $fourth);
 }
+```
+
+You can also set the $base-size variable to a list to interrelate two significant known sizes in your design
+*note:* the starting point of the scale will always be the *lowest* value in this list
 
-// You can also set the $base-size variable to a list
-// to interrelate two significant known sizes in your design
-// note: the starting point of the scale will always be the *lowest* value in this list
+```scss
 .multibases {
   width: ms(7, 16px 300px, $golden);
 }
-  
-// You can use multiple $base-sizes and multiple $ratios together
+```
+
+You can use multiple $base-sizes and multiple $ratios together
+
+```scss
 .multibase-multiratio {
   width: ms(7, 16px 300px, $golden $fourth);
 }
@@ -61,25 +83,33 @@ h3 { @extend .ms-0; }
 
 ## Ratios
 
-Below is a list of Ratios to choose from. By default, the variable `$ratio` is set to `$golden`.
-
-* $golden: 1.618 
-* $double-octave: (4 / 1)
-* $major-twelfth: (3 / 1)
-* $major-eleventh: (8 / 3)
-* $major-tenth: (5 / 2)
-* $octave: (2 / 1)
-* $major-seventh: (15 / 8)
-* $minor-seventh: (16 / 9)
-* $major-sixth: (5 / 3)
-* $minor-sixth: (8 / 5)
-* $fifth: (3 / 2)
-* $augfourth: (1 / √2)
-* $fourth: (4 / 3)
-* $major-third: (5 / 4)
-* $minor-third: (6 / 5)
-* $major-second: (9 / 8)
-* $minor-second: (16 / 15)
+The included ratios are called by functions. You can add your own ratios as well.
+
+Below is a list of ratios to choose from. By default, the variable `$ratio` is set to `golden()`.
+
+* golden()
+* double-octave()
+* major-twelfth()
+* major-eleventh()
+* major-tenth()
+* octave()
+* major-seventh()
+* minor-seventh()
+* major-sixth()
+* minor-sixth()
+* fifth()
+* augfourth()
+* fourth()
+* major-third()
+* minor-third()
+* major-second()
+* minor-second()
+
+Add your own ratio in Sass by setting a variable and passing that to modular-scale.
+
+```scss
+$my-variable: 1 / 3.14159265;
+```
 
 ## Inspiration
 
@@ -87,10 +117,10 @@ Sassy Modular Scale was adapted from [modularscale.com](http://modularscale.com/
 
 ## License
 
-Copyright (c) 2011 [Scott Kellum](http://www.scottkellum.com/) ([@scottkellum](http://twitter.com/scottkellum)), [Adam Stacoviak](http://adamstacoviak.com/) ([@adamstac](http://twitter.com/adamstac)) and [Mason Wendell](http://thecodingdesigner.com/) ([@canarymason](http://twitter.com/canarymason))
+Copyright (c) 2011 [Scott Kellum](http://www.scottkellum.com/) ([@scottkellum](http://twitter.com/scottkellum)), [Adam Stacoviak](http://adamstacoviak.com/) ([@adamstac](http://twitter.com/adamstac)) and [Mason Wendell](http://thecodingdesigner.com/) ([@codingdesigner](http://twitter.com/codingdesigner))
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/modular-scale.rb

@@ -1,9 +1,115 @@
 require 'compass'
+require 'sassy-math'
 Compass::Frameworks.register("modular-scale", :path => "#{File.dirname(__FILE__)}/..")
 
+
 module ModularScale
-  
-  VERSION = "0.0.5"
-  DATE = "2011-09-15"
+  VERSION = "1.0.rc.1"
+  DATE = "2012-08-08"
+end
+
+
+# Modular Scale Sass Script
+module Sass::Script
+  class Number < Literal
+    # Comparison
+    def <=>(other)
+      value <=> other.value
+    end
+  end
+end
+
+module Sass::Script::Functions
+  # Modular Scale
+  def double_octave
+    value = 4 / 1.0
+    Sass::Script::Number.new(value)
+  end
+  def major_twelfth
+    value = 3 / 1.0
+    Sass::Script::Number.new(value)
+  end
+  def major_eleventh
+    value = 8 / 3.0
+    Sass::Script::Number.new(value)
+  end
+  def major_tenth
+    value = 5 / 2.0
+    Sass::Script::Number.new(value)
+  end
+  def octave
+    value = 2 / 1.0
+    Sass::Script::Number.new(value)
+  end
+  def major_seventh
+    value = 15 / 8.0
+    Sass::Script::Number.new(value)
+  end
+  def minor_seventh
+    value = 16 /9.0
+    Sass::Script::Number.new(value)
+  end
+  def major_sixth
+    value = 5 / 3.0
+    Sass::Script::Number.new(value)
+  end
+  def minor_sixth
+    value = 8 / 5.0
+    Sass::Script::Number.new(value)
+  end
+  def fifth
+    value = 3 / 2.0
+    Sass::Script::Number.new(value)
+  end
+  def augmented_forth
+    value = Math.sqrt(2) / 1.0
+    Sass::Script::Number.new(value)
+  end
+  def fourth
+    value = 4 / 3.0
+    Sass::Script::Number.new(value)
+  end
+  def major_third
+    value = 5 / 4.0
+    Sass::Script::Number.new(value)
+  end
+  def minor_third
+    value = 6 / 5.0
+    Sass::Script::Number.new(value)
+  end
+  def major_second
+    value = 9 / 8.0
+    Sass::Script::Number.new(value)
+  end
+  def minor_second
+    value = 16 / 15.0
+    Sass::Script::Number.new(value)
+  end
 
-end
+  # Lists
+  def sort_list(list)
+    sep = list.separator if list.is_a?(Sass::Script::List)
+    list = list.to_a.sort
+    Sass::Script::List.new(list, sep)
+  end
+  def reverse_list(list)
+    sep = list.separator if list.is_a?(Sass::Script::List)
+    list = list.to_a.reverse
+    Sass::Script::List.new(list, sep)
+  end
+  def trim_list(list, threshold, ascending)
+    # remove list items above or below a threshold
+    sep = list.separator if list.is_a?(Sass::Script::List)
+    list = list.to_a
+    if ascending.value
+      list = list.delete_if {
+        |x| x.value <= threshold.value
+      }
+    else
+      list = list.delete_if {
+        |x| x.value >= threshold.value
+      }
+    end
+    Sass::Script::List.new(list, sep)
+  end
+end

data/stylesheets/_modular-scale.sass

@@ -1,40 +1,17 @@
 // SASSY MODULAR-SCALE
 // https://github.com/scottkellum/modular-scale
 
-@charset "UTF-8"
-
-// Ratios
-$golden: 1.618 
-$gold: $golden
-$double-octave: (4 / 1)
-$major-twelfth: (3 / 1)
-$major-eleventh: (8 / 3)
-$major-tenth: (5 / 2)
-$octave: (2 / 1)
-$major-seventh: (15 / 8)
-$minor-seventh: (16 / 9)
-$major-sixth: (5 / 3)
-$minor-sixth: (8 / 5)
-$fifth: (3 / 2)
-$augfourth: (1 / 1.4142135623730950488) // (1 / √2)
-$fourth: (4 / 3)
-$major-third: (5 / 4)
-$minor-third: (6 / 5)
-$major-second: (9 / 8)
-$minor-second: (16 / 15)
-
 // Defaults
-$ratio: $golden !default
+$ratio: golden_ratio() !default
 $base-size: 16px !default
-$property: font-size !default
-$class-slug: ms !default
+$round_pixels: true !default
 
 // Modular Scale function
-@function modular-scale($multiple, $base-size, $ratio)
+@function modular-scale($multiple, $base-size, $ratio, $round_pixels)
   // return the $base-size if $multiple is zero
   @if $multiple == 0
     @if type-of($base-size) == 'list'
-      $base-size: sort-list($base-size)
+      $base-size: sort_list($base-size)
       @return nth($base-size, 1)
     // return just the simple $base-size value if it's not a list
     @return $base-size
@@ -43,36 +20,36 @@ $class-slug: ms !default
   // and multiple ratios are passed in as a list
   // calculate values in using each base-size / ratio combination
   @if type-of($base-size) == 'list' and type-of($ratio) == 'list'
-    @if unit(ms-multibase-multiratio($multiple, $base-size, $ratio)) == 'px'
+    @if unit(ms-multibase-multiratio($multiple, $base-size, $ratio)) == 'px' and $round_pixels == true
       @return round(ms-multibase-multiratio($multiple, $base-size, $ratio))
     @return ms-multibase-multiratio($multiple, $base-size, $ratio)
-    
+
   // if multiple base-sizes are passed in as a list
   // calculate values in using each base-size
   @if type-of($base-size) == 'list' and type-of($ratio) == 'number'
-    @if unit(ms-multibase($multiple, $base-size, $ratio)) == 'px'
+    @if unit(ms-multibase($multiple, $base-size, $ratio)) == 'px' and $round_pixels == true
       @return round(ms-multibase($multiple, $base-size, $ratio))
     @return ms-multibase($multiple, $base-size, $ratio)
-      
+
   // if multiple ratios are passed in as a list
   // calculate values in using each ratio
   @if type-of($base-size) == 'number' and type-of($ratio) == 'list'
-    @if unit(ms-multiratio($multiple, $base-size, $ratio)) == 'px'
+    @if unit(ms-multiratio($multiple, $base-size, $ratio)) == 'px' and $round_pixels == true
       @return round(ms-multiratio($multiple, $base-size, $ratio))
     @return ms-multiratio($multiple, $base-size, $ratio)
-    
+
   // If there are no lists just run the simple function
-  @if unit(exponent($ratio, $multiple) * $base-size) == 'px'
-    @return round(exponent($ratio, $multiple) * $base-size)
-  @return exponent($ratio, $multiple) * $base-size
-  
-  
+  @if unit(power($ratio, $multiple) * $base-size) == 'px' and $round_pixels == true
+    @return round(power($ratio, $multiple) * $base-size)
+  @return power($ratio, $multiple) * $base-size
+
+
 // calculate values in using each base-size / ratio combination
 @function ms-multibase-multiratio($multiple, $base-size, $ratio)
   // start with an empty list to place all values in
   $scale-values: ()
   // make sure base sizes are in ascending order
-  $base-size: sort-list($base-size)
+  $base-size: sort_list($base-size)
   // take each base-size in turn
   $k: 1
   @while $k <= length($base-size)
@@ -84,41 +61,41 @@ $class-slug: ms !default
     @while $j <= length($ratio)
       // reset $modular-scale for each set
       $modular-scale: nth($base-size, $k)
-      // do the scale for each base-size using this ratio 
+      // do the scale for each base-size using this ratio
       @if $multiple > 0
         // up $multiple times
-        // and add the result to $scale-values        
+        // and add the result to $scale-values
         @for $i from 1 through $multiple
-          $modular-scale: exponent(nth($ratio, $j), $i) * nth($base-size, $k)
+          $modular-scale: power(nth($ratio, $j), $i) * nth($base-size, $k)
           $scale-values: append($scale-values, $modular-scale)
         // and down until the value is lower than the lowest $base-size
         // and add the result to $scale-values
         $i: -1
         $modular-scale: nth($base-size, $k)
         @while $modular-scale >= nth($base-size, 1)
-          $modular-scale: exponent(nth($ratio, $j), $i) * nth($base-size, $k)
+          $modular-scale: power(nth($ratio, $j), $i) * nth($base-size, $k)
           $scale-values: append($scale-values, $modular-scale)
           $i: $i - 1
       @if $multiple < 0
         // do the scale down for each set to below 1px
-        $i: -1
+        $i: 0
         $modular-scale: nth($base-size, $k)
-        @while $modular-scale > 1
-          $modular-scale: exponent(nth($ratio, $j), $i) * nth($base-size, $k)
+        @while $i >= $multiple
+          $modular-scale: power(nth($ratio, $j), $i) * nth($base-size, $k)
           $scale-values: append($scale-values, $modular-scale)
           $i: $i - 1
       $j: $j + 1
     $k: $k + 1
   // return trimmed and sorted final list
   @return trim-sort($multiple, $scale-values, $base-size)
-    
-    
+
+
 // calculate values in using each base-size
 @function ms-multibase($multiple, $base-size, $ratio)
   // start with an empty list to place all values in
   $scale-values: ()
   // make sure base sizes are in ascending order
-  $base-size: sort-list($base-size)
+  $base-size: sort_list($base-size)
   // take each base-size in turn
   $k: 1
   @while $k <= length($base-size)
@@ -127,34 +104,34 @@ $class-slug: ms !default
       $scale-values: append($scale-values, nth($base-size, $k))
     // reset $modular-scale for each set
     $modular-scale: nth($base-size, $k)
-    // do the scale for each base-size using this ratio 
+    // do the scale for each base-size using this ratio
     @if $multiple > 0
       // up $multiple times
-      // and add the result to $scale-values        
+      // and add the result to $scale-values
       @for $i from 1 through $multiple
-        $modular-scale: exponent($ratio, $i) * nth($base-size, $k)
+        $modular-scale: power($ratio, $i) * nth($base-size, $k)
         $scale-values: append($scale-values, $modular-scale)
       // and down until the value is lower than the lowest $base-size
       // and add the result to $scale-values
       $i: -1
       $modular-scale: nth($base-size, $k)
       @while $modular-scale >= nth($base-size, 1)
-        $modular-scale: exponent($ratio, $i) * nth($base-size, $k)
+        $modular-scale: power($ratio, $i) * nth($base-size, $k)
         $scale-values: append($scale-values, $modular-scale)
         $i: $i - 1
     @if $multiple < 0
       // do the scale down for each set to below 1px
-      $i: -1
+      $i: 0
       $modular-scale: nth($base-size, $k)
-      @while $modular-scale > 1
-        $modular-scale: exponent($ratio, $i) * nth($base-size, $k)
+      @while $i >= $multiple
+        $modular-scale: power($ratio, $i) * nth($base-size, $k)
         $scale-values: append($scale-values, $modular-scale)
         $i: $i - 1
     $k: $k + 1
   // return trimmed and sorted final list
   @return trim-sort($multiple, $scale-values, $base-size)
 
-    
+
 // calculate values in using each ratio
 @function ms-multiratio($multiple, $base-size, $ratio)
   // start with an empty list to place all values in
@@ -168,11 +145,11 @@ $class-slug: ms !default
       $modular-scale: $base-size
       // do the scale using this ratio thru the multiple, and add the result to $scale-values
       @for $i from 1 through $multiple
-        $modular-scale: exponent(nth($ratio, $j), $i) * $base-size
+        $modular-scale: power(nth($ratio, $j), $i) * $base-size
         $scale-values: append($scale-values, $modular-scale)
       $j: $j + 1
-    // sort acsending      
-    $scale-values: sort-list($scale-values)
+    // sort acsending
+    $scale-values: sort_list($scale-values)
     // return the final value using the laced list
     @return nth($scale-values, $multiple)
   // If $multiple is a negative integer (down the scale)
@@ -184,137 +161,60 @@ $class-slug: ms !default
       $modular-scale: $base-size
       // do the scale using this ratio thru the multiple, and add the result to $scale-values
       @for $i from 1 through ($multiple * -1)
-        $modular-scale: exponent(nth($ratio, $j), -$i) * $base-size
+        $modular-scale: power(nth($ratio, $j), -$i) * $base-size
         $scale-values: append($scale-values, $modular-scale)
       $j: $j + 1
     // sort decending
-    $scale-values: sort-list($scale-values, 'dec')
+    $scale-values: reverse_list(sort_list($scale-values))
     // return the final value using the laced list
     @return nth($scale-values, $multiple * -1)
-    
-    
+
+
 // trim and sort the final list
 @function trim-sort($multiple, $scale-values, $base-size)
   @if $multiple > 0
     // trim list so we can count from the lowest $base-size
-    $scale-values: trim-list($scale-values, nth($base-size, 1))
-    // sort acsending      
-    $scale-values: sort-list($scale-values)
+    $scale-values: trim_list($scale-values, nth($base-size, 1), true)
+    // sort acsending
+    $scale-values: sort_list($scale-values)
     // return the final value using the laced list
     @return nth($scale-values, $multiple)
   @else
     // trim list so we can count from the lowest $base-size
-    $scale-values: trim-list($scale-values, nth($base-size, 1), 'dec')
-    // sort acsending      
-    $scale-values: sort-list($scale-values, 'dec')
+    $scale-values: trim_list($scale-values, nth($base-size, 1), false)
+    // sort acsending
+    $scale-values: reverse_list(sort_list($scale-values))
     // return the final value using the laced list
     @return nth($scale-values, -$multiple)
-  
-  
+
+
 /////////////////////////////////////////////////////////////////////////
-  
+
+// alias for golden_ratio()
+@function golden()
+  @return golden_ratio()
+
 // Shortcut
 @function ms($multiple, $base-size, $ratio)
   // Return the value from the Modular Scale function
   @return modular-scale($multiple, $base-size, $ratio)
 
-// Mixin
-// Deprecated. Use the modular-scale() function instead
-=modular-scale($property, $multiple, $base-size, $ratio)
-  // Print the $property and return the value from the Modular Scale function
-  @warn "The modular-scale mixin is deprecated. Instead use the function: width: modular-scale(3)" 
-  #{$property}: modular-scale($multiple, $base-size, $ratio)
-
-// Classes Mixin
-=modular-scale-classes($multiple, $property, $class-slug, $base-size, $ratio)
-  // Loop from 0 through the value of $multiple and generate a range of classes
-  @for $i from 0 through $multiple
-    .#{$class-slug}-#{$i}
-      // Print the $property and return the value from the Modular Scale function
-      #{$property}: modular-scale($i, $base-size, $ratio)
-      
-
-/////////////////////////////////////////////////////////////////////////
+// Write Modular Scale List
+@function modular-scale-list($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio)
+  $ms-list: unquote("MS-LIST:")
+  @for $i from $start through $finish
+    $ms-list: append($ms-list, ms($i, $base-size, $ratio))
+  @return $ms-list
 
+@function ms-list($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio)
+  @return modular-scale-list($start, $finish, $base-size, $ratio)
 
-// Sass exponent support
-@function exponent($base, $exponent)
-  // reset value
-  $value: $base
-  // positive intergers get multiplied
-  @if $exponent > 1
-    @for $i from 2 through $exponent
-      $value: $value * $base
-  // negitive intergers get divided. A number divided by itself is 1
-  @if $exponent < 1
-    @for $i from 0 through -$exponent
-      $value: $value / $base
-  // return the last value written
-  @return $value
+=modular-scale-list($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio)
+  @debug modular-scale-list($start, $finish, $base-size, $ratio)
 
+=ms-list($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio)
+  @debug modular-scale-list($start, $finish, $base-size, $ratio)
 
-// Sass list sorting support
-@function sort-list($list, $dir: 'asc')
-  // built-in list sorting in Sass would make this go away.
-  // declare some empty lists to put our new order and temporary values 
-  $new-order: ()
-  $temp: ()
-  // fill $temp with the contents of $list
-  $temp: join($temp, $list)
-  // if sorting ascending
-  @if $dir == 'asc'
-    // loop through all values in $list
-    @for $i from 1 through length($list)
-      // impossibly high starter value to compare
-      $low: 1000000
-      // check for lowest value in $temp
-      @for $j from 1 through length($temp)
-        @if nth($temp, $j) < $low
-          $low: nth($temp, $j)
-      // add lowest value to $new-order
-      $new-order: append($new-order, $low)
-      // empty $temp for the next comparison
-      $temp: ()
-      // re-populate $temp with remaining values to sort
-      @for $k from 1 through length($list)
-        @if nth($list, $k) > $low
-          $temp: append($temp, nth($list, $k))
-  @if $dir == 'dec'
-    // loop through all values in $list
-    @for $i from 1 through length($list)
-      // 0 starter value
-      $high: 0
-      // check for highest value in $temp
-      @for $j from 1 through length($temp)
-        @if nth($temp, $j) > $high
-          $high: nth($temp, $j)
-      $new-order: append($new-order, $high)
-      // empty $temp for the next comparison
-      $temp: ()
-      // re-populate $temp with remaining values to sort
-      @for $k from 1 through length($list)
-        @if nth($list, $k) < $high
-          $temp: append($temp, nth($list, $k))
-  @return $new-order
-  
-  
-// Sass list trimming support
-@function trim-list($list, $start, $dir: 'asc')
-  // built-in list trimming in Sass would make this go away.
-  // declare some empty lists to put our trimmed values
-  $trimmed: ()
-  // if sorting ascending
-  @if $dir == 'asc'
-    // loop through all values in $list
-    @for $i from 1 through length($list)
-      @if nth($list, $i) >= $start
-        $trimmed: append($trimmed, nth($list, $i))
-  @if $dir == 'dec'
-    // loop through all values in $list
-    @for $i from 1 through length($list)
-      @if nth($list, $i) <= $start
-        $trimmed: append($trimmed, nth($list, $i))
-  @return $trimmed
 
 // Other libraries can easily query if this function is avalible
-$modular-scale-loaded: true
+$modular-scale-loaded: true

metadata

@@ -1,69 +1,98 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: modular-scale
-version: !ruby/object:Gem::Version
-  version: 0.0.5
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 1
+  - 0
+  - rc
+  - 1
+  version: 1.0.rc.1
 platform: ruby
-authors:
+authors: 
 - Scott Kellum
 - Adam Stacoviak
 - Mason Wendell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-15 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-08-08 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: compass
-  requirement: &70108860747360 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 11
+        - 5
         version: 0.11.5
   type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sassy-math
   prerelease: false
-  version_requirements: *70108860747360
-description: Sassy Modular Scale calculates the incremental values of the modular
-  scale.
-email:
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  type: :runtime
+  version_requirements: *id002
+description: Sassy Modular Scale calculates the incremental values of the modular scale.
+email: 
 - scott@scottkellum.com
 - adam@stacoviak.com
-- mason@zivtech.com
+- mason@canarypromo.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - README.mdown
 - lib/modular-scale.rb
 - stylesheets/_modular-scale.sass
+has_rdoc: true
 homepage: https://github.com/scottkellum/modular-scale
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-      segments:
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
       - 0
-      hash: -3912929455498838517
-required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
       version: 1.3.6
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Sassy Modular Scale calculates the incremental values of the modular scale
-  in proportion to a set size and ratio. Inspired by and adapted from Tim Brown's
-  modularscale.com.
+summary: Sassy Modular Scale calculates the incremental values of the modular scale in proportion to a set size and ratio. Inspired by and adapted from Tim Brown's modularscale.com.
 test_files: []
+