habaki 0.5.0

data/lib/habaki/selectors.rb

@@ -0,0 +1,49 @@
+module Habaki
+  # Array of {Selectors}
+  class Selectors < NodeArray
+    # parse selectors from string
+    # @param [String] data
+    # @return [Selectors]
+    def self.parse(data)
+      sels = self.new
+      sels.parse!(data)
+      sels
+    end
+
+    # parse selectors from string and append to current selectors
+    # @param [String] data
+    # @return [void]
+    def parse!(data)
+      return unless data
+
+      out = Katana.parse_selectors(data)
+      if out.selectors
+        read_from_katana(out.selectors)
+      end
+    end
+
+    # does one of theses selectors match {Visitor::Element} ?
+    # @param [Visitor::Element] element
+    # @return [Boolean]
+    def element_match?(element)
+      each do |selector|
+        return true if selector.element_match?(element)
+      end
+      false
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      string_join(format, ",")
+    end
+
+    # @api private
+    # @param [Katana::Array<Katana::Selector>] sels
+    def read_from_katana(sels)
+      sels.each do |sel|
+        push Selector.read_from_katana(sel)
+      end
+    end
+  end
+end

data/lib/habaki/style_rule.rb

@@ -0,0 +1,35 @@
+module Habaki
+  # CSS style rule selectors + declarations
+  class StyleRule < Rule
+    # @return [Selectors]
+    attr_accessor :selectors
+    # @return [Declarations]
+    attr_accessor :declarations
+
+    def initialize
+      @selectors = Selectors.new
+      @declarations = Declarations.new
+    end
+
+    # does rule match {Visitor::Element} ?
+    # @param [Visitor::Element] element
+    # @return [Boolean]
+    def element_match?(element)
+      selectors.element_match?(element)
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      "#{@selectors.string(format)} {#{format.declarations_prefix}#{@declarations.string(format+1)}#{format.declarations_suffix}#{format.rules_prefix}}"
+    end
+
+    # @api private
+    # @param [Katana::StyleRule] rule
+    # @return [void]
+    def read_from_katana(rule)
+      @selectors = Selectors.read_from_katana(rule.selectors)
+      @declarations = Declarations.read_from_katana(rule.declarations)
+    end
+  end
+end

data/lib/habaki/stylesheet.rb

