graphite-sass 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a729fce009bac9a9d3ba1958ee974348ee835a6
-  data.tar.gz: 0d14b138dc1fc26908ed8f6b9e98e3428c1b4895
+  metadata.gz: d6dfdf2ba17c3ce27f5996b96139007e09168240
+  data.tar.gz: 53479525087dbf9bb1b462e34a73388e517d6b00
 SHA512:
-  metadata.gz: 3ac5f2adc48891ee67ff6ca97ea6be7b1b17227f1b1f0b8f3ea4580d228d519161569e7bd96dc57287b4fbc2a67ab07eb4639e6e4c10f642028d0ea53b30364c
-  data.tar.gz: 2da410c5f1a43a20c22a8c818019323d61701e2c2ad3951b36fb1991130c012deb543dcd4052e96f06e2aab5d3118a0f50c1505065c7b3fed8665053003aeee2
+  metadata.gz: 92025a770a52d24183e45870a7cebe407bbc9ec4bd3fe16c0acf42f4aadbfd36763b43838c6de227fe7bf8797e183a30b2f9d81c7065848eeaf591e6ff43f58a
+  data.tar.gz: cb5636454adcb5cb6fe7dc379a396b0b05f578910cce74aee27d5260722c5f044b3dc3023eb320387641e25dc0b37e3a6d6e44145bb750290909836a8fdddd20

data/README.md

@@ -1,16 +1,16 @@
 # Graphite [![Gem Version](https://badge.fury.io/rb/graphite-sass.svg)](http://badge.fury.io/rb/graphite-sass)
 
-Graphite imports a folder of fonts and automagically outputs font-face directives for each font into your stylesheet. Will write up better documentation soon.
+Graphite allows you to import fonts into your stylesheet in a syntax similar to Google Fonts. Quick and simple.
 
 ## Requirements
 
-* Sass `~> 3.3.0`
+* Sass `~> 3.2.0`
 
 ## Installation
 
 1. `gem install graphite-sass` / `bower install graphite-sass`
 2. Add `require "graphite"` to your `config.rb`
-3. Import into your stylesheet with `@import "graphite";`
+3. Import into your stylesheet with `@import "graphite"`
 
 ## Documentation
 
@@ -39,87 +39,56 @@ In order for Graphite to successfully import your fonts, please follow this conv
 
 > ###### name: \<string\>
 > ###### weight: \<100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900\>
-> ###### style: \<normal | italic\>
+> ###### style: \<normal | italic\> (defaults to normal if blank)
 > ###### extension: \<woff | woff2 | ttf | eot | svg | otf\>
 
 #### name-weight-style.extension
 
 Example,
-`helvetica-neue-400-italic.woff`, `helvetica-neue-400-normal.ttf`, `helvetica-neue-100-normal.svg`
-
-### Configuration
-
-These global variables can be changed according to your needs.
-
-```scss
-// Filename seperator
-// ----
-$graphite_seperator: "-" !global;
-
-// Prepend directory path
-// ----
-$graphite_chdir: ".." !global;
-```
-
-`$graphite_seperator` is used for the filename in the output file path. When the font gets parsed within Graphite and outputted into the `url(...)`,
-it will use this seperator variable for you guessed it, seperating the variabiles within your font's filename when rebuilding the parsed font's name.
-`$graphite_chdir` is used in the output file path to your font folder _from_ your stylesheet folder. For example, the path `url("../fonts/helvetica[...]")`
-has the `$graphite_chdir` variable (`".."`) placed at the beginning of the path. You can edit these variables according to your project needs, though these are
-the recommended settings.
+`helvetica-neue-400-italic.woff`, `helvetica-neue-400-normal.ttf`, `helvetica-neue-100.svg`
 
 ### Usage
 
 ```scss
-// Import fonts from $dir
-// ----
-// @param $dir [string] : directory to import fonts
-// @param $legacy-ie [bool] : support legacy ie
-// ----
-// @return $fonts [map] : imports fonts from $dir and creates
-//   a $var for each font family containing [string] name
-
-@include graphite("/fonts", true);
+@import "fonts/lato?styles=200,700,200-italic,700-italic";
+@import "fonts/helvetica-neue?styles=500";
 ```
 
