modular-scale 1.0.6 → 2.0.0.alpha1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 11a5c866b76f13e5501ae74c55ab575528a56f86
+  data.tar.gz: e706db9fa0902a6595831c0ac4c4a7592b26bfd7
+SHA512:
+  metadata.gz: ee2c1d671e279b41c69858efd3d1e5db9514502ea2c1cfe618d4a60cb0f3fbbb6a456ffed5c3f14d666f76f22838fed872b35f7a16d9d1f38b9e6e0f9d262cc5
+  data.tar.gz: 447e0e020b7df1af562d6402bb5ba07bbb2b5bc8ad075915f42a5976182a38acb73f4279bd5d51dcc3079d59f5f928dc3adcaaeae5f4979d141e7640bc9e6804

data/lib/modular-scale.rb

@@ -1,128 +1,29 @@
+# All gems that are required for this extension to work should go here.
+# These are the requires you would normally put in your config.rb file
+# By default, you should always included Compass. Do not include your
+#  extension.
 require 'compass'
-require 'sassy-math'
 
 # This tells Compass what your Compass extension is called, and where to find
 #  its files
-# Replace 'extension' with the name of your extension. Spaces allowed.
 extension_path = File.expand_path(File.join(File.dirname(__FILE__), ".."))
 Compass::Frameworks.register('modular-scale', :path => extension_path)
 
 # Version and date of version for your Compass extension.
-# Replace Extension with the name of your extension
+# Replace ModularScale with the name of your extension
 #  Letters, numbers, and underscores only
 #  Version is a number. If a version contains alphas, it will be created as
 #    a prerelease version
 #  Date is in the form of YYYY-MM-DD
 module ModularScale
-  VERSION = "1.0.6"
-  DATE = "2012-08-13"
+  VERSION = "2.0.0.alpha1"
+  DATE = "2013-12-20"
 end
 
 # This is where any custom SassScript should be placed. The functions will be  
 #  available on require of your extension without the need for users to import
 #  any partials. Uncomment below.
 
-# 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_fourth
-    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
-
-  # 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
+# module Sass::Script::Functions
+# 
+# end

data/license.md

@@ -0,0 +1,36 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Scott Kellum, Mason Wendell
+
+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.
+
+Modular Scale
+Copyright (C) 2013  Scott Kellum, Mason Wendell
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/stylesheets/_modular-scale.scss

@@ -1,310 +1,14 @@
-// SASSY MODULAR-SCALE
-// https://github.com/scottkellum/modular-scale
+@import "modular-scale/ratios";
 
-// Defaults
-$ratio: golden_ratio() !default;
-$base-size: 16px !default;
-$round-pixels: true !default;
+$ms-base: 1em !default;
+$ms-ratio: $golden !default;
 
-// Modular Scale function
-@function modular-scale($multiple, $base-size: $base-size, $ratio: $ratio, $round-pixels: $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);
-      @return nth($base-size, 1);
-    }
-    
-    // return just the simple $base-size value if it's not a list
-    @return $base-size;
-  }
-  
-  // if multiple base-sizes are passed in as a list
-  // 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" 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" 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" 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(power($ratio, $multiple) * $base-size) == "px" and $round-pixels == true {
-    @return round(power($ratio, $multiple) * $base-size);
-  }
-  @return power($ratio, $multiple) * $base-size;
-}
+@import "modular-scale/tests";
 
