archetype 0.0.1.pre.10 → 0.0.1.pre.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76f9c81397416d6b304275d0be066bd0f7b63bbb
-  data.tar.gz: 92bf858e2784bc85bb687d9836c401718bd26b32
+  metadata.gz: 192dd0037d6555124a87aadae4a22c1be1fe080c
+  data.tar.gz: 7cc39be2c7bb42aeb4580baf1481ac2d4a1dcd48
 SHA512:
-  metadata.gz: 907804823810690498dd247dde990ad9def057416b6b9de4f159cc632054fea8d372739d92c16cebd33357071cf1246b144de9067431247b39041c3cbe16d3f3
-  data.tar.gz: 4a3ed261f9f1fe3fe3bfe6c1f81d2038bfa96b967531a0c8180f9394bac8ea4f36f2c1fd8e7d484e8baf55ab64cff6200fa6c37c1b120b1e235d162a74077a5f
+  metadata.gz: 2a8a13bf6c81307af54fc6ebbcd0a23c40446d3d3d00f73a695aeef338a08ee1de9521a0a78bc8d3e2eecd73b70118470483ddfa82f9a967de627a637fca8e47
+  data.tar.gz: 648a999357a50954db62eee54078e250ae061d0f3e579a6473b31f8582080a73e04659161dae47032ed43190753bfe29ef7cccdf38a2af5bbceb0e15473b45bc

data/lib/archetype.rb

@@ -33,10 +33,6 @@ module Archetype
     Compass::Configuration.add_configuration_property(:memoize, "should the memoizer be used to improve compilation speed") do
       not (Compass.configuration.environment || :development).to_s.include?('dev')
     end
-    # testing (for running unit tests)
-    Compass::Configuration.add_configuration_property(:testing, "is this a testing environment") do
-      ENV['CI']
-    end
   end
 end
 

data/lib/archetype/functions/hash.rb

@@ -1,8 +1,6 @@
 # :stopdoc:
 # This module extends the native Ruby Hash class to support deep merging
 # and comparing the difference between hashes.
-# This functionality mimics that found in ActiveSupport
-# @see https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
 #
 module Archetype::Functions::Hash
   #
@@ -13,10 +11,13 @@ module Archetype::Functions::Hash
   # *Returns*:
   # - {Hash} a new hash containing the contents of other_hash and the contents of hsh, deep merged
   #
-  def rmerge(other_hash, &block)
-    dup.rmerge!(other_hash, &block)
+  def rmerge(other_hash)
+    new_hash = {}
+    merge(other_hash) do |key, oldval, newval|
+      new_hash[key] = oldval.class == self.class ? oldval.rmerge(newval) : newval
+    end
   end
-
+  
   #
   # adds the contents of other_hash to hsh, deep merged
   #
@@ -25,16 +26,10 @@ module Archetype::Functions::Hash
   # *Returns*:
   # - {Hash} the original hash with the addition of the contents of other_hash
   #
-  def rmerge!(other_hash, &block)
-    other_hash.each_pair do |k,v|
-      tv = self[k]
-      if tv.is_a?(Hash) && v.is_a?(Hash)
-        self[k] = tv.rmerge(v, &block)
-      else
-        self[k] = block && tv ? block.call(k, tv, v) : v
-      end
+  def rmerge!(other_hash)
+    merge!(other_hash) do |key, oldval, newval|
+      oldval.class == self.class ? oldval.rmerge!(newval) : newval
     end
-    return self
   end
 
   #
@@ -46,7 +41,7 @@ module Archetype::Functions::Hash
   # - {Hash} a representation of the difference between the two hashes
   #
   def diff(other_hash)
-    (self.keys + other_hash.keys).uniq.inject(Archetype::Hash.new) do |tmp, key|
+    (self.keys + other_hash.keys).uniq.inject({}) do |tmp, key|
       # special comparison for gradients
       are_gradients = self[key].is_a?(Compass::SassExtensions::Functions::GradientSupport::LinearGradient) and other_hash[key].is_a?(Compass::SassExtensions::Functions::GradientSupport::LinearGradient)
       eq_gradients = are_gradients ? (self[key].to_s == other_hash[key].to_s) : true
