SassyStrings 0.0.1

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+
+* `1.0.0`: initial commit

data/README.md

@@ -0,0 +1,45 @@
+# SassyStrings
+
+Here is a [Compass Extension](http://compass-style.org/) providing you all functions you need to manipulate your [Sass](http://sass-lang.com/) strings.
+
+## What's in there? 
+
+* `char-at($string, $index)`: returns the character from `$string` at index `$index`
+* `levenshtein($a, $b)`: returns the Levenshtein distance betwee `$a` and `$b`
+* `str-count($string, $needle)`: counts number of occurrences of `$needle` in `$string`
+* `str-ends-width($string, $needle)`: returns wether `$string` ends with `$needle`
+* `str-explode($string, $separator)`: explodes `$string` on `$separator` occurrences 
+* `str-implode($list)`: implodes `$list` into a string
+* `str-last-index($string, $needle)`: returns last index of `$needle` in `$string`
+* `str-lcfirst($string)`: turns first letter of `$string` into lower case
+* `str-pad($string, $length, $pad: " ", $direction: left)`: pads `$string` with `$pad` to match `$length` starting from `$direction`
+* `str-printf($string, $elements...)`: replaces occurrences of `%s` in `$string` by elements from `$elements`
+* `str-repeat($string, $times)`: repeats `$string` `$times` times
+* `str-replace($string, $old, $new: "", $case-sensitive: true)`: replaces `$old` by `$new` in `$string` respecting `$case-sensitive`
+* `str-reverse($string)`: reverses string
+* `str-rot($string, $rot: 13)`: rotates letters in `$string` of `$rot` position in alphabet
+* `str-shuffle($string)`: shuffles letters in string
+* `str-split($string)`: splits `$string` into a list of characters
+* `str-starts-width($string, $needle)`: returns wether `$string` starts with `$needle`
+* `str-trim($string)`: removes white spaces before and after `$string`
+* `str-ucfirst($string)`: turns first letter of `$string` into upper case 
+* `str-word-count($string)`: counts number of words in `$string`
+* `stringify($literal)`: casts to stringify
+
+As well as default Sass core functions:
+
+* `str-index`
+* `str-slice`
+* `str-length`
+* `str-insert`
+* `to-lower-case`
+* `to-upper-case`
+
+If you feel like an explorer, you can have a look at the code [here](https://github.com/HugoGiraudel/SassyStrings/tree/master/stylesheets).
+
+## Requirements
+
+* Sass ~> 3.3.0
+* Compass ~> 1.0
+
+Some functions depend on other functions. If you include functions individually, make sure to check for these dependencies in their respective docs.

data/lib/SassyStrings.rb

@@ -0,0 +1,14 @@
+require 'compass'
+
+extension_path = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+Compass::Frameworks.register("SassyStrings", :path => "#{File.dirname(__FILE__)}/..")
+
+module SassyStrings
+  VERSION = "0.0.1"
+  DATE = "2014-02-16"
+end
+
+# Sassy String Functions
+module Sass::Script::Functions
+
+end

data/stylesheets/_SassyStrings.scss

@@ -0,0 +1,23 @@
+// -------------------------------------------------------------------------------
+// SassyStrings - A couple of advanced Sass string functions
+// -------------------------------------------------------------------------------
+// Repository: https://github.com/HugoGiraudel/SassyStrings/
+// -------------------------------------------------------------------------------
+
+@import "functions/char-at";
+@import "functions/levenshtein";
+@import "functions/str-count";
+@import "functions/str-ends-with";
+@import "functions/str-explode";
+@import "functions/str-implode";
+@import "functions/str-lcfirst";
+@import "functions/str-pad";
+@import "functions/str-repeat";
+@import "functions/str-replace";
+@import "functions/str-rot";
+@import "functions/str-shuffle";
+@import "functions/str-starts-with";
+@import "functions/str-trim";
+@import "functions/str-ucfirst";
+@import "functions/str-word-count";
+@import "functions/stringify";

data/stylesheets/functions/_char-at.scss

@@ -0,0 +1,25 @@
+// Return character from $string at $index
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [string] $index: index to inspect
+// ----------------------------------------------------------------------------------------------------
+// @return [string]
+
+@function char-at($string, $index) {
+  @if type-of($string) != "string" {
+    @warn "`char-at` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($index) != "number" {
+    @warn "`char-at` function expecting a number for $index; #{type-of($index)} given.";
+    @return false;
+  }
+
+  @if $index < 1 or $index > str-length($string) {
+    @warn "Out of bounds $index for `char-at`.";
+    @return false;
+  }
+
+  @return str-slice($string, $index, $index);
+}

data/stylesheets/functions/_levenshtein.scss

@@ -0,0 +1,99 @@
+// Calculating Levenshtein distance between two strings
+// ----------------------------------------------------------------------------------------------------
+// @param $a: first string
+// @param $b: second string
+// ----------------------------------------------------------------------------------------------------
+// @return [number]
+
+@function levenshtein($a, $b) {
+  @if type-of($a) != "string" {
+    @warn "`str-count` function expecting a string for $a; #{type-of($a)} given.";
+    @return false;
+  }
+
+  @if type-of($b) != "string" {
+    @warn "`str-count` function expecting a string for $b; #{type-of($b)} given.";
+    @return false;
+  }
+
+  $a: to-lower-case($a);
+  $b: to-lower-case($b);
+
+  $n: str-length($a);
+  $m: str-length($b);
+
+  $matrix: _matrix($n + 1, $m + 1);
+  $cost: _matrix($n, $m);
+
+  @if $a == $b { @return 0; }
+  @if $n == 0  { @return $m; }
+  @if $m == 0  { @return $n; }
+
+  @for $i from 0 through $n  {
+    @for $j from 0 through $m  {
+      $v: if($i == 0, $j, if($j == 0, $i, 0));
+      @if $v != 0 {
+        $matrix: _set-matrix($matrix, $i + 1, $j + 1, $v);
+      }
+      @if $i != 0 and $j != 0 {
+        $v: if(str-slice($a, $i, $i) == str-slice($b, $j, $j), 0, 1);
+        @if $v != 0 {
+          $cost: _set-matrix($cost, $i, $j, $v);
+        }
+      }
+    }
+  }
+
+  @for $i from 2 through length($matrix) {
+    @for $j from 2 through length(nth($matrix, $i)) {
+      $matrix: _set-matrix($matrix, $i, $j, min(_e($matrix, $i - 1, $j) + 1, _e($matrix, $i, $j - 1) + 1, _e($matrix, $i - 1, $j - 1) + _e($cost, $i - 1, $j - 1)));
+    }
+  }
+
+  @return _e($matrix, length($matrix), length(nth($matrix, 1)));
+}
+
+
+// Helper to target an element in a matrix
+// ----------------------------------------------------------------------------------------------------
+// @param $m: matrix
+// @param $x: x coord
+// @param $y: y coord
+// ----------------------------------------------------------------------------------------------------
+// @return [literal]
+
+@function _e($m, $x, $y) {
+  @return nth(nth($m, $x), $y);
+}
+
+// Helper instanciation a matrix of $x by $y
+// ----------------------------------------------------------------------------------------------------
+// @param $x: number of cols
+// @param $y: number of lines
+// ----------------------------------------------------------------------------------------------------
+// @return [list]
+
+@function _matrix($x, $y) {
+  $matrix: ();
+  @for $i from 1 through $x {
+    $tmp: ();
+    @for $y from 1 through $y {
+      $tmp: append($tmp, 0)
+    }
+    $matrix: append($matrix, $tmp);
+  }
+  @return $matrix;
+}
+
+// Helper assigning $value at $matrix[$x, $y]
+// ----------------------------------------------------------------------------------------------------
+// @param $matrix: matrix to update
+// @param $x: x coord
+// @param $y: y coord
+// @param $value: value to assign at $matrix[$x, $y]
+// ----------------------------------------------------------------------------------------------------
+// @return [list]
+
+@function _set-matrix($matrix, $x, $y, $value) {
+  @return set-nth($matrix, $x, set-nth(nth($matrix, $x), $y, $value));
+}

data/stylesheets/functions/_str-count.scss

@@ -0,0 +1,31 @@
+// Count the number of occurrences of $needle in $string
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [string] $needle: substring to count in $string
+// ----------------------------------------------------------------------------------------------------
+// @return [number] | false
+
+@function str-count($string, $needle) {
+  @if type-of($string) != "string" {
+    @warn "`str-count` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($needle) != "string" {
+    @warn "`str-count` function expecting a string for $needle; #{type-of($needle)} given.";
+    @return false;
+  }
+
+  $index: str-index($string, $needle);
+  $result: if($index, 1, 0);
+
+  @if $index {
+    @for $i from $index + str-length($needle) through str-length($string) {
+      @if str-slice($string, $i, $i + str-length($needle) - 1) == $needle {
+        $result: $result + 1;
+      }
+    }
+  }
+
+  @return $result;
+}

data/stylesheets/functions/_str-ends-with.scss

@@ -0,0 +1,20 @@
+// Check whether $string ends with $needle
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [string] $needle: substring to check
+// ----------------------------------------------------------------------------------------------------
+// @return [bool]
+
+@function str-ends-with($string, $needle) {
+  @if type-of($string) != "string" {
+    @warn "`str-starts-with` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($needle) != "string" {
+    @warn "`str-starts-with` function expecting a string for $needle; #{type-of($needle)} given.";
+    @return false;
+  }
+
+  @return str-slice($string, -1 * str-length($needle)) == $needle;
+}

data/stylesheets/functions/_str-explode.scss

@@ -0,0 +1,45 @@
+// Split $string into several parts using $delimiter
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [string] $delimiter: string to use as a delimiter to split $string
+// ----------------------------------------------------------------------------------------------------
+// @return [list] | false
+
+@function str-explode($string, $delimiter: '') {
+  @if type-of($string) != "string" {
+    @warn "`explode` function expecting a string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($delimiter) != "string" {
+    @warn "`explode` function expecting a string; #{type-of($delimiter)} given.";
+    @return false;
+  }
+
+  $result: ();
+  $length: str-length($string);
+
+  @if str-length($delimiter) == 0 {
+    @for $i from 1 through $length {
+      $result: append($result, str-slice($string, $i, $i));
+    }
+    @return $result;
+  }
+
+  $running: true;
+  $remaining: $string;
+
+  @while $running {
+    $index: str-index($remaining, $delimiter);
+    @if $index {
+      $slice: str-slice($remaining, 1, $index - 1);
+      $result: append($result, $slice);
+      $remaining: str-slice($remaining, $index + str-length($delimiter));
+    }
+    @else {
+      $running: false;
+    }
+  }
+
+  @return append($result, $remaining);
+}

data/stylesheets/functions/_str-implode.scss

@@ -0,0 +1,15 @@
+// Implode $list into a string
+// ----------------------------------------------------------------------------------------------------
+// @param [list] $list: list to convert to string
+// ----------------------------------------------------------------------------------------------------
+// @return [string]
+
+@function str-implode($list) {
+  $result: "";
+
+  @each $item in $list {
+    $result: $result + if(length($item) > 1, str-implode($item), $item);
+  }
+
+  @return $result;
+}

data/stylesheets/functions/_str-last-index.scss

@@ -0,0 +1,30 @@
+// Return last index of $needle in $string
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// ----------------------------------------------------------------------------------------------------
+// @return [number] | null | false
+
+@function str-last-index($string, $needle) {
+  @if type-of($string) != "string" {
+    @warn "`str-last-index` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($needle) != "string" {
+    @warn "`str-last-index` function expecting a string for $needle; #{type-of($needle)} given.";
+    @return false;
+  }
+
+  $index: str-index($string, $needle);
+  $result: $index;
+
+  @if $index {
+    @for $i from $index + str-length($needle) through str-length($string) {
+      @if str-slice($string, $i, $i + str-length($needle) - 1) == $needle {
+        $result: $i;
+      }
+    }
+  }
+
+  @return $result;
+}

data/stylesheets/functions/_str-lcfirst.scss

@@ -0,0 +1,14 @@
+// Lower case first character of $string
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// ----------------------------------------------------------------------------------------------------
+// @return [string]
+
+@function str-lcfirst($string) {
+  @if type-of($string) != "string" {
+    @warn "`str-lcfirst` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @return to-lower-case(str-slice($string, 1, 1)) + str-slice($string, 2);
+}

data/stylesheets/functions/_str-pad.scss

@@ -0,0 +1,45 @@
+// Pad $string from $direction with $pad to reach $length characters
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [number] $length: number of characters to go for in returned string
+// @param [string] $pad: string to use to pad $string
+// @param [string] $direction: direction left or right for padding
+// ----------------------------------------------------------------------------------------------------
+// @return [string] | false
+
+@function str-pad($string, $length, $pad: " ", $direction: left) {
+  @if type-of($string) != "string" {
+    @warn "`str-pad` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($pad) != "string" {
+    @warn "`str-pad` function expecting a string for $pad; #{type-of($pad)} given.";
+    @return false;
+  }
+
+  @if type-of($length) != "number" {
+    @warn "`str-pad` function expecting a number for $length; #{type-of($length)} given.";
+    @return false;
+  }
+
+  $direction: if(index(left right, $direction), $direction, left);
+  $new-string: $string;
+  $index: 1;
+
+  @if $length > str-length($string) {
+    @while str-length($new-string) < $length {
+      $remains: $length - str-length($new-string);
+      $pad: if($remains < str-length($pad), str-slice($pad, 1, $remains), $pad);
+      @if $direction == left {
+        $new-string: str-insert($new-string, $pad, $index);
+        $index: $index + str-length($pad);
+      }
+      @else {
+        $new-string: $new-string + $pad;
+      }
+    }
+  }
+
+  @return $new-string;
+}

data/stylesheets/functions/_str-printf.scss

@@ -0,0 +1,28 @@
+// Replace occurrences of %s in $string by $elements
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [arglist] $elements: strings to use for replacements in %s
+// ----------------------------------------------------------------------------------------------------
+// @return [string] | false
+
+@function str-printf($string, $elements...) {
+  @if type-of($string) != "string" {
+    @warn "`str-printf` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  $breaker: '%s'; 
+  $result: $string;
+
+  @for $i from 1 through length($elements) {
+    $index: str-index($result, $breaker);
+    @if $index {
+      $result: str-slice($result, 1, $index - 1) + stringify(nth($elements, $i)) + str-slice($result, $index + str-length($breaker));
+    }
+    @else {
+      @return $result;
+    }
+  }
+
+  @return $result;
+}

data/stylesheets/functions/_str-repeat.scss

@@ -0,0 +1,26 @@
+// Repeat $string $times times
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [number] $times: number of times to repeat $string
+// ----------------------------------------------------------------------------------------------------
+// @return [string] | false
+
+@function str-repeat($string, $times) {
+  @if type-of($string) != "string" {
+    @warn "`str-repeat` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($times) != "number" {
+    @warn "`str-repeat` function expecting a number for $times; #{type-of($times)} given.";
+    @return false;
+  }
+
+  $result: "";
+
+  @for $i from 1 through $times {
+    $result: $result + $string;
+  }
+
+  @return $result;
+}

data/stylesheets/functions/_str-replace.scss

@@ -0,0 +1,47 @@
+// Replace $old occurrences by $new in $string respecting $case-sensitive
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [string] $old: old substring to replace by $new
+// @param [string] $new: new substring to replace $old
+// @param [bool] $case-sensitive: case-sensitivity
+// ----------------------------------------------------------------------------------------------------
+// @return [string] | false
+
+@function str-replace($string, $old, $new: '', $case-sensitive: true) {
+  @if type-of($string) != "string" {
+    @warn "`str-replace` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($old) != "string" {
+    @warn "`str-replace` function expecting a string for $old; #{type-of($old)} given.";
+    @return false;
+  }
+
+  @if type-of($new) != "string" {
+    @warn "`str-replace` function expecting a string for $new; #{type-of($new)} given.";
+    @return false;
+  }
+
+  @if str-index($new, $old) {
+    @warn "The string to be replaced is contained in the new string. Infinite recursion avoided.";
+    @return $string;
+  }
+
+  $index: if(not $case-sensitive, str-index(to-lower-case($string), to-lower-case($old)),  str-index($string, $old));
+
+  @if $index and $new != $old {
+    $result: if($index != 1, quote(str-slice($string, 1, $index - 1)), '');
+
+    @for $i from $index through str-length($string) {
+      @if $i < $index or $i >= $index + str-length($old) {
+        $result: $result + str-slice($string, $i, $i);
+      }
+    }
+
+    @return quote(str-replace(str-insert($result, $new, $index), $old, $new, $case-sensitive)); 
+  }
+
+  @return $string;
+}
+

data/stylesheets/functions/_str-reverse.scss

@@ -0,0 +1,20 @@
+// Reverse $string
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// ----------------------------------------------------------------------------------------------------
+// @return [string] | false
+
+@function str-reverse($string) {
+  @if type-of($string) != "string" {
+    @warn "`str-reverse` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  $result: "";
+
+  @for $i from str-length($string) * -1 through -1 {
+    $result: $result + str-slice($string, abs($i), abs($i));
+  }
+
+  @return $result;
+}

data/stylesheets/functions/_str-rot.scss

@@ -0,0 +1,43 @@
+// Rotate all characters from the alphabet in $string by $rot positions
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [number] $rot: number of positions to switch in alphabet
+// ----------------------------------------------------------------------------------------------------
+// @return [string] | false
+
+@function str-rot($string, $rot: 13) {
+  @if type-of($string) != "string" {
+    @warn "`str-rot` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($rot) != "number" {
+    @warn "`str-rot` function expecting a number for $rot; #{type-of($rot)} given.";
+    @return false;
+  }
+
+  $alphabet: a b c d e f g h i j k l m n o p q r s t u v w x y z;
+  $result: "";
+  $rot: if(type-of($rot) == "number", floor($rot), 13);
+
+  @for $i from 1 through str-length($string) {
+    $char: str-slice($string, $i, $i);
+    $index: index($alphabet, to-lower-case($char));
+    $is-caps: $index and (index($alphabet, to-lower-case($char)) != index($alphabet, $char));
+    $new-char: if($index, 
+      if($index + $rot > length($alphabet), 
+        nth($alphabet, $index + $rot - length($alphabet)), 
+        nth($alphabet, $index + $rot)
+      ),
+      $char
+    );
+
+    @if $is-caps {
+      $new-char: to-upper-case($new-char);
+    }
+
+    $result: $result + $new-char;
+  }
+
+  @return $result;
+}

data/stylesheets/functions/_str-shuffle.scss

@@ -0,0 +1,26 @@
+// Shuffle characters from $string
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// ----------------------------------------------------------------------------------------------------
+// @return [string]
+
+@function str-shuffle($string) {
+  @return str-implode(_shuffle(str-explode($string)));
+}
+
+// Shuffle a list
+// ----------------------------------------------------------------------------------------------------
+// @param [list] $list: shuffle a list
+// ----------------------------------------------------------------------------------------------------
+// @return [list]
+
+@function _shuffle($list) {
+  @for $i from -1 * length($list) through -1 {
+    $i: abs($i);
+    $j: random(length($list) - 1) + 1;
+    $tmp: nth($list, $i);
+    $list: set-nth($list, $i, nth($list, $j));
+    $list: set-nth($list, $j, $tmp);
+  }
+  @return $list;
+}

data/stylesheets/functions/_str-starts-with.scss

@@ -0,0 +1,20 @@
+// Check whether $string stars with $needle
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// @param [string] $needle: substring to check
+// ----------------------------------------------------------------------------------------------------
+// @return [bool] | false
+
+@function str-starts-with($string, $needle) {
+  @if type-of($string) != "string" {
+    @warn "`str-starts-with` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @if type-of($needle) != "string" {
+    @warn "`str-starts-with` function expecting a string for $needle; #{type-of($needle)} given.";
+    @return false;
+  }
+
+  @return str-slice($string, 1, str-length($needle)) == $needle;
+}

data/stylesheets/functions/_str-trim.scss

@@ -0,0 +1,30 @@
+// Remove all trailing and leading whitespaces from $string
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// ----------------------------------------------------------------------------------------------------
+// @return [string] | false
+
+@function str-trim($string) {
+  @if type-of($string) != "string" {
+    @warn "`str-trim` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  $start: 1;
+  $end: str-length($string);
+
+  @for $i from 1 through str-length($string) {
+    $first: str-slice($string, $i, $i);
+    $last: str-slice($string, -$i, -$i);
+
+    @if $first == " " and $i + 1 == $start + 1 {
+      $start: $i + 1;
+    }
+
+    @if $last == " " and str-length($string) - $i == $end - 1 {
+      $end: str-length($string) - $i;
+    }
+  }
+
+  @return str-slice($string, $start, $end);
+}

data/stylesheets/functions/_str-ucfirst.scss

@@ -0,0 +1,14 @@
+// Capitalize first letter from $strign
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// ----------------------------------------------------------------------------------------------------
+// @return [string] | false
+
+@function str-ucfirst($string) {
+  @if type-of($string) != "string" {
+    @warn "`str-ucfirst` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  @return to-upper-case(str-slice($string, 1, 1)) + str-slice($string, 2);
+}

data/stylesheets/functions/_str-word-count.scss

@@ -0,0 +1,26 @@
+// Count number of words in $string
+// ----------------------------------------------------------------------------------------------------
+// @param [string] $string: string
+// ----------------------------------------------------------------------------------------------------
+// @return [string] | false
+
+@function str-word-count($string) {
+  @if type-of($string) != "string" {
+    @warn "`str-word-count` function expecting a string for $string; #{type-of($string)} given.";
+    @return false;
+  }
+
+  $string: str-trim($string);
+  $words: ();
+  $i: str-length($string);
+
+  @while $i > 0 {
+    @if str-slice($string, $i, $i) == " " {
+      $words: append($words, str-slice($string, $i + 1));
+      $string: str-slice($string, 1, $i - 1);
+    }
+    $i: $i - 1;
+  }
+
+  @return length(append($words, $string));
+}

data/stylesheets/functions/_stringify.scss

@@ -0,0 +1,21 @@
+// Cast anything to string
+// ----------------------------------------------------------------------------------------------------
+// @param [literal] $literal: literal to cast to string
+// ----------------------------------------------------------------------------------------------------
+// @return [string]
+
+@function stringify($literal) {
+  $result: "";
+
+  @if length($literal) == 1 {
+    $result: $literal + unquote("");
+  }
+
+  @else {
+    @each $item in $literal {
+      $result: $result + stringify($item);
+    }
+  }
+
+  @return quote($result);
+}

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: SassyStrings
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Hugo Giraudel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-16 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.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: compass
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: A collection of Sass functions to manipulate strings.
+email:
+- hugo.giraudel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- CHANGELOG.md
+- lib/SassyStrings.rb
+- stylesheets/functions/_char-at.scss
+- stylesheets/functions/_levenshtein.scss
+- stylesheets/functions/_str-count.scss
+- stylesheets/functions/_str-ends-with.scss
+- stylesheets/functions/_str-explode.scss
+- stylesheets/functions/_str-implode.scss
+- stylesheets/functions/_str-last-index.scss
+- stylesheets/functions/_str-lcfirst.scss
+- stylesheets/functions/_str-pad.scss
+- stylesheets/functions/_str-printf.scss
+- stylesheets/functions/_str-repeat.scss
+- stylesheets/functions/_str-replace.scss
+- stylesheets/functions/_str-reverse.scss
+- stylesheets/functions/_str-rot.scss
+- stylesheets/functions/_str-shuffle.scss
+- stylesheets/functions/_str-starts-with.scss
+- stylesheets/functions/_str-trim.scss
+- stylesheets/functions/_str-ucfirst.scss
+- stylesheets/functions/_str-word-count.scss
+- stylesheets/functions/_stringify.scss
+- stylesheets/_SassyStrings.scss
+homepage: https://github.com/HugoGiraudel/SassyStrings
+licenses: []
+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.2'
+requirements: []
+rubyforge_project: SassyStrings
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Advanced String handling for Sass
+test_files: []