habaki 0.5.0

data/lib/habaki/media_rule.rb

@@ -0,0 +1,173 @@
+module Habaki
+  class MediaQueryExpression < Node
+    # @return [String]
+    attr_accessor :feature
+    # @return [Values]
+    attr_accessor :values
+
+    def initialize
+      @values = Values.new
+    end
+
+    # @return [Value]
+    def value
+      @values.first
+    end
+
+    # @param [Visitor::Media] media
+    # @return [Boolean]
+    def media_match?(media)
+      case @feature
+      when "min-width"
+        return true unless media.width
+        media.width >= value.to_px
+      when "max-width"
+        return true unless media.width
+        media.width <= value.to_px
+      when "min-height"
+        return true unless media.height
+        media.height >= value.to_px
+      when "max-height"
+        return true unless media.height
+        media.height <= value.to_px
+      end
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      "(#{@feature}#{@values.any? ? ": #{@values.string(format)}" : ""})"
+    end
+
+    # @api private
+    # @param [Katana::MediaQueryExpression] exp
+    # @return [void]
+    def read_from_katana(exp)
+      @feature = exp.feature
+      if exp.values
+        @values = Values.read_from_katana(exp.values)
+      end
+    end
+  end
+
+  class MediaQuery < Node
+    # @return [String]
+    attr_accessor :type
+    # @return [Symbol]
+    attr_accessor :restrictor
+    # @return [Array<MediaQueryExpression>]
+    attr_accessor :expressions
+
+    def initialize
+      @expressions = []
+    end
+
+    def media_match_type?(mediatype = "all")
+      return true unless mediatype
+      case @restrictor
+      when :none, :only
+        @type == mediatype || @type == "all" || !mediatype
+      when :not
+        @type != mediatype
+      else
+        false
+      end
+    end
+
+    # @param [Visitor::Media] media
+    def media_match?(media)
+      return false unless media_match_type?(media.type)
+      @expressions.each do |exp|
+        return false unless exp.media_match?(media)
+      end
+      true
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      str = (@restrictor != :none ? @restrictor.to_s + " " : "") + (@type ? @type : "")
+      if @expressions.any?
+        @expressions.each do |exp|
+          str += " and " if str != ""
+          str += exp.string(format)
+        end
+      end
+      str
+    end
+
+    # @api private
+    # @param [Katana::MediaQuery] med
+    # @return [void]
+    def read_from_katana(med)
+      @type = med.type
+      @restrictor = med.restrictor
+      med.expressions.each do |exp|
+        @expressions << MediaQueryExpression.read_from_katana(exp)
+      end
+    end
+  end
+
+  # Array of {MediaQuery}
+  class MediaQueries < NodeArray
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      string_join(format, ",")
+    end
+
+    # @param [Visitor::Media] media
+    # @return [Boolean]
+    def media_match?(media)
+      inject(false) { |result, q| result ||= q.media_match?(media) }
+    end
+
+    # @api private
+    # @param [Katana::Array<Katana::MediaQuery>] meds
+    # @return [void]
+    def read_from_katana(meds)
+      meds.each do |med|
+        push MediaQuery.read_from_katana(med)
+      end
+    end
+  end
+
+  # Rule for @media
+  class MediaRule < Rule
+    # @return [MediaQueries]
+    attr_accessor :medias
+    # @return [Rules]
+    attr_accessor :rules
+
+    def initialize
+      @medias = MediaQueries.new
+      @rules = Rules.new
+    end
+
+    # does rule media match ?
+    # @param [Visitor::Media, String, NilClass] media use String (eg: "print") to check only media type, nil to match everything, or Visitor::Media for complex query
+    # @return [Boolean]
+    def media_match?(media)
+      case media
+      when ::String, NilClass
+        @medias.media_match?(Visitor::Media.new(media))
+      else
+        @medias.media_match?(media)
+      end
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      "@media #{@medias.string(format)} {\n#{@rules.string(format + 1)}\n}"
+    end
+
+    # @api private
+    # @param [Katana::MediaRule] rule
+    # @return [void]
+    def read_from_katana(rule)
+      @medias = MediaQueries.read_from_katana(rule.medias)
+      @rules = Rules.read_from_katana(rule.rules)
+    end
+  end
+end

data/lib/habaki/namespace_rule.rb

