css_compare 0.1.0

data/lib/css_compare/css/component/keyframes_selector.rb

@@ -0,0 +1,94 @@
+module CssCompare
+  module CSS
+    module Component
+      # Represents a rule of the @keyframe directive.
+      #
+      # Examples:
+      #   - from { top: 0; } // also meaning the same as 0%
+      #   - 50%  { top: 50; }
+      #   - to   { top: 100; } // also meaning the same as 100%
+      class KeyframesSelector < Base
+        # The value of the rule. Possible values:  <'0%';'100%'>.
+        #
+        # @return [String]
+        attr_reader :value
+
+        # The properties specified at this rule.
+        #
+        # @return [Hash{String => Property}]
+        attr_reader :properties
+
+        # @param [Sass::Tree::KeyframeRuleNode] node a rule node
+        #   of the @keyframe directive.
+        def initialize(node)
+          @value = value(node.resolved_value)
+          @properties = {}
+          process_properties(node.children)
+        end
+
+        # Checks, whether two keyframes selectors are equal.
+        #
+        # They are equal only if they have declared the same
+        # properties and they are also equal.
+        #
+        # @param [KeyframesSelector] other the keyframes selector
+        #   to compare this with.
+        # @return [Boolean]
+        def ==(other)
+          super(@properties, other.properties)
+        end
+
+        # Returns the value represented as percentage, even if
+        # declared with the well-known keywords.
+        #
+        # @return [String] the value of the rule
+        def value(value = nil)
+          aliases = { :from => '0%', :to => '100%' }
+          return  aliases[value.to_sym] || value if value
+          @value
+        end
+
+        # Adds a new or rewrites an already existing property
+        # of this rule's set of properties.
+        #
+        # @return [Void]
+        def add_property(property)
+          name = property.name
+          if @properties[name]
+            @properties[name].merge(property)
+          else
+            @properties[name] = property
+          end
+        end
+
+        def deep_copy(value = @value)
+          copy = dup
+          copy.value = value
+          copy.properties = @properties.inject({}) do |result, (k, v)|
+            result.update(k => v.deep_copy)
+          end
+        end
+
+        # Creates the JSON representation of this keyframes
+        # selector.
+        #
+        # @return [Hash]
+        def to_json
+          @properties.inject({}) do |result, (name, prop)|
+            result.update(name.to_sym => prop.to_json)
+          end
+        end
+
+        # Creates and puts te properties into the set of
+        # properties of this rule.
+        #
+        # @return [Void]
+        def process_properties(properties)
+          properties.each do |prop|
+            add_property(Property.new(prop, ['no condition'])) if prop.is_a?(Sass::Tree::PropNode)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/css_compare/css/component/margin_box.rb

@@ -0,0 +1,40 @@
+module CssCompare
+  module CSS
+    module Component
+      # Represents a @page's margin box declaration.
+      # A page margin box consists of a margin symbol, like
+      # `@top-left-corner` and a list of declarations.
+      #
+      # MarginBox inherits from the Selector class, since
+      # there are inevitable similarities. The specified margin
+      # symbol can be reached by the `value` property of the
+      # instance of this class.
+      #
+      # @see Selector
+      class MarginBox < Selector
+        IGNORED_CONDITIONS = %w(width height aspect-ratio orientation).freeze
+
+        # Looks for a `size` property to delete the values
+        # that should be ignored according to the @page
+        # W3 specification.
+        #
+        # If a size property declaration is qualified by a
+        # 'width', 'height', 'device-width', 'device-height',
+        # 'aspect-ratio', 'device-aspect-ratio' or 'orientation'
+        # media query (or other conditional on the size of the
+        # paper), then the declaration must be ignored.
+        #
+        # @see https://www.w3.org/TR/css3-page/#page-size
+        #   ISSUE 3 and EXAMPLE 23
+        #
+        # @see Property#add_property
+        def add_property(prop, deep_copy = false)
+          prop.values.delete_if do |k, _|
+            IGNORED_CONDITIONS.any? { |condition| k.include?(condition) }
+          end if prop.name == 'size'
+          super(prop, deep_copy)
+        end
+      end
+    end
+  end
+end

