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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de11d6f34cd0100f0c778cbcc6934c7f309aa600
-  data.tar.gz: 322e13961821f4017eabbc64680da8ffe970a62d
+  metadata.gz: d73c8fbdab53ce9a623ba9c8f8bfa25defd2dca3
+  data.tar.gz: bde34dc53d79e37772e9c1397509ffcdfb778f43
 SHA512:
-  metadata.gz: 7ddb73df40c54934eacaefe7e5ebe95e01b474f6f2625e0712e3b77cd5014ef68236e45ce3595b4c750b097c3806137db7dc89ecda31a97e5fd8530f2cd2350f
-  data.tar.gz: 440f5eded8d3a1deeeb79fddb99ae6582fe712b5caa9c5d8349a431321c9d203b21cf9a2d20058743dc9ef7ec6d705688c9042795ea95679f79797cb910f3d37
+  metadata.gz: 367183d15630183a4e101f58b913a1c85028064a74b0cd269586157bf19818a39288ef0eaee64ffed617fe002653b3e245931fb9c94ca9f0bf3975c03fc3c22e
+  data.tar.gz: 892fb1fa496f0d55ec61fefbeef8404d35df8458034b8f8b5dd5983f5d1793c019e7fccb4cb9179aea7b77f1e992bdccd302c83926c47570aeeee247fa3ab202

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

@@ -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}".hash
+    return "#{id}::#{(modifiers.to_a.sort + extensions).join('$')}::#{state}"
   end
 
   #
@@ -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/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
@@ -176,7 +144,7 @@ module Archetype::SassExtensions::Lists
   # - <tt>$haystack</tt> {List} input list
   # - <tt>$needle</tt> {List} the value(s) to search for
   # *Returns*:
-  # - {Number|Bool} if an item is found, returns the index, otherwise returns false
+  # - {Number|Boolean} if an item is found, returns the index, otherwise returns false
   #
   def index2(haystack, needle)
     haystack = haystack.to_a
@@ -210,14 +178,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> {Bool} if true, does a strict match against the key
+  # - <tt>$strict</tt> {Boolean} 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)]
+    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