archetype 0.0.1.pre.13 → 1.0.0.alpha.1

data/lib/archetype/functions/hash.rb

@@ -1,149 +1,3 @@
-# :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
-  #
-  # recursively merge two hashes with deep merging
-  #
-  # *Parameters*:
-  # - +other_hash+ {Hash} the other hash to merge with
-  # *Returns*:
-  # - {Hash} a new hash containing the contents of other_hash and the contents of hsh, deep merged
-  #
-  def rmerge(other_hash, &block)
-    dup.rmerge!(other_hash, &block)
-  end
-
-  #
-  # adds the contents of other_hash to hsh, deep merged
-  #
-  # *Parameters*:
-  # - +other_hash+ {Hash} the other hash to merge with
-  # *Returns*:
-  # - {Hash} the original hash with the addition of the contents of other_hash
-  #
-  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
-
-  #
-  # get the difference of another hash
-  #
-  # *Parameters*:
-  # - +other_hash+ {Hash} the other hash to compare against
-  # *Returns*:
-  # - {Hash} a representation of the difference between the two hashes
-  #
-  def diff(other_hash)
-    (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
-      unless self[key] == other_hash[key] and eq_gradients
-        if self[key].kind_of?(Hash) && other_hash[key].kind_of?(Hash)
-          tmp[key] = self[key].diff(other_hash[key])
-        else
-          tmp[key] = other_hash[key] || css_defaults(key)
-          # if the key is `filter-gradient` and it was removed, we need to change the key to `ie-filter`
-          tmp['ie-filter'] = css_defaults('ie-filter') if key == 'filter-gradient' and tmp[key].nil?
-          # if it came back as `nil` we couldn't understand it or it has no default, so axe it
-          tmp.delete(key) if tmp[key].nil?
-        end
-      end
-      tmp
-    end
-  end
-
-private
-  #
-  # returns a best guess for the default CSS value of a given property
-  #
-  # *Parameters*:
-  # - <tt>key</tt> {String} the property to lookup
-  # *Returns*:
-  # - {Sass::String|Sass::Number} the default value
-  #
-  def css_defaults(key)
-    if @css_defaults.nil?
-      s = {}
-      # color
-      s['color'] = 'inherit'
-      # text
-      s['font'] = s['font-size'] = s['font-family'] = s['font-style'] = s['font-variant'] = s['font-weight'] = 'inherit'
-      s['text-decoration'] = s['text-transform'] = 'none'
-      s['text-align'] = 'left'
-      s['text-indent'] = 0
-      s['text-justify'] = 'auto'
-      s['text-overflow'] = 'clip'
-      s['line-height'] = 'normal'
-      # backgrounds
-      s['background'] = 'none'
-      s['background-color'] = 'transparent'
-      s['background-image'] = 'none'
-      s['background-repeat'] = 'repeat'
-      s['background-position'] = 'left top'
-      s['background-attachment'] = 'scroll'
-      s['background-clip'] = 'border-box'
-      s['background-size'] = 'auto'
-      s['background-origin'] = 'padding-box'
-      # borders
-      s['border'] = s['border-top'] = s['border-left'] = s['border-bottom'] = s['border-right'] = 'none'
-      s['border-color'] = s['border-top-color'] = s['border-left-color'] = s['border-bottom-color'] = s['border-right-color'] = 'transparent'
-      s['border-width'] = s['border-top-width'] = s['border-left-width'] = s['border-bottom-width'] = s['border-right-width'] = 0
-      s['border-style'] = s['border-top-style'] = s['border-left-style'] = s['border-bottom-style'] = s['border-right-style'] = 'solid'
-      # border-radius
-      s['border-radius'] = s['border-top-left-radius'] = s['border-top-right-radius'] = s['border-bottom-left-radius'] = s['border-bottom-right-radius'] = 0
-      # margin
-      s['margin'] = s['margin-top'] = s['margin-left'] = s['margin-bottom'] = s['margin-right'] = 0
-      # padding
-      s['padding'] = s['padding-top'] = s['padding-left'] = s['padding-bottom'] = s['padding-right'] = 0
-      # shadows
-      s['text-shadow'] = s['box-shadow'] = 'none'
-      # width/height
-      s['height'] = s['width'] = 'auto'
-      s['min-width'] = s['max-width'] = s['min-height'] = s['max-height'] = 'none'
-      # position
-      s['position'] = 'static'
-      s['top'] = s['right'] = s['bottom'] = s['left'] = 'auto'
-      s['clear'] = s['float'] = 'none'
-      # misc
-      s['overflow'] = 'visible'
-      s['opacity'] = 1
-      s['visibility'] = 'visible'
-      s['ie-filter'] = 'gradient(enabled=false)'
-      s['z-index'] = 0
-      # --------------------
-      @css_defaults = s
-    end
-    value = @css_defaults[key]
-    value = Sass::Script::String.new(value) if value.is_a? String
-    value = Sass::Script::Number.new(value) if value.is_a? Numeric
-    return value
-  end
-end
-
-# 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
-
+%w(extend shim).each do |dep|
+  require "archetype/functions/hash/#{dep}"
+end

data/lib/archetype/functions/hash/extend.rb

@@ -0,0 +1,74 @@
+# :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
+  #
+  # recursively merge two hashes with deep merging
+  #
+  # *Parameters*:
+  # - +other_hash+ {Hash} the other hash to merge with
+  # *Returns*:
+  # - {Hash} a new hash containing the contents of other_hash and the contents of hsh, deep merged
+  #
+  def rmerge(other_hash, &block)
+    dup.rmerge!(other_hash, &block)
+  end
+
+  #
+  # adds the contents of other_hash to hsh, deep merged
+  #
+  # *Parameters*:
+  # - +other_hash+ {Hash} the other hash to merge with
+  # *Returns*:
+  # - {Hash} the original hash with the addition of the contents of other_hash
+  #
+  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
+
+  #
+  # get the difference of another hash
+  #
+  # *Parameters*:
+  # - +other_hash+ {Hash} the other hash to compare against
+  # *Returns*:
+  # - {Hash} a representation of the difference between the two hashes
+  #
+  def diff(other_hash)
+    (self.keys + other_hash.keys).uniq.inject(Archetype::Hash.new) do |tmp, key|
+      item_1, item_2 = self[key], other_hash[key]
+      # special comparison for gradients
+      are_gradients = (item_1.class == item_2.class) && (item_1.is_a?(Compass::Core::SassExtensions::Functions::GradientSupport::LinearGradient) or item_1.is_a?(Compass::Core::SassExtensions::Functions::GradientSupport::RadialGradient))
+      eq_gradients = are_gradients ? (item_1.to_s == item_2.to_s) : true
+      unless item_1 == item_2 and eq_gradients
+        if item_1.kind_of?(Hash) and item_2.kind_of?(Hash)
+          tmp[key] = item_1.diff(item_2)
+        else
+          tmp[key] = item_2 || Archetype::Functions::CSS.default(key)
+          # if the key is `filter-gradient` and it was removed, we need to change the key to `ie-filter`
+          tmp['ie-filter'] = Archetype::Functions::CSS.default('ie-filter') if key == 'filter-gradient' and tmp[key].nil?
+          # if it came back as `nil` we couldn't understand it or it has no default, so axe it
+          tmp.delete(key) if tmp[key].nil?
+        end
+      end
+      tmp
+    end
+  end
+
+  unless self.respond_to?(:to_h)
+    def to_h
+      return self
+    end
+  end
+end

data/lib/archetype/functions/hash/shim.rb

@@ -0,0 +1,48 @@
+# :stopdoc:
+# 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
+
+      # make select behave like its 1.9+ counterpart
+      def select
+        hsh = ::Archetype::Hash.new
+        self.each do |key, value|
+          hsh[key] = value if yield(key, value)
+        end
+        return hsh
+      end
+
+      # make select! behave like its 1.9+ counterpart
+      def select!
+        self.each do |key, value|
+          self.delete[key] unless yield(key, value)
+        end
+        return self
+      end
+
+      # make reject behave like its 1.9+ counterpart
+      def reject
+        hsh = ::Archetype::Hash.new
+        self.each do |key, value|
+          hsh[key] = value unless yield(key, value)
+        end
+        return hsh
+      end
+
+      # make reject! behave like its 1.9+ counterpart
+      def reject!
+        self.each do |key, value|
+          self.delete[key] if yield(key, value)
+        end
+        return self
+      end
+    end
+  else
+    class Hash < ::Hash
+      include Archetype::Functions::Hash
+    end
+  end
+end

data/lib/archetype/functions/helpers.rb

@@ -2,7 +2,18 @@
 # This module provides a set of helper functions and methods for working with Sass literals.
 #
 module Archetype::Functions::Helpers
-private
+
+  # used for archetype meta objects on a Map
+  META = {
+    :meta => '-archetype-meta',
+    :has_multiples => 'has-multiple-values',
+    :values => 'values',
+    :message => 'message',
+    :original => 'original',
+    :decorators => {
+      :runtime_locales => 'has-runtime-locales'
+    }
+  }
 
   #
   # provides a convenience interface to the Compass::Logger
@@ -12,14 +23,21 @@ private
   end
 
   #
-  # convert a Hash to a Sass::List
+  # provides a convenience interface for logging warnings
+  #
+  def self.warn(msg)
+    logger.record(:warning, msg)
+  end
+
+  #
+  # convert an Archetype::Hash to a Sass::Script::Value::List
   #
   # *Parameters*:
-  # - <tt>hsh</tt> {Hash} the hash to convert
+  # - <tt>hsh</tt> {Archetype::Hash} the hash to convert
   # - <tt>depth</tt> {Integer} the depth to walk down into the hash
-  # - <tt>separator</tt> {Symbol} the separator to use for the Sass::List
+  # - <tt>separator</tt> {Symbol} the separator to use for the Sass::Script::Value::List
   # *Returns*:
-  # - {Sass::List} the converted list
+  # - {Sass::Script::Value::List} the converted list
   #
   def self.hash_to_list(hsh, depth = 0, separator = :comma)
     if hsh.is_a? Hash
@@ -31,35 +49,47 @@ private
           tmp = []
           item[1] = [item[1]] if not item[1].is_a? Array
           item[1].each do |i|
-            list.push Sass::Script::List.new([Sass::Script::String.new(item[0]), hash_to_list(i, depth + 1)], separator)
+            list.push Sass::Script::Value::List.new([Sass::Script::Value::String.new(item[0]), hash_to_list(i, depth + 1)], separator)
           end
         end
       end
-      return Sass::Script::List.new(list, separator)
+      return Sass::Script::Value::List.new(list, separator)
     end
     # if its an array, cast to a List
-    return Sass::Script::List.new(hsh, separator) if hsh.is_a? Array
+    return Sass::Script::Value::List.new(hsh, separator) if hsh.is_a? Array
     # otherwise just return it
     return hsh
   end
 
   #
-  # convert a Sass::List to a Hash
+  # convert a Sass::Script::Value::List to an Archetype::Hash
   #
   # *Parameters*:
-  # - <tt>list</tt> {Sass::List} the list to convert
+  # - <tt>list</tt> {Sass::Script::Value::List} the list to convert
   # - <tt>depth</tt> {Integer} the depth to reach into nested Lists
   # - <tt>nest</tt> {Array} a list of keys to treat as nested objects
+  # - <tt>additives</tt> {Array} a list of keys that are additive
   # *Returns*:
-  # - {Hash} the converted hash
+  # - {Archetype::Hash} the converted hash
   #
   def self.list_to_hash(list, depth = 0, nest = [], additives = [])
     list = list.to_a
     previous = nil
     hsh = Archetype::Hash.new
+    dups = Set.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 = "[#{Archetype.name}:hash] you're likely missing a comma or parens in your data structure"
+        begin
+          warn("#{msg}: #{item}")
+        rescue
+          warn(msg)
+        end
+      end
+
       # convert the key to a string and strip off quotes
       key = to_str(item[0], ' ' , :quotes)
       # capture the value
@@ -77,7 +107,7 @@ private
           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[1..-1] 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)