@@ -0,0 +1,31 @@
+module Habaki
+  # Rule for @namespace
+  # TODO: implement QualifiedName namespace resolution
+  class NamespaceRule < Rule
+    # @return [String]
+    attr_accessor :prefix
+    # @return [String]
+    attr_accessor :uri
+
+    # @param [String] prefix
+    # @param [String] uri
+    def initialize(prefix = nil, uri = nil)
+      @prefix = prefix
+      @uri = uri
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      "@namespace #{@prefix.length > 0 ? "#{@prefix} " : ""}\"#{@uri}\";"
+    end
+
+    # @api private
+    # @param [Katana::NamespaceRule] rule
+    # @return [void]
+    def read_from_katana(rule)
+      @prefix = rule.prefix
+      @uri = rule.uri
+    end
+  end
+end

data/lib/habaki/node.rb

@@ -0,0 +1,52 @@
+module Habaki
+  module NodeReader
+    # read from low level Katana struct
+    def read_from_katana(low)
+      obj = self.new
+      obj.read_from_katana(low)
+      obj
+    end
+  end
+
+  class Node
+    extend NodeReader
+
+    # @param [Formatter::Base] format
+    # @return [::String]
+    def string(format = Formatter::Base.new)
+      ""
+    end
+
+    # @return [::String]
+    def to_s
+      string(Formatter::Flat.new)
+    end
+
+    # read from low level Katana struct
+    # @return [nil]
+    def read_from_katana(low) end
+  end
+
+  class NodeArray < Array
+    extend NodeReader
+
+    # @param [Formatter::Base] format
+    # @return [::String]
+    def string(format = Formatter::Base.new)
+      ""
+    end
+
+    def string_join(format, sep)
+      map do |node| node.string(format) end.join(sep)
+    end
+
+    # @return [::String]
+    def to_s
+      string(Formatter::Flat.new)
+    end
+
+    # read from low level Katana struct
+    # @return [nil]
+    def read_from_katana(low) end
+  end
+end

data/lib/habaki/page_rule.rb

@@ -0,0 +1,24 @@
+module Habaki
+  # page rule @page
+  class PageRule < Rule
+    # @return [Declarations]
+    attr_accessor :declarations
+
+    def initialize
+      @declarations = Declarations.new
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      "@page {#{@declarations.string(format + 1)}}"
+    end
+
+    # @api private
+    # @param [Katana::PageRule] rule
+    # @return [void]
+    def read_from_katana(rule)
+      @declarations = Declarations.read_from_katana(rule.declarations)
+    end
+  end
+end

data/lib/habaki/qualified_name.rb

@@ -0,0 +1,29 @@
+module Habaki
+  # name with optional ns prefix
+  class QualifiedName < Node
+    # @return [String]
+    attr_accessor :local
+    # @return [String]
+    attr_accessor :prefix
+
+    # @param [String] local
+    # @param [String] prefix
+    def initialize(local = nil, prefix = nil)
+      @local = local
+      @prefix = prefix
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      @prefix ? "#{@prefix}|#{@local}" : @local
+    end
+
+    # @api private
+    # @param [Katana::QualifiedName] tag
+    def read_from_katana(tag)
+      @local = tag.local
+      @prefix = tag.prefix
+    end
+  end
+end

data/lib/habaki/rule.rb

@@ -0,0 +1,48 @@
+module Habaki
+  # @abstract CSS rule
+  class Rule < Node
+    # @return [Stylesheet]
+    attr_accessor :stylesheet
+
+    # @return [Array, nil]
+    def selectors
+      nil
+    end
+
+    # traverse selector if selectors
+    # @yieldparam [Selector] selector
+    def each_selector(&block)
+      return unless selectors
+
+      selectors.each do |decl|
+        block.call decl
+      end
+    end
+
+    # @return [Array, nil]
+    def declarations
+      nil
+    end
+
+    # traverse declarations if declarations
+    # @yieldparam [Declaration] declaration
+    def each_declaration(&block)
+      return unless declarations
+
+      declarations.each do |decl|
+        block.call decl
+      end
+    end
+
+    # @return [Array, nil]
+    def rules
+      nil
+    end
+
+    # @param [Visitor::Element] element
+    # @return [Boolean]
+    def element_match?(element)
+      false
+    end
+  end
+end

data/lib/habaki/rules.rb

