archetype 0.0.1.pre.1 → 0.0.1.pre.3.00dfd9a

data/lib/archetype/functions/styleguide_memoizer.rb

@@ -0,0 +1,61 @@
+# :stopdoc:
+# This module implements a memoizer for caching styleguide() invocations.
+#
+module Archetype::Functions::StyleguideMemoizer
+private
+  # memoized store for components we've already computed
+  @components ||= {}
+
+  #
+  # get the token for a styleguide reference given the current state of the theme
+  #
+  # *Parameters*:
+  # - <tt>theme</tt> {String} the theme name
+  # - <tt>extensions</tt> {Array} the list of currently installed extensions
+  # - <tt>id</tt> {String} the component identifier
+  # - <tt>modifiers</tt> {Array} the list of modifiers
+  # - <tt>state</tt> {String} the name of the state
+  # *Returns*:
+  # - {Fixnum} whether or not the value is nil/blank
+  #
+  def self.tokenize(theme, extensions, id, modifiers, state)
+    return nil if extensions.nil? or id.nil?
+    return "#{id}::#{(modifiers.to_a.sort + extensions).join('$')}::#{state}".hash
+  end
+
+  #
+  # add a value to the memoizer given a token
+  #
+  # *Parameters*:
+  # - <tt>theme</tt> {String} the theme name
+  # - <tt>token</tt> {Fixnum} the token to register
+  # - <tt>value</tt> {Hash} the value to store
+  #
+  def self.add(theme, token, value)
+    (@components[theme] ||= {})[token] = value if Compass.configuration.memoize
+  end
+
+  #
+  # fetch a value from the memoizer given a token
+  #
+  # *Parameters*:
+  # - <tt>theme</tt> {String} the theme name
+  # - <tt>token</tt> {Fixnum} the token to lookup
+  # *Returns*:
+  # - <tt>value</tt> {Hash} the value from the memoizer
+  #
+  def self.fetch(theme, token)
+    return false if token.nil?
+    return (@components[theme] ||= {})[token]
+  end
+
+  #
+  # invalidate the entire memoizer for the theme
+  #
+  # *Parameters*:
+  # - <tt>theme</tt> {String} the theme name
+  #
+  def self.clear(theme)
+    @components[theme] = {}
+  end
+end

data/lib/archetype/sass_extensions.rb

@@ -0,0 +1,6 @@
+# :stopdoc:
+# This module exposes the available methods to Sass
+module Archetype::SassExtensions
+end
+
+require 'archetype/sass_extensions/functions'

data/lib/archetype/sass_extensions/functions.rb

@@ -0,0 +1,14 @@
+%w(lists styleguide ui locale numbers version environment).each do |func|
+  require "archetype/sass_extensions/functions/#{func}"
+end
+
+# :stopdoc:
+module Sass::Script::Functions
+  include Archetype::SassExtensions::Lists
+  include Archetype::SassExtensions::Styleguide
+  include Archetype::SassExtensions::UI
+  include Archetype::SassExtensions::Locale
+  include Archetype::SassExtensions::Numbers
+  include Archetype::SassExtensions::Version
+  include Archetype::SassExtensions::Environment
+end

data/lib/archetype/sass_extensions/functions/environment.rb

@@ -0,0 +1,14 @@
+#
+# Archetype environment
+#
+module Archetype::SassExtensions::Environment
+  #
+  # get the current environment (this is similar to compass_env)
+  #
+  # *Returns*:
+  # - {String} the current environment the compiler is running in
+  #
+  def archetype_env
+    return Sass::Script::String.new((Compass.configuration.environment || :development).to_s)
+  end
+end

data/lib/archetype/sass_extensions/functions/lists.rb