@@ -97,39 +127,214 @@ private
         if additives.include?(key)
           hsh[key] ||= []
           hsh[key].push(value)
+          dups << key
         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?
+    dups.each do |key|
+      # convert it's array of values into a meta object
+      hsh[key] = self.array_to_meta(hsh[key])
+    end
+
+    warn("[#{Archetype.name}:hash] one of your data structures is ambiguous, please double check near `#{previous}`") unless (previous.nil? or previous.empty?)
 
     return hsh
   end
 
+  #
+  # convert a Sass::Script::Value::List or Sass::Script::Value::Map to an Archetype::Hash
+  #
+  # *Parameters*:
+  # - <tt>data</tt> {Sass::Script::Value::List|Sass::Script::Value::Map} the data to convert
+  # - <tt>depth</tt> {Integer} the depth to reach into nested Lists
+  # - <tt>nest</tt> {Array} a list of keys to treat as nested objects
+  # - <tt>additives</tt> {Array} a list of keys that are additive
+  # *Returns*:
+  # - {Archetype::Hash} the converted hash
+  #
+  def self.data_to_hash(data, depth = 0, nest = [], additives = [])
+    method = data.is_a?(Sass::Script::Value::Map) ? :map_to_hash : :list_to_hash
+    return self.method(method).call(data, depth, nest, additives)
+  end
+
+  #
+  # converts a Sass::Script::Value::Map to an Archetype::Hash
+  # - <tt>data</tt> {Sass::Script::Value::Map} the map to convert
+  # - <tt>depth</tt> {Integer} the depth to reach into nested Lists
+  # - <tt>nest</tt> {Array} a list of keys to treat as nested objects
+  # - <tt>additives</tt> {Array} a list of keys that are additive
+  # *Returns*:
+  # - {Archetype::Hash} the converted hash
+  #
+  def self.map_to_hash(data, depth = 0, nest = [], additives = [])
+    data = data.to_h if data.respond_to?(:to_h)
+    hsh = Archetype::Hash.new
+    # recurisvely convert sub-maps into a hash
+    data.each do |key, value|
+      key = to_str(key, ' ' , :quotes)
+      hsh[key] = value.is_a?(Sass::Script::Value::Map) ? map_to_hash(value) : value
+    end
+    return hsh
+  end
+
+  #
+  # convert an Archetype::Hash to a Sass::Script::Value::Map
+  #
+  # *Parameters*:
+  # - <tt>hsh</tt> {Archetype::Hash} the hash to convert
+  # - <tt>depth</tt> {Integer} the depth to walk down into the hash
+  # - <tt>separator</tt> {Symbol} the separator to use for the Sass::Script::Value::List
+  # *Returns*:
+  # - {Sass::Script::Value::List} the converted list
+  #
+  def self.hash_to_map(hsh)
+    if hsh.is_a? Hash
+      new_hsh = Archetype::Hash.new
+      hsh.each do |key, item|
+        new_hsh[Sass::Script::Value::String.new(key)] = (item.is_a? Hash) ? self.hash_to_map(item) : item
+      end
+    else
+      new_hsh = {}
+    end
+    return Sass::Script::Value::Map.new(new_hsh)
+  end
+
+  #
+  # convert an array of values into a Sass map with meta data
+  #
+  # *Example*:
+  #   array_to_meta([1, "foo", "bar", 2, "baz"])
+  #     #=> ((-archetype-meta: (has-multiple-values: true), values: (1, "foo", "bar", 2, "baz")))
+  # *Parameters*:
+  # - <tt>array</tt> {Array} the array to convert
+  # *Returns*:
+  # - {Sass::Script::Value::Map} the converted map
+  #
+  def self.array_to_meta(array)
+    return array[0] if array.size == 1
+    return Sass::Script::Value::Map.new({
+      Sass::Script::Value::String.new(META[:meta]) => Sass::Script::Value::Map.new({
+        Sass::Script::Value::String.new(META[:has_multiples]) => Sass::Script::Value::Bool.new(true)
+      }),
+      Sass::Script::Value::String.new(META[:values]) => Sass::Script::Value::List.new(array, :comma)
+    })
+  end
+
+  #
+  # convert a Sass map with meta data to an array of values
+  #
+  # *Example*:
+  #   meta_to_array(((-archetype-meta: (has-multiple-values: true), values: (1, "foo", "bar", 2, "baz"))))
+  #     #=> [1, "foo", "bar", 2, "baz"]
+  # *Parameters*:
+  # - <tt>map</tt> {Sass::Script::Value::Map} the map to convert
+  # *Returns*:
+  # - {Array} the converted array
+  #
+  def self.meta_to_array(map)
+    hash = map.is_a?(Sass::Script::Value::Map) ? map_to_hash(map) : map
+    if hash.is_a?(Hash)
+      meta = hash[META[:meta]]
+      if not meta.nil? and not meta[META[:has_multiples]].nil? and meta[META[:has_multiples]]
+        return (hash[META[:values]] || []).to_a
+      end
+    end
+    # dunno what we got, but it wasn't meta enough, so just return the original map
+    return map
+  end
+
+  #
+  # decorates a value into a meta object
+  #
+  # *Parameters*:
+  # - <tt>value</tt> {*} the value to decorate
+  # *Returns*:
+  # - {Sass::Script::Value::Map} the decorated map
+  #
+  def self.meta_decorate(value, decorator)
+    return Sass::Script::Value::Null.new if is_null(value)
+    return Sass::Script::Value::Map.new({
+      Sass::Script::Value::String.new(META[:meta]) => Sass::Script::Value::Map.new({
+        Sass::Script::Value::String.new(META[:decorators][decorator] || decorator) => Sass::Script::Value::Bool.new(true)
+      }),
+      Sass::Script::Value::String.new(META[:original]) => value
+    })
+  end
+
+  #
+  # adds a meta message to the hash
+  #
+  # *Parameters*:
+  # - <tt>hash</tt> {Hash} the hash to store the message onto
+  # - <tt>message</tt> {String} the message to store
+  # *Returns*:
+  # - {Hash} the hash with the injected message
+  #
+  def self.add_meta_message(hash, message)
+    hash[META[:meta]] = Sass::Script::Value::Map.new({
+      Sass::Script::Value::String.new(META[:message]) => Sass::Script::Value::String.new(message)
+    })
+    return hash
+  end
+
+  #
+  # retrieves a meta message from a hash
+  #
+  # *Parameters*:
+  # - <tt>hash</tt> {Hash} the hash to retrieve the message from
+  # *Returns*:
+  # - {String} the meta message stored on the hash
+  #
+  def self.get_meta_message(hash)
+    if not hash[META[:meta]].nil?
+      meta = map_to_hash(hash[META[:meta]])
+      message = meta[META[:message]]
+      return message.to_s if not message.nil?
+    end
+    return nil
+  end
+
   #
   # convert things to a String
   #
   # *Parameters*:
