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

data/lib/archetype/functions/css/routers/list.rb

@@ -0,0 +1,63 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # router for `list-style` properties
+  #
+  def self.get_derived_styles_router_for_list(related, property)
+    properties = %w(style-type style-position style-image)
+    styles, reconstruct = with_each_available_relative_if_root(related, property) do |items, comma_separated|
+      styles = ::Archetype::Hash.new
+      if helpers.to_str(items) == 'inherit'
+        styles[:style_image] = styles[:style_type] = styles[:style_position] = items
+      else
+        items.reject! do |item|
+          case helpers.to_str(item)
+          when /^(?:armenian|circle|cjk-ideographic|decimal(?:-leading-zero)?|disc|georgian|hebrew|(?:hiragana|katakana)(?:-iroha)?|(?:lower|upper)-(?:alpha|greek|latin|roman)|square)$/
+            styles[:style_type] = item
+          when /^(?:inside|outside)$/
+            styles[:style_position] = item
+          when /^url\(.*\)$/
+            styles[:style_image] = item
+          else
+            next
+          end
+          true
+        end
+
+        items.each do |item|
+          case helpers.to_str(item)
+          when 'none'
+            if styles[:style_type].nil?
+              styles[:style_type] = item
+            else
+              styles[:style_image] ||= item
+            end
+          when 'inherit'
+            if styles[:style_type].nil?
+              styles[:style_type] = item
+            elsif styles[:style_type].nil?
+              styles[:style_position] = item
+            else
+              styles[:style_image] ||= item
+            end
+          end
+        end
+      end
+      styles
+    end
+
+    if reconstruct
+      return nil if styles.nil? or styles.empty?
+      styles = set_default_styles(styles, 'list', properties)
+      value = [styles[:style_type], styles[:style_position], styles[:style_image]]
+      # we simplify it if the values are all identical
+      return value.first if value.uniq.length == 1
+      return Sass::Script::Value::List.new(value, :space)
+    end
+
+    # otherwise just return the value we were asked for
+    return styles
+  end
+end

data/lib/archetype/functions/css/routers/margin_padding.rb

@@ -0,0 +1,40 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # router for `margin` properties
+  #
+  def self.get_derived_styles_router_for_margin(related, property)
+    return get_derived_styles_router_for_margin_padding(related, property)
+  end
+
+  #
+  # router for `padding` properties
+  #
+  def self.get_derived_styles_router_for_padding(related, property)
+    return get_derived_styles_router_for_margin_padding(related, property)
+  end
+
+  #
+  # (real) router for both `margin` and `padding` properties
+  #
+  def self.get_derived_styles_router_for_margin_padding(related, property)
+    styles, reconstruct = with_each_available_relative_if_root(related, property) do |items, comma_separated|
+      # blow away anything we've already discovered (because it's irrelevant)
+      # and extract the top/right/bottom/left values
+      # make the styles available to the calling context
+      extract_symmetical_values(items)
+    end
+    # if we're getting the shorthand property, reconstruct the shorthand value
+    if reconstruct
+      value = extrapolate_shorthand_symmetrical(styles)
+      # if the value came back nil, we were missing something, so throw a warning...
+      return warn_not_enough_infomation_to_derive(property) if value.nil?
+      return value
+    end
+
+    # otherwise just return the value we were asked for
+    return styles
+  end
+end

data/lib/archetype/functions/css/routers/outline.rb

