archetype 0.0.1.pre.13 → 1.0.0.alpha.1

data/lib/archetype/functions/styleguide_memoizer.rb

@@ -20,7 +20,7 @@ private
   #
   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}"
+    return "#{id}::#{(modifiers.to_a.sort + extensions).join('$')}::#{state}".hash
   end
 
   #
@@ -49,6 +49,23 @@ private
     return (@components[theme] ||= {})[token]
   end
 
+  #
+  # fetch a value from the memoizer if available, otherwise execute the block and create it
+  #
+  # *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_or_create(theme, token)
+    fetched = self.fetch(theme, token)
+    return fetched if fetched
+    fetched = yield if block_given?
+    self.add(theme, token, fetched)
+    return fetched
+  end
+
   #
   # invalidate the memoizer for the theme
   #

data/lib/archetype/sass_extensions.rb

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

data/lib/archetype/sass_extensions/functions.rb

@@ -1,14 +1,28 @@
-%w(lists styleguide ui locale numbers version environment).each do |func|
+# leverage Sass::Script::Value::Helpers
+require 'sass/script/value/helpers'
+
+%w(lists strings styleguide ui locale numbers version environment util).each do |func|
   require "archetype/sass_extensions/functions/#{func}"
 end
 
 # :stopdoc:
 module Sass::Script::Functions
+  include Archetype::SassExtensions::Util
   include Archetype::SassExtensions::Lists
+  include Archetype::SassExtensions::Strings
   include Archetype::SassExtensions::Styleguide
   include Archetype::SassExtensions::UI
   include Archetype::SassExtensions::Locale
   include Archetype::SassExtensions::Numbers
   include Archetype::SassExtensions::Version
   include Archetype::SassExtensions::Environment
+
+  private
+    # shortcut to Archetype::Functions::Helpers
+    def helpers
+      Archetype::Functions::Helpers
+    end
+
+    # include the Sass::Script::Value::Helpers in the context for all included modules
+    include Sass::Script::Value::Helpers
 end

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

@@ -9,6 +9,157 @@ module Archetype::SassExtensions::Environment
   # - {String} the current environment the compiler is running in
   #
   def archetype_env
-    return Sass::Script::String.new((Compass.configuration.environment || :development).to_s)
+    return identifier((Compass.configuration.environment || :development).to_s)
   end