@@ -0,0 +1,225 @@
+module Habaki
+  # selector matcher helper
+  module SelectorMatcher
+    # small hash index on tag, class and id
+    def index_selectors!(*args)
+      @hash_tree[args] = {}
+
+      each_rule(*args) do |rule|
+        rule.each_selector do |selector|
+          sub_sels = selector.sub_selectors.last
+          tag_name = nil
+          class_name = nil
+          id_name = nil
+          sub_sels.each do |sub_sel|
+            case sub_sel.match
+            when :tag
+              tag_name = sub_sel.tag.local
+            when :class
+              class_name = sub_sel.value
+            when :id
+              id_name = sub_sel.value
+            end
+          end
+
+          class_or_id = nil
+          class_or_id = ".#{class_name}" if class_name
+          class_or_id = "##{id_name}" if id_name
+
+          @hash_tree[args][tag_name||"*"] ||= {}
+          @hash_tree[args][tag_name||"*"][class_or_id] ||= Set.new
+          @hash_tree[args][tag_name||"*"][class_or_id] << rule
+        end
+      end
+    end
+
+    def lookup_rules(args, tag_name, class_name, id_name, &block)
+      class_or_id = nil
+      class_or_id = ".#{class_name}" if class_name
+      class_or_id = "##{id_name}" if id_name
+
+      @hash_tree[args].dig(tag_name, nil)&.each do |rule|
+        block.call rule
+      end
+
+      @hash_tree[args].dig("*", class_or_id)&.each do |rule|
+        block.call rule
+      end
+
+      @hash_tree[args].dig(tag_name, class_or_id)&.each do |rule|
+        block.call rule
+      end
+    end
+
+    # traverse rules matching with {Visitor::Element}
+    # @param [Visitor::Element] element
+    # @yieldparam [Rule] rule
+    # @yieldparam [Selector] selector
+    # @yieldparam [Specificity] specificity
+    # @return [void]
+    def each_match(element, *args, &block)
+      @hash_tree ||= {}
+      index_selectors!(*args) unless @hash_tree[args]
+
+      lookup_rules(args, element.tag_name, element.class_name, element.id_name) do |rule|
+        rule.each_selector do |selector|
+          specificity = Specificity.new
+          if selector.element_match?(element, specificity)
+            block.call rule, selector, specificity
+          end
+        end
+      end
+    end
+
+    # traverse rules matching with {Visitor::Element}
+    # @param [Visitor::Element] element
+    # @yieldparam [Rule] rule
+    # @return [void]
+    def each_matching_rule(element, *args, &block)
+      find_matching_rules(element, *args).each do |rule|
+        block.call rule
+      end
+    end
+
+    # rules matching with {Visitor::Element} ordered by specificity score (highest last)
+    # @param [Visitor::Element] element
+    # @return [Array<Rule>]
+    def find_matching_rules(element, *args)
+      results = []
+      each_match(element, *args) do |rule, selector, specificity|
+        results << [specificity.score, rule]
+      end
+      results.sort! { |a, b| a.first <=> b.first }
+      results.map(&:last)
+    end
+
+    # get cascaded declarations results for {Visitor::Element}
+    # @param [Visitor::Element] element
+    # @return [Declarations]
+    def find_matching_declarations(element, *args)
+      declarations = Declarations.new
+      each_matching_rule(element, *args) do |rule|
+        rule.each_declaration do |decl|
+          declarations.replace_important(decl)
+        end
+      end
+      declarations
+    end
+  end
+
+  class Rules < NodeArray
+    include SelectorMatcher
+
+    # @param [Class<Rule>] klass
+    # @return [Enumerator<Rule>]
+    def enum_with_class(klass)
+      Enumerator.new do |rules|
+        each do |rule|
+          rules << rule if rule.is_a?(klass)
+        end
+      end
+    end
+
+    # @return [CharsetRule, nil]
+    def charset
+      enum_with_class(CharsetRule).first
+    end
+
+    # @return [Enumerator<MediaRule>]
+    def medias
+      enum_with_class(MediaRule)
+    end
+
+    # @return [Enumerator<SupportsRule>]
+    def supports
+      enum_with_class(SupportsRule)
+    end
+
+    # @return [Enumerator<NamespaceRule>]
+    def namespaces
+      enum_with_class(NamespaceRule)
+    end
+
+    # @return [Enumerator<FontFaceRule>]
+    def font_faces
+      enum_with_class(FontFaceRule)
+    end
+
+    # @return [Enumerator<PageRule>]
+    def pages
+      enum_with_class(PageRule)
+    end
+
+    # @return [Enumerator<StyleRule>]
+    def styles
+      enum_with_class(StyleRule)
+    end
+
+    # add rule by selectors string
+    # @param [String] selector_str
+    # @return [StyleRule]
+    def add_by_selector(selector_str)
+      rule = StyleRule.new
+      rule.selectors = Selectors.parse(selector_str)
+      push rule
+      rule
+    end
+
+    # find rules from selector str
+    # @param [String] selector_str
+    # @return [Array<Rule>]
+    def find_by_selector(selector_str)
+      results = []
+      each do |rule|
+        rule.each_selector do |selector|
+          results << rule if selector_str == selector.to_s
+        end
+      end
+      results
+    end
+
+    def each_rule(&block)
+      each &block
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      "#{format.rules_prefix}#{string_join(format, format.rules_join)}"
+    end
+
+    # @api private
+    # @param [Katana::Array] rules
+    # @return [void]
+    def read_from_katana(rules)
+      rules.each do |rule|
+        push read_rule(rule)
+      end
+    end
+
+    private
+
+    def read_rule(rul)
+      case rul
+      when Katana::ImportRule
+        ImportRule.read_from_katana(rul)
+      when Katana::CharsetRule
+        CharsetRule.read_from_katana(rul)
+      when Katana::MediaRule
+        MediaRule.read_from_katana(rul)
+      when Katana::FontFaceRule
+        FontFaceRule.read_from_katana(rul)
+      when Katana::PageRule
+        PageRule.read_from_katana(rul)
+      when Katana::NamespaceRule
+        NamespaceRule.read_from_katana(rul)
+      when Katana::StyleRule
+        StyleRule.read_from_katana(rul)
+      when Katana::SupportsRule
+        SupportsRule.read_from_katana(rul)
+      else
+        raise "Unsupported rule #{rul.class}"
+      end
+    end
+  end
+end