@@ -0,0 +1,56 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # router for `outline` properties
+  #
+  def self.get_derived_styles_router_for_outline(related, property)
+    properties = %w(color style width)
+    styles, reconstruct = with_each_available_relative_if_root(related, property) do |items, comma_separated|
+      # blow away anything we've already discovered (because it's irrelevant)
+      styles = ::Archetype::Hash.new
+      items.reject! do |item|
+        if item.is_a?(Sass::Script::Value::Color)
+          styles[:color] = item
+        elsif item.is_a?(Sass::Script::Value::Number)
+          styles[:width] = item
+        else
+          case helpers.to_str(item)
+          when 'invert'
+            styles[:color] = item
+          when /^(?:none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset)$/
+            styles[:style] = item
+          when /^(?:thin|medium|thick)$/
+            styles[:width] = item
+          when 'inherit'
+            next
+          end
+        end
+        true
+      end
+      # at this point, we should only have `inherit` values left
+      items.each do |item|
+        if styles[:color].nil?
+          styles[:color] = item
+        elsif styles[:style].nil?
+          styles[:style] = item
+        else
+          styles[:width] ||= item
+        end
+      end
+      styles = set_default_styles(styles, 'outline', properties)
+      # make the styles available to the calling context
+      styles
+    end
+
+    if reconstruct
+      return nil if styles.nil? or styles.empty?
+      styles = set_default_styles(styles, 'outline', properties)
+      return Sass::Script::Value::List.new([styles[:color], styles[:style], styles[:width]], :space)
+    end
+
+    # otherwise just return the value we were asked for
+    return styles
+  end
+end

data/lib/archetype/functions/css/routers/overflow.rb

@@ -0,0 +1,11 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # router for `overflow` properties
+  #
+  def self.get_derived_styles_router_for_overflow(related, property)
+    return is_root_property?(property) ? nil : filter_available_relatives(related, property).values.last
+  end
+end

data/lib/archetype/functions/css/routers/target.rb

@@ -0,0 +1,38 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # router for `target` properties
+  #
+  def self.get_derived_styles_router_for_target(related, property)
+    properties = %w(name new position)
+    styles, reconstruct = with_each_available_relative_if_root(related, property) do |items, comma_separated|
+      # blow away anything we've already discovered (because it's irrelevant)
+      # target-name target-new target-position
+      styles = ::Archetype::Hash.new
+      styles[:name] = items.shift
+
+      items.each do |item|
+        case helpers.to_str(item)
+        when /^(?:window|tab|none)$/
+          styles[:new] = item
+        when /^(?:above|behind|front|back)$/
+          styles[:position] = item
+        end
+      end
+      # set defaults if we missed anything...
+      styles = set_default_styles(styles, 'target', properties)
+      # make the styles available to the calling context
+      styles
+    end
+    if reconstruct
+      return warn_not_enough_infomation_to_derive(property) if styles.nil? or styles[:name].nil?
+      value = extrapolate_shorthand_simple(styles, property, properties)
+      return Sass::Script::Value::List.new(value, :space)
+    end
+
+    # otherwise just return the value we were asked for
+    return styles
+  end
+end

data/lib/archetype/functions/css/routers/transition.rb

@@ -0,0 +1,48 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # router for `transition` properties
+  #
+  def self.get_derived_styles_router_for_transition(related, property)
+    properties = %w(property duration timing-function delay)
+    styles, reconstruct = with_each_available_relative_if_root(related, property) do |items, comma_separated|
+      # blow away anything we've already discovered (because it's irrelevant)
+      timings = get_timing_values(items)
+      items = items - timings
+      # property duration timing-function delay
+      styles = ::Archetype::Hash.new
+      styles[:duration] = timings.shift
+      styles[:delay]    = timings.shift
+
+      items.reject! do |item|
+        case helpers.to_str(item)
+        when R_TIMING_FUNCTION
+          styles[:timing_function] = item
+        else
+          next
+        end
+        true
+      end
+
+      # set defaults if we missed anything...
+      styles[:property] = items.shift
+      styles = set_default_styles(styles, 'transition', properties)
+      # make the styles available to the calling context
+      styles
+    end
+
+    if reconstruct
+      if styles.nil? or styles[:property].nil?
+        return warn_not_enough_infomation_to_derive(property) if not styles.empty?
+        return nil
+      end
+      value = extrapolate_shorthand_simple(styles, property, properties)
+      return Sass::Script::Value::List.new(value, :space)
+    end
+
+    # otherwise just return the value we were asked for
+    return styles
+  end
+end

