archetype 0.0.1.pre.3.811928f → 0.0.1.pre.4

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:
 
@@ -76,7 +79,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] ||= {}).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
@@ -98,7 +101,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) if not extension.nil?
+      extension = helpers.to_str(extension).hash if not extension.nil?
       return Sass::Script::Bool.new( component_exists(id, theme, extension, force) )
     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)
@@ -348,9 +427,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

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

data/lib/archetype/sass_extensions/monkey_patches/handle_include_loop.rb

@@ -0,0 +1,13 @@
+# :stopdoc:
+# monkey patch Sass to exclude special mixins from it's include loop logic
+module Sass
+  module Tree
+    module Visitors
+      class Perform
+        def handle_include_loop!(node)
+          # do nothing
+        end
+      end
+    end
+  end
+end

data/lib/archetype/version.rb

@@ -10,7 +10,7 @@ module Archetype
     # Method borrowed from Compass. All credit goes to Chris Eppstein and other contributors
     # https://github.com/chriseppstein/compass/blob/stable/lib/compass/version.rb
     # \(This method swiped from Haml and then modified, some credit goes to Nathan Weizenbaum\)
-    # 
+    #
     # *Returns*:
     # - {String} the version of Archetype
     #
@@ -29,18 +29,25 @@ module Archetype
 
     def read_version
       require 'yaml'
-      @version = YAML::load(File.read(scope('VERSION.yml')))
-      @version[:teeny] = @version[:patch]
-      @version[:string] = "#{@version[:major]}.#{@version[:minor]}"
-      @version[:string] << ".#{@version[:patch]}" if @version[:patch]
-      @version[:string] << ".#{@version[:build]}" if @version[:build]
-      @version[:string] << ".#{@version[:state]}" if @version[:state]
-      @version[:string] << ".#{@version[:iteration]}" if @version[:iteration]
-      if !ENV['OFFICIAL'] && r = revision
-        @version[:string] << ".#{r[0..6]}"
-        @version[:rev] = r
+      begin
+        @version = YAML.load(File.read(scope('VERSION.yml')))
+        @version[:teeny] = @version[:patch]
+        @version[:string] = "#{@version[:major]}.#{@version[:minor]}"
+        @version[:string] << ".#{@version[:patch]}" if @version[:patch]
+        @version[:string] << ".#{@version[:build]}" if @version[:build]
+        @version[:string] << ".#{@version[:state]}" if @version[:state]
+        @version[:string] << ".#{@version[:iteration]}" if @version[:iteration]
+        if !ENV['OFFICIAL'] && r = revision
+          @version[:string] << ".#{r[0..6]}"
+          @version[:rev] = r
+        end
+        return @version
+      rescue
+        # this is a hack, but I'm not fully understanding how to fix this correctly
+        # see issue #4
+        # if it failed, try again, for now
+        return read_version
       end
-      @version
     end
 
     def revision

data/stylesheets/archetype/_base.scss

@@ -38,6 +38,9 @@ $RESET_INIT: false !default;
   // the font-face mixin will likely change in a future version, keep an eye on this
   // https://github.com/chriseppstein/compass/issues/867
   @include font-face($CONFIG_GLYPHS_NAME, $CONFIG_GLYPHS_FILES, $CONFIG_GLYPHS_EOT, $CONFIG_GLYPHS_WEIGHT, $CONFIG_GLYPHS_STYLE);
+  // output a second @font-face set with a versioned family name
+  // this will help avoid collisions when multi-app CSS is loaded on a single page
+  @include font-face('#{$CONFIG_GLYPHS_NAME}-#{$CONFIG_GLYPHS_VERSION}', $CONFIG_GLYPHS_FILES, $CONFIG_GLYPHS_EOT, $CONFIG_GLYPHS_WEIGHT, $CONFIG_GLYPHS_STYLE);
 }
 
 // auto invoke base reset

data/stylesheets/archetype/_config.scss

