archetype 0.0.1.pre.12 → 0.0.1.pre.13

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

@@ -3,17 +3,36 @@
 #
 module Archetype::SassExtensions::Locale
   #
-  # get the current locale specified in config
+  # 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} the current locale
+  # - {String|Boolean} the current locale or whether or not the current locale is in the test set
   #
-  def locale
-    return Sass::Script::String.new(Compass.configuration.locale || 'en_US')
+  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 (supports an alias map)
+  # 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
@@ -21,16 +40,9 @@ module Archetype::SassExtensions::Locale
   # - {Boolean} is the current locale in the list or not
   #
   def lang(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))
+    return locale(locales)
   end
-  
+
   #
   # get the current reading direction
   #
@@ -43,6 +55,9 @@ module Archetype::SassExtensions::Locale
   end
 
 private
+
+  LOCALE_PATTERN = /([a-z]{2})[-_]?([a-z]{2}?)/i
+
   #
   # provides an alias mapping for locale names
   #
@@ -52,8 +67,9 @@ private
   # TODO - make this easily extensible
   def locale_aliases
     if @locale_aliases.nil?
-      a = {}
-      a['CJK'] = ['ja_JP', 'ko_KR', 'zh_TW', 'zh_CN']
+      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,10 +15,13 @@ 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)
-  ADDITIVES   = FALLBACKS + [DROP, INHERIT, STYLEGUIDE]
+  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
   @@archetype_styleguide_mutex = Mutex.new
   # :startdoc:
 
@@ -72,11 +75,11 @@ module Archetype::SassExtensions::Styleguide
       # if force was set, we'll create a random token for the name
       extension = rand(36**8).to_s(36) if force
       # convert the extension into a hash (if we don't have an extension, compose one out of its data)
-      extension = helpers.to_str(extension || data).hash
+      extension = helpers.to_str(extension || data)
       extensions = theme[:extensions]
       return Sass::Script::Bool.new(false) if component_exists(id, theme, extension, force)
       extensions.push(extension)
-      components[id] = (components[id] ||= {}).rmerge(helpers.list_to_hash(data, 1, SPECIAL, ADDITIVES))
+      components[id] = (components[id] ||= Archetype::Hash.new).rmerge(helpers.list_to_hash(data, 1, SPECIAL, ADDITIVES))
       return Sass::Script::Bool.new(true)
     end
   end
@@ -223,29 +226,34 @@ private
   #
   def extract_styles(id, modifiers, strict = false, theme = nil, context = nil)
     theme = get_theme(theme)
-    context ||= theme[:components][id] || {}
+    context ||= theme[:components][id] || Archetype::Hash.new
     modifiers = helpers.to_str(modifiers)
-    return {} if context.nil? or context.empty?
+    return Archetype::Hash.new if context.nil? or context.empty?
     # push on the defaults first
-    out = (strict ? resolve_dependents(id, context[modifiers], theme[:name], context) : context[DEFAULT]) || {}
+    out = (strict ? resolve_dependents(id, context[modifiers], theme[:name], context) : context[DEFAULT]) || Archetype::Hash.new
     out = out.clone
     # if it's not strict, find anything that matched
     if not strict
       modifiers = modifiers.split