data/lib/archetype/functions/css/shorthands.rb

@@ -0,0 +1,43 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # extrapolates shorthand value from a simple list of ordered properties
+  #
+  def self.extrapolate_shorthand_simple(styles, base, properties)
+    styles = set_default_styles(styles, base, properties)
+    value = []
+    properties.each { |k| value << styles[normalize_property_key(k, base)] }
+    return value
+  end
+
+  #
+  # extrapolates shorthand value for symmetrical properties
+  #
+  def self.extrapolate_shorthand_symmetrical(styles)
+    # make sure we have enough info to continue
+    return nil if styles.nil? or styles.length < 4
+    # can we use 3 values?
+    if styles[:left] == styles[:right]
+      # can we use 2 values?
+      if styles[:bottom] == styles[:top]
+        # can we use just 1 value?
+        if styles[:top] == styles[:right]
+          styles = [styles[:top]] # 1 value
+        else
+          styles = [styles[:top], styles[:right]] # 2 values
+        end
+      else
+        styles = [styles[:top], styles[:right], styles[:bottom]] # 3 values
+      end
+    else
+      styles = [styles[:top], styles[:right], styles[:bottom], styles[:left]] # 4 values
+    end
+    return Sass::Script::Value::List.new(styles, :space)
+  end
+end
+
+%w(animation background border).each do |shorthand|
+  require "archetype/functions/css/shorthands/#{shorthand}"
+end

data/lib/archetype/functions/css/shorthands/animation.rb

@@ -0,0 +1,18 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # extrapolates shorthand value for `animation` property
+  #
+  def self.extrapolate_shorthand_animation(styles)
+    # make sure we have enough info to continue
+    return nil if styles.nil? or styles[:name].nil?
+    shorthand = []
+    shorthand << styles[:name]
+    %w(duration timing-function delay iteration-count direction fill-mode play-state).each do |k|
+      shorthand << (styles[normalize_property_key(k, 'animation')] || default("animation-#{k}")).to_a.first
+    end
+    return Sass::Script::Value::List.new(shorthand, :space)
+  end
+end

data/lib/archetype/functions/css/shorthands/background.rb

@@ -0,0 +1,68 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # deconstructs `background` shorthand property into it's longhand values
+  #
+  def self.deconstruct_shorthand_for_background(items, comma_separated, properties)
+    i = 0
+    # blow away anything we've already discovered (because it's irrelevant)
+    styles = ::Archetype::Hash.new
+    properties.each { |k| styles[k.to_sym] = [] }
+
+    (comma_separated ? items.to_a : [items]).each do |items|
+      items = items.to_a.dup if items.respond_to?(:to_a)
+      items.reject! do |item|
+        if item.is_a?(Sass::Script::Value::Color)
+          styles[:color] << item
+        else
+          case helpers.to_str(item)
+          when /^(?:(?:no-)?repeat(?:-[xy])?|inherit)$/
+            styles[:repeat] << item
+          # origin or clip
+          when /^(?:border|padding|content)-box$/
+            # if we already have an `origin`, then this is `clip`, otherwise it's `origin`
+            styles[styles[:origin][iteration].nil? ? :origin : :clip] << item
+          when /^(?:url\(.*\)|none)$/
+            # record multiple images if needed
+            styles[:image] << item
+          when /^(?:scroll|fixed|local)$/
+            styles[:attachment] << item
+          when /^(?:cover|contain)$/
+            styles[:size] << item
+          when /^(?:top|right|bottom|left|center)$/
+            styles[:position][i] ||= []
+            styles[:position][i] << item
+          else
+            next
+          end
+        end
+        true
+      end
+
+      # deal with the `position` and `size`, as they're order dependent...
+      items.each do |item|
+        if item.is_a?(Sass::Script::Value::Number) or helpers.to_str(item) == 'auto'
+          styles[:position][i] ||= []
+          if styles[:position][i].length < 2
+            styles[:position][i] << item
+          else
+            styles[:size][i] ||= []
+            styles[:size][i] = styles[:size][i].to_a
+            styles[:size][i] << item
+          end
+        end
+      end
+
+      [:position, :size].each do |k|
+        styles[k][i] = Sass::Script::List.new(styles[k][i], :space) if styles[k][i].is_a?(Array)
+      end
+
+      # ...
+      properties.each { |k| styles[k.to_sym] << default("background-#{k}") if styles[k.to_sym][i].nil?}
+      i += 1
+    end
+    return styles
+  end
+end