+
+  #
+  # namespaces a string
+  #
+  # *Parameters*:
+  # - <tt>$string</tt> {String} the string to namespace
+  # *Returns*:
+  # - {String} the namespaced string
+  #
+  def archetype_namespace(string)
+    namespace = environment.var('CONFIG_NAMESPACE')
+    return string if is_null(namespace).value
+    return identifier(namespace.value + '_' + string.value)
+  end
+
+  #
+  # gets the value of the given key from the `meta` config map
+  #
+  # *Parameters*:
+  # - <tt>$key</tt> {String} the key to lookup
+  # *Returns*:
+  # - {*} the value from the meta map
+  #
+  def archetype_meta(key)
+    # if `$CONFIG_META` is set, use it, otherwise, use the one set on the configuration object
+    meta = environment.var('CONFIG_META') || Compass.configuration.archetype_meta || {}
+    # convert it to a hash
+    meta = helpers.map_to_hash(meta)
+    # fetch the value for the key
+    value = meta[key.value]
+    # if we got nothing...
+    if value.nil?
+      # return `null`
+      return null
+    # if it's a Sass::Script value...
+    elsif value.is_a?(Sass::Script::Value::Base)
+      # just return it
+      return value
+    # otherwise...
+    else
+      # convert it to a Sass::Script::String
+      return identifier(helpers.to_str(value))
+    end
+  end
+
+  #
+  # registers an Archetype module as active
+  #
+  # *Parameters*:
+  # - <tt>$name</tt> {String} the module name
+  # *Returns*:
+  # - {List} the list of current registered modules
+  #
+  def register_archetype_module(name)
+    registry = archetype_modules_registry
+    # if it's already in the registry, just return the current list
+    return list(registry, :comma) if archetype_modules_registry.include?(name)
+    # update the registry with the module name
+    registry = list(registry.dup.push(name), :comma)
+    environment.global_env.set_var('ARCHETYPE_MODULES_REGISTRY', registry)
+    # return the registry
+    return registry
+  end
+
+  #
+  # checks to see if a required module is loaded or not
+  #  if not, throws an error
+  #
+  # *Parameters*:
+  # - <tt>$name</tt> {String} the module name
+  # *Returns*:
+  # - {Boolean} whether or not all the modules are registered
+  #
+  def require_archetype_modules(*names)
+    return check_archetype_modules(names, true)
+  end
+  alias_method :require_archetype_module, :require_archetype_modules
+
+  #
+  # checks whether or not a module has been registered
+  #
+  # *Parameters*:
+  # - <tt>$name</tt> {String} the module name
+  # *Returns*:
+  # - {Boolean} whether or not all the modules are registered
+  #
+  def has_archetype_modules(*names)
+    return check_archetype_modules(names, false)
+  end
+  alias_method :has_archetype_module, :has_archetype_modules
+
+  #
+  # sets the intialization state of Archetype
+  #
+  # *Parameters*
+  # - <tt>$state</tt> {*} the state to set
+  # *Returns*:
+  # - {*} the state that was just set
+  #
+  def init_archetype(state = identifier('done'))
+    environment.global_env.set_var('ARCHETYPE_INIT', state)
+    return state
+  end
+
+  #
+  # sets the intialization state of Archetype to `skip`
+  #
+  # *Returns*:
+  # - {String} the state `skip` that was just set
+  #
+  def skip_archetype_init
+    init_archetype(identifier('skip'))
+  end
+
+  #
+  # sets the intialization state of Archetype to `null`
+  #
+  # *Returns*:
+  # - {Null} the state `null` that was just set
+  #
+  def force_archetype_init
+    init_archetype(null)
+  end
+
+  #
+  # gets Archetype's current initialization state
+  #
+  # *Returns*:
+  # - {*} Archetype's current initialization state
+  #
+  def archetype_init_state
+    return environment.var('ARCHETYPE_INIT') || null
+  end
+
+private
+
+  def check_archetype_modules(names, warn = false)
+    missing = []
+    names.each do |name|
+      missing << name unless archetype_modules_registry.include?(name)
+    end
+    if missing.count > 0 and warn
+      helpers.logger.record(:error, "[archetype:module:missing] the required module#{missing.count > 1 ? 's are' : ' is'} missing: #{helpers.to_str(missing)}")
+    end
+    return bool(missing.count == 0)
+  end
+
+  def archetype_modules_registry
+    (environment.var('ARCHETYPE_MODULES_REGISTRY') || []).to_a
+  end
+
 end

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

@@ -1,7 +1,5 @@
-require 'archetype/functions/helpers'
-
 #
-# This module provides a set of Sass functions for working with Sass::List
+# This module provides a set of Sass functions for working with Sass::Script::Value::List
 #
 module Archetype::SassExtensions::Lists
   #
@@ -17,18 +15,19 @@ module Archetype::SassExtensions::Lists
   #
   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')
+    return list if (!idx || is_null(idx).value || idx.value == false)
+    separator ||= list.separator if list.is_a?(Sass::Script::Value::List)
     # cast and zero-index $idx
     idx = (idx.value) - 1
     # cast list to a ruby array
-    list = list.to_a
+    list = list.to_a.dup
     # 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)
+    if value.nil? or value == null
+      list.delete_at(idx)
+    else
+      list[idx] = value
+    end
+    return Sass::Script::Value::List.new(list, separator)
   end
   Sass::Script::Functions.declare :list_replace, [:list, :idx]
   Sass::Script::Functions.declare :list_replace, [:list, :idx, :value]
@@ -75,7 +74,7 @@ module Archetype::SassExtensions::Lists
   # add values(s) to a list
   #
   # *Parameters*:
