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

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 10b8c76537375cc63d59a51cd980ff057de481ae
+  data.tar.gz: cb746cde2c62f0b0c1165d80c0f8e79436ed4f44
+SHA512:
+  metadata.gz: 6758bc5a310d1a0c10e97285e3aeace27781a8f3e3516da5867fb741d1b48b83926189792e855dbedebf767c07898e299b30027045b270f68e51e8dd6bc9ba2b
+  data.tar.gz: 8aef25fe89a313843d68471fe7dacc28c7da625f054c6ef42801680da48a42a9ba1d32e94fa86cc83c99f4d037058ab5cfdd0f3a0bc2facd94093db1a54f804b

data/CHANGELOG.md

@@ -4,13 +4,36 @@
 
 - initial public release
 
-## 0.0.1.pre.3 (unreleased)
+## 0.0.1.pre.3 (pre-released)
 
 ### New Features:
 
 - added `styleguide-component-exists()` method to check if a component/extension has already been registered in the theme
 - added `memoize` compiler configuration to allow enabling/disabling the internal styleguide memoizer
+- `glyph-icon()` can now take `false` as an icon name and not output anything
+- added `unstyled-button()` method to remove default styling from a `<button>` element
+- added `prefixed-tag()` method for consistency when generating tag names
+- added Chinese font stacks
+- added wildcard support to `locale()` function (e.g. `locale(en_ ja_JP _DE)`)
+- added `transparent-focusable()` mixin for transparent background support in older IE
+- added ability to customize `output-style()` with `custom-output-styler()` mixin and `has-custom-output-styler()` function (NEEDS DOCUMENTATION)
+- added better support for targeting IE6/7 glyphs and `ie-pseudo()` generated elements (NEEDS DOCUMENTATION)
+- making `unique()` generated IDs genuinely unique
+- adding support for a `testing` config flag
+- adding support for `@extend` from a styleguide component
+
+### Resolved Issues:
+
+- quotes on strings passed to `associative()` weren't being stripped correctly
+- fixed some minor glyph issues
+- out-of-order CSS issues in Ruby 1.8.7 are fixed using `Hashery::OrderedHash`
+- fixed issue with `archetype-version()` incorrectly matching comparators
+
+### Tests:
+
 - added test case for fallback CSS properties
+- added test case for generating loading spinner keyframe animations
+- updated test cases for minor changes
 
 ## 0.0.1.pre.2 (unreleased)
 

data/LICENSE

@@ -1,5 +1,5 @@
 Archetype
-Copyright (c) 2012 LinkedIn
+Copyright (c) 2013 LinkedIn Corp.  All rights reserved.
 Apache Software License 2.0
 
 

data/README.md

@@ -1,6 +1,6 @@
 # Archetype
 