@@ -0,0 +1,158 @@
+module Habaki
+  # main structure
+  class Stylesheet < Node
+    include SelectorMatcher
+
+    # @return [Rules]
+    attr_accessor :rules
+    # @return [Array<Error>]
+    attr_accessor :errors
+
+    def initialize
+      @rules = Rules.new
+      @errors = []
+    end
+
+    # traverse rules
+    # @param [Visitor::Media, String, NilClass] media
+    # @yieldparam [Rules] rules
+    # @return [void]
+    def each_rules(media = nil, &block)
+      block.call @rules
+      @rules.each do |rule|
+        next unless rule.rules
+        next if rule.is_a?(MediaRule) && !rule.media_match?(media)
+        block.call rule.rules
+      end
+    end
+
+    # traverse all rules (including all media & supports)
+    # @param [Visitor::Media, String, NilClass] media
+    # @yieldparam [Rule] rule
+    # @return [void]
+    def each_rule(media = nil, &block)
+      each_rules(media) do |rules|
+        rules.each do |rule|
+          block.call rule
+        end
+      end
+    end
+
+    # does selector exists ?
+    # @param [String] selector_str
+    # @param [Visitor::Media, String, NilClass] media
+    # @return [Boolean]
+    def has_selector?(selector_str, media = nil)
+      each_rule do |rule|
+        rule.each_selector do |selector|
+          return true if selector_str == selector.to_s
+        end
+      end
+      false
+    end
+
+    # find rule from selector str
+    # @param [String] selector_str
+    # @param [Visitor::Media, String, NilClass] media
+    # @return [Array<Rule>]
+    def find_by_selector(selector_str, media = nil)
+      results = []
+      each_rule(media) do |rule|
+        rule.each_selector do |selector|
+          results << rule if selector_str == selector.to_s
+        end
+      end
+      results
+    end
+
+    # find declarations from selector str
+    # @param [String] selector_str
+    # @param [Visitor::Media, String, NilClass] media
+    # @return [Array<Declarations>]
+    def find_declarations_by_selector(selector_str, media = nil)
+      results = []
+      each_rule(media) do |rule|
+        next unless rule.selectors
+        results << rule.declarations if rule.selectors.map(&:to_s).include?(selector_str)
+      end
+      results
+    end
+
+    # remove rules with no declaration
+    def compact!
+      @rules.reject! { |rule| rule.declarations&.empty? || false }
+      @rules.each do |rule|
+        if rule.rules
+          rule.rules.reject! { |emb_rule| emb_rule.declarations&.empty? || false }
+        end
+      end
+      @rules.reject! { |rule| rule.rules&.empty? || false }
+    end
+
+    # instanciate and parse from data
+    # @param [String] data
+    # @return [Stylesheet]
+    def self.parse(data)
+      stylesheet = self.new
+      stylesheet.parse!(data)
+      stylesheet
+    end
+
+    # instanciate and parse from file
+    # @param [String] filename
+    # @return [Stylesheet]
+    def self.parse_file(filename)
+      parse(File.read(filename))
+    end
+
+    # parse from data and append to current stylesheet
+    # @param [String] data
+    # @return [void]
+    def parse!(data)
+      return unless data
+
+      read_from_katana(Katana.parse(data))
+    end
+
+    # parse from file and append to current stylesheet
+    # @param [String] filename
+    # @return [void]
+    def parse_file!(filename)
+      parse(File.read(filename))
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      @rules.string(format)
+    end
+
+    # @api private
+    # @param [Katana::Output] out
+    # @return [void]
+    def read_from_katana(out)
+      @rules.read_from_katana(out.stylesheet.imports)
+      @rules.read_from_katana(out.stylesheet.rules)
+
+      # keep reference to this stylesheet in each rule
+      each_rule do |rule|
+        rule.stylesheet = self
+      end
+
+      out.errors.each do |err|
+        @errors << Error.read_from_katana(err)
+      end
+    end
+  end
+
+  # group of stylesheets to match through multiple {Stylesheet}
+  class Stylesheets < Array
+    include SelectorMatcher
+
+    def each_rule(media = nil, &block)
+      each do |stylesheet|
+        stylesheet.each_rule(media, &block)
+      end
+    end
+  end
+end

data/lib/habaki/sub_selector.rb