-  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$list</tt> {List} the list operate to on
   # - <tt>$values</tt> {List|Number|String} the value(s) to add to the list
   # *Returns*:
   # - {List} the final list
@@ -83,12 +82,13 @@ module Archetype::SassExtensions::Lists
   def list_add(list, values)
     return list_math(list, values, :plus)
   end
+  Sass::Script::Functions.declare :list_add, [:list, :values]
 
   #
   # subtract values(s) from a list
   #
   # *Parameters*:
-  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$list</tt> {List} the list operate to on
   # - <tt>$values</tt> {List|Number|String} the value(s) to subtract from the list
   # *Returns*:
   # - {List} the final list
@@ -96,12 +96,13 @@ module Archetype::SassExtensions::Lists
   def list_subtract(list, values)
     return list_math(list, values, :minus)
   end
+  Sass::Script::Functions.declare :list_subtract, [:list, :values]
 
   #
   # multiply values(s) into a list
   #
   # *Parameters*:
-  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$list</tt> {List} the list operate to on
   # - <tt>$values</tt> {List|Number|String} the value(s) to multiply into the list
   # *Returns*:
   # - {List} the final list
@@ -109,12 +110,13 @@ module Archetype::SassExtensions::Lists
   def list_multiply(list, values)
     return list_math(list, values, :times)
   end
+  Sass::Script::Functions.declare :list_multiply, [:list, :values]
 
   #
   # divide values(s) into a list
   #
   # *Parameters*:
-  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$list</tt> {List} the list operate to on
   # - <tt>$values</tt> {List|Number|String} the value(s) to divide into the list
   # *Returns*:
   # - {List} the final list
@@ -122,12 +124,13 @@ module Archetype::SassExtensions::Lists
   def list_divide(list, values)
     return list_math(list, values, :div)
   end
+  Sass::Script::Functions.declare :list_divide, [:list, :values]
 
   #
   # list modulus value(s)
   #
   # *Parameters*:
-  # - <tt>$list</tt> {List} the list operate on
+  # - <tt>$list</tt> {List} the list to operate on
   # - <tt>$values</tt> {List|Number|String} the value(s) to modulus into the list
   # *Returns*:
   # - {List} the final list
@@ -135,6 +138,23 @@ module Archetype::SassExtensions::Lists
   def list_mod(list, values)
     return list_math(list, values, :mod)
   end
+  Sass::Script::Functions.declare :list_mod, [:list, :values]
+
+  #
+  # joins a list into a string with the separator given
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} the list operate to on
+  # - <tt>$separator</tt> {String} the separator to insert between each item
+  # *Returns*:
+  # - {String} string conversions of all list item joined into one string
+  #
+  def list_join(list, separator = ', ')
+    list = list.to_a
+    separator = (separator.respond_to?(:value) ? separator.value : separator).to_s
+    return identifier(list.join(separator))
+  end
+  Sass::Script::Functions.declare :list_join, [:list, :separator]
 
   #
   # find if any set of values is in a list
@@ -151,11 +171,12 @@ module Archetype::SassExtensions::Lists
     needle = needle.to_a
     index = haystack.index(haystack.detect { |i| needle.include?(i) })
     if index
-      return Sass::Script::Number.new(index + 1)
+      return number(index + 1)
     else
       return Sass::Script::Bool.new(false)
     end
   end
+  Sass::Script::Functions.declare :index2, [:haystack, :needle]
 
   #
   # treats a list cyclically (never out of bounds, just wraps around)
@@ -167,10 +188,12 @@ module Archetype::SassExtensions::Lists
   # - {*} the nth item in the List
   #
   def nth_cyclic(list, n = 1)
-    n = n.to_i if n.is_a?(Sass::Script::Number)
+    n = n.to_i if n.is_a?(Sass::Script::Value::Number)
     list = list.to_a
     return list[(n - 1) % list.size]
   end