@@ -46,7 +46,7 @@ $CONFIG_Z_INDEX_BASE:             0 !default;
 $CONFIG_Z_LAYERS_OFFSET:          100 !default;                                                     // the offset between z-layers
 $CONFIG_Z_LAYERS:                 (default dialog navigation) !default;                             // the orders for the z-layers
 
-// compass 
+// compass
 $COMPASS_RTL_SUPPORT:             false !default;                                                   // does your Compass version support RTL? set to true if Compass mixins support RTL
 
 // sprites
@@ -304,12 +304,12 @@ $CONFIG_BROWSER_WARN_ON_HACK:     false !default;
 $CONFIG_BROWSER_VENDORS_HACK: (
   (webkit-all, safari webkit chrome),
   (gecko-all,  firefox gecko mozilla),
-  (opera-all,  opera)
+  (opera-all,  opera) // NOTE: this may stop working once Opera switches over to using WebKit/Blink
 ) !default;
 
 // os targeting
 $CONFIG_OS_VENDORS_CLASS: (
-  (os-win,   windows win winxp win7),
+  (os-win,   windows win winxp win7 win8),
   (os-mac,   apple mac osx),
   (os-linux, linux),
   (os-other, other misc unknown)
@@ -321,21 +321,38 @@ $CORE_SAFE_FONTS: (
   (sans-serif, (
     (default, (
       (default          (sans-serif)),
-      (ko_KR            ('Malgun Gothic', default))
+      (ko_KR            ('Malgun Gothic', default)),
+      (zh_TW            (SimSun, default)),
+      (zh_CN            (SimSun, default)),
+      (th_TH            (Tahoma, default)),
+      (ar_AE            (Tahoma, Arial, 'Times New Roman', default))
     )),
     (win, (
       (default          (Arial, sans-serif)),
       (ja_JP            (メイリオ, Meiryo, 'ＭＳ Ｐゴシック', 'MS PGothic', default)),
-      (ko_KR            nil)
+      (zh_TW            (default, '微軟正黑體', 'Microsoft JhengHei', PMingLiu, '宋体', SimSun)),
+      (zh_CN            (Arial, '华文细黑', 'STHeiti Light', '微软雅黑体', 'Microsoft Yahei', '新宋体', NSimSun, '宋体', SimSun)), // Heiti/Yahei not showing up in Chrome and FF in windows. Removal of sans-serif fixes it.
+      (th_TH            nil),
+      (ko_KR            nil),
+      (ar_AE            nil)
     )),
     (mac, (
       (default          (Helvetica, Arial, sans-serif)),
+      (zh_TW            (default, '黑體-繁', 'Heiti TC', '儷黑Pro', 'LiHei Pro', PMingLiu, '宋体', SimSun)),
+      (zh_CN            (default, '黑体-简', 'Heiti SC', '华文细黑', 'STHeiti Light', '华文黑体', STHeiti)),
       (ja_JP            ('Hiragino Kaku Gothic Pro', 'ヒラギノ角ゴ Pro W3', 'ＭＳ Ｐゴシック', 'MS PGothic', default)),
-      (ko_KR            nil)
+      (th_TH            nil),
+      (ko_KR            nil),
+      (ar_AE            nil)
     )),
     (linux, (
       (default          (Helvetica, FreeSans, 'Liberation Sans', Helmet, Arial, sans-serif)),
-      (CJK              nil)
+      (zh_TW            (default, PMingLiu, '宋体', SimSun)),
+      (zh_CN            (default, '新宋体', NSimSun, '宋体', SimSun)),
+      (ja_JP            nil),
+      (th_TH            nil),
+      (ko_KR            nil),
+      (ar_AE            nil)
     ))
   )),
   (serif, (
@@ -351,6 +368,13 @@ $CORE_SAFE_FONTS: (
       nil
     )),
     nil
+  )),
+  (headline, (
+    (default, (
+      (default          nil), // by default, dont style headlines differently
+      (ar_AE            ('Droid Arabic Naskh')) // TODO: need to include the webfont
+    )),
+    nil
   ))
 ); // 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;