archetype 0.0.1.pre.3.f9dde24 → 0.0.1.pre.3.90263a7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d8111354af528e1158bffdbf5a605d91777d741
-  data.tar.gz: aeb843b2e32d7c191c5e0e137baa48b835021f3f
+  metadata.gz: 79510cfaba6afef89a552a3ac086173c80c73822
+  data.tar.gz: 2214d9ff17d64a4fab9829e870ac8849e952cec4
 SHA512:
-  metadata.gz: d9e9e587c6300790c9b16e4ce8547312ffa74b224dc981512a99af210b5433413d695786e08def6ad2758e558ec12087be1d146bfb9166d8f616b5300139737d
-  data.tar.gz: e13543614e78725f830aa69078645e419d84ab42b5d01063a6847830c7458952147056a953fed0a82e618d269799cfc10201f3c31776658171962cf112b799c7
+  metadata.gz: 90fd7abc4d5707b492d987a3e0870b911f27d08e1baec5a16bee065f101927ce44a443727cb0b3640a2a0fa509cac2c9f4ce29a34709645f6637f12214bee1f3
+  data.tar.gz: 95fa9484e95e38ad062889e68bb11aa2d7d21a4edbb2c1e9db8be53b729ba1d795d9a1ca67e8586526493486770d51a976a593937218166c4e38637e00a271b6

data/bin/archetype

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

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/helpers.rb

@@ -55,30 +55,66 @@ private
   #
   def self.list_to_hash(list, depth = 0, nest = [], additives = [])
     list = list.to_a
+    previous = nil
     hsh = Archetype::Hash.new
     list.each do |item|
       item = item.to_a
+
+      # if a 3rd item exists, we probably forgot a comma or parens somewhere
+      if previous.nil? and not item[2].nil?
+        msg = "you're likely missing a comma or parens in your data structure"
+        begin
+          logger.record(:warning, "#{msg}: #{item}")
+        rescue
+          logger.record(:warning, msg)
+        end
+      end
+
       # convert the key to a string and strip off quotes
       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
 
@@ -92,7 +128,9 @@ private
   # - {String} the converted String
   #
   def self.to_str(value, separator = ' ', strip = nil)
-    value = value.is_a?(String) ? value : ((value.to_a).each{ |i| i.is_a?(String) ? i : i.value }).join(separator || '')
+    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
@@ -112,11 +150,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/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 extend)
-  ADDITIVES   = FALLBACKS + [DROP, INHERIT, STYLEGUIDE]
+  # 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:
 
@@ -246,7 +249,11 @@ private
             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
@@ -254,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 = Archetype::Hash.new
-        (special || Archetype::Hash.new).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)
@@ -270,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
   #
@@ -282,31 +374,17 @@ 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 = Archetype::Hash.new
-        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 = Archetype::Hash.new
         inherit.each { |related| tmp = tmp.rmerge(extract_styles(id, related, true, theme, context)) }
@@ -349,9 +427,8 @@ private
   #
   def get_styles(description, theme = nil, state = 'false')
     state = helpers.to_str(state)
-    description = description.to_a
     styles = Archetype::Hash.new
-    description.each do |sentence|
+    description.to_a.each do |sentence|
       # get the grammar from the sentence
       id, modifiers, token = grammar(sentence, theme, state)
       if id