-[![Build Status](https://travis-ci.org/eoneill/archetype.png)](https://travis-ci.org/eoneill/archetype)
+[![Build Status](https://travis-ci.org/linkedin/archetype.png)](https://travis-ci.org/linkedin/archetype) [![Gem Version](https://badge.fury.io/rb/archetype.png)](http://badge.fury.io/rb/archetype)
 
 Archetype is a UI pattern and component library for quickly iterating on and maintaining scalable web interfaces.
 

data/VERSION.yml

@@ -3,4 +3,4 @@
 :minor: 0
 :build: 1
 :state: pre
-:iteration: 3
+:iteration: 4

data/bin/archetype

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib/archetype/executor')

data/lib/archetype.rb

@@ -33,6 +33,10 @@ 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/actions/help.rb

@@ -0,0 +1,16 @@
+description = "Get help on an Archetype action"
+if @description.nil?
+  # do stuff...
+  @help = true
+
+  if not ARGV[1].nil? and ARGV[1] != 'help'
+    action = File.join(@actions_path, ARGV[1])
+    begin
+      load "#{action}.rb"
+    rescue
+      puts "unknown action: #{ARGV[1]}"
+    end
+  end
+else
+  @description = description
+end

data/lib/archetype/actions/theme.rb

@@ -0,0 +1,73 @@
+require 'fileutils'
+description = "Generate a new Archetype theme"
+
+if @description.nil?
+  options = {
+    :extends => 'archetype'
+  }
+  OptionParser.new do |opts|
+    opts.banner = description
+    opts.define_head "Usage: archetype theme [path] [options]"
+    opts.separator ""
+    opts.separator "Example usage:"
+    opts.separator " archetype theme /path/to/scss/ --name=myCustomTheme"
+    opts.separator " archetype theme --name=themes/myExtendedTheme --extends=themes/myBaseTheme"
+
+    opts.on('-n', '--name THEME', 'theme name') do |v|
+      options[:theme] = v
+    end
+
+    opts.on('-x', '--extends THEME', 'theme name to extend') do |v|
+      options[:extends] = v
+    end
+
+    opts.on('-h', '--help', 'shows this help message') do
+      puts opts
+      exit
+    end
+
+    if not @help.nil?
+      puts opts
+      exit
+    end
+  end.parse!
+
+  if not options[:theme].nil?
+    base = ARGV[1] || '.'
+    tmp = '/tmp/theme_' + rand(36**8).to_s(36)
+    theme_template = File.join(File.dirname(__FILE__), '../../../templates/_theme/')
+    theme_path = File.join(base, options[:theme])
+    extends = "#{options[:extends]}"
+    if options[:extends] != 'archetype'
+      extends = "#{extends}/core"
+    end
+    theme_name = File.basename(options[:theme])
+    # copy template files to tmp dir
+    FileUtils.mkdir_p(tmp)
+    FileUtils.cp_r(Dir["#{theme_template}/**"], tmp)
+
+    puts "Creating theme '#{theme_name}' in #{File.expand_path(theme_path)}..."
+    puts "extending from #{options[:extends]}" if options[:extends] != 'archetype'
+
+    # update all placeholders in template files
+    Dir.glob("#{tmp}/**/*.scss") do |filename|
+      out = File.read(filename).gsub(/__THEME_NAME__/, theme_name).gsub(/__THEME_EXTENDS__/, extends)
+      File.open(filename, "w") { |file| file.puts out }
+    end
+
+    # now move all the theme files to their destination
+    FileUtils.mkdir_p(theme_path)
+    FileUtils.cp_r(Dir["#{tmp}/**"], theme_path)
+
+    # create convenience file _<theme>.scss ...
+    File.open(File.join(File.dirname(theme_path), "_#{theme_name}.scss"), "w") { |file| file.puts "// #{theme_name} theme\n@import \"#{theme_name}/core\";\n" }
+
+    # remove tmp dir
+    FileUtils.rm_rf(tmp)
+    puts "Congratulations! Your new theme has been created!"
+    puts "Use @import \"#{options[:theme]}\" in your scss files."
+    exit
+  end
+else
+  @description = description
+end

data/lib/archetype/executor.rb

@@ -0,0 +1,27 @@
+require 'optparse'
+
+@actions_path = File.join(File.dirname(__FILE__), 'actions')
+
+if not ARGV[0].nil? and not ARGV[0].empty?
+  action_name = ARGV[0]
+  action = File.join(@actions_path, action_name)
+  begin
+    require action
+  rescue
+    puts "unknown action: #{action_name}"
+  end
+end
+
+# if we got here, there was either no action, or the action was invalid
+OptionParser.new do |opts|
+  opts.banner = "Archetype command line actions\n\n"
+  opts.define_head "Usage: archetype <action> [options]"
+  opts.separator ""
+  opts.separator "Available Actions:"
+  Dir.glob("#{@actions_path}/*.rb") do |action|
+    @description = true
+    load action
+    opts.separator "  * #{File.basename(action, '.rb')}\t- #{@description}"
+  end
+  puts opts
+end.parse!

data/lib/archetype/functions/hash.rb

@@ -1,6 +1,8 @@
 # :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
   #
@@ -11,13 +13,10 @@ 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)
-    new_hash = {}
-    merge(other_hash) do |key, oldval, newval|
-      new_hash[key] = oldval.class == self.class ? oldval.rmerge(newval) : newval
-    end
+  def rmerge(other_hash, &block)
+    dup.rmerge!(other_hash, &block)
   end
-  
+
   #
   # adds the contents of other_hash to hsh, deep merged
   #
@@ -26,10 +25,16 @@ module Archetype::Functions::Hash
   # *Returns*:
   # - {Hash} the original hash with the addition of the contents of other_hash
   #
-  def rmerge!(other_hash)
-    merge!(other_hash) do |key, oldval, newval|
-      oldval.class == self.class ? oldval.rmerge!(newval) : newval
+  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
     end
+    return self
   end
 
   #
@@ -41,7 +46,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({}) do |tmp, key|
+    (self.keys + other_hash.keys).uniq.inject(Archetype::Hash.new) 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
@@ -128,6 +133,17 @@ private
   end
 end
 
-class Hash
-  include Archetype::Functions::Hash
+# 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
 end
+

data/lib/archetype/functions/helpers.rb

@@ -24,7 +24,8 @@ private
   def self.hash_to_list(hsh, depth = 0, separator = :comma)
     if hsh.is_a? Hash
       list = []
-      hsh.each do |item|
+      hsh.each do |key, item|
+        item = [key, item]
         # if its a hash, convert it to a List
         if item.is_a? Hash or item.is_a? Array
           tmp = []
@@ -54,30 +55,56 @@ private
   #
   def self.list_to_hash(list, depth = 0, nest = [], additives = [])
     list = list.to_a
-    hsh = {}
+    previous = nil
+    hsh = Archetype::Hash.new
     list.each do |item|
       item = item.to_a
+
       # convert the key to a string and strip off quotes
-      key = to_str(item[0]).gsub(/\A"|"\Z/, '')
+      key = to_str(item[0], ' ' , :quotes)
+      # capture the value
       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
-        # 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
+
+        if additives.include?(key)
+          hsh[key] ||= []
+          hsh[key].push(value)
+        else
+          hsh[key] = value
         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
 
@@ -90,8 +117,12 @@ private
   # *Returns*:
   # - {String} the converted String
   #
-  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 || '')
+  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, '')
   end
 
   #
@@ -109,11 +140,13 @@ 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 entire memoizer for the theme
+  # invalidate the memoizer for the theme
   #
   # *Parameters*:
   # - <tt>theme</tt> {String} the theme name
@@ -58,4 +58,12 @@ private
   def self.clear(theme)
     @components[theme] = {}
   end
+
+
+  #
+  # resets the entire memoizer
+  #
+  def self.reset!
+    @components = {}
+  end
 end

data/lib/archetype/sass_extensions.rb

@@ -4,3 +4,4 @@ module Archetype::SassExtensions
 end
 
 require 'archetype/sass_extensions/functions'
+require 'archetype/sass_extensions/monkey_patches'

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_replace, [:list, :idx]
-  Sass::Script::Functions.declare :list_replace, [:list, :idx, :separator]
+  Sass::Script::Functions.declare :list_remove, [:list, :idx]
+  Sass::Script::Functions.declare :list_remove, [:list, :idx, :separator]
 
   #
   # insert an item into a list
@@ -67,41 +67,9 @@ 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_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
+  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]
 
   #
   # add values(s) to a list
@@ -217,7 +185,7 @@ module Archetype::SassExtensions::Lists
   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)]
+    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)
@@ -243,7 +211,33 @@ module Archetype::SassExtensions::Lists
     list = list.rmerge(extender)
     return helpers.hash_to_list(list, 0, separator)
   end
-  Sass::Script::Functions.declare :list_extend, [:list, :extender]
+  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
 
 private
   def helpers