@@ -133,17 +128,6 @@ private
   end
 end
 
-# this shims the Hash functionality to ensure we have an ordered hash guarantee
-module Archetype
-  if RUBY_VERSION < '1.9'
-    require 'hashery/ordered_hash'
-    class Hash < Hashery::OrderedHash
-      include Archetype::Functions::Hash
-    end
-  else
-    class Hash < ::Hash
-      include Archetype::Functions::Hash
-    end
-  end
+class Hash
+  include Archetype::Functions::Hash
 end
-

data/lib/archetype/functions/helpers.rb

@@ -24,8 +24,7 @@ private
   def self.hash_to_list(hsh, depth = 0, separator = :comma)
     if hsh.is_a? Hash
       list = []
-      hsh.each do |key, item|
-        item = [key, item]
+      hsh.each do |item|
         # if its a hash, convert it to a List
         if item.is_a? Hash or item.is_a? Array
           tmp = []
@@ -55,56 +54,30 @@ private
   #
   def self.list_to_hash(list, depth = 0, nest = [], additives = [])
     list = list.to_a
-    previous = nil
-    hsh = Archetype::Hash.new
+    hsh = {}
     list.each do |item|
       item = item.to_a
-
       # convert the key to a string and strip off quotes
-      key = to_str(item[0], ' ' , :quotes)
-      # capture the value
+      key = to_str(item[0]).gsub(/\A"|"\Z/, '')
       value = item[1]
-
       if key != 'nil'
-        if is_value(value, :blank)
-          if previous.nil?
-            previous = key
-            next
-          else
-            value = item[0]
-            key = previous
-            previous = nil
-          end
-        elsif not previous.nil?
-          # if we got here, something is wrong with the structure
-          list.shift if to_str(list[0]) == previous # remove the first item if it's the previous key, which is now the parent key
-          list = list[0].to_a # now the remaining items were munged, so split them out
-          hsh = Archetype::Hash.new
-          hsh[previous] = list_to_hash(list, depth - 1, nest, additives)
-          return hsh
-        end
-      end
-
-      # update the hash if we have a valid key and hash
-      if key != 'nil' and not is_value(value, :blank)
         # check if if it's a nesting hash
         nested = nest.include?(key)
         # if it's nested or we haven't reached out depth, recurse
         if nested or depth > 0
           value = list_to_hash(value, nested ? depth + 1 : depth - 1, nest, additives)
         end
-
-        if additives.include?(key)
-          hsh[key] ||= []
-          hsh[key].push(value)
-        else
-          hsh[key] = value
+        # update the hash key
+        if not is_value(value, :blank)
+          if additives.include?(key)
+            hsh[key] ||= []
+            hsh[key].push(value)
+          else
+            hsh[key] = value
+          end
         end
       end
     end
-
-    logger.record(:warning, "one of your data structures is ambiguous, please double check near `#{previous}`") if not previous.nil?
-
     return hsh
   end
 
@@ -117,12 +90,8 @@ private
   # *Returns*:
   # - {String} the converted String
   #
-  def self.to_str(value, separator = ' ', strip = nil)
-    if not value.is_a?(String)
-      value = ((value.to_a).each{ |i| i.nil? ? 'nil' : (i.is_a?(String) ? i : i.value) }).join(separator || '')
-    end
-    strip = /\A"|"\Z/ if strip == :quotes
-    return strip.nil? ? value : value.gsub(strip, '')
+  def self.to_str(value, separator = ' ')
+    return value.is_a?(String) ? value : ((value.to_a).each{ |i| i.is_a?(String) ? i : i.value }).join(separator || '')
   end
 
   #
@@ -140,13 +109,11 @@ private
     when :blank
       is_it = false
       value = value.value if value.is_a?(Sass::Script::String)