data/lib/css_compare/css/component/page_selector.rb

@@ -0,0 +1,126 @@
+module CssCompare
+  module CSS
+    module Component
+      # Represents @page directive's page selector
+      # (`:right`, `LandscapeTable`, `CompanyLetterHead:first`)
+      # combined with the page body, that can contain a
+      # list of declarations and a list of page margin boxes.
+      #
+      # The declarations not assigned to any margin symbol
+      # will be automatically grouped under the global
+      # margin symbol.
+      #
+      # @see https://www.w3.org/TR/css3-page/
+      class PageSelector < Base
+        # The value of this page selector
+        #
+        # @return [String]
+        attr_accessor :value
+
+        # The margin box directives containing
+        # the declarations.
+        #
+        # @return [Hash{String => MarginBox}]
+        attr_accessor :margin_boxes
+
+        # The global margin symbol.
+        GLOBAL_MARGIN_SYMBOL = '@all'.freeze
+
+        # @param [String] value the page selector
+        # @param [Array<Sass::Tree::Node>] children page body
+        # @param [Array<String>] conditions applying media query conditions
+        def initialize(value, children, conditions)
+          @value = value
+          @margin_boxes = {}
+          process_margin_boxes(children, conditions)
+        end
+
+        # Checks, whether two page selectors are equal.
+        #
+        # Two page selectors are equal only if both have
+        # declared the same margin boxes and they are also
+        # equal.
+        #
+        # @param [PageSelector] other the page selector to
+        #   compare this with.
+        # @return [Boolean]
+        def ==(other)
+          super(@margin_boxes, other.margin_boxes)
+        end
+
+        # Merges this page selector with another one.
+        #
+        # @param [PageSelector]
+        # @return [Void]
+        def merge(other)
+          other.margin_boxes.each do |_, prop|
+            add_margin_box(prop, true)
+          end
+        end
+
+        # Creates a deep copy of this page selector.
+        #
+        # @param [String] value the new value of
+        #   the selector's copy.
+        # @return [PageSelector] a copy of self
+        def deep_copy(value = @value)
+          copy = dup
+          copy.value = value
+          copy.margin_boxes = @margin_boxes.inject({}) do |result, (k, v)|
+            result.update(k => v.deep_copy)
+          end
+          copy
+        end
+
+        # Creates the JSON representation of this page selector.
+        #
+        # @return [Hash]
+        def to_json
+          json = { :selector => @value, :margin_boxes => [] }
+          @margin_boxes.inject(json[:margin_boxes]) do |result, (_k, v)|
+            result << v.to_json
+          end
+          json
+        end
+
+        private
+
+        # Adds a new or updates an already existing margin box.
+        #
+        # @param [MarginBox] margin_box the margin box to be added
+        # @param [Boolean] deep_copy checks whether the margin_box
+        #   should be added by reference or its deep copied value.
+        def add_margin_box(margin_box, deep_copy = false)
+          if @margin_boxes[margin_box.name]
+            @margin_boxes[margin_box.name].merge(margin_box)
+          else
+            @margin_boxes[margin_box.name] = if deep_copy
+                                               margin_box.deep_copy
+                                             else
+                                               margin_box
+                                             end
+          end
+        end
+
+        # Processes and evaluates the page body.
+        #
+        # @param [Array<Sass::Tree::Node>] nodes (see #initialize)
+        # @param [Array<String>] conditions (see #initialize)
+        def process_margin_boxes(nodes, conditions)
+          nodes.each do |node|
+            if node.is_a?(Sass::Tree::PropNode)
+              margin_box = GLOBAL_MARGIN_SYMBOL
+              children = [node]
+            elsif node.is_a?(Sass::Tree::DirectiveNode)
+              margin_box = node.resolved_value
+              children = node.children
+            else
+              next # just ignore these nodes
+            end
+            add_margin_box(MarginBox.new(margin_box, children, conditions))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/css_compare/css/component/property.rb