@@ -0,0 +1,284 @@
+require 'archetype/functions/helpers'
+
+#
+# This module provides a set of Sass functions for working with Sass::List
+#
+module Archetype::SassExtensions::Lists
+  #
+  # replace an index in a list
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list to replace from
+  # - <tt>$value</tt> {\*} the value to replace (if nil, it's a removal)
+  # - <tt>$idx</tt> {Number} the index to replace
+  # - <tt>$separator</tt> {String} the separator to use [auto|comma|space]
+  # *Returns*:
+  # - {List} the list with replaced index
+  #
+  def list_replace(list, idx = false, value = nil, separator = nil)
+    # return early if the index is invalid (no operation)
+    return list if (not idx or idx == Sass::Script::Bool.new(false))
+    separator ||= list.separator if list.is_a?(Sass::Script::List)
+    # if $value is `nil`, make sure we can use it
+    value = nil if value == Sass::Script::String.new('nil')
+    # cast and zero-index $idx
+    idx = (idx.value) - 1
+    # cast list to a ruby array
+    list = list.to_a
+    # remove or replace the given value
+    list.delete_at(idx) if value.nil?
+    list[idx,1] = value if not value.nil?
+    return Sass::Script::List.new(list, separator)
+  end
+  Sass::Script::Functions.declare :list_replace, [:list, :idx]
+  Sass::Script::Functions.declare :list_replace, [:list, :idx, :value]
+  Sass::Script::Functions.declare :list_replace, [:list, :idx, :value, :separator]
+
+  #
+  # remove an index from a list
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list to remove from
+  # - <tt>$idx</tt> {Number} the index to remove
+  # - <tt>$separator</tt> {String} the separator to use [auto|comma|space]
+  # *Returns*:
+  # - {List} the list with removed index
+  #
+  def list_remove(list, idx = false, separator = nil)
+    return list_replace(list, idx, nil, separator)
+  end
+  Sass::Script::Functions.declare :list_remove, [:list, :idx]
+  Sass::Script::Functions.declare :list_remove, [:list, :idx, :separator]
+
+  #
+  # insert an item into a list
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list to insert into
+  # - <tt>$idx</tt> {Number} the index to insert at
+  # - <tt>$value</tt> {\*} the value to insert
+  # - <tt>$separator</tt> {String} the separator to use [auto|comma|space]
+  # *Returns*:
+  # - {List} the list with inserted value
+  #
+  def list_insert(list, idx = false, value = nil, separator = nil)
+    value = nil if value == Sass::Script::String.new('nil')
+    # return early if the index is invalid (no operation) or $value is `nil`
+    return list if (not idx or idx == Sass::Script::Bool.new(false)) or value.nil?
+    return list_replace(list, idx, value, separator, -1)
+  end
+  Sass::Script::Functions.declare :list_insert, [:list, :idx]
+  Sass::Script::Functions.declare :list_insert, [:list, :idx, :value]
+  Sass::Script::Functions.declare :list_insert, [:list, :idx, :value, :separator]
+
+  #
+  # sort a list
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list to sort
+  # - <tt>$reverse</tt> {Boolean} sort the list in reverse order
+  # *Returns*:
+  # - {List} the sorted list
+  #
+  # TODO - this is failing, fix this
+  #def list_sort(list, reverse = false)
+  #  separator = list.separator if list.is_a?(Sass::Script::List)
+  #  list = list.to_a.sort
+  #  list = list.reverse if (reverse == Sass::Script::Bool.new(true))
+  #  return Sass::Script::List.new(list, separator)
+  #end
+
+  #
+  # reverse order a list
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list to reverse
+  # *Returns*:
+  # - {List} the reversed list
+  #
+  # TODO - this is failing, fix this
+  #def list_reverse(list)
+  #  separator = list.separator if list.is_a?(Sass::Script::List)
+  #  list = list.to_a.reverse
+  #  return Sass::Script::List.new(list, separator)
+  #end
+
+  #
+  # add values(s) to a list
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$values</tt> {List|Number|String} the value(s) to add to the list
+  # *Returns*:
+  # - {List} the final list
+  #
+  def list_add(list, values)
+    return list_math(list, values, :plus)
+  end
+
+  #
+  # subtract values(s) from a list
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$values</tt> {List|Number|String} the value(s) to subtract from the list
+  # *Returns*:
+  # - {List} the final list
+  #
+  def list_subtract(list, values)
+    return list_math(list, values, :minus)
+  end
+
+  #
+  # multiply values(s) into a list
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$values</tt> {List|Number|String} the value(s) to multiply into the list
+  # *Returns*:
+  # - {List} the final list
+  #
+  def list_multiply(list, values)
+    return list_math(list, values, :times)
+  end
+
+  #
+  # divide values(s) into a list
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$values</tt> {List|Number|String} the value(s) to divide into the list
+  # *Returns*:
+  # - {List} the final list
+  #
+  def list_divide(list, values)
+    return list_math(list, values, :div)
+  end
+
+  #
+  # list modulus value(s)
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$values</tt> {List|Number|String} the value(s) to modulus into the list
+  # *Returns*:
+  # - {List} the final list
+  #
+  def list_mod(list, values)
+    return list_math(list, values, :mod)
+  end
+
+  #
+  # find if any set of values is in a list
+  # this is similar to `index()`, but allows $values to contain multiple values to test against
+  #
+  # *Parameters*:
+  # - <tt>$haystack</tt> {List} input list
+  # - <tt>$needle</tt> {List} the value(s) to search for
+  # *Returns*:
+  # - {Number|Bool} if an item is found, returns the index, otherwise returns false
+  #
+  def index2(haystack, needle)
+    haystack = haystack.to_a
+    needle = needle.to_a
+    index = haystack.index(haystack.detect { |i| needle.include?(i) })
+    if index
+      return Sass::Script::Number.new(index + 1)
+    else
+      return Sass::Script::Bool.new(false)
+    end
+  end
+
+  #
+  # treats a list cyclically (never out of bounds, just wraps around)
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list
+  # - <tt>$idx</tt> {Number} the index
+  # *Returns*:
+  # - {*} the nth item in the List
+  #
+  def nth_cyclic(list, n = 1)
+    n = n.to_i if n.is_a?(Sass::Script::Number)
+    list = list.to_a
+    return list[(n - 1) % list.size]
+  end
+
+  #
+  # find a key within a nested list of ordered pairs
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list to search in
+  # - <tt>$key</tt> {String} the key identifier (name)
+  # - <tt>$strict</tt> {Bool} if true, does a strict match against the key
+  # *Returns*:
+  # - {*} the data associated with $key
+  #
+  def associative(list, key, strict = false)
+    separator = list.separator if list.is_a?(Sass::Script::List)
+    list = helpers.list_to_hash(list)
+    item = list[helpers.to_str(key, ' ' , :quotes)]
+    item ||= list.first[1] if not strict
+    return Sass::Script::List.new([], separator) if item.nil?
+    return helpers.hash_to_list(item, 0, separator) if item.is_a?(Array) or item.is_a?(Hash)
+    # no conversion needed, so just return
+    return item
+  end
+  Sass::Script::Functions.declare :associative, [:list, :key]
+  Sass::Script::Functions.declare :associative, [:list, :key, :strict]
+
+  #
+  # extend a key-value paired list with another
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list to extend to
+  # - <tt>$extender</tt> {List} the list to extend with
+  # *Returns*:
+  # - <tt>$list</tt> {List} the extended list
+  #
+  def associative_merge(list, extender, kwargs = {})
+    separator = list.separator if list.is_a?(Sass::Script::List)
+    list = helpers.list_to_hash(list)
+    extender = helpers.list_to_hash(extender)
+    list = list.rmerge(extender)
+    return helpers.hash_to_list(list, 0, separator)
+  end
+  Sass::Script::Functions.declare :associative_merge, [:list, :extender]
+
+private
+  def helpers
+    @helpers ||= Archetype::Functions::Helpers
+  end
+
+  #
+  # perform math operations on a list
+  #
+  # *Parameters*:
+  # - <tt>list</tt> {Sass::List} the list operate on
+  # - <tt>values</tt> {Sass::List|Sass::Number|Sass::String} the value(s) perform with
+  # - <tt>method</tt> {Symbol} the method to perform [:plus|:minus|:times|:div|:mod]
+  # *Returns*:
+  # - {Sass::List} the final list
+  #
+  def list_math(list, values, method = :plus)
+    separator = list.separator if list.is_a?(Sass::Script::List)
+    values = values.to_a
+    list = list.to_a
+    values.fill(values[0], 0..(list.size - 1)) if values.size < list.size
+    list = [list, values].transpose.map do |x|
+      case method
+      when :plus
+        x[0].plus(x[1])
+      when :minus
+        x[0].minus(x[1])
+      when :times
+        x[0].times(x[1])
+      when :div
+        x[0].div(x[1])
+      when :mod
+        x[0].mod(x[1])
+      end
+    end
+    return Sass::Script::List.new(list, separator)
+  end
+end