-      is_it = value.nil?
       is_it = value.empty? if value.is_a?(String)
       is_it = value.to_a.empty? if value.is_a?(Sass::Script::List) or value.is_a?(Array)
     when :nil
       is_it = false
       value = value.value if value.is_a?(Sass::Script::String)
-      is_it = value.nil?
       is_it = value == 'nil' if value.is_a?(String)
       is_it = to_str(value) == 'nil' if value.is_a?(Sass::Script::List) or value.is_a?(Array)
     end

data/lib/archetype/functions/styleguide_memoizer.rb

@@ -50,7 +50,7 @@ private
   end
 
   #
-  # invalidate the memoizer for the theme
+  # invalidate the entire memoizer for the theme
   #
   # *Parameters*:
   # - <tt>theme</tt> {String} the theme name
@@ -58,12 +58,4 @@ private
   def self.clear(theme)
     @components[theme] = {}
   end
-
-
-  #
-  # resets the entire memoizer
-  #
-  def self.reset!
-    @components = {}
-  end
 end

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

@@ -6,7 +6,7 @@ require 'archetype/functions/helpers'
 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)
@@ -47,8 +47,8 @@ module Archetype::SassExtensions::Lists
   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]
+  Sass::Script::Functions.declare :list_replace, [:list, :idx]
+  Sass::Script::Functions.declare :list_replace, [:list, :idx, :separator]
 
   #
   # insert an item into a list
@@ -67,9 +67,41 @@ module Archetype::SassExtensions::Lists
     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]
+  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]
+
+  #
+  # 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
@@ -144,7 +176,7 @@ module Archetype::SassExtensions::Lists
   # - <tt>$haystack</tt> {List} input list
   # - <tt>$needle</tt> {List} the value(s) to search for
   # *Returns*:
-  # - {Number|Boolean} if an item is found, returns the index, otherwise returns false
+  # - {Number|Bool} if an item is found, returns the index, otherwise returns false
   #
   def index2(haystack, needle)
     haystack = haystack.to_a
@@ -178,14 +210,14 @@ module Archetype::SassExtensions::Lists
   # *Parameters*:
   # - <tt>$list</tt> {List} the list to search in
   # - <tt>$key</tt> {String} the key identifier (name)
-  # - <tt>$strict</tt> {Boolean} if true, does a strict match against the key
+  # - <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[helpers.to_str(key)]
     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)
@@ -211,33 +243,7 @@ module Archetype::SassExtensions::Lists
     list = list.rmerge(extender)
     return helpers.hash_to_list(list, 0, separator)
   end
-  Sass::Script::Functions.declare :associative_merge, [:list, :extender]
-
-  #
-  # given a string of styles, convert it into a key-value pair list
-  #
-  # *Parameters*:
-  # - <tt>$string</tt> {String} the string to convert
-  # *Returns*:
-  # - <tt>$list</tt> {List} the converted list of styles
-  #
-  def _style_string_to_list(string = '')
-    # convert to string and strip all comments
-    string = helpers.to_str(string, ' ').gsub(/\/\*[^\*\/]*\*\//, '')
-    # then split it on each rule
-    tmp = string.split(';')
-    styles = []
-    # and for each rule break it into it's key-value pairs
-    tmp.each do |rule|
-      kvp = []
-      rule.split(':').each do |str|
-        kvp.push Sass::Script::String.new(str)
-      end
-      styles.push Sass::Script::List.new(kvp, :comma)
-    end
-    # the recompose the list
-    return Sass::Script::List.new(styles, :comma)
-  end
+  Sass::Script::Functions.declare :list_extend, [:list, :extender]
 
 private
   def helpers

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

@@ -3,36 +3,17 @@
 #
 module Archetype::SassExtensions::Locale
   #
-  # get the current locale specified in config or test a list of locales against the current locale
+  # get the current locale specified in config
   #
-  # *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
+  # - {String} the current locale
   #
-  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))
+  def locale
+    return Sass::Script::String.new(Compass.configuration.locale || 'en_US')
   end
 
   #