-  # - <tt>value</tt> {String|Sass::String|Sass::List} the thing to convert
-  # - <tt>separator</tt> {String} the separator to use for joining Sass::List
+  # - <tt>value</tt> {String|Sass::Script::Value::String|Sass::Script::Value::List} the thing to convert
+  # - <tt>separator</tt> {String} the separator to use for joining Sass::Script::Value::List
+  # - <tt>strip</tt> {\*} the properties to strip from the resulting string
   # *Returns*:
   # - {String} the converted String
   #
   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 || '')
+      value = ((value.to_a).each{ |i| i.nil? ? 'nil' : (i.is_a?(String) ? i : i.is_a?(Array) ? to_str(i, separator, strip) : i.value) }).join(separator || '')
     end
     strip = /\A"|"\Z/ if strip == :quotes
     return strip.nil? ? value : value.gsub(strip, '')
   end
 
   #
-  # test a value for blankness or nilness
+  # simple test for `null` or `nil` (deprecated) value. this is here for back-compat support with old `nil` syntax
+  #
+  # *Parameters*:
+  # - <tt>$value</tt> {*} the value to test
+  # *Returns*:
+  # - {Boolean} whether or not the value is null
+  #
+  def self.is_null(value)
+    return true if value.nil?
+    is_deprecated_nil = (value.is_a?(Sass::Script::Value::String) && value.value == 'nil')
+    #helpers.warn("[#{Archetype.name}:nil] the usage of `nil` will be removed in a future release, please use the Sass standard `null`")
+    return value.is_a?(Sass::Script::Value::Null) || is_deprecated_nil
+  end
+
+  #
+  # test a value for various conditions
   #
   # *Parameters*:
-  # - <tt>value</tt> {String|Array|Sass::String|Sass::List} the thing to test
+  # - <tt>value</tt> {String|Array|Sass::Script::Value::String|Sass::Script::Value::List} the thing to test
   # - <tt>test</tt> {Symbol} the test to perform [:blank|:nil]
   # *Returns*:
   # - {Boolean} whether or not the value is nil/blank
@@ -139,16 +344,20 @@ private
     case test
     when :blank
       is_it = false
-      value = value.value if value.is_a?(Sass::Script::String)
+      value = value.value if value.is_a?(Sass::Script::Value::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)
+      is_it = value.to_a.empty? if value.is_a?(Sass::Script::Value::List) or value.is_a?(Array)
     when :nil
       is_it = false
-      value = value.value if value.is_a?(Sass::Script::String)
+      value = value.value if value.is_a?(Sass::Script::Value::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)
+      is_it = value.empty? if value.is_a?(Hash)
+      is_it = to_str(value) == 'nil' if value.is_a?(Sass::Script::Value::List) or value.is_a?(Array)
+      is_it = true if value.is_a?(Sass::Script::Value::Null)
+    when :hashy
+      is_it = value.is_a?(Hash) || value.is_a?(Sass::Script::Value::Map)
     end
     return is_it
   end