-Graphite will also create a local Sass variable for each font-family, so with the example above we would have a `$helvetica-neue: "helvetica-neue"` variable to use within the stylesheet, such as for a font stack. Graphite does not handle creating font stacks; that is left up to you. Graphite will import the correct filetypes for each font-family. This check is run on a family-to-family basis, and not a font-to-font basis; be sure to include the same filetypes for each font in your font-family folder to avoid any 404 request errors.
-
 ### Output
 
 The output is similar to what Google Fonts does with their CSS. All fonts share the same font-family, and each fonts style and weight is assigned appropriately.
 
 ```scss
-$helvetica-neue: "helvetica-neue";
-
 @font-face {
-  font-family: "helvetica-neue";
+  font-family: "lato";
   font-weight: 200;
-  font-style: italic;
-  src: url("../fonts/helvetica-neue/helvetica-neue-200-italic.eot");
-  src: url("../fonts/helvetica-neue/helvetica-neue-200-italic.eot?#iefix") format("embedded-opentype"), url("../fonts/helvetica-neue/helvetica-neue-200-italic.woff") format("woff"), url("../fonts/helvetica-neue/helvetica-neue-200-italic.ttf") format("truetype"), url("../fonts/helvetica-neue/helvetica-neue-200-italic.svg#helvetica-neue") format("svg");
+  font-style: normal;
+  src: url("fonts/lato/lato-200.ttf") format("truetype");
 }
-
 @font-face {
-  font-family: "helvetica-neue";
-  font-weight: 200;
+  font-family: "lato";
+  font-weight: 700;
   font-style: normal;
-  src: url("../fonts/helvetica-neue/helvetica-neue-200-normal.eot");
-  src: url("../fonts/helvetica-neue/helvetica-neue-200-normal.eot?#iefix") format("embedded-opentype"), url("../fonts/helvetica-neue/helvetica-neue-200-normal.woff") format("woff"), url("../fonts/helvetica-neue/helvetica-neue-200-normal.ttf") format("truetype"), url("../fonts/helvetica-neue/helvetica-neue-200-normal.svg#helvetica-neue") format("svg");
+  src: url("fonts/lato/lato-700.ttf") format("truetype");
 }
-
 @font-face {
-  font-family: "helvetica-neue";
+  font-family: "lato";
+  font-weight: 200;
+  font-style: italic;
+  src: url("fonts/lato/lato-200-italic.ttf") format("truetype");
+}
+@font-face {
+  font-family: "lato";
   font-weight: 700;
   font-style: italic;
-  src: url("../fonts/helvetica-neue/helvetica-neue-700-italic.eot");
-  src: url("../fonts/helvetica-neue/helvetica-neue-700-italic.eot?#iefix") format("embedded-opentype"), url("../fonts/helvetica-neue/helvetica-neue-700-italic.woff") format("woff"), url("../fonts/helvetica-neue/helvetica-neue-700-italic.ttf") format("truetype"), url("../fonts/helvetica-neue/helvetica-neue-700-italic.svg#helvetica-neue") format("svg");
+  src: url("fonts/lato/lato-700-italic.ttf") format("truetype");
 }
-
 @font-face {
   font-family: "helvetica-neue";
-  font-weight: 700;
+  font-weight: 500;
   font-style: normal;
-  src: url("../fonts/helvetica-neue/helvetica-neue-700-normal.eot");
-  src: url("../fonts/helvetica-neue/helvetica-neue-700-normal.eot?#iefix") format("embedded-opentype"), url("../fonts/helvetica-neue/helvetica-neue-700-normal.woff") format("woff"), url("../fonts/helvetica-neue/helvetica-neue-700-normal.ttf") format("truetype"), url("../fonts/helvetica-neue/helvetica-neue-700-normal.svg#helvetica-neue") format("svg");
+  src: url("fonts/helvetica-neue/helvetica-neue-500.eot");
+  src: url("fonts/helvetica-neue/helvetica-neue-500.eot?#iefix") format("embedded-opentype"), url("fonts/helvetica-neue/helvetica-neue-500.woff") format("woff"), url("fonts/helvetica-neue/helvetica-neue-500.ttf") format("truetype"), url("fonts/helvetica-neue/helvetica-neue-500.svg#helvetica-neue") format("svg");
 }
 ```
 