@@ -0,0 +1,234 @@
+module Habaki
+  # CSS specificity score
+  class Specificity
+    attr_accessor :score
+
+    def initialize
+      @score = 0
+    end
+  end
+
+  # part of selector (eg in p.t, p is a tag subselector and .t a class subselector)
+  class SubSelector < Node
+    # @return [Symbol]
+    attr_accessor :match
+    # @return [String]
+    attr_accessor :tag
+    # @return [Symbol]
+    attr_accessor :pseudo
+
+    # @return [String]
+    attr_accessor :attribute
+    # @return [String]
+    attr_accessor :value
+    # @return [String]
+    attr_accessor :argument
+    # @return [Selectors]
+    attr_accessor :selectors
+
+    # @return [SourcePosition]
+    attr_accessor :position
+
+    # is this selector on attribute ?
+    # @return [Boolean]
+    def attribute_selector?
+      @match.to_s.start_with?("attribute_")
+    end
+
+    # does sub selector match {Visitor::Element} ?
+    # @param [Visitor::Element] element
+    # @param [Specificity, nil] specificity
+    # @return [Boolean]
+    def element_match?(element, specificity = nil)
+      case @match
+      when :tag
+        tag_match?(element.tag_name, specificity)
+      when :class
+        class_match?(element.class_name, specificity)
+      when :id
+        id_match?(element.id_name, specificity)
+      when :pseudo_class
+        pseudo_class_match?(element, specificity)
+      when :pseudo_element
+        # TODO
+        false
+      else
+        if attribute_selector?
+          element_attr = element.attr(@attribute.local)
+          (element_attr ? attribute_value_match?(element_attr, specificity) : false)
+        else
+          false
+        end
+      end
+    end
+
+    # does selector match tag ?
+    # @param [String] name
+    # @param [Specificity, nil] specificity
+    # @return [Boolean]
+    def tag_match?(name, specificity = nil)
+      match_with_specificity(@tag.local == name, specificity, 1) || @tag.local == "*"
+    end
+
+    # does selector match class ?
+    # @param [String] name
+    # @param [Specificity, nil] specificity
+    # @return [Boolean]
+    def class_match?(name, specificity = nil)
+      match_with_specificity(@value == name, specificity, 10)
+    end
+
+    # does selector match id ?
+    # @param [String] name
+    # @param [Specificity, nil] specificity
+    # @return [Boolean]
+    def id_match?(name, specificity = nil)
+      match_with_specificity(@value == name, specificity, 100)
+    end
+
+    # does selector match attribute value ?
+    # @param [String] val
+    # @param [Specificity, nil] specificity
+    # @return [Boolean]
+    def attribute_value_match?(val, specificity = nil)
+      match_with_specificity(
+        case @match
+        when :attribute_exact
+          val == @value
+        when :attribute_begin
+          val.start_with?(@value)
+        when :attribute_end
+          val.end_with?(@value)
+        when :attribute_contain
+          val.include?(@value)
+        when :attribute_hyphen
+          val.start_with?("#{@value}-")
+        else
+          false
+        end, specificity, 10)
+    end
+
+    # does selector pseudo class match {Visitor::Element} ?
+    # @param [Visitor::Element] element
+    # @param [Specificity, nil] specificity
+    # @return [Boolean]
+    def pseudo_class_match?(element, specificity = nil)
+      match_with_specificity(
+        case @pseudo
+        when :root
+          element.tag_name == "html"
+        when :empty
+          element.children.empty?
+        when :first_child
+          parent_element = element.parent
+          parent_element&.children.first == element
+        when :last_child
+          parent_element = element.parent
+          parent_element&.children.last == element
+        when :only_child
+          parent_element = element.parent
+          parent_element&.children.length == 1 && parent_element&.children.first == element
+        when :nth_child
+          parent_element = element.parent
+          arg = @argument.split("+")
+          case arg[0]
+          when "odd"
+            ((parent_element&.children.index(element) + 1) % 2 == 1)
+          when "even"
+            ((parent_element&.children.index(element) + 1) % 2 == 0)
+          when /^\d+$/
+            parent_element&.children[@argument.to_i - 1] == element
+          when "n"
+            ((parent_element&.children.index(element) + 1) % 1) == (arg[1]&.to_i || 0)
+          when /n$/
+            ((parent_element&.children.index(element) + 1) % arg[0].sub("n", "").to_i) == (arg[1]&.to_i || 0)
+          else
+            # TODO "of type"
+            false
+          end
+        when :not
+          !@selectors.element_match?(element)
+        when :not_parsed, :unknown
+          true
+        else
+          # STDERR.puts "unsupported pseudo #{sub_sel.pseudo}"
+          false
+        end, specificity, 10)
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      str = ""
+      if attribute_selector?
+        str += "[#{@attribute.string(format)}"
+        case @match
+        when :attribute_exact
+          str += "="
+        when :attribute_set
+          str += "]"
+        when :attribute_list
+          str += "~="
+        when :attribute_hyphen
+          str += "|="
+        when :attribute_begin
+          str += "^="
+        when :attribute_end
+          str += "$="
+        when :attribute_contain
+          str += "*="
+        end
+        str += "\"#{@value}\"]" if @match != :attribute_set
+      else
+        case @match
+        when :tag
+          str += @tag.string(format)
+        when :class
+          str += ".#{@value}"
+        when :id
+          str += "##{@value}"
+        when :pseudo_class, :pseudo_page_class
+          str += ":#{@value}"
+          case @pseudo
+          when :any, :not, :host, :host_context
+            str += @selectors.string(format)
+            str += ")"
+          when :lang, :nth_child, :nth_last_child, :nth_of_type, :nth_last_of_type
+            str += "#{@argument})"
+          end
+        when :pseudo_element
+          str += "::#{@value}"
+        end
+      end
+      str
+    end
+
+    # @api private
+    # @param [Katana::Selector] sel
+    def read_from_katana(sel)
+      @match = sel.match
+      @tag = QualifiedName.read_from_katana(sel.tag) if sel.tag
+      @pseudo = sel.pseudo
+
+      @attribute = QualifiedName.read_from_katana(sel.data.attribute) if sel.data.attribute
+      @value = sel.data.value
+      @argument = sel.data.argument
+
+      @selectors = Selectors.read_from_katana(sel.data.selectors) if sel.data.selectors
+
+      @position = SourcePosition.new(sel.position.line, sel.position.column)
+    end
+
+    private
+
+    # @param [Boolean] comp
+    # @param [Specificity, nil] specificity
+    # @param [Integer] score
+    # @return [Boolean]
+    def match_with_specificity(comp, specificity, score)
+      specificity.score += score if specificity && comp
+      comp
+    end
+
+  end
+end