data/lib/habaki/selector.rb

@@ -0,0 +1,98 @@
+module Habaki
+  # CSS selector
+  class Selector < Node
+    # Array of {SubSelectors} group
+    # @return [Array<SubSelectors>]
+    attr_accessor :sub_selectors
+
+    def initialize
+      @sub_selectors = []
+    end
+
+    # does selector match {Visitor::Element} ?
+    # @param [Visitor::Element] element
+    # @param [Specificity, nil] specificity
+    # @return [Boolean]
+    def element_match?(element, specificity = nil)
+      return false if @sub_selectors.empty?
+
+      current_sub_selector = nil
+      @sub_selectors.reverse_each do |sub_selector|
+        if current_sub_selector
+          case current_sub_selector.relation
+          when :descendant
+            parent_element = element.parent
+            sub_match = false
+            while parent_element do
+              sub_match = sub_selector.element_match?(parent_element, specificity)
+              parent_element = parent_element.parent
+              break if sub_match
+            end
+            return false unless sub_match
+          when :child
+            parent_element = element.parent
+            return false unless parent_element
+            return false unless sub_selector.element_match?(parent_element, specificity)
+          when :direct_adjacent
+            previous_element = element.previous
+            return false unless previous_element
+            return false unless sub_selector.element_match?(previous_element, specificity)
+          when :indirect_adjacent
+            previous_element = element.previous
+            sub_match = false
+            while previous_element do
+              sub_match = sub_selector.element_match?(previous_element, specificity)
+              previous_element = previous_element.previous
+              break if sub_match
+            end
+            return false unless sub_match
+          else
+            # STDERR.puts "unknown relation #{current_sub_selector.relation}"
+            return false
+          end
+        else
+          return false unless sub_selector.element_match?(element, specificity)
+        end
+
+        current_sub_selector = sub_selector
+      end
+      true
+    end
+
+    # @param [Formatter::Base] format
+    # @return [String]
+    def string(format = Formatter::Base.new)
+      @sub_selectors.map do |sub_sel|
+        sub_sel.string(format)
+      end.join("")
+    end
+
+    # @api private
+    # @param [Katana::Selector] sel
+    def read_from_katana(sel)
+      @sub_selectors = rec_sub_sel(sel)
+    end
+
+    private
+
+    # parse sub selectors recursively
+    def rec_sub_sel(sel)
+      sub_sels = []
+      cur_sel = sel
+      cur_sub_sel = SubSelectors.new
+      while cur_sel do
+        cur_sub_sel << SubSelector.read_from_katana(cur_sel)
+        break if cur_sel.relation != :sub_selector || !cur_sel.tag_history
+        cur_sel = cur_sel.tag_history
+      end
+
+      cur_sub_sel.relation = cur_sel.relation if cur_sel.relation != :sub_selector
+      sub_sels << cur_sub_sel
+
+      if cur_sel.relation != :sub_selector
+        sub_sels = rec_sub_sel(cur_sel.tag_history) + sub_sels
+      end
+      sub_sels
+    end
+  end
+end