+  Sass::Script::Functions.declare :nth_cyclic, [:list]
+  Sass::Script::Functions.declare :nth_cyclic, [:list, :n]
 
   #
   # find a key within a nested list of ordered pairs
@@ -183,11 +206,11 @@ module Archetype::SassExtensions::Lists
   # - {*} the data associated with $key
   #
   def associative(list, key, strict = false)
-    separator = list.separator if list.is_a?(Sass::Script::List)
+    separator = list.separator if list.is_a?(Sass::Script::Value::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 Sass::Script::Value::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
@@ -205,7 +228,7 @@ module Archetype::SassExtensions::Lists
   # - <tt>$list</tt> {List} the extended list
   #
   def associative_merge(list, extender, kwargs = {})
-    separator = list.separator if list.is_a?(Sass::Script::List)
+    separator = list.separator if list.is_a?(Sass::Script::Value::List)
     list = helpers.list_to_hash(list)
     extender = helpers.list_to_hash(extender)
     list = list.rmerge(extender)
@@ -213,6 +236,47 @@ module Archetype::SassExtensions::Lists
   end
   Sass::Script::Functions.declare :associative_merge, [:list, :extender]
 
+  #
+  # map collection items to conform to a well defined collection
+  # this is primarily used to convert shorthand notations into symmetrical longhand notations
+  #
+  # *Parameters*:
+  # - <tt>$list</tt> {List} input list
+  # - <tt>$components</tt> {List} list of components
+  # - <tt>$min</tt> {List} the minimum length of the collection
+  # *Returns*:
+  # - {List} formatted collection
+  #
+  def get_collection(list = bool(false), components = [], min = number(1))
+    list = list.value ? list.to_a : components.to_a
+    while(list.length < min.value)
+      list = list.concat(list)
+    end
+    return list(list, :space)
+  end
+  Sass::Script::Functions.declare :get_collection, [:list]
+  Sass::Script::Functions.declare :get_collection, [:components]
+  Sass::Script::Functions.declare :get_collection, [:list, :min]
+  Sass::Script::Functions.declare :get_collection, [:components, :min]
+  Sass::Script::Functions.declare :get_collection, [:list, :components, :min]
+
+  # Returns a list object from a value that was passed.
+  # This can be used to unpack a space separated list that got turned
+  # into a string by sass before it was passed to a mixin.
+  #  this is shamelessly stolen from Compass :)
+  #
+  # *Parameters*:
+  # - <tt>$arg</tt> {*} the item to cast to a list
+  # *Returns*:
+  # - <tt>$list</tt> {List} the item as a list
+  #
+  def _archetype_list(arg)
+    # if it's already a list, just return it
+    return arg if arg.is_a?(Sass::Script::Value::List)
+    # otherwise, we'll try to cast it
+    return list(arg, :space)
+  end
+
   #
   # given a string of styles, convert it into a key-value pair list
   #
@@ -231,48 +295,34 @@ module Archetype::SassExtensions::Lists
     tmp.each do |rule|
       kvp = []
       rule.split(':').each do |str|
-        kvp.push Sass::Script::String.new(str)
+        kvp.push identifier(str)
       end
-      styles.push Sass::Script::List.new(kvp, :comma)
+      styles.push Sass::Script::Value::List.new(kvp, :comma)
     end
-    # the recompose the list
-    return Sass::Script::List.new(styles, :comma)
+    # then recompose the list
+    return Sass::Script::Value::List.new(styles, :comma)
   end
 
 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>list</tt> {Sass::Script::Value::List} the list operate to on
+  # - <tt>values</tt> {Sass::Script::Value::List|Sass::Script::Value::Number|Sass::Script::Value::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
+  # - {Sass::Script::Value::List} the final list
   #
   def list_math(list, values, method = :plus)
-    separator = list.separator if list.is_a?(Sass::Script::List)
+    separator = list.separator if list.is_a?(Sass::Script::Value::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
+      x[0].method(method).call(x[1])
     end
-    return Sass::Script::List.new(list, separator)
+    return Sass::Script::Value::List.new(list, separator)
   end
 end