data/lib/archetype/sass_extensions/functions/locale.rb

@@ -0,0 +1,77 @@
+#
+# This module provides an interface for localization.
+#
+module Archetype::SassExtensions::Locale
+  #
+  # get the current locale specified in config or test a list of locales against the current locale
+  #
+  # *Parameters*:
+  # - <tt>$locales</tt> {List} the list of locales to test
+  # *Returns*:
+  # - {String|Boolean} the current locale or whether or not the current locale is in the test set
+  #
+  def locale(locales = nil)
+    locale = (Compass.configuration.locale || 'en_US').to_s
+    # if the locales are nil, just return the current locale
+    return Sass::Script::String.new(locale) if locales.nil?
+    locales = locales.to_a.collect{|i| i.to_s}
+    # add wild card support for language or territory
+    match = locale.match(LOCALE_PATTERN)
+    # language with wildcard territory
+    language = match[1] + '_'
+    # territory with wildcard language
+    territory = '_' + match[2]
+    # for each item, look it up in the alias list
+    locales.each do |key|
+      if a = locale_aliases[key]
+        locales.delete(key)
+        locales.concat(a)
+      end
+    end
+    return Sass::Script::Bool.new(locales.include?(locale) || locales.include?(language) || locales.include?(territory))
+  end
+
+  #
+  # test a list of locales against the current locale (this is now just an alias for locales(), for back-compat)
+  #
+  # *Parameters*:
+  # - <tt>$locales</tt> {List} the list of locales to test
+  # *Returns*:
+  # - {Boolean} is the current locale in the list or not
+  #
+  def lang(locales)
+    return locale(locales)
+  end
+
+  #
+  # get the current reading direction
+  #
+  # *Returns*:
+  # - {String} is the current reading direction [ltr|rtl]
+  #
+  def reading_direction
+    direction = Compass.configuration.reading || 'ltr'
+    return Sass::Script::String.new(direction == 'rlt' ? 'rtl' : 'ltr')
+  end
+
+private
+
+  LOCALE_PATTERN = /([a-z]{2})[-_]?([a-z]{2}?)/i
+
+  #
+  # provides an alias mapping for locale names
+  #
+  # *Returns*:
+  # - {Hash} a hash of aliases
+  #
+  # TODO - make this easily extensible
+  def locale_aliases
+    if @locale_aliases.nil?
+      a = {
+        'CJK' => ['ja_JP', 'ko_KR', 'zh_TW', 'zh_CN']
+      }
+      @locale_aliases = a
+    end
+    return @locale_aliases
+  end
+end