@@ -127,10 +96,6 @@ $helvetica-neue: "helvetica-neue";
 
 [Ezekiel Gabrielse](http://ezekielg.com)
 
-## Credits
-
-[Scott Davis, for creating Sassy Hash](https://github.com/scottdavis/sassy_hash)
-
 ## License
 
 Graphite is available under the [MIT](http://opensource.org/licenses/MIT) license.

data/lib/graphite.rb

@@ -1,5 +1,7 @@
 require 'sass'
-require 'sassy_hash'
+require_relative "graphite/version"
+require_relative "graphite/importer"
+require_relative "graphite/monkeypatch"
 
 base_directory = File.expand_path(File.join(File.dirname(__FILE__), '..'))
 graphite_stylesheets_path = File.join(base_directory, 'stylesheets')
@@ -11,180 +13,5 @@ else
 end
 
 module Graphite
-    VERSION = "0.4.1"
-    DATE = "2014-08-18"
-end
-
-# Graphite : import fonts from font_dir into map
-# ----------------------------------------------------------------------------------------------------
-# @param font_dir [string] : path to top-level font directory
-# @param legacy_ie [bool] : support legacy versions of ie
-# @param debug [bool] : print debug information
-# ----------------------------------------------------------------------------------------------------
-# @return map of fonts, variable for each font
-
-module Sass::Script::Functions
-    def graphite(font_dir, legacy_ie, debug)
-
-        def opts(value)
-            value.options = options
-            value
-        end
-
-        # Set Sass variable to environment
-        def set_sass_var(literal, name = literal)
-            environment.global_env.set_var("#{name}", Sass::Script::Value::String.new(literal))
-        end
-
-        # Get weights and styles for passed font
-        def font_has_weights?(font)
-            # Keep hash of weights found
-            weights = {}
-            # Valid weights
-            valid_weights = ["100", "200", "300", "400", "500", "600", "700", "800", "900"]
-            # valid styles
-            valid_styles = ["normal", "italic"]
-            # Get weights for font
-            valid_weights.each do | weight |
-                # Check filename for weight
-                if font.include?(weight)
-                    # Get styles for weight
-                    styles = []
-                    # Check filename for style
-                    valid_styles.each do | style |
-                        # Save to styles
-                        styles << style if font.include?(style)
-                    end
-                    # Keep hash of each weight
-                    w = {
-                        weight => {
-                            "styles" => styles
-                        }
-                    }
-                    # Merge weight into weights hash
-                    weights.merge!(w)
-                end
-            end
-            # Return weights
-            return weights
-        end
-
-        # Add style to passed weight
-        def set_font_style(font, style)
-            font.merge!(style) do | k, o, n |
-                # Merge styles
-                if o.is_a?(Hash)
-                    # Get key => value of old map
-                    o.each do | key, value |
-                        # Does new map have key?
-                        if n.has_key?(key)
-                            # Then concat values
-                            n.each do | k, v |
-                                value.concat(v)
-                            end
-                        end
-                    end
-                end
-            end
-        end
-
-        # Check if passed dir has fonts
-        def dir_has_fonts?(dir, debug)
-            # Keep hash of all fonts found
-            fonts = {}
-            # Valid font extensions
-            valid_extensions = ["eot", "otf", "woff2", "woff", "ttf", "svg"]
-
-            if File.exists?(dir)
-                # Print debug
-                puts "Fonts directory found: #{dir}" if debug
-                # Change dir to font_dir
-                Dir.chdir(dir) do
-                    # Search each dir
-                    Dir.glob("**/") do | d |
-                        # Check if dir has fonts
-                        Dir.chdir(d) do
-                            path = d
-                            # Clean up font name
-                            family = d.delete("/")
-                            # Print debug
-                            puts "Font family found: #{family}" if debug
-                            # Get matched extensions
-                            extensions = []
-                            # Get matched weights and styles
-                            variations = {}
-                            # Check dir for matching extensions
-                            valid_extensions.each do | ext |
-                                Dir.glob("*.#{ext}") do | filename |
-                                    puts "Font found: #{filename}" if debug
-                                    # Check if filename has weights
-                                    w = font_has_weights?(filename.to_s)
-                                    # Merge weights and styles
-                                    set_font_style(variations, w)
-                                    # Save extensions that don't already exist
-                                    extensions << ext if extensions.include?(ext) === false
-                                end
-                            end
-                            # Build out font hash
-                            font = {
-                                "#{family}" => {
-                                    "path" => path,
-                                    "extensions" => extensions,
-                                    "weights" => variations
-                                }
-                            }
-                            # Merge into fonts hash
-                            fonts = fonts.merge(font)
-                            # Set Sass variable for font family
-                            set_sass_var(family)
-                        end
-                    end
-                end
-            else
-                puts "Directory was not found: #{dir}. Aborting mission."
-            end
-            # Return hash of all fonts
-            return fonts
-        end
-
-        # Assert types
-        assert_type font_dir, :String, :font_dir
-        assert_type legacy_ie, :Bool, :legacy_ie
-        assert_type debug, :Bool, :debug
-
-        # Cast to bool
-        legacy_ie = legacy_ie.to_bool
-        debug = debug.to_bool
-
-        # Define root path up to current working directory
-        root = Dir.pwd
-
-        # Clean up font_dir
-        font_dir = unquote(font_dir).to_s
-
-        # Define dir path
-        dir_path = root
-        dir_path += font_dir
-
-        # Normalize windows path
-        dir_path = Sass::Util.pathname(dir_path)
-
-        # Create Sass variable for font path
-        set_sass_var(font_dir, 'graphite_font_dir')
-
-        # Font naming convention : name-weight-variant.extension
-        fonts = {
-            "legacy-ie" => legacy_ie,
-        }
-
-        # Get all fonts in dir
-        f = dir_has_fonts?(dir_path, debug)
-
-        # Merge results into fonts
-        fonts = fonts.merge(f)
-
-        # Convert hash to map, return
-        Sass::Script::Value::Map.new(SassyHash[fonts])
-    end
-    declare :graphite, [:font_dir]
+    Sass::Script::Functions.send(:include, Graphite)
 end

data/lib/graphite/importer.rb

@@ -0,0 +1,207 @@
+require "sass"
+require "cgi/core"
+
+module Graphite
+    class Importer < Sass::Importers::Filesystem
+
+        FONT_EXTENSIONS = [
+            "eot",
+            "woff2",
+            "woff",
+            "otf",
+            "ttf",
+            "svg"
+        ]
+
+        FONT_WEIGHTS = [
+            "100",
+            "200",
+            "300",
+            "400",
+            "500",
+            "600",
+            "700",
+            "800",
+            "900"
+        ]
+
+        FONT_STYLES = [
+            "normal",
+            "italic",
+            "oblique"
+        ]
+
+        def find(name, options)
+            if options[:filename]
+                if name.include? "?styles="
+                    find_fonts(name, options[:filename], options)
+                else
+                    super(name, options)
+                end
+            else
+                nil
+            end
+        end
+
+        def key(name, options)
+             ["Graphite:" + File.dirname(File.expand_path(name)), File.basename(name)]
+        end
+
+        def to_s
+            "Graphite::Importer"
+        end
+
+        protected
+
+        def find_fonts(name, base, options)
+
+            # Directory path
+            @font_family_path = strip_params(name)
+
+            # Get font name
+            @font_family_name = File.basename(@font_family_path)
+
+            # Get params from URI
+            @font_family_styles = get_params(name)
+
+            # Hash of fonts
+            @fonts = {
+                "#{@font_family_name}" => {
+                    "path" => @font_family_path,
+                    "styles" => {}
+                }
+            }
+
+            # Make sure path exists, else throw SyntaxError
+            if File.exists?(@font_family_path)
+                # Now loop through each weight and find match with ext
+                @font_family_styles.each do |style|
+
+                    # Keep array of matching extensions
+                    extensions = []
+
+                    # Empty path for font file
+                    path = ""
+
+                    # Loop over each extension
+                    FONT_EXTENSIONS.each do |ext|
+                        # Check if the file exists with passed param
+                        if File.exists?("#{@font_family_path}/#{@font_family_name}-#{style}.#{ext}")
+                            # Save ext
+                            extensions << ext unless extensions.include? ext
+                            # Grab path
+                            path = "#{@font_family_path}/#{@font_family_name}-#{style}"
+                        end
+                    end
+
+                    # Create hash of style and extensions
+                    font = {
+                        "#{style}" => {
+                            "path" => path,
+                            "extensions" => extensions,
+                            "weight" => get_weight(style),
+                            "style" => get_style(style) || "normal"
+                        }
+                    }
+
+                    # Merge into main fonts hash
+                    unless extensions.empty?
+                        @fonts[@font_family_name]["styles"].merge!(font)
+                    else
+                        raise ArgumentError, "Font family contained no valid fonts for: #{@font_family_name}-#{style}. Import failed."
+                    end
+                end
+            else
+                raise ArgumentError, "Font family to import could not be found, or it's unreadable: #{@font_family_path}."
+            end
+
+            unless @fonts.nil?
+                Sass::Engine.new(output_fonts(@fonts), options.merge(
+                    :filename => Pathname.new(base).to_s,
+                    :importer => self,
+                    :syntax => :scss
+                ))
+            end
+        end
+
+        def get_weight(filename)
+            FONT_WEIGHTS.any? do |weight|
+                if filename.include? weight
+                    return weight
+                end
+            end
+        end
+
+        def get_style(filename)
+            FONT_STYLES.any? do |style|
+                if filename.include? style
+                    return style
+                end
+            end
+        end
+
+        def get_params(uri)
+            CGI.parse(URI.parse(uri).query)["styles"].to_s[2..-3].split(",")
+        end
+
+        def strip_params(name)
+            name.include?("?") ? name[0..name.rindex("?")-1] : name
+        end
+
+        private
+
+        def output_fonts(fonts)
+            content = ""
+
+            fonts.each do |font, keys|
+                keys["styles"].each do |style, atts|
+                    content += "@font-face {\n"
+
+                    # Font attributes
+                    content += "\tfont-family: \"#{font}\";\n"
+                    content += "\tfont-weight: #{atts["weight"]};\n"
+                    content += "\tfont-style: #{atts["style"]};\n"
+
+                    # Include this for IE9
+                    if atts["extensions"].include? "eot"
+                        content += "\tsrc: url('#{atts["path"]}.eot');\n"
+                    end
+
+                    # Create array of src urls
+                    src = []
+
+                    # Push extensions to src arr if match
+                    if atts["extensions"].include? "eot"
+                        src << "url('#{atts["path"]}.eot?#iefix') format('embedded-opentype')"
+                    end
+                    if atts["extensions"].include? "woff2"
+                        src << "url('#{atts["path"]}.woff2') format('woff2')"
+                    end
+                    if atts["extensions"].include? "woff"
+                        src << "url('#{atts["path"]}.woff') format('woff')"
+                    end
+                    if atts["extensions"].include? "otf"
+                        src << "url('#{atts["path"]}.otf') format('opentype')"
+                    end
+                    if atts["extensions"].include? "ttf"
+                        src << "url('#{atts["path"]}.ttf') format('truetype')"
+                    end
+                    if atts["extensions"].include? "svg"
+                        src << "url('#{atts["path"]}.svg##{font}') format('svg')"
+                    end
+
+                    # Join src together
+                    unless src.empty?
+                        content += "\tsrc: #{src.join(",")}\n;"
+                    else
+                        raise ArgumentError, "Font family contained no valid font extensions: #{font}. Import failed."
+                    end
+
+                    content += "}\n"
+                end
+            end
+
+            content
+        end
+    end
+end

data/lib/graphite/monkeypatch.rb

@@ -0,0 +1,19 @@
+require_relative "importer"
+
+# Taken from https://github.com/chriseppstein/sass-css-importer/blob/master/lib/sass/css_importer/monkey_patches.rb
+# TODO: This feels wrong, surely there must be a better way to handle this
+
+class Sass::Engine
+    alias initialize_without_graphite_importer initialize
+
+    def initialize(template, options={})
+        initialize_without_graphite_importer(template, options)
+
+        graphite_importer = self.options[:load_paths].find {|lp| lp.is_a?(Graphite::Importer) }
+
+        unless graphite_importer
+            root = File.dirname(options[:filename] || ".")
+            self.options[:load_paths] << Graphite::Importer.new(root)
+        end
+    end
+end

data/lib/graphite/version.rb

@@ -0,0 +1,4 @@
+module Graphite
+    VERSION = "0.5.0"
+    DATE = "2014-10-07"
+end

metadata

@@ -1,54 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: graphite-sass
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Ezekiel Gabrielse
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-18 00:00:00.000000000 Z
+date: 2014-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sass
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: 3.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 3.3.0
-- !ruby/object:Gem::Dependency
-  name: sassy_hash
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.6
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.6
-description: Graphite imports a folder of fonts and automagically outputs font-face
-  directives for each font into your stylesheet.
+        version: 3.2.0
+description: Graphite allows you to import fonts into your stylesheet in a syntax
+  similar to Google Fonts. Quick and simple.
 email:
 - ezekg@yahoo.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
+- lib/graphite/importer.rb
+- lib/graphite/monkeypatch.rb
+- lib/graphite/version.rb
 - lib/graphite.rb
-- stylesheets/_graphite.scss
+- README.md
 homepage: https://github.com/ezekg/Graphite/
 licenses:
 - MIT
@@ -57,22 +45,21 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
-- stylesheets
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: '0'
 requirements: []
 rubyforge_project: graphite
-rubygems_version: 2.2.2
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
-summary: Graphite imports a folder of fonts and automagically outputs their font-face
-  directives.
+summary: Graphite allows you to import fonts into a syntax similar to Google Fonts.
+  Quick and simple.
 test_files: []

data/stylesheets/_graphite.scss

@@ -1,170 +0,0 @@
-// Filename seperator
-// ----
-// @var [string] : used when rebuilding parsed filenames
-// ----
-$graphite_seperator: "-" !global;
-
-// Prepend directory path
-// ----
-// @var [string] : prepends string to asset path in font-face output
-// ----
-$graphite_chdir: ".." !global;
-
-// Relative asset paths
-// ----
-// @var [bool] : removes leading slash for asset path in font-face output
-// ----
-$graphite_relative_assets: false !global;
-
-// Checks if item is map
-// ----
-// @param $n [literal] : item
-// ----
-// @return [bool]
-
-@function graphite-is-map($n) {
-    @return type-of($n) == "map";
-}
-
-// Fetch value from key in map
-// ----
-// @param $map [map] : map to fetch from
-// @param $keys [list] : list of keys
-// ----
-// @return fetched literal | false
-
-@function graphite-map-fetch($map, $keys) {
-	$has-key: graphite-is-map($map) and map-has-key($map, nth($keys, 1)) and map-get($map, nth($keys, 1)) or false;
-	$length: length($keys);
-
-	@if $has-key and $length > 1 {
-		$remainder: ();
-
-		@for $i from 2 through $length {
-			$remainder: append($remainder, nth($keys, $i))
-		}
-
-		@return graphite-map-fetch($has-key, $remainder);
-	}
-
-	@return $has-key;
-}
-
-// Import fonts from $dir
-// ----
-// @param $dir [string] : directory to import fonts
-// @param $legacy-ie [bool] : support legacy ie
-// ----
-// @return $fonts [map] : imports fonts from $dir and creates
-//   a $var for each font family containing [string] name
-
-@mixin graphite($dir, $legacy-ie: false, $debug: false) {
-    $graphite_fonts: graphite("#{$dir}", $legacy-ie, $debug) !global;
-
-    // Make sure it's a valid map before attempting the loop
-    @if graphite-is-map($graphite_fonts) {
-        // Start legacy with null value
-        $legacy-ie: null;
-
-    	// Loop over each label => font and output a @font-face directive
-    	@each $key, $value in $graphite_fonts {
-
-            // Support legacy IE?
-            @if $key == "legacy-ie" {
-                $legacy-ie: map-get($graphite_fonts, "legacy-ie");
-            }
-
-            @if graphite-is-map($value) {
-                // Font name
-                $name: $key;
-                // Path to top-level font directory
-                $path: $graphite_font_dir;
-                // Empty list of extensions
-                $extensions: ();
-                // Empty list of declared fonts
-                $history: ();
-
-                // Break down the font map
-                @each $k, $v in $value {
-
-                    // Font directory string
-                    @if $k == "path" {
-                        // Define path to font directory
-                        $path: $graphite_chdir + $path + "/" + $v;
-
-                        @if $graphite_relative_assets {
-                            $path: str-slice($path, 2, str-length($path));
-                        }
-                    }
-
-                    // List of extensions found
-                    @if $k == "extensions" {
-                        // Get each extension
-                        @each $ext in $v {
-                            // Append ext to list
-                            $extensions: append($extensions, $ext);
-                        }
-                    }
-
-                    // Map of font weights
-                    @if $k == "weights" {
-                        $weights: graphite-map-fetch($graphite_fonts, $key $k);
-
-                        // Iterate over each weight
-                        @each $weight, $styles in $weights {
-                            // Get list of styles for weight
-                            $styles: graphite-map-fetch($weights, $weight "styles");
-
-                            // Iterate over each style
-                            @each $style in $styles {
-                                // Contatenate vars to create filename
-                                $filename: "#{$name + $graphite_seperator + $weight + $graphite_seperator + $style}";
-
-                                // If filename has not already been declared
-                                @if not index($history, "#{$filename}") {
-                                    // Add filename to history
-                                    $history: append($history, $filename, "comma");
-
-                                    @font-face {
-                                        // Empty list of valid extensions
-                                        $types: (local('☺'));
-
-                                        font: {
-                                            family: "#{$name}";
-                                            weight: $weight;
-                                            style: $style;
-                                        }
-
-                                        // IE9
-                                        @if index($extensions, "eot") and $legacy-ie {
-                                            src: url("#{$path + $filename}.eot");
-                                        }
-
-                                        // Define value for each type
-                                        $eot: if(index($extensions, "eot"), url("#{$path + $filename}.eot?#iefix") format("embedded-opentype"), null);
-                                        $woff2: if(index($extensions, "woff2"), url("#{$path + $filename}.woff2") format("woff2"), null);
-                                        $woff: if(index($extensions, "woff"), url("#{$path + $filename}.woff") format("woff"), null);
-                                        $otf: if(index($extensions, "otf"), url("#{$path + $filename}.otf") format("opentype"), null);
-                                        $ttf: if(index($extensions, "ttf"), url("#{$path + $filename}.ttf") format("truetype"), null);
-                                        $svg: if(index($extensions, "svg"), url("#{$path + $filename + '.svg#' + $name}") format("svg"), null);
-
-                                        // Append to types list if not null
-                                        $types: if($eot != null, append($types, #{$eot}, "comma"), $types);
-                                        $types: if($woff2 != null, append($types, #{$woff2}, "comma"), $types);
-                                        $types: if($woff != null, append($types, #{$woff}, "comma"), $types);
-                                        $types: if($otf != null, append($types, #{$otf}, "comma"), $types);
-                                        $types: if($ttf != null, append($types, #{$ttf}, "comma"), $types);
-                                        $types: if($svg != null, append($types, #{$svg}, "comma"), $types);
-
-                                        // Output types
-                                        src: #{$types};
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-    	}
-    }
-}