@@ -0,0 +1,155 @@
+module CssCompare
+  module CSS
+    module Component
+      # Represents a CSS property tied to a specific selector.
+      # It can have several values based on the conditions
+      # specified by the @media queries.
+      class Property < Base
+        # @return [String] name of the property
+        attr_reader :name
+
+        # Key-value pair of property values.
+        #
+        # The key represents the condition set by a media query
+        # and the value is the actual value of the property.
+        #
+        # @return [Hash{String=>Value}] name of the property
+        attr_accessor :values
+
+        # @note An optimization has been done here, as well.
+        #   If there are several conditions, all should be
+        #   paired with the same value but not the same object,
+        #   since the value can be overridden later in the process
+        #   of the stylesheet evaluation. A clone of the value is
+        #   paired with each of the conditions.
+        #
+        # @param [Sass::Tree::PropNode] node the property node
+        # @param [Array<String>] conditions media query conditions
+        def initialize(node, conditions)
+          @name = node.resolved_name
+          @values = {}
+          value = Value.new(node.resolved_value)
+          conditions.each { |c| set_value(value.clone, c) }
+        end
+
+        # Checks whether two properties are equal.
+        #
+        # Properties are equal only if both contain
+        # the same keys and the values under those
+        # keys are also equal.
+        #
+        # @param [Property] other the property to compare this
+        #   with.
+        # @return [Boolean]
+        def ==(other)
+          super(@values, other.values)
+        end
+
+        # Merges the property with another one.
+        #
+        # @param [Property] property to be merged with `self`
+        # @return [Void]
+        def merge(property)
+          property.values.each { |cond, v| set_value(v, cond) }
+        end
+
+        # Replaces the original value of the property under a certain
+        # media query condition.
+        #
+        # If the value does not exist under the specified condition,
+        # it is added into the set of property values. Otherwise, it
+        # rewrites the current value if it's not set as important.
+        # However, if the replacing value is also set as important,
+        # the current value will be replaced with the new one.
+        #
+        # If the condition does not exist but there is an important
+        # global value assigned to the property, the replacing value
+        # will be used only, if it's set to important, too. Otherwise,
+        # the global value should be cloned in there.
+        #
+        # @param [Value] val that should replace the current value
+        # @param [String] condition the circumstance, under which
+        #   the property should take the new value.
+        # @return [Void]
+        def set_value(val, condition = 'all')
+          global_value = @values['all']
+          val_to_replace = value(condition)
+          # Check, whether the condition exists
+          if val_to_replace
+            @values[condition].value = val if val.important? || !val_to_replace.important?
+          else
+            @values[condition] = if global_value && global_value.important?
+                                   val.important? ? val : global_value.clone
+                                 else
+                                   val
+                                 end
+          end
+        end
+
+        # Returns the property's value taken under a certain
+        # circumstance
+        #
+        # @return [#to_s]
+        def value(condition = 'all')
+          @values[condition]
+        end
+
+        # Whether the property is a complex one.
+        # One property, that can be separated
+        # into smaller chunks of elementary properties.
+        #
+        # Example:
+        #   `border: 1px solid black` => `{
+        #       border-width: 1px;
+        #       border-style: solid;
+        #       border-color: black;
+        #   }`
+        #
+        # @see #process
+        # @return [Boolean]
+        def complex?
+          COMPLEX_PROPERTIES.include?(@name)
+          false
+        end
+
+        # Creates a deep copy of this property.
+        #
+        # @return [Property]
+        def deep_copy
+          copy = dup
+          copy.values = {}
+          @values.each { |k, v| copy.values[k] = v.clone }
+          copy
+        end
+
+        # Creates the JSON representation of this property.
+        #
+        # @return [Hash]
+        def to_json
+          @values.inject({}) { |result, (k, v)| result.update(k => v.to_s) }
+        end
+
+        private
+
+        COMPLEX_PROPERTIES = [].freeze
+
+        # Checks, whether an unprocessed value is important
+        # or not
+        #
+        # @return [Boolean]
+        def important_value?(val)
+          val.to_s.include?('!important')
+        end
+
+        # Breaks down complex properties like `border` into
+        # smaller chunks (`border-width`, `border-style`, `border-color`)
+        #
+        # @return [Array<Property>]
+        def process
+          return nil unless complex?
+          []
+        end
+      end
+    end
+  end
+end

