css_compare 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6abcfc4cf2f5468f2fa82b1bfedc3eb7b9555d92
+  data.tar.gz: 85c19fb0d3993629cda8586a41a6f7b53d380e2c
+SHA512:
+  metadata.gz: 55e74e0702da7383a1d2259d5ea73eafc182c983ffc2d1ecd3d77e7a51a73fe4f39a0a37a66cda847f2e3c8a69fae5be3668f210fb600b8700b593a27f412136
+  data.tar.gz: b77a5b69826a4458e415e1c94dd5ed0b6a38bae4e95a34b1d273e59bc274bb4e8a7fe7d01c3b986d3ff5dc8adf49f8e1f82b93267fa3c2e881c6fc7a1311be55

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Attila Večerek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# CSS Compare
+
+Processes, evaluates and compares 2 CSS files based on their AST. The repository has been created in order to be able to test the [less2sass](https://github.com/vecerek/less2sass) project. The program returns `true` or `false` to the `$stdout`, so far.
+Uses the Sass parser to get the CSS files' AST.
+
+Supported CSS features:
+- all types of selectors (they are normalized - duplicity removal and logical/alphabetical ordering)
+- @media, partially
+- @import (lazy loading of imported css files, that can be found, otherwise ignored)
+- @font-face
+- @namespace
+- @charset
+- @keyframes
+- @page
+- @supports, partially
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'css_compare'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install css_compare
+
+## Usage
+Command line usage:
+
+    $ css_compare <CSS file> <CSS file>
+    
+Programmatic usage:
+
+```ruby
+opts = {
+    :operands => ["path/to/file1.css", "path/to/file2.css"]
+}
+result = CssCompare::Engine.new(opts)
+                   .parse!
+                   .equal?
+```
+
+## TODO
+
+- Evaluate shorthand properties, so the values of base properties get overridden.
+- Evaluate @media rule's and @supports rule's conditions.
+- Output the difference, optionally.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/vecerek/css_compare.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/css_compare

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# A command line CSS comparison tool
+
+begin
+  require_relative '../lib/css_compare'
+rescue
+  require 'css_compare'
+end
+
+opts = CssCompare::Comparison.new(ARGV)
+opts.parse!

data/lib/css_compare.rb

@@ -0,0 +1,6 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'css_compare/constants'
+require 'css_compare/exec'
+require 'css_compare/util'

data/lib/css_compare/constants.rb

@@ -0,0 +1,5 @@
+module CssCompare
+  # The root directory of the Less2Sass source tree.
+  ROOT_DIR = File.expand_path(File.join(__FILE__, '../../..'))
+  VERSION = '0.1.0'.freeze
+end

data/lib/css_compare/css.rb

@@ -0,0 +1,3 @@
+require 'css_compare/css/component'
+require 'css_compare/css/parser'
+require 'css_compare/css/engine'

data/lib/css_compare/css/component.rb

@@ -0,0 +1,45 @@
+require 'css_compare/css/component/base'
+require 'css_compare/css/component/value'
+require 'css_compare/css/component/property'
+require 'css_compare/css/component/selector'
+require 'css_compare/css/component/keyframes_selector'
+require 'css_compare/css/component/keyframes'
+require 'css_compare/css/component/supports'
+require 'css_compare/css/component/margin_box'
+require 'css_compare/css/component/page_selector'
+require 'css_compare/css/component/font_face'
+
+module CssCompare
+  module CSS
+    module Component
+      # Creates a new {Sass::Tree::RootNode}.
+      #
+      # @param [Array<Sass::Tree::Node>] children the child nodes
+      #   of the newly created node.
+      # @param [Hash] options node options
+      # @return [Sass::Tree::RootNode]
+      def root_node(children, options)
+        root = Sass::Engine.new('').to_tree
+        root.options = options
+        root.children = children.is_a?(Array) ? children : [children]
+        root
+      end
+
+      # Creates a new {Sass::Tree::MediaNode} from scratch.
+      #
+      # @param [Array<String, Sass::Media::Query>] query the
+      #   list of media queries
+      # @param [Sass::Tree::Node] children (see #root_node)
+      # @param [Hash] options (see #root_node)
+      # @return [Sass::Tree::MediaNode]
+      def media_node(query, children, options)
+        media_node = Sass::Tree::MediaNode.new(query)
+        media_node.options = options
+        media_node.line = 1
+        media_node = Sass::Tree::Visitors::Perform.visit(media_node)
+        media_node.children = children
+        media_node
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module CssCompare
+  module CSS
+    module Component
+      class Base
+        # Checks, whether two hashes are equal.
+        #
+        # They are equal, if they contain the same keys
+        # and also have the same values assigned.
+        #
+        # @param [Hash] this first hash to compare
+        # @param [Hash] that second hash to compare
+        # @return [Boolean]
+        def ==(this, that)
+          keys = this.keys + that.keys
+          keys.uniq!
+          keys.all? { |key| this[key] && that[key] && this[key] == that[key] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+module CssCompare
+  module CSS
+    module Component
+      # Represents the @font-face directive.
+      #
+      # Multiple @font-face rules can be used to construct
+      # font families with a variety of faces. Each @font-face
+      # rule specifies a value for every font descriptor,
+      # either implicitly or explicitly. Those not given explicit
+      # values in the rule take the initial value listed with
+      # each descriptor in the w3.org specification.
+      #
+      # If multiple declarations of @font-face rules, that share
+      # the same `font-family` and `src` values are present, the last
+      # declaration overrides the other.
+      #
+      # `Font-family` property is saved downcased, since the user
+      # agents, when matching font-family names, do it in
+      # a case-insensitive manner.
+      #
+      # @see https://www.w3.org/TR/css-fonts-3/#font-face-rule
+      class FontFace < Base
+        attr_reader :declarations
+
+        # @param [Array<Sass::Tree::PropNode>] children font properties
+        def initialize(children)
+          @declarations = {}
+          init_declarations
+          process_declarations(children)
+        end
+
+        # Checks, whether two @font-face declarations are equal.
+        #
+        # No need to check, whether both font-faces have the same
+        # keys, since they are also initialized with the default
+        # values.
+        #
+        # @param [FontFace] other the @font-face to compare this
+        #   with.
+        def ==(other)
+          @declarations.all? { |k, _| @declarations[k] == other.declarations[k] }
+        end
+
+        # Tells, whether this rule is valid or not.
+        #
+        # @font-face rules require a font-family and src descriptor;
+        # if either of these are missing, the @font-face rule is
+        # invalid and must be ignored entirely.
+        #
+        # @return [Boolean]
+        def valid?
+          family && src
+        end
+
+        # @return [String, nil] font-family name, if set
+        def family
+          @declarations['font-family']
+        end
+
+        # @return [String, nil] the source of the font if set
+        def src
+          @declarations['src']
+        end
+
+        # Creates the JSON representation of this object.
+        #
+        # @return [Hash]
+        def to_json
+          @declarations
+        end
+
+        private
+
+        INITIAL_VALUES = {
+          :font_family => {
+            :default => nil
+          },
+          :src => {
+            :default => nil
+          },
+          :font_style => {
+            :default => 'normal',
+            :allowed => %w(normal italic oblique)
+          },
+          :font_weight => {
+            :default => '400',
+            :allowed => %w(normal bold 100 200 300 400 500 600 700 800 900),
+            :synonyms => {
+              :normal => '400',
+              :bold => '600'
+            }
+          },
+          :font_stretch => {
+            :default => 'normal',
+            :allowed => %w(normal ultra-condensed extra-condensed condensed semi-condensed semi-expanded expanded
+                           extra-expanded ultra-expanded)
+          },
+          :unicode_range => {
+            :default => 'U+0-10FFFF'
+          },
+          :font_variant => {
+            :default => 'normal'
+          },
+          :font_feature_settings => {
+            :default => 'normal'
+          },
+          :font_kerning => {
+            :default => 'auto',
+            :allowed => %w(auto normal none)
+          },
+          :font_variant_ligatures => {
+            :default => 'normal'
+          },
+          :font_variant_position => {
+            :default => 'normal',
+            :allowed => %w(normal sub super)
+          },
+          :font_variant_caps => {
+            :default => 'normal',
+            :allowed => %w(normal small-caps all-small-caps petite-caps all-petite-caps unicase titling-caps)
+          },
+          :font_variant_numeric => {
+            :default => 'normal'
+          },
+          :font_variant_alternates => {
+            :default => 'normal'
+          },
+          :font_variant_east_asian => {
+            :default => 'normal'
+          },
+          :font_language_override => {
+            :default => 'normal'
+          }
+
+        }.freeze
+
+        # Initializes the font-face with values from
+        # the official specifications.
+        #
+        # @return [Void]
+        def init_declarations
+          INITIAL_VALUES.each { |k, v| @declarations[k.to_s.tr('_', '-')] = v[:default] }
+        end
+
+        # Processes the @font-face declarations and set
+        # the values if:
+        #   1. the property processed is a valid font-face property
+        #   2. the property has a valid value
+        # If the property's value is not valid, it falls back to
+        # the default one.
+        #
+        # @param [Array<Sass::Tree::PropNode>] children
+        # @return [Void]
+        def process_declarations(children)
+          children.each do |child|
+            next unless child.is_a?(Sass::Tree::PropNode)
+            name = child.resolved_name
+            value = child.resolved_value
+            key = name.tr('-', '_').to_sym
+            property = INITIAL_VALUES[key]
+            next unless property
+            @declarations[name] = value.downcase if name == 'font-family'
+            @declarations[name] = value.gsub(/'|"/, '') if name == 'src'
+            next if name == 'font-family' || name == 'src'
+            @declarations[name] = value
+            allowed_values = property[:allowed]
+            next unless allowed_values
+            if allowed_values.include?(value)
+              @declarations[name] = get_synonym(property, value.to_sym) || value
+            else
+              @declaration[name] = property[:default]
+            end
+          end
+        end
+
+        # Returns the synonym for a property's value.
+        #
+        # @example
+        #   get_synonym(INITIAL_VALUES[:font-weight], [:bold]) #=> '600'
+        #
+        # @return [String, nil] a string, if a synonym exists
+        #                       nil otherwise
+        def get_synonym(property, key)
+          return unless property[:synonyms] && property[:synonyms].include?(key)
+          property[:synonyms][key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+module CssCompare
+  module CSS
+    module Component
+      # Represents an @keyframes declaration
+      #
+      # @see https://www.w3.org/TR/css3-animations/#keyframes
+      class Keyframes < Base
+        # The name of the keyframes.
+        #
+        # @return [String] the name
+        attr_reader :name
+
+        # The rules of the keyframe grouped by
+        # @media query conditions.
+        #
+        # Rules' example structure:
+        #   {
+        #     'all' => {
+        #       '0%'   => {KeyframeSelector},
+        #       '100%' => {KeyframeSelector}
+        #     },
+        #     '(max-width: 600px)' => {
+        #       '0%'   => {KeyframeSelector},
+        #       '50%'  => {KeyframeSelector},
+        #       '100%' => {KeyframeSelector}
+        #     }
+        #   }
+        #
+        # @return [Hash{String => Hash{String => KeyframeSelector}}]
+        attr_reader :rules
+
+        def initialize(node, conditions)
+          @name = node.value[1]
+          process_conditions(conditions, process_rules(node.children))
+        end
+
+        # Checks, whether two @keyframes are equal.
+        #
+        # Two @keyframes are only equal, if they both have equal
+        # keyframe selectors under each and every condition.
+        # If a condition or frame is missing from one or another,
+        # the @keyframes are not equal.
+        #
+        # @param [Keyframes] other the @keyframe to compare this
+        #   with.
+        # @param [Boolean]
+        def ==(other)
+          conditions = @rules.keys + other.rules.keys
+          conditions.uniq!
+          conditions.all? do |condition|
+            return false unless @rules[condition] && other.rules[condition]
+            super(@rules[condition], other.rules[condition])
+          end
+        end
+
+        # Merges this selector with another one.
+        #
+        # The new declaration of the keyframe under the same
+        # condition rewrites the previous one. No deep_copy
+        # needs to be made and the value can be passed by
+        # reference.
+        #
+        # @param [Keyframes] keyframes the keyframes to
+        #   extend this one.
+        # @return [Void]
+        def merge(keyframes)
+          keyframes.rules.each do |condition, selector|
+            @rules[condition] = selector
+          end
+        end
+
+        def deep_copy(name = @name)
+          copy = dup
+          copy.name = name
+          copy.rules = @rules.inject({}) do |result, (k, v)|
+            result.update(k => v.deep_copy)
+          end
+        end
+
+        # Creates the JSON representation of this keyframes.
+        #
+        # @return [Hash]
+        def to_json
+          json = { :name => @name.to_sym, :rules => {} }
+          @rules.each_with_object(json[:rules]) do |(cond, rules), frames|
+            rules.each_with_object(frames[cond.to_sym] = {}) do |(value, rule), result|
+              result.update(value.to_sym => rule.to_json)
+            end
+            frames
+          end
+          json
+        end
+
+        # Assigns the processed rules to the passed conditions
+        # By reference. No deep copy needed, as the {KeyframeSelector}s
+        # won't be altered or merged with another {KeyframeSelector},
+        # since this feature is missing at @keyframe directives.
+        #
+        # @return [Hash{String => Hash}]
+        # @see `@rules`
+        def process_conditions(conditions, keyframe_rules)
+          @rules = conditions.inject({}) do |kf, condition|
+            kf.update(condition => keyframe_rules)
+          end
+        end
+
+        # Processes the keyframe rules and creates their
+        # internal representation.
+        #
+        # @return [Hash{String => KeyframeSelector}]
+        def process_rules(rule_nodes)
+          rule_nodes.each_with_object({}) do |node, rules|
+            if node.is_a?(Sass::Tree::KeyframeRuleNode)
+              rule = Component::KeyframesSelector.new(node)
+              rules.update(rule.value => rule)
+            end
+            rules
+          end
+        end
+      end
+    end
+  end
+end