-// calculate values in using each base-size / ratio combination
-@function ms-multibase-multiratio($multiple, $base-size: $base-size, $ratio: $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);
-  
-  // take each base-size in turn
-  $k: 1;
-  @while $k <= length($base-size) {
-    
-    // add each $base-size to the list except the first
-    @if $k > 1 {
-      $scale-values: append($scale-values, nth($base-size, $k));
-    }
-    
-    // take each ratio in turn
-    $j: 1;
-    @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
-      @if $multiple > 0 {
-        
-        // up $multiple times
-        // and add the result to $scale-values
-        @for $i from 1 through $multiple {
-          $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: 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: 0;
-        $modular-scale: 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: $base-size, $ratio: $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);
-  
-  // take each base-size in turn
-  $k: 1;
-  @while $k <= length($base-size) {
-    
-    // add each $base-size to the list except the first
-    @if $k > 1 {
-      $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
-    @if $multiple > 0 {
-      
-      // up $multiple times
-      // and add the result to $scale-values
-      @for $i from 1 through $multiple {
-        $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: 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: 0;
-      $modular-scale: 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: $base-size, $ratio: $ratio) {
-  
-  // start with an empty list to place all values in
-  $scale-values: ();
-  
-  // If $multiple is a positive integer (up the scale)
-  @if $multiple > 0 {
-    
-    // take each ratio in turn
-    $j: 1;
-    @while $j <= length($ratio) {
-      
-      // reset $modular-scale for each set
-      $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: 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);
-    
-    // return the final value using the laced list
-    @return nth($scale-values, $multiple);
-  }
-  
-  // If $multiple is a negative integer (down the scale)
-  @if $multiple < 0 {
-    
-    // take each ratio in turn
-    $j: 1;
-    @while $j <= length($ratio) {
-      
-      // reset $modular-scale for each set
-      $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: power(nth($ratio, $j), -$i) * $base-size;
-        $scale-values: append($scale-values, $modular-scale);
-      }
-      $j: $j + 1;
-    }
-    
-    // sort decending
-    $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: $scale-values, $base-size: $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), 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), 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: $base-size, $ratio: $ratio, $round-pixels: $round-pixels) {
-  // Return the value from the Modular Scale function
-  @return modular-scale($multiple, $base-size, $ratio, $round-pixels);
-}
-
-// Write Modular Scale List
-@function modular-scale-list($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio, $round-pixels: $round-pixels) {
-  $ms-list: unquote("MS-LIST:");
-  @for $i from $start through $finish {
-    $ms-list: append($ms-list, ms($i, $base-size, $ratio, $round-pixels));
-  }
-  @return $ms-list;
-}
-
-@function ms-list($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio, $round-pixels: $round-pixels) {
-  @return modular-scale-list($start, $finish, $base-size, $ratio, $round-pixels);
-}
-
-@mixin modular-scale-list($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio, $round-pixels: $round-pixels) {
-  @debug modular-scale-list($start, $finish, $base-size, $ratio, $round-pixels);
-}
-
-@mixin ms-list($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio, $round-pixels: $round-pixels) {
-  @debug modular-scale-list($start, $finish, $base-size, $ratio, $round-pixels);
-}
-
-@mixin modular-scale-list-output($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio, $round-pixels: $round-pixels) {
-    MODULAR-SCALE-LIST {
-      ms-list: modular-scale-list($start, $finish, $base-size, $ratio, $round-pixels);
-    }
-  }
-
-@mixin ms-list-output($start: 0, $finish: 20, $base-size: $base-size, $ratio: $ratio, $round-pixels: $round-pixels) {
-  @include modular-scale-list-output($start, $finish, $base-size, $ratio, $round-pixels);
-}
-
-// Other libraries can easily query if this function is avalible
-$modular-scale-loaded: true;
+@import "modular-scale/cache";
+@import "modular-scale/pow";
+@import "modular-scale/calc";
+@import "modular-scale/generate-list";
+@import "modular-scale/sort-list";
+@import "modular-scale/function";
+@import "modular-scale/function-list";

data/stylesheets/modular-scale/_cache.scss

@@ -0,0 +1,25 @@
+// An empty cache map
+$MS-cache: ();
+
+@function ms-cache($Value, $Bases, $Ratios, $Return) {
+
+  $MS-new-map: ();
+
+  @if $Value >= 0 {
+    $MS-new-map: (
+      "#{$Bases} #{$Ratios}": (
+        pos: $Return,
+      ),
+    );
+  }  
+
+  @if $Value < 0 {
+    $MS-new-map: (
+      "#{$Bases} #{$Ratios}": (
+        neg: $Return,
+      ),
+    );
+  }  
+
+  @return map-merge($MS-cache, $MS-new-map);
+}

data/stylesheets/modular-scale/_calc.scss

@@ -0,0 +1,17 @@
+@function ms-calc($Value, $Base: $ms-base, $Ratio: $ms-ratio) {
+  
+  // If pow exists use it.
+  // It supports non-interger values!
+  @if $MS-pow-exists {
+
+    // The formula for figuring out modular scales is:
+    // (r^v)*b
+    @return pow($Ratio, $Value) * $Base;
+  }
+
+  // If not, use ms-pow().
+  // Not as fast or capable of non-integer exponents.
+  @else {
+    @return ms-pow($Ratio, $Value) * $Base;
+  }
+}

data/stylesheets/modular-scale/_function-list.scss

@@ -0,0 +1,60 @@
+// Outputs a list of values instead of a single value
+@function ms-list($Start: 0, $End: 0, $Bases: $ms-base, $Ratios: $ms-ratio) {
+  
+  $Positive-return: ();
+  $Negitive-return: ();
+  $Return: ();
+
+  @if $End >= 0 {
+    // Generate a list of all possible values
+    $Positive-return: ms-generate-list($End, $Bases, $Ratios);
+    
+    // Sort the generated lists
+    $Positive-return: ms-sort-list($Positive-return);
+
+    // Trim list
+    $Trim-list: ();
+    // If the starting value is a positive number
+    // trim the positive return from that
+    @if $Start >= 0 {
+      @for $i from ($Start + 1) through $End + 1 {
+        $Trim-list: join($Trim-list, nth($Positive-return, $i));
+      }
+    }
+    // If not, then include everything up to the end.
+    @else {
+      @for $i from 1 through $End + 1 {
+        $Trim-list: join($Trim-list, nth($Positive-return, $i));
+      }
+    }
+    $Positive-return: $Trim-list;
+  }
+  
+  // Generate a negitive list
+  @if $Start < 0 {
+    // Generate a list of all possible values
+    $Negitive-return: ms-generate-list($Start, $Bases, $Ratios);
+    
+    // Sort the generated lists
+    $Negitive-return: ms-sort-list($Negitive-return);
+
+    // Trim list
+    $Trim-list: ();
+    @if $End < 0 {
+      @for $i from abs($End) through abs($Start) {
+        $Trim-list: join($Trim-list, nth($Negitive-return, $i));
+      }
+    }
+    @else {
+      @for $i from 1 through abs($Start) {
+        $Trim-list: join($Trim-list, nth($Negitive-return, $i));
+      }
+    }
+    $Negitive-return: $Trim-list;
+  }
+  
+  // Join both positive and negitive possibilities.
+  $Return: join($Negitive-return, $Positive-return);
+
+  @return $Return;
+}

data/stylesheets/modular-scale/_function.scss

@@ -0,0 +1,62 @@
+// The main function that brings it all together
+@function ms($Value: 0, $Bases: $ms-base, $Ratios: $ms-ratio) {
+  
+  // If no multi-base or multi-ratio stuff is going on
+  // then just retrn the basic calculaiton
+  @if length($Bases) == 1 and length($Ratios) == 1 {
+    @return ms-calc($Value, $Bases, $Ratios);
+  }
+  
+  // Use cached values if they exist
+  @if $MS-maps-exist {
+    // Find the map
+    // it's labeld with the base and ratio values
+    @if map-get($MS-cache, "#{$Bases} #{$Ratios}") {
+      // Positive list
+      $MS-pos: map-get(map-get($MS-cache, "#{$Bases} #{$Ratios}"), pos);
+      // See if the map matches the range
+      @if $Value >= 0 and length($MS-pos) > $Value {
+        @return nth($MS-pos, $Value + 1);
+      }
+      // And again for negitive values
+      $MS-neg: map-get(map-get($MS-cache, "#{$Bases} #{$Ratios}"), neg);
+      @if $Value < 0 and length($MS-neg) > abs($Value - 1) {
+        @return nth($MS-neg, $Value - 1);
+      }
+    }
+    // If nothing matched criteria in map
+    // then just carry on with calculaitons.
+  }
+  
+  // Generate a list of all possible values
+  $Return: ms-generate-list($Value, $Bases, $Ratios);
+  
+  // Sort the generated lists
+  $Return: ms-sort-list($Return);
+
+  // Cache
+  @if $MS-maps-exist {
+    $MS-cache: ms-cache($Value, $Bases, $Ratios, $Return) !global;
+  }
+
+  // Normalize value for counting from 1
+  // Because CSS counts things from 1
+  // So Sass does as well
+  // So I get to write fun stuff like this
+  @if $Value >= 0 {
+    $Value: $Value + 1;
+  }
+  @else {
+    $Value: $Value - 1;
+  }
+
+  // Find the correct value in the list
+  $Return: nth($Return, $Value);
+
+  @return $Return;
+}
+
+// Same function, different name, for good measure.
+@function modular-scale($Value: 0, $Bases: $ms-base, $Ratios: $ms-ratio) {
+  @return ms($Value, $Bases, $Ratios);
+}

data/stylesheets/modular-scale/_generate-list.scss

@@ -0,0 +1,80 @@
+@function ms-generate-list($Value: 0, $Bases: $ms-base, $Ratios: $ms-ratio) {
+
+  // Create blank lists
+  $MS-list: ();
+  $MS-base-list: ();
+
+  // Loop through each ratio AND each base
+  // to generate all possibilities.
+  @each $Ratio in $Ratios {
+    @each $Base in $Bases {
+      
+      // Set base variables
+      $MS-base-list: ();
+      $Base-counter: 0;
+      
+      // Seed list with an initial value
+      @if $Base == nth($Bases, 1) {
+        $MS-base-list: $Base;
+      }
+      
+      // Find values on a positive scale
+      @if $Value > 0 {
+        
+        // Find lower values on the scale
+        $Base-counter: -1;
+        @while ms-calc($Base-counter, $Base, $Ratio) >= nth($Bases, 1) {
+          $MS-base-list: join($MS-base-list, ms-calc($Base-counter, $Base, $Ratio));
+          $Base-counter: $Base-counter - 1;
+        }
+        
+        // Find higher possible values on the scale
+        $Base-counter: 1;
+        @while ms-calc($Base-counter, $Base, $Ratio) <= ms-calc($Value, nth($Bases, 1), $ms-ratio) {
+          $MS-base-list: join($MS-base-list, ms-calc($Base-counter, $Base, $Ratio));
+          $Base-counter: $Base-counter + 1;
+        }
+      }
+
+      // Find values on a negitive scale
+      @if $Value < 0 {
+        
+        // Find lower values on the scale
+        $Base-counter: 1;
+        @while ms-calc($Base-counter, $Base, $Ratio) <= nth($Bases, 1) {
+          $MS-base-list: join($MS-base-list, ms-calc($Base-counter, $Base, $Ratio));
+          $Base-counter: $Base-counter + 1;
+        }
+
+        // Find higher possible values on the scale
+        $Base-counter: -1;
+        @while ms-calc($Base-counter, $Base, $Ratio) >= ms-calc($Value, nth($Bases, 1), $Ratio) {
+          $MS-calc: ms-calc($Base-counter, $Base, $Ratio);
+          // detect if the value excedes the main base value
+          @if $MS-calc < nth($Bases, 1) {
+            $MS-base-list: join($MS-base-list, $MS-calc);
+          }
+          $Base-counter: $Base-counter - 1;
+        }
+      }
+      
+      // reverse list if its largest to smallest
+      @if length($MS-base-list) > 1 {
+        @if nth($MS-base-list, 1) > nth($MS-base-list, length($MS-base-list)) {
+          $ms-reversed-list: ();
+          @each $Value in $MS-base-list {
+            $ms-reversed-list: join($Value, $ms-reversed-list);
+          }
+          $MS-base-list: $ms-reversed-list;
+        }
+      }
+
+      // Add new possibilities to the master list
+      $MS-list: append($MS-list, $MS-base-list, comma);
+
+    }
+  }
+  
+  // After all the possibilities are found, output a master list
+  @return $MS-list;
+}

data/stylesheets/modular-scale/_pow.scss

@@ -0,0 +1,39 @@
+// If a native exponent function doesnt exist
+// this one is needed.
+@function ms-pow($Base, $Exponent) {
+  
+  // Find and remove unit.
+  // Avoids messyness with unit calculations
+  $Unit: $Base * 0 + 1;
+  $Base: $Base/$Unit;
+
+  // This function doesnt support non-interger exponents.
+  // Warn the user about why this is breaking.
+	@if round($Exponent) != $Exponent {
+		@warn "Unfortunately, you need Compass to use non-integer exponents";
+	}
+
+  // Set up the loop, priming the return with the base.
+	$Return: $Base;
+  
+  // If the number is positive, multiply it.
+  @if $Exponent > 0 {
+    // Basic feedback loop as exponents
+    // are recursivley multiplied numbers.
+    @for $i from 1 to $Exponent {
+      $Return: $Return * $Base;
+    }
+  }
+  
+  // If the number is 0 or negitive
+  // divide instead of multiply.
+  @else {
+    @for $i from -1 to abs($Exponent) {
+      $Return: $Return / $Base;
+    }
+  }
+
+  // Return is now compounded redy to be returned.
+  // Add the unit back onto the number.
+	@return $Return * $Unit;
+}

data/stylesheets/modular-scale/_ratios.scss

@@ -0,0 +1,20 @@
+// Golden ratio
+$phi              : 1.618034          ;
+$golden           : $phi              ;
+
+$double-octave    : 4                 ;
+$major-twelfth    : 3                 ;
+$major-eleventh   : 2.666666667       ;
+$major-tenth      : 2.5               ;
+$octave           : 2                 ;
+$major-seventh    : 1.875             ;
+$minor-seventh    : 1.777777778       ;
+$major-sixth      : 1.666666667       ;
+$minor-sixth      : 1.6               ;
+$fifth            : 1.5               ;
+$augmented-fourth : 1.41421           ;
+$fourth           : 1.333333333       ;
+$major-third      : 1.25              ;
+$minor-third      : 1.2               ;
+$major-second     : 1.125             ;
+$minor-second     : 1.066666667       ;

data/stylesheets/modular-scale/_sort-list.scss

@@ -0,0 +1,92 @@
+// List sorting via a modified merge-sort algorythmn
+// http://en.wikipedia.org/wiki/Merge_sort
+
+@function ms-merge($A, $B) {
+  
+  $Return: ();
+  
+  // Some empty lists get passed through
+  // so just pass the other list throguh
+  @if length($A) == 0 {
+    @return $B;
+  }
+
+  // If lists fit next to each other, just merge them
+  // This helps performance skipping the need to check each value
+  @if nth($A, length($A)) < nth($B, 1) {
+    @return join($A, $B);
+  }
+  @if nth($B, length($B)) < nth($A, 1) {
+    @return join($B, $A);
+  }
+  
+  // Counters start at 1
+  $A-counter: 1;
+  $B-counter: 1;
+  
+  // Start looping through all numbers in array
+  @while $A-counter <= length($A) and $B-counter <= length($B) {
+    
+    // Check if the A value is smaller
+    // Uses or equal to avoid duplicate numbers
+    @if nth($A, $A-counter) <= nth($B, $B-counter) {
+      $Return: join($Return, nth($A, $A-counter));
+      $A-counter: $A-counter + 1;
+    }
+    
+    // Check if the B value is smaller
+    @elseif nth($A, $A-counter) > nth($B, $B-counter) {
+      $Return: join($Return, nth($B, $B-counter));
+      $B-counter: $B-counter + 1;
+    }
+  }
+  
+
+  // Run through remainder values in the list
+  @while $A-counter <= length($A) {
+    $Current: nth($A, $A-counter);
+    @if $Current != nth($Return, length($Return)) {
+      $Return: join($Return, $Current);
+    }
+    $A-counter: $A-counter + 1;
+  }
+  @while $B-counter <= length($B) {
+    $Current: nth($B, $B-counter);
+    @if $Current != nth($Return, length($Return)) {
+      $Return: join($Return, $Current);
+    }
+    $B-counter: $B-counter + 1;
+  }
+  
+  // Done! return is now sorted and complete
+  @return $Return;
+}
+
+// Pull it all together
+@function ms-sort-list($Lists) {
+  
+  $Return: ();
+
+  @each $List in $Lists {
+    @if $Return == () {
+      $Return: $List;
+    }
+    @else {
+      $Return: ms-merge($List, $Return);
+    }
+  }
+
+  // final cleanup of repeated items
+  $Last: null;
+  $New-list: ();
+  @each $Item in $Return {
+    @if $Item != $Last {
+      $New-list: join($New-list, $Item);
+    }
+    $Last: $Item;
+  }
+  $Return: $New-list;
+
+
+  @return $Return;
+}

data/stylesheets/modular-scale/_tests.scss

@@ -0,0 +1,28 @@
+// Feature testing
+
+
+// Test if the pow() function exists
+
+@function ms-pow-exists() {
+  @if pow(4, 2) == 16 {
+    @return true;
+  }
+  @return false;
+}
+
+$MS-pow-exists: ms-pow-exists();
+
+
+// Test if map capability exists
+// maps are used to cache calculations
+
+@function ms-maps-exist() {
+  @if function-exists(map-get) == true {
+    @return true;
+  }
+  @else {
+    @return false;
+  }
+}
+
+$MS-maps-exist: ms-maps-exist();

metadata

@@ -1,103 +1,70 @@
 --- !ruby/object:Gem::Specification
 name: modular-scale
 version: !ruby/object:Gem::Version
-  version: 1.0.6
-  prerelease: 
+  version: 2.0.0.alpha1
 platform: ruby
 authors:
-- Scott Kellum
-- Adam Stacoviak
-- Mason Wendell
+- First Last
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-13 00:00:00.000000000 Z
+date: 2013-12-20 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: sass
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: compass
   requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.12.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.12.1
-- !ruby/object:Gem::Dependency
-  name: sassy-math
-  requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: 0.12.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.5'
-description: Sassy Modular Scale calculates the incremental values of the modular
-  scale
+        version: 0.12.0
+description: A generalized Compass extension to build off of
 email:
-- scott@scottkellum.com
-- adam@stacoviak.com
-- mason@canarypromo.com
+- firstlast@extension.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- readme.md
+- license.md
 - lib/modular-scale.rb
 - stylesheets/_modular-scale.scss
-homepage: https://github.com/scottkellum/modular-scale
-licenses: []
+- stylesheets/modular-scale/_cache.scss
+- stylesheets/modular-scale/_calc.scss
+- stylesheets/modular-scale/_function-list.scss
+- stylesheets/modular-scale/_function.scss
+- stylesheets/modular-scale/_generate-list.scss
+- stylesheets/modular-scale/_pow.scss
+- stylesheets/modular-scale/_ratios.scss
+- stylesheets/modular-scale/_sort-list.scss
+- stylesheets/modular-scale/_tests.scss
+homepage: http://extension.com
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.24
+rubyforge_project: modular-scale
+rubygems_version: 2.0.3
 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.
+specification_version: 4
+summary: An easy to use system for writing and managing media queries.
 test_files: []

data/readme.md

@@ -1,138 +0,0 @@
-# Sassy Modular Scale
-
-## Put down the calculator and let Sass do the work.
-
-Sassy Modular Scale is a Sass based mixin that calculates the incremental values of the modular scale in proportion to a set size and ratio. It was inspired by and adapted from Tim Brown's modularscale.com.
-
-Sassy Modular Scale can be used as a [Compass](http://compass-style.org/) [extension](http://compass-style.org/help/tutorials/extensions/) and can be installed as a [Ruby gem](https://rubygems.org/gems/modular-scale).
-
-## Installation
-
-Usage requires Sass. Visit [sass-lang.com](http://sass-lang.com) to learn more and install.
-
-`gem install modular-scale`
-
-Add `require 'modular-scale'` to your Compass config file.
-
-Import the file into your stylesheets: `@import 'modular-scale';`
-
-## Usage
-
-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.
-
-```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
-```
-
-You can also write the output to your CSS file if you are using the terminal:
-
-```scss
-@include ms-list-output($start, $end, $base-size, $ratio);
-```
-
-As a side effect of the modular-scale functions a `power` function is also available.
-
-```scss
-@include power($base, $power);
-```
-
-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() );
-```
-
-
-
-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
-
-```scss
-.multibases {
-  width: ms(7, 16px 300px, golden() );
-}
-```
-
-You can use multiple $base-sizes and multiple $ratios together
-
-```scss
-.multibase-multiratio {
-  width: ms(7, 16px 300px, golden() fourth() );
-}
-```
-
-## Ratios
-
-Modular scale includes functions for a number of classic design and musical scale ratios. You can add your own ratios as well.
-
-By default, the variable `$ratio` is set to `golden()`.
-
-<table>
-
-  <tr><th>Function</th><th>Ratio</th><th>Decimal value</th></tr>
-
-  <tr><td>golden()</td><td>1:1.618</td><td>1.618</td></tr>
-  <tr><td>double-octave()</td><td>1:4</td><td>4</td></tr>
-  <tr><td>major-twelfth()</td><td>1:3</td><td>3</td></tr>
-  <tr><td>major-eleventh()</td><td>3:8</td><td>2.667</td></tr>
-  <tr><td>major-tenth()</td><td>2.5</td><td>2:5</td></tr>
-  <tr><td>octave()</td><td>1:2</td><td>2</td></tr>
-  <tr><td>major-seventh()</td><td>8:15</td><td>1.875</td></tr>
-  <tr><td>minor-seventh()</td><td>9:16</td><td>1.778</td></tr>
-  <tr><td>major-sixth()</td><td>3:5</td><td>1.667</td></tr>
-  <tr><td>minor-sixth()</td><td>5:8</td><td>1.6</td></tr>
-  <tr><td>fifth()</td><td>2:3</td><td>1.5</td></tr>
-  <tr><td>augmented-fourth()</td><td>1:√2</td><td>1.414</td></tr>
-  <tr><td>fourth()</td><td>3:4</td><td>1.333</td></tr>
-  <tr><td>major-third()</td><td>4:5</td><td>1.25</td></tr>
-  <tr><td>minor-third()</td><td>5:6</td><td>1.2</td></tr>
-  <tr><td>major-second()</td><td>8:9</td><td>1.125</td></tr>
-  <tr><td>minor-second()</td><td>15:16</td><td>1.067</td></tr>
-
-</table>
-
-Add your own ratio in Sass by setting a variable and passing that to modular-scale.
-
-```scss
-$my-variable: 1 / 3.14159265;
-$ratio: $my-variable;
-```
-
-## Inspiration
-
-Sassy Modular Scale was adapted from [modularscale.com](http://modularscale.com/) by Tim Brown ([@nicewebtype](http://twitter.com/nicewebtype)). Tim also wrote a supporting article at [A List Apart](http://www.alistapart.com/) titled ["More Meaningful Typography"](http://www.alistapart.com/articles/more-meaningful-typography/). Additional inspiration goes to [Robert Bringhurst](http://en.wikipedia.org/wiki/Robert_Bringhurst), author of ["The Elements of Typographic Style"](http://en.wikipedia.org/wiki/The_Elements_of_Typographic_Style) - specifically Chapter 8 titled "Shaping the Page"
-
-## 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/) ([@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.