data/lib/habaki/sub_selectors.rb

@@ -0,0 +1,42 @@
+module Habaki
+  # Array of {SubSelector}
+  class SubSelectors < NodeArray
+    # @return [Symbol]
+    attr_accessor :relation
+
+    # does every sub selectors match {Visitor::Element} ?
+    # @param [Visitor::Element] element
+    # @param [Specificity, nil] specificity
+    # @return [Boolean]
+    def element_match?(element, specificity = nil)
+      each do |sub_sel|
+        return false unless sub_sel.element_match?(element, specificity)
+      end
+      true
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      "#{string_relation}#{string_join(format, "")}"
+    end
+
+    private
+
+    def string_relation
+      case @relation
+      when :descendant
+        " "
+      when :child
+        " > "
+      when :direct_adjacent
+        " + "
+      when :indirect_adjacent
+        " ~ "
+      else
+        ""
+      end
+    end
+
+  end
+end

data/lib/habaki/supports_rule.rb

@@ -0,0 +1,65 @@
+module Habaki
+  class SupportsExpression < Node
+    # @return [Symbol]
+    attr_accessor :operation
+    # @return [Array<SupportsExpression>]
+    attr_accessor :expressions
+    # @return [Declaration]
+    attr_accessor :declaration
+
+    def initialize
+      @expressions = []
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      str = ""
+      case @expressions.length
+      when 0
+        if @declaration
+          str += "(#{@declaration.string(format)})"
+        end
+      when 1
+        str += "(#{@operation == :not ? "not " : ""}" + @expressions[0].string(format) + ")"
+      when 2
+        str += "#{@expressions[0].string(format)} #{@operation} #{@expressions[1].string(format)}"
+      end
+      str
+    end
+
+    # @api private
+    def read_from_katana(exp)
+      @operation = exp.operation
+      exp.expressions.each do |sub_exp|
+        @expressions << SupportsExpression.read_from_katana(sub_exp)
+      end
+      @declaration = Declaration.read_from_katana(exp.declaration) if exp.declaration
+    end
+  end
+
+  # supports rule @supports
+  class SupportsRule < Rule
+    # @return [SupportsExpression]
+    attr_accessor :expression
+    # @return [Rules]
+    attr_accessor :rules
+
+    def initialize
+      @rules = Rules.new
+    end
+
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      "@supports #{@expression.string(format)} {\n#{@rules.string(format + 1)}\n}"
+    end
+
+    # @api private
+    # @param [Katana::SupportsRule] rule
+    # @return [void]
+    def read_from_katana(rule)
+      @expression = SupportsExpression.read_from_katana(rule.expression)
+      @rules = Rules.read_from_katana(rule.rules)
+    end
+  end
+end