data/lib/archetype/functions/css/shorthands/border.rb

@@ -0,0 +1,102 @@
+module Archetype::Functions::CSS
+
+  private
+
+  #
+  # deconstructs `border` shorthand properties into it's longhand values
+  #
+  def self.deconstruct_shorthand_for_border(items, types)
+    tmp = ::Archetype::Hash.new
+    items.reject! do |item|
+      if item.is_a?(Sass::Script::Value::Number)
+        tmp[:width] = item
+      elsif item.is_a?(Sass::Script::Value::Color)
+        tmp[:color] = item
+      else
+        case helpers.to_str(item)
+        when /^(?:thin|medium|thick)$/
+          tmp[:width] = item
+        when /^(?:none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset)$/
+          tmp[:style] = item
+        else
+          next
+        end
+      end
+      true
+    end
+    items.each do |item|
+      if helpers.to_str(item) == 'inherit'
+        if tmp[:width].nil?
+          tmp[:width] = item
+        elsif tmp[:style].nil?
+          tmp[:style] = item
+        else
+          tmp[:color] ||= item
+        end
+      end
+    end
+    return set_default_styles(tmp, 'border', types)
+  end
+
+  #
+  # deconstructs `border-image` shorthand property into it's longhand values
+  #
+  def self.deconstruct_shorthand_for_border_image(items, properties)
+    contexts = [:image_slice, :image_width, :image_outset]
+    context = contexts.shift
+    count = 1
+    styles = ::Archetype::Hash.new
+    items.each do |item|
+      # source slice width outset repeat
+      # <source> <slice {1,4}> / <width {1,4}> <outset> <repeat{1,2}>
+      case helpers.to_str(item)
+      when /^(?:url\(.*\)|none)$/
+        styles[:image_source] = item
+      when /^(?:stretch|repeat|round|space)$/
+        styles[:image_repeat] ||= []
+        styles[:image_repeat] << item
+      when /(.+)\/(.+)/ # delimiter to denote which context (slice, width, outset) we're observing
+        [$1, $2].each_with_index do |item, i|
+          count -= 1 if item == 'fill' # don't count `fill`
+          if count > 4 or i == 1
+            context = contexts.shift
+            count = 1
+          end
+          if context
+            item = (item =~ /^(\d+(?:\.\d+)?)(.*)/) ? Sass::Script::Value::Number.new($1.to_f, [$2]) : Sass::Script::Value::String.new(item)
+            styles[context] ||= []
+            styles[context] << item
+            count += 1
+          end
+        end
+      when /^\d+/
+        # if we've reached out limit for the current context, adjust
+        if count > 4
+          context = contexts.shift
+          count = 1
+        end
+        # if we have a context, stash the value onto it
+        if context
+          styles[context] ||= []
+          styles[context] << item
+          count += 1
+        end
+      when /^fill$/
+        styles[:image_slice] ||= []
+        styles[:image_slice] << item
+         # don't count `fill`
+      when /^auto$/
+        styles[:image_width] ||= []
+        styles[:image_width] << item
+        count += 1
+      when '/'
+        context = contexts.shift
+        count = 1
+      else
+        next
+      end
+      true
+    end
+    styles = set_default_styles(styles, 'border-image', properties)
+  end
+end