scss_beautifier 0.1.0

data/lib/scss_beautifier/formatters/bang_format.rb

@@ -0,0 +1,21 @@
+class SCSSBeautifier::Formatters::BangFormat < Sass::Tree::Visitors::Base
+  # def visit_extend(node)
+  #   format_bang(node)
+  # end
+
+  def visit_prop(node)
+    node.value.each{ |item| format_bang(item) }
+  end
+
+  # def visit_variable(node)
+  #   format_bang(node)
+  # end
+
+  def format_bang(item)
+    if Sass::Script::Tree::Literal === item && Sass::Script::Value::String === item.value
+      if item.value.value.include?("!")
+        item.instance_variable_set(:@value, Sass::Script::Value::String.new(item.value.value.gsub(/\s*!\s*/, ' !')))
+      end
+    end
+  end
+end

data/lib/scss_beautifier/formatters/border_zero.rb

@@ -0,0 +1,22 @@
+class SCSSBeautifier::Formatters::BorderZero < Sass::Tree::Visitors::Base
+  BORDER_PROPERTIES = %w[
+    border
+    border-top
+    border-right
+    border-bottom
+    border-left
+  ].freeze
+
+
+  def visit_prop(node)
+    return unless BORDER_PROPERTIES.include?(node.name.first.to_s)
+    # return unless node.value.length == 1
+    format_border(node.value)
+  end
+
+  def format_border(node)
+    return unless Sass::Script::Tree::Literal === node
+    return unless node.value.value == "0"
+    node.instance_variable_set(:@value, Sass::Script::Value::String.new("none"))
+  end
+end

data/lib/scss_beautifier/formatters/color.rb