-  # test a list of locales against the current locale (this is now just an alias for locales(), for back-compat)
+  # test a list of locales against the current locale (supports an alias map)
   #
   # *Parameters*:
   # - <tt>$locales</tt> {List} the list of locales to test
@@ -40,9 +21,16 @@ module Archetype::SassExtensions::Locale
   # - {Boolean} is the current locale in the list or not
   #
   def lang(locales)
-    return locale(locales)
+    locales = locales.to_a.collect{|i| i.to_s}
+    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.to_s))
   end
-
+  
   #
   # get the current reading direction
   #
@@ -55,9 +43,6 @@ module Archetype::SassExtensions::Locale
   end
 
 private
-
-  LOCALE_PATTERN = /([a-z]{2})[-_]?([a-z]{2}?)/i
-
   #
   # provides an alias mapping for locale names
   #
@@ -67,9 +52,8 @@ private
   # TODO - make this easily extensible
   def locale_aliases
     if @locale_aliases.nil?
-      a = {
-        'CJK' => ['ja_JP', 'ko_KR', 'zh_TW', 'zh_CN']
-      }
+      a = {}
+      a['CJK'] = ['ja_JP', 'ko_KR', 'zh_TW', 'zh_CN']
       @locale_aliases = a
     end
     return @locale_aliases

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

@@ -15,13 +15,10 @@ module Archetype::SassExtensions::Styleguide
   DEFAULT     = 'default'
   REGEX       = 'regex'
   SPECIAL     = %w(states selectors)
-  DROPALL     = %w(all true)
   # these are unique CSS keys that can be exploited to provide fallback functionality by providing a second value
   # e.g color: red; color: rgba(255,0,0, 0.8);
-  FALLBACKS   = %w(background background-image background-color border border-bottom border-bottom-color border-color border-left border-left-color border-right border-right-color border-top border-top-color clip color layer-background-color outline outline-color white-space extend)
-  # these are mixins that make sense to run multiple times within a block
-  MULTIMIXINS = %w(target-browser)
-  ADDITIVES   = FALLBACKS + [DROP, INHERIT, STYLEGUIDE] + MULTIMIXINS
+  FALLBACKS   = %w(background background-image background-color border border-bottom border-bottom-color border-color border-left border-left-color border-right border-right-color border-top border-top-color clip color layer-background-color outline outline-color white-space)
+  ADDITIVES   = FALLBACKS + [DROP, INHERIT, STYLEGUIDE]
   @@archetype_styleguide_mutex = Mutex.new
   # :startdoc:
 
@@ -79,7 +76,7 @@ module Archetype::SassExtensions::Styleguide
       extensions = theme[:extensions]
       return Sass::Script::Bool.new(false) if component_exists(id, theme, extension, force)
       extensions.push(extension)
-      components[id] = (components[id] ||= Archetype::Hash.new).rmerge(helpers.list_to_hash(data, 1, SPECIAL, ADDITIVES))
+      components[id] = (components[id] ||= {}).rmerge(helpers.list_to_hash(data, 1, SPECIAL, ADDITIVES))
       return Sass::Script::Bool.new(true)
     end
   end
@@ -101,7 +98,7 @@ module Archetype::SassExtensions::Styleguide
   #
   def styleguide_component_exists(id, theme = nil, extension = nil, force = false)
     @@archetype_styleguide_mutex.synchronize do
-      extension = helpers.to_str(extension).hash if not extension.nil?
+      extension = helpers.to_str(extension) if not extension.nil?
       return Sass::Script::Bool.new( component_exists(id, theme, extension, force) )
     end
   end
@@ -226,34 +223,29 @@ private
   #
   def extract_styles(id, modifiers, strict = false, theme = nil, context = nil)
     theme = get_theme(theme)
-    context ||= theme[:components][id] || Archetype::Hash.new
+    context ||= theme[:components][id] || {}
     modifiers = helpers.to_str(modifiers)
-    return Archetype::Hash.new if context.nil? or context.empty?
+    return {} if context.nil? or context.empty?
     # push on the defaults first