-      context.each do |definition|
+      context.each do |key, definition|
+        definition = [key, 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(' ') =~ /#{modifiers[1].gsub(/\A"|"\Z/, '')}/i
+            match = modifiers.join(' ') =~ /#{modifier[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
-          out = out.rmerge(resolve_dependents(id, definition[1], theme[:name], nil, out.keys)) if match
+          if match
+            tmp = resolve_dependents(id, definition[1], theme[:name], nil, out)
+            out, tmp = post_resolve_drops(out, tmp)
+            out = out.rmerge(tmp)
+          end
         end
       end
     end
@@ -253,15 +261,19 @@ private
     # this lets us define special states and elements
     SPECIAL.each do |special_key|
       if out.is_a? Hash
-        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?
+        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
       end
     end
     # check for nested styleguides
     styleguide = out[STYLEGUIDE]
-    if styleguide and not styleguide.empty?
+    if not (styleguide.nil? or styleguide.empty?)
       styles = get_styles(styleguide, theme[:name])
       out.delete(STYLEGUIDE)
       out = styles.rmerge(out)
@@ -269,6 +281,87 @@ 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
   #
@@ -281,33 +374,19 @@ private
   # *Returns*:
   # - {Hash} a hash of the resolved styles
   #
-  def resolve_dependents(id, value, theme = nil, context = nil, keys = nil)
+  def resolve_dependents(id, value, theme = nil, context = nil, obj = 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
-      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
+      value = resolve_drops(value, obj)
+
       # check for inheritance
       inherit = value[INHERIT]
-      if inherit and not inherit.empty?
+      if not (inherit.nil? or inherit.empty?)
         # create a temporary object and extract the nested styles
-        tmp = {}
+        tmp = Archetype::Hash.new
         inherit.each { |related| tmp = tmp.rmerge(extract_styles(id, related, true, theme, context)) }
         # remove the inheritance key and update the styles
         value.delete(INHERIT)
@@ -329,13 +408,24 @@ private
   def get_theme(theme)
     theme_name = helpers.to_str(theme || 'archetype')
     @@styleguide_themes ||= {}
-    theme = @@styleguide_themes[theme_name] ||= {}
+    themes = @@styleguide_themes[theme_name] ||= {}
+    cleanup_old_themes!(themes, options[:css_filename]) if rand < 0.333  # cleanup 1/3 of the time.
+    theme = themes[options[:css_filename]] ||= {}
     theme[:name] ||= theme_name
     theme[:components] ||= {}
     theme[:extensions] ||= []
     return theme
   end
 
+  def cleanup_old_themes!(themes, css_filename)
+    themes.keys.each do |key|
+      if key != css_filename
+        themes.delete(key)
+      end
+    end
+    nil
+  end
+
   #
   # driver method for converting a sentence into a list of styles
   #
@@ -348,9 +438,8 @@ private
   #
   def get_styles(description, theme = nil, state = 'false')
     state = helpers.to_str(state)
-    description = description.to_a
-    styles = {}
-    description.each do |sentence|
+    styles = Archetype::Hash.new
+    description.to_a.each do |sentence|
       # get the grammar from the sentence
       id, modifiers, token = grammar(sentence, theme, state)
       if id

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

@@ -18,10 +18,11 @@ module Archetype::SassExtensions::UI
   # - {String} the unique string
   #
   def unique(prefix = '')
-    prefix = helpers.to_str(prefix).gsub(/\A"|"\Z/, '')
+    prefix = helpers.to_str(prefix, ' ', :quotes)
     prefix = '.' if prefix == 'class'
     prefix = '#' if prefix == 'id'
-    return Sass::Script::String.new("#{prefix}archetype-uid-#{uid}")
+    suffix = Compass.configuration.testing ? "RANDOM_UID" : "#{Time.now.to_i}-#{rand(36**8).to_s(36)}-#{uid}"
+    return Sass::Script::String.new("#{prefix}archetype-uid-#{suffix}")
   end
 
   #

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

@@ -8,7 +8,7 @@ require 'sass/version'
 #
 module Archetype::SassExtensions::Version
   # :stopdoc:
-  COMPARATOR_PATTERN  = /([neglt]+|[><=!]+)/
+  COMPARATOR_PATTERN  = /(\s[neqglt]+\s|[><=!]+)/
   VERSION_PATTERN     = /\d+(\.\d+)*(\.[x|\*])?/
   # :startdoc:
 
@@ -21,10 +21,15 @@ module Archetype::SassExtensions::Version
   # - {String|Boolean} if no test or test is just a lookup of a framework, it returns the version of that framework, otherwise it returns the result of the test
   #
   def archetype_version(test = nil)
-    test = test.nil? ? 'archetype' : helpers.to_str(test).gsub(/\A"|"\Z/, '').downcase
-    lib = Archetype::VERSION
-    lib = Compass::VERSION if test.include?('compass')
-    lib = Sass::VERSION if test.include?('sass')
+    test = test.nil? ? 'archetype' : helpers.to_str(test, ' ', :quotes).downcase
+    lib = ''
+    if test.include?('compass')
+      lib = Compass::VERSION
+    elsif test.include?('sass')
+      lib = Sass::VERSION
+    else
+      lib = Archetype::VERSION
+    end
     # strip off any non-official versioning (e.g. pre/alpha/rc)
     lib = lib.match(VERSION_PATTERN)[0]
     result = compare_version(lib, test.match(VERSION_PATTERN), test.match(COMPARATOR_PATTERN))
@@ -55,7 +60,7 @@ private
     # check for wild cards
     wild = version.index('x')
     # check the comparison
-    comparator = (comparator || [])[0] || 'eq'
+    comparator = ((comparator || [])[0] || 'eq').strip
     eq = comparator =~ /(e|=)/
     lt = comparator =~ /(l|<)/
     gt = comparator =~ /(g|>)/

data/lib/archetype/sass_extensions/monkey_patches.rb

@@ -1,3 +1,3 @@
 %w(handle_include_loop).each do |patch|
   require "archetype/sass_extensions/monkey_patches/#{patch}"
-end
+end

data/lib/archetype/version.rb

@@ -1,3 +1,3 @@
 module Archetype
-  VERSION = '0.0.1.pre.12'
-end
+  VERSION = '0.0.1.pre.13'
+end

data/stylesheets/archetype/_base.scss

@@ -2,6 +2,7 @@
 @import "base/normalize";
 @import "base/reset";
 @import "base/hybrid";
+@import "base/h5bp";
 
 // protect against multiple resets
 $RESET_INIT: false !default;
@@ -11,8 +12,8 @@ $RESET_INIT: false !default;
 // sets the base styles for the page (e.g. reset or normalize)
 // @mixin     base
 // @param     $exclude {List} the list of styles to exclude @see _normalize.scss and _reset.scss
-// @param     $method {String} reset method [reset|normalize|hybrid]
-// @param     $force {Bool} force reset to invoke; by default base() can only be invoked once, to re-invoke must pass in $force: true
+// @param     $method {String} reset method [reset|normalize|h5bp|hybrid]
+// @param     $force {Boolean} force reset to invoke; by default base() can only be invoked once, to re-invoke must pass in $force: true
 @mixin base($exclude: $CONFIG_RESET_EXCLUDES, $method: $CONFIG_RESET_METHOD, $force: false) {
   @if not $RESET_INIT or $force {
     $RESET_INIT: true;
@@ -20,6 +21,10 @@ $RESET_INIT: false !default;
     @if $method == normalize {
       @include base-normalize($exclude: $exclude);
     }
+    // html5 boiler plate
+    @else if $method == h5bp {
+      @include base-h5bp($exclude: $exclude);
+    }
     // hyrbid reset (reset + some normalize)
     @else if $method == hybrid {
       @include base-hybrid($exclude: $exclude);

data/stylesheets/archetype/_config.scss

@@ -40,6 +40,7 @@ $CONTENT_PLACEHOLDER:             '\0020' !default;
 $CONFIG_DISABLED_CSS:             () !default;                                                      // a list of CSS3 features to always disable when using output-style()
 $CONFIG_GENERATED_TAG_PREFIX:     x-archetype !default;                                             // the prefix for the tag name to create when using ie-pseudo method
 $CONFIG_GENERATED_TAG_CSS:        false !default;                                                   // styles to apply to the generated tag when using ie-pseudo method (use this as a way to reset styles on these tags)
+$CONFIG_GENERATED_TAG_INLINE:     true !default;                                                    // if `true` insert the styles inline on the generated tag, otherwise insert the styles in a unique css rule
 
 // z-layers
 $CONFIG_Z_INDEX_BASE:             0 !default;                                                       // the default starting layer for z-index calculations
@@ -60,7 +61,7 @@ $CONFIG_KEYFRAME_LOADERS:         archetype-loader !default;
 $CONFIG_GLYPHS_NAME:              FontAwesome !default;                                             // name for the font-face
 $CONFIG_GLYPHS_VERSION:           '0.0.1' !default;                                                 // the glyph library version number
 $CONFIG_GLYPHS_SVG_ID:            $CONFIG_GLYPHS_NAME !default;
-$CONFIG_GLYPHS_BASE_PATH:         'vendor/archetype/fontawesome-webfont' !default;                  // generic path to all glpyh fonts (sans extensions)
+$CONFIG_GLYPHS_BASE_PATH:         'vendor/archetype/fontawesome-webfont' !default;                  // generic path to all glyph fonts (sans extensions)
 $CONFIG_GLYPHS_EOT:               '#{$CONFIG_GLYPHS_BASE_PATH}.eot' !default;
 $CONFIG_GLYPHS_FILES:             font-files('#{$CONFIG_GLYPHS_BASE_PATH}.woff', '#{$CONFIG_GLYPHS_BASE_PATH}.ttf', '#{$CONFIG_GLYPHS_BASE_PATH}.svg##{$CONFIG_GLYPHS_SVG_ID}') !default;
 $CONFIG_GLYPHS_WEIGHT:            normal !default;                                                  // font-weight for glyphs
@@ -380,3 +381,9 @@ $CORE_SAFE_FONTS: (
 ); // note that this declaration isn't a `default`, but rather is enforced everytime. this can be modified (via extending $CONFIG_SAFE_FONTS)
 $CONFIG_SAFE_FONTS: () !default;
 $CONFIG_SAFE_FONTS: associative-merge($CORE_SAFE_FONTS, $CONFIG_SAFE_FONTS);
+
+$archetype-glyph-selector: false !default;
+$archetype-pseudo-selector: false !default;
+
+$CORE_GLYPH_SELECTOR_VAR: '$archetype-glyph-selector';
+$CORE_GLYPH_SELECTOR_VAR: '$archetype-pseudo-selector';