@@ -0,0 +1,24 @@
+class SCSSBeautifier::Formatters::Color < Sass::Tree::Visitors::Base
+  def visit_prop(node)
+    if node.value.respond_to?(:each)
+      node.value.each{ |item| format_color(item) }
+    else
+      format_color(node.value)
+    end
+  end
+
+  def format_color(item)
+    if Sass::Script::Tree::Literal === item && Sass::Script::Value::String === item.value
+      if color = Sass::Script::Value::Color::COLOR_NAMES[item.value.value]
+        color_value = Sass::Script::Value::Color.new(color)
+        color_value.options = {}
+        item.instance_variable_set(:@value, Sass::Script::Value::String.new(color_value.inspect))
+      elsif item.value.value =~ /(#\h{3})(?!\h)/
+        hex = item.value.value
+        long_form = [hex[0..1], hex[1], hex[2], hex[2], hex[3], hex[3]].join
+        item.instance_variable_set(:@value, Sass::Script::Value::String.new(long_form))
+      end
+    end
+  end
+
+end

data/lib/scss_beautifier/formatters/comment.rb

@@ -0,0 +1,17 @@
+class SCSSBeautifier::Formatters::Comment < Sass::Tree::Visitors::Base
+  def visit_comment(node)
+    # require 'pry'; binding.pry
+    format_comment(node)# if !node.invisible?
+  end
+
+  def format_comment(node)
+    node.value.first.gsub!(/\/\*\s?/, "// ")
+    node.value.last.gsub!(/\*\//, "")
+    # require 'pry'; binding.pry
+    node.value.each do |item|
+      if String === item
+        item.gsub!(/\n\s?/, "\n// ")
+      end
+    end
+  end
+end

data/lib/scss_beautifier/formatters/debug.rb

@@ -0,0 +1,8 @@
+class SCSSBeautifier::Formatters::Debug < Sass::Tree::Visitors::Base
+  def visit_rule(node)
+    filtered = node.children.reject do |c|
+      Sass::Tree::DebugNode === c
+    end
+    node.children = filtered
+  end
+end

data/lib/scss_beautifier/formatters/declaration_order.rb

@@ -0,0 +1,23 @@
+class SCSSBeautifier::Formatters::DeclarationOrder < Sass::Tree::Visitors::Base
+  # TODO: Account for if/else blocks and include blocks
+  NODE_ORDER = ["ExtendNode", "MixinNode", "PropNode", "RuleNode"]
+
+  def visit_rule(node)
+    order_children(node)
+    visit_children(node)
+  end
+
+  def order_children(node)
+    node_hash = Hash.new { |h, k| h[k] = [] }
+    node.children.each do |child|
+      hash_key = child.class.to_s.split("::").last
+      node_hash[hash_key] << child
+    end
+
+    compiled_array = NODE_ORDER.reduce([]) do |memo, key|
+      memo.concat(node_hash[key])
+    end
+
+    node.children = compiled_array
+  end
+end

data/lib/scss_beautifier/formatters/empty_rule.rb

@@ -0,0 +1,19 @@
+class SCSSBeautifier::Formatters::EmptyRule < Sass::Tree::Visitors::Base
+  def visit_root(node)
+    remove_empty_rule(node)
+    yield
+    remove_empty_rule(node)
+  end
+  def visit_rule(node)
+    remove_empty_rule(node)
+    visit_children(node)
+    remove_empty_rule(node)
+  end
+
+  def remove_empty_rule(node)
+    filtered = node.children.reject do |c|
+      Sass::Tree::RuleNode === c && c.children.empty?
+    end
+    node.children = filtered
+  end
+end

data/lib/scss_beautifier/formatters/leading_zero.rb

@@ -0,0 +1,12 @@
+class SCSSBeautifier::Formatters::LeadingZero < Sass::Tree::Visitors::Base
+  # ExcludeZero Only
+  def visit_prop(node)
+    if Sass::Script::Tree::Literal === node.value && Sass::Script::Value::String === node.value.value
+      node_value = node.value.value
+
+      if node.value.value.to_s.match(/\b0./)
+        node.instance_variable_set(:@value, Sass::Script::Value::String.new(node.value.value.to_s.gsub(/\b0/, '')))
+      end
+    end
+  end
+end

data/lib/scss_beautifier/formatters/name_format.rb

@@ -0,0 +1,45 @@
+class SCSSBeautifier::Formatters::NameFormat < Sass::Tree::Visitors::Base
+  def visit_function(node)
+    check_name(node)
+  end
+
+  def visit_mixin(node)
+    check_name(node)
+  end
+
+  def visit_placeholder(node)
+    check_name(node)
+  end
+
+  def visit_mixindef(node)
+    check_name(node)
+  end
+
+  def visit_script_funcall(node)
+    check_name(node)
+  end
+
+  def visit_script_variable(node)
+    check_name(node)
+  end
+
+  def visit_variable(node)
+    check_name(node)
+  end
+
+  def visit_rule(node)
+    check_rule(node)
+  end
+
+  private
+
+  def check_name(node)
+    # return unless node.name
+    node.instance_variable_set(:@name, Sass::Script::Value::String.new(node.name.to_s.gsub(/[[:upper:]]/) { "-#{$&}" }.downcase.gsub(/_/, '-')))
+  end
+
+  def check_rule(node)
+    node.rule = Sass::Util.strip_string_array(node.rule.map { |r| r.to_s.gsub(/[[:upper:]]/) { "-#{$&}" }.downcase.gsub(/_/, '-') })
+    node.send(:try_to_parse_non_interpolated_rules)
+  end
+end

data/lib/scss_beautifier/formatters/property_sort_order.rb

@@ -0,0 +1,23 @@
+class SCSSBeautifier::Formatters::PropertySortOrder < Sass::Tree::Visitors::Base
+  def visit_rule(node)
+    order_children(node)
+    visit_children(node)
+  end
+
+  def order_children(node)
+    prop_node_indices = []
+    prop_nodes = []
+    node.children.each_with_index do |child, index|
+      hash_key = child.class.to_s.split("::").last
+      if hash_key == 'PropNode'
+        prop_node_indices << index
+        prop_nodes << child
+      end
+    end
+    prop_nodes.sort! { |x,y| x.name[0] <=> y.name[0] }
+    # Replace children being respective of other types of props/funcs/etc
+    prop_nodes.each_with_index do |n, index|
+      node.children[prop_node_indices[index]] = n
+    end
+  end
+end

data/lib/scss_beautifier/formatters/pseudo_element.rb

@@ -0,0 +1,20 @@
+PSEUDO_ELEMENTS = File.read('./data/pseudo_elements.txt').split("\n")
+
+class SCSSBeautifier::Formatters::PseudoElement < Sass::Tree::Visitors::Base
+  def visit_rule(node)
+    check_pseudo(node) if node.rule.join.match(/::?/)
+    visit_children(node)
+  end
+
+  def check_pseudo(node)
+    node.rule = Sass::Util.strip_string_array(node.rule.map { |r|
+      require_double_colon = PSEUDO_ELEMENTS.index(r.split(":").last)
+
+      colon_type = require_double_colon ? '::' : ':'
+
+      r.gsub(/::?/, colon_type)
+    })
+
+    node.send(:try_to_parse_non_interpolated_rules)
+  end
+end

data/lib/scss_beautifier/formatters/qualifying_element.rb

@@ -0,0 +1,14 @@
+class SCSSBeautifier::Formatters::QualifyingElement < Sass::Tree::Visitors::Base
+  def visit_rule(node)
+    check_qualifying_element(node)
+    visit_children(node)
+  end
+
+  def check_qualifying_element(node)
+    node.rule.each do |r|
+      # What do we do when something breaks this rule?
+    end
+
+    node.send(:try_to_parse_non_interpolated_rules)
+  end
+end

data/lib/scss_beautifier/formatters/selector.rb

@@ -0,0 +1,8 @@
+class SCSSBeautifier::Formatters::Selector < Sass::Tree::Visitors::Base
+  def visit_rule(node)
+    node.rule = node.rule.each do |rule|
+      rule.gsub!(/,/, ",\n")
+    end
+    node.send(:try_to_parse_non_interpolated_rules)
+  end
+end

data/lib/scss_beautifier/formatters/shorthand.rb

@@ -0,0 +1,112 @@
+class SCSSBeautifier::Formatters::Shorthand < Sass::Tree::Visitors::Base
+  def visit_prop(node)
+    property_name = node.name.join
+    return unless SHORTHANDABLE_PROPERTIES.include?(property_name)
+
+    case node.value
+    when Sass::Script::Tree::Literal
+      update_script_literal(property_name, node)
+    when Sass::Script::Tree::ListLiteral
+      update_script_list(property_name, node)
+    end
+  end
+
+  def update_script_literal(pName, node)
+    nValue = node.value
+
+    return unless values = nValue.value.to_s.strip[LIST_LITERAL_REGEX, 1]
+    values = values.split(' ')
+
+    check_shorthand(pName, node, values)
+  end
+
+  def update_script_list(pName, node)
+    nValue = node.value
+
+    check_shorthand(pName, node, nValue.children.map(&:to_sass), true)
+  end
+
+  private
+
+  SHORTHANDABLE_PROPERTIES = %w[
+    border-color
+    border-radius
+    border-style
+    border-width
+    margin
+    padding
+  ].freeze
+
+  LIST_LITERAL_REGEX = /
+    \A
+    (\S+\s+\S+(\s+\S+){0,2})   # Two to four values separated by spaces
+    (\s+!\w+)?                 # Ignore `!important` priority overrides
+    \z
+  /x
+
+  def check_shorthand(prop, node, values)
+    shortest_form = condensed_shorthand(*values)
+
+    return if values == shortest_form
+
+    node.instance_variable_set(:@value, Sass::Script::Value::String.new(shortest_form.join(' ')))
+  end
+
+  def allowed?(size)
+    # return false unless config['allowed_shorthands']
+    # config['allowed_shorthands'].map(&:to_i).include?(size)
+    [1, 2, 3, 4].map(&:to_i).include?(size)
+  end
+
+  # @param top [String]
+  # @param right [String]
+  # @param bottom [String]
+  # @param left [String]
+  # @return [Array]
+  def condensed_shorthand(top, right, bottom = nil, left = nil)
+    if condense_to_one_value?(top, right, bottom, left)
+      [top]
+    elsif condense_to_two_values?(top, right, bottom, left)
+      [top, right]
+    elsif condense_to_three_values?(top, right, bottom, left)
+      [top, right, bottom]
+    else
+      [top, right, bottom, left].compact
+    end
+  end
+
+  # @param top [String]
+  # @param right [String]
+  # @param bottom [String]
+  # @param left [String]
+  # @return [Boolean]
+  def condense_to_one_value?(top, right, bottom, left)
+    return unless allowed?(1)
+    return unless top == right
+
+    top == bottom && (bottom == left || left.nil?) ||
+      bottom.nil? && left.nil?
+  end
+
+  # @param top [String]
+  # @param right [String]
+  # @param bottom [String]
+  # @param left [String]
+  # @return [Boolean]
+  def condense_to_two_values?(top, right, bottom, left)
+    return unless allowed?(2)
+
+    top == bottom && right == left ||
+      top == bottom && left.nil? && top != right
+  end
+
+  # @param right [String]
+  # @param left [String]
+  # @return [Boolean]
+  def condense_to_three_values?(_, right, __, left)
+    return unless allowed?(3)
+
+    right == left
+  end
+
+end

data/lib/scss_beautifier/formatters/string_quotes.rb

@@ -0,0 +1,33 @@
+class SCSSBeautifier::Formatters::StringQuotes < Sass::Tree::Visitors::Base
+  def visit_prop(node)
+    check_quotes(node)
+    visit_children(node)
+  end
+  def check_quotes(node)
+    return unless node.value.is_a?(Sass::Script::Tree::Literal)
+
+    # TODO Check for single or double quote preference
+    str_without_quotes = extract_string_without_quotes(node.value.value.to_s)
+    change_to_single_quotes(node) if str_without_quotes && !str_without_quotes.match(/'/)
+  end
+
+  private
+
+  STRING_WITHOUT_QUOTES_REGEX = %r{
+    \A
+    ["'](.*)["']    # Extract text between quotes
+    \s*\)?\s*;?\s*  # Sometimes the Sass parser includes a trailing ) or ;
+    (//.*)?         # Exclude any trailing comments that might have snuck in
+    \z
+  }x
+
+  def change_to_single_quotes(node)
+    new_val = node.value.value.to_s.gsub('"', '\'')
+    node.instance_variable_set(:@value, Sass::Script::Value::String.new(new_val))
+  end
+
+  def extract_string_without_quotes(source)
+    return unless match = STRING_WITHOUT_QUOTES_REGEX.match(source)
+    match[1]
+  end
+end

data/lib/scss_beautifier/formatters/trailing_zero.rb

@@ -0,0 +1,24 @@
+class SCSSBeautifier::Formatters::TrailingZero < Sass::Tree::Visitors::Base
+  def visit_prop(node)
+    check_trailing_zero(node)
+    visit_children(node)
+  end
+
+  private
+
+  FRACTIONAL_DIGIT_REGEX = /^-?(\d*\.\d+[a-zA-Z]*)/
+
+  def check_trailing_zero(node)
+    return unless number = node.value.to_s[FRACTIONAL_DIGIT_REGEX, 1]
+
+    return unless match = /^(\d*\.(?:[0-9]*[1-9]|[1-9])*)0+([a-zA-Z]*)$/.match(number)
+
+    fixed_number = match[1]
+    extension = match[2]
+
+    # Handle special case of 0 being the only trailing digit
+    fixed_number = fixed_number[0..-2] if fixed_number.end_with?('.')
+    fixed_number = 0 if fixed_number.empty? # Handle ".0" -> "0"
+    node.instance_variable_set(:@value, Sass::Script::Value::String.new(fixed_number + extension))
+  end
+end