-    out = (strict ? resolve_dependents(id, context[modifiers], theme[:name], context) : context[DEFAULT]) || Archetype::Hash.new
+    out = (strict ? resolve_dependents(id, context[modifiers], theme[:name], context) : context[DEFAULT]) || {}
     out = out.clone
     # if it's not strict, find anything that matched
     if not strict
       modifiers = modifiers.split
-      context.each do |key, definition|
-        definition = [key, definition]
+      context.each do |definition|
         modifier = definition[0]
         if modifier != DEFAULT
           match = true
           modifier = modifier.split
           if modifier[0] == REGEX
             # if it's a regex pattern, test if it matches
-            match = modifiers.join(' ') =~ /#{modifier[1].gsub(/\A"|"\Z/, '')}/i
+            match = modifiers.join(' ') =~ /#{modifiers[1].gsub(/\A"|"\Z/, '')}/i
           else
             # otherwise, if the modifier isn't in our list of modifiers, it's not valid and just move on
             modifier.each { |i| match = false if not modifiers.include?(i) }
           end
           # if it matched, process it
-          if match
-            tmp = resolve_dependents(id, definition[1], theme[:name], nil, out)
-            out, tmp = post_resolve_drops(out, tmp)
-            out = out.rmerge(tmp)
-          end
+          out = out.rmerge(resolve_dependents(id, definition[1], theme[:name], nil, out.keys)) if match
         end
       end
     end
@@ -261,19 +253,15 @@ private
     # this lets us define special states and elements
     SPECIAL.each do |special_key|
       if out.is_a? Hash
-        special = out[special_key] || Archetype::Hash.new
-        if special == 'nil'
-          out[special_key] = Archetype::Hash.new
-        else
-          tmp = Archetype::Hash.new
-          special.each { |key, value| tmp[key] = extract_styles(key, key, true, theme[:name], special) }
-          out[special_key] = tmp if not tmp.empty?
-        end
+        special = out[special_key]
+        tmp = {}
+        (special || {}).each { |key, value| tmp[key] = extract_styles(key, key, true, theme[:name], special) }
+        out[special_key] = tmp if not tmp.empty?
       end
     end
     # check for nested styleguides
     styleguide = out[STYLEGUIDE]
-    if not (styleguide.nil? or styleguide.empty?)
+    if styleguide and not styleguide.empty?
       styles = get_styles(styleguide, theme[:name])
       out.delete(STYLEGUIDE)
       out = styles.rmerge(out)
@@ -281,87 +269,6 @@ private
     return out
   end
 