data/lib/css_compare/css/component/selector.rb

@@ -0,0 +1,118 @@
+module CssCompare
+  module CSS
+    module Component
+      # Represents one simple selector sequence, like
+      # .a.b.c > div.f:first-child.
+      #
+      # @see https://www.w3.org/TR/css3-selectors/#selectors
+      class Selector < Base
+        # @return [String] selector's name
+        attr_accessor :name
+
+        # Hash of the selector's properties. Could have been
+        # an array but this structure has been chosen, so the
+        # properties' lookup gets optimized.
+        #
+        # @return [Hash{String => Component::Property}] properties
+        attr_accessor :properties
+
+        # @param [String] name of the selector
+        # @param [Array<Sass::Tree::PropNode>] properties to be included
+        # @param [Array<String>] conditions @media query conditions
+        def initialize(name, properties, conditions)
+          @name = name
+          @properties = {}
+          process_properties(properties, conditions)
+        end
+
+        # Checks, whether two selector are equal.
+        #
+        # Two selectors are equal only if they both have declared
+        # the same properties and they are also equal.
+        #
+        # @param [Selector] other the selector to compare this with.
+        # @return [Boolean]
+        def ==(other)
+          super(@properties, other.properties)
+        end
+
+        # Combines the selector's properties with the
+        # properties of another selector.
+        #
+        # @param [Property, Array<Property>] other
+        #   the selector to be merged with
+        # @return [Void]
+        def merge(other)
+          other.properties.each do |_, prop|
+            add_property(prop, true)
+          end
+        end
+
+        # Adds a property to the existing set of properties
+        # of this selector.
+        #
+        # If the property does not exist, it will be
+        # added. Otherwise the values of the properties
+        # will be merged.
+        #
+        # @see {Property#merge}
+        # @param [Property] prop the property to add
+        # @param [Boolean] deep_copy tells, whether a
+        #   deep copy should be applied onto the property.
+        # @return [Void]
+        def add_property(prop, deep_copy = false)
+          name = prop.name
+          if @properties[name]
+            @properties[name].merge(prop)
+          else
+            @properties[name] = if deep_copy
+                                  prop.deep_copy
+                                else
+                                  prop
+                                end
+          end
+        end
+
+        # Creates a deep copy of this selector.
+        #
+        # @param [String] name the new name of
+        #   the selector's copy.
+        # @return [Selector] a copy of self
+        def deep_copy(name = @name)
+          copy = dup
+          copy.name = name
+          copy.properties = {}
+          @properties.each { |k, v| copy.properties[k] = v.deep_copy }
+          copy
+        end
+
+        # Creates the JSON representation of this selector.
+        #
+        # @return [Hash]
+        def to_json
+          key = @name.to_sym
+          json = { key => {} }
+          @properties.inject(json[key]) do |result, (k, v)|
+            result.update(k => v.to_json)
+          end
+          json
+        end
+
+        private
+
+        # Walks through the property nodes ands merges them
+        # to the selector's set of properties.
+        #
+        # @param [Array<Sass::Tree::Node>] properties potential property
+        #   nodes of the selector.
+        # @param [Array<String>] conditions @media query conditions
+        # @return [Void]
+        def process_properties(properties, conditions)
+          properties.each do |property|
+            add_property(Property.new(property, conditions)) if property.is_a?(Sass::Tree::PropNode)
+          end
+        end
+      end
+    end
+  end
+end