-  #
-  # given two objects, resolve the chain of dropped styles
-  #  this runs after having already resolved the dropped styles and merged
-  #
-  # *Parameters*:
-  # - <tt>obj</tt> {Hash} the source object
-  # - <tt>merger</tt> {Hash} the object to be merged in
-  # *Returns*:
-  # - {Array.<Hash>} the resulting `obj` and `merger` objects
-  #
-  def post_resolve_drops(obj, merger)
-    return [obj, merger] if obj.nil? or merger.nil?
-    drop = merger[DROP]
-    keys = obj.keys
-    if not drop.nil?
-      drop.to_a.each do |key|
-        key = helpers.to_str(key)
-        obj.delete(key) if not SPECIAL.include?(key)
-      end
-      merger.delete(DROP)
-    else
-    end
-    SPECIAL.each do |special|
-      if obj[special].is_a?(Hash) and merger[special].is_a?(Hash)
-        obj[special], merger[special] = post_resolve_drops(obj[special], merger[special])
-      end
-    end
-    return [obj, merger]
-  end
-
-  #
-  # given two objects, resolve the chain of dropped styles
-  #
-  # *Parameters*:
-  # - <tt>value</tt> {Hash} the source object
-  # - <tt>obj</tt> {Hash} the object to be merged in
-  # - <tt>is_special</tt> {Boolean} whether this is from a SPECIAL branch of a Hash
-  # *Returns*:
-  # - {Array.<Hash>} the resulting value
-  #
-  def resolve_drops(value, obj, is_special = false)
-    return value if not (value.is_a?(Hash) and obj.is_a?(Hash))
-    keys = obj.keys
-    drop = value[DROP]
-    if not drop.nil?
-      tmp = Archetype::Hash.new
-      if DROPALL.include?(helpers.to_str(drop))
-        if not keys.nil?
-          keys.each do |key|
-            if SPECIAL.include?(key)
-              if not (obj[key].nil? or obj[key].empty?)
-                tmp[key] = Archetype::Hash.new
-                tmp[key][DROP] = obj[key].keys
-              end
-            else
-              tmp[key] = 'nil'
-            end
-          end
-        end
-      else
-        drop.to_a.each do |key|
-          key = helpers.to_str(key)
-          if SPECIAL.include?(key)
-            if not (obj[key].nil? or obj[key].empty?)
-              tmp[key] = Archetype::Hash.new
-              tmp[key][DROP] = obj[key].keys
-            end
-          else
-            tmp[key] = 'nil'
-          end
-        end
-      end
-      value.delete(DROP) if not is_special
-      value = tmp.rmerge(value)
-    end
-    value.each do |key|
-      value[key] = resolve_drops(value[key], obj[key], key, SPECIAL.include?(key)) if not value[key].nil?
-    end
-    return value
-  end
-
   #
   # resolve any dependent references from the component
   #
@@ -374,19 +281,33 @@ private
   # *Returns*:
   # - {Hash} a hash of the resolved styles
   #
-  def resolve_dependents(id, value, theme = nil, context = nil, obj = nil)
+  def resolve_dependents(id, value, theme = nil, context = nil, keys = nil)
     # we have to create a clone here as the passed in value is volatile and we're performing destructive changes
     value = value.clone
     # check that we're dealing with a hash
     if value.is_a?(Hash)
       # check for dropped styles
-      value = resolve_drops(value, obj)
-
+      drop = value[DROP]
+      if not drop.nil?
+        tmp = {}
+        if %w(all true).include?(helpers.to_str(drop)) and not keys.nil? and not keys.empty?
+          keys.each do |key|
+            tmp[key] = 'nil'
+          end
+        else
+          drop = drop.to_a
+          drop.each do |key|
+            tmp[helpers.to_str(key)] = 'nil'
+          end
+        end
+        value.delete(DROP)
+        value = tmp.rmerge(value)
+      end
       # check for inheritance
       inherit = value[INHERIT]
-      if not (inherit.nil? or inherit.empty?)
+      if inherit and not inherit.empty?
         # create a temporary object and extract the nested styles
-        tmp = Archetype::Hash.new
+        tmp = {}
         inherit.each { |related| tmp = tmp.rmerge(extract_styles(id, related, true, theme, context)) }
         # remove the inheritance key and update the styles
         value.delete(INHERIT)
@@ -407,18 +328,14 @@ private
   #
   def get_theme(theme)
     theme_name = helpers.to_str(theme || 'archetype')
-    theme = _get_persisted_theme(theme_name)
+    @@styleguide_themes ||= {}
+    theme = @@styleguide_themes[theme_name] ||= {}
     theme[:name] ||= theme_name
     theme[:components] ||= {}
     theme[:extensions] ||= []
     return theme
   end
 
-  def _get_persisted_theme(theme_name)
-    theme = Thread.current[:styleguide_themes] ||= {}
-    theme[theme_name] ||= {}
-  end
-
   #
   # driver method for converting a sentence into a list of styles
   #
@@ -431,8 +348,9 @@ private
   #
   def get_styles(description, theme = nil, state = 'false')
     state = helpers.to_str(state)
-    styles = Archetype::Hash.new
-    description.to_a.each do |sentence|
+    description = description.to_a
+    styles = {}
+    description.each do |sentence|
       # get the grammar from the sentence
       id, modifiers, token = grammar(sentence, theme, state)
       if id