html-conditional-comment 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf4b71499353f362569739053e61a2557c2a4cea
+  data.tar.gz: dba497e3d758323e16684aff985ad62e807ba564
+SHA512:
+  metadata.gz: cbe607ef7e65c9b3fc5207b3f0e6d9275b638a897093e2d608bd9189614a98a9d789fee620d83a495df56437d087241054031cc57b75c7fec40f9b0be9f32d16
+  data.tar.gz: 5ab6afde82cf240722973804f7f43fff9889fe61b5929ff3d4d11a07e440d831dd20831505a7c71d98d5e7816a3f5e96c075c9cae5e7c5294d9b1e9bdbbbb514

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.byebug_history

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.3
+before_install: gem install bundler -v 1.13.7

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in html-conditional-comment.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Carson Reinke
+
+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,41 @@
+# HTML Conditional Comment Evaluater, Parser, and Lexer
+
+Evaluate, parse, and tokenizing HTML conditional comments using provided features and version.  Allows for existing HTML to be maintained and only conditional comments to evaluated.
+
+## Why?
+
+Conditional comments are really a legacy approach, however the application is still quite prevelant in the email marketing industry.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'html-conditional-comment'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install html-conditional-comment
+
+## Usage
+
+* Evaluating:
+`HtmlConditionalComment.to_string("What is the <!--[if gte mso 9]>Outlook<![endif]-->?", "mso", 9) => "What is the Outlook?"`
+
+* Parsing: `HtmlConditionalComment.parse(...) => HtmlConditionalComment::Nodes::Nodes`
+
+* Tokenizing: `HtmlConditionalComment.lex(...) => [[:open, "<!--["], [:if, "if"]...`
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/carsonreinke/html-conditional-comment.
+
+
+## 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,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "html-conditional-comment"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/html-conditional-comment.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'html-conditional-comment/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "html-conditional-comment"
+  spec.version       = HtmlConditionalComment::VERSION
+  spec.authors       = ["Carson Reinke"]
+  spec.email         = ["carson@reinke.co"]
+
+  spec.summary       = %q{Parse HTML conditional comments}
+  spec.homepage      = "https://github.com/carsonreinke/html-conditional-comment"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "byebug"
+end

data/lib/html-conditional-comment.rb

@@ -0,0 +1,35 @@
+require 'html-conditional-comment/version'
+require 'html-conditional-comment/lexer'
+require 'html-conditional-comment/parser'
+require 'html-conditional-comment/nodes'
+require 'html-conditional-comment/visitor'
+require 'html-conditional-comment/version_vector'
+
+module HtmlConditionalComment
+  class << self
+    ##
+    # Tokenize the HTML into an array of tokens 
+    #
+    def lex(html)
+      Lexer.new(html).tokenize()
+    end
+
+    ##
+    # Parse into tree of nodes the HTML
+    #
+    def parse(html)
+      Parser.new(self.lex(html)).parse()
+    end
+
+    ##
+    # Evaluate conditional comments in HTML using the supplied browser
+    # information and return a string
+    #
+    # * +features+ - String or Array of features of browser
+    # * +version+ - String, Integer, or Float representing version of the browser
+    #
+    def to_string(html, features, version)
+      self.parse(html).accept(Visitors::ToString.new(features, version))
+    end
+  end
+end

data/lib/html-conditional-comment/lexer.rb

@@ -0,0 +1,108 @@
+module HtmlConditionalComment
+  class TokenError < StandardError
+    def initialize(rest)
+      super("Invalid token \"#{rest.slice(0, 25)}\"")
+    end
+  end
+
+  ##
+  # Converts string into array of tokens.  Token is an array, first element is
+  # symbol representing the token, second element is string value.
+  #
+  class Lexer
+    LESS_THAN = /lt/i
+    LESS_THAN_EQUAL = /lte/i
+    GREATER_THAN = /gt/i
+    GREATER_THAN_EQUAL = /gte/i
+    OPEN_PAREN = /\(/
+    CLOSE_PAREN = /\)/
+    NOT = /\!/
+    OR = /\|/
+    AND = /\&/
+    TRUE = /true/i
+    FALSE = /false/i
+    IF_STATEMENT = /if/i
+    ENDIF_STATEMENT = /endif/i
+    #Opening statement plus positive look ahead to avoid conflicts with other
+    #comments
+    OPEN = /<!(\-\-)?\[(?=(end)?if)/
+    CLOSE = /\](\-\-)?>/
+    WHITE_SPACE = /\s+/
+    FEATURE = /[a-z]+/i
+    VERSION_VECTOR = /\d+(\.[\d]+)?/
+
+    TOKENS = [
+      [:if, IF_STATEMENT],
+      [:endif, ENDIF_STATEMENT],
+
+      [:paren_open, OPEN_PAREN],
+      [:paren_close, CLOSE_PAREN],
+
+      [:operator_less_than_equal, LESS_THAN_EQUAL],
+      [:operator_less_than, LESS_THAN],
+      [:operator_greater_than_equal, GREATER_THAN_EQUAL],
+      [:operator_greater_than, GREATER_THAN],
+
+      [:operator_not, NOT],
+      [:operator_or, OR],
+      [:operator_and, AND],
+
+      [:boolean_true, TRUE],
+      [:boolean_false, FALSE],
+      [:feature, FEATURE],
+      [:version_vector, VERSION_VECTOR]
+    ]
+
+    def initialize(html_or_comment)
+      @scanner = StringScanner.new(html_or_comment)
+    end
+
+    def tokenize()
+      tokens = []
+      open = false
+
+      #Run until nothing left in string
+      until @scanner.eos?()
+        #Split between if the conditional comment has been opened or not
+        #State will help handle all the other HTML we don't care about
+        if open
+          @scanner.skip(WHITE_SPACE)
+          if token = @scanner.scan(CLOSE)
+            open = false
+            tokens << [:close, token]
+          else
+            #Go through token specs and scan and stop on first one
+            token = TOKENS.inject(nil) do |previous, spec|
+              t = @scanner.scan(spec[1])
+              unless t.nil?()
+                break [spec[0], t]
+              end
+            end
+            if token
+              tokens << token
+            else
+              raise TokenError.new(@scanner.rest())
+            end
+          end
+        #Closed (not opened) conditional comment
+        else
+          #Scan till we find an open token, if not done and use the rest
+          if match = @scanner.scan_until(OPEN)
+            open = true
+            #TODO Gross way to get up till scan has succeeded
+            match = match.slice(0..-(@scanner.matched.size() + 1))
+            tokens << [:html, match] unless match.empty?()
+            tokens << [:open, @scanner.matched]
+          else
+            tokens << [:html, @scanner.rest()] if @scanner.rest?()
+            break
+          end
+        end
+      end
+      @scanner.reset()
+
+      tokens
+    end
+
+  end
+end

data/lib/html-conditional-comment/nodes.rb

@@ -0,0 +1,54 @@
+require 'singleton'
+require 'delegate'
+
+module HtmlConditionalComment
+  module Nodes
+    module Node
+      def accept(visitor)
+        visitor.visit(self)
+      end
+    end
+
+    class NodeItem
+      include Node
+    end
+
+    class Nodes < Array
+      include Node
+    end
+
+    class ChildOperator < NodeItem
+      attr_accessor :child
+    end
+    class BranchOperator < NodeItem
+      attr_accessor :left, :right
+    end
+    class Comparison < ChildOperator; end
+    class Condition < BranchOperator; end
+
+
+    class Or < BranchOperator; end
+    class And < BranchOperator; end
+    class Not < ChildOperator; end
+
+    class Equal < Comparison; end
+    class LessThan < Comparison; end
+    class LessThanEqual < Comparison; end
+    class GreaterThan < Comparison; end
+    class GreaterThanEqual < Comparison; end
+
+    class Browser < NodeItem
+      attr_accessor :feature, :version_vector
+    end
+    class True < NodeItem
+      include Singleton
+    end
+    class False < NodeItem
+      include Singleton
+    end
+
+    class Html < NodeItem
+      attr_accessor :content
+    end
+  end
+end

data/lib/html-conditional-comment/parser.rb

@@ -0,0 +1,228 @@
+module HtmlConditionalComment
+  class ParseError < StandardError
+    def initialize(msg, example)
+      super("#{msg} at \"#{example.slice(0, 25)}\"")
+    end
+  end
+
+  ##
+  #
+  # Parse tokens into a tree of nodes
+  #
+  # Pseudo grammar
+  #
+  #template = { html | statement }
+  #statement = "<!" , [ "--" ] , "if" , expression , "]" , [ "--" ] , ">" , template , "<!" , [ "--" ] , "endif" , "]" , [ "--" ] , ">"
+  #expression = term [ "|" , term ]
+  #term = factor [ "&" , factor ]
+  #factor = subexpression | "!" , factor | "(" , expression , ")"
+  #subexpression = [ operator ] browser | boolean
+  #operator = "gt" | "gte" | "lt" | "lte"
+  #boolean = "true" | "false"
+  #browser = feature [ version_vector ]
+  #
+  class Parser
+    def initialize(tokens)
+      @symbol = nil
+      @tokens = tokens
+      @max_pos = tokens.size() - 1
+      @pos = -1
+    end
+
+    def parse()
+      self.next()
+
+      nodes = template()
+
+      #Tokens left, syntax error
+      error() if @pos < @max_pos
+
+      nodes
+    end
+
+
+protected
+    #Browser is combination of feature and optional version
+    def browser()
+      node = Nodes::Browser.new()
+      node.feature = @value
+      expect(:feature)
+
+      if current(:version_vector)
+        node.version_vector = VersionVector.new(@value)
+        accept(:version_vector)
+      else
+        node.version_vector = VersionVector.new(nil)
+      end
+
+      node
+    end
+
+    #True or false
+    def boolean()
+      if accept(:boolean_true)
+        Nodes::True.instance()
+      elsif accept(:boolean_false)
+        Nodes::False.instance()
+      else
+        error()
+      end
+    end
+
+    #Comparison operators
+    def operator()
+      if accept(:operator_less_than)
+        Nodes::LessThan.new()
+      elsif accept(:operator_less_than_equal)
+        Nodes::LessThanEqual.new()
+      elsif accept(:operator_greater_than)
+        Nodes::GreaterThan.new()
+      elsif accept(:operator_greater_than_equal)
+        Nodes::GreaterThanEqual.new()
+      else
+        error()
+      end
+    end
+
+    #Either a comparison with the browser, boolean, or simply just the browser
+    def subexpression()
+      node = nil
+
+      if current(:operator_less_than) || current(:operator_less_than_equal) ||
+        current(:operator_greater_than) || current(:operator_greater_than_equal)
+
+        node = operator()
+        node.child = browser()
+      elsif current(:boolean_true) || current(:boolean_false)
+        node = boolean()
+      else
+        #No comparison operator is assuming equals
+        node = Nodes::Equal.new()
+        node.child = browser()
+      end
+
+      node
+    end
+
+    #Negated self or paranthesised expression
+    def factor()
+      node = nil
+
+      if accept(:operator_not)
+        node = Nodes::Not.new()
+        node.child = factor()
+      elsif accept(:paren_open)
+        node = expression()
+        expect(:paren_close)
+      else
+        node = subexpression()
+      end
+
+      node
+    end
+
+    #And
+    def term()
+      node = factor()
+      while accept(:operator_and)
+        branch_node = Nodes::And.new()
+        branch_node.left = node
+        branch_node.right = factor()
+        node = branch_node
+      end
+
+      node
+    end
+
+    #Or
+    def expression()
+      node = term()
+      while accept(:operator_or)
+        branch_node = Nodes::Or.new()
+        branch_node.left = node
+        branch_node.right = term()
+        node = branch_node
+      end
+
+      node
+    end
+
+    def condition()
+      node = Nodes::Condition.new()
+
+      expect(:open)
+      expect(:if)
+      node.left = expression()
+      expect(:close)
+
+      unless current(:open) && peek(:endif)
+        node.right = template()
+      end
+
+      expect(:open)
+      expect(:endif)
+      expect(:close)
+
+      node
+    end
+
+    def html()
+      node = Nodes::Html.new()
+      node.content = @value
+      expect(:html)
+      node
+    end
+
+    def template()
+      nodes = Nodes::Nodes.new()
+
+      while current(:html) || (current(:open) && peek(:if))
+        nodes << if current(:html)
+          html()
+        elsif current(:open) && peek(:if)
+          condition()
+        end
+      end
+
+      nodes
+    end
+
+
+protected
+    #Accept the symbol and move on or not
+    def accept(symbol)
+      if(symbol == @symbol)
+        self.next()
+        return true
+      else
+        return false
+      end
+    end
+
+    #Expect a current symbol or raise
+    def expect(symbol)
+      raise HtmlConditionalComment::ParseError.new("Expected #{symbol}, received #{@symbol}", @value) unless accept(symbol)
+    end
+
+    def current(symbol)
+      @symbol == symbol
+    end
+
+    def peek(symbol)
+      @tokens[@pos+1][0] == symbol
+    end
+
+    def next()
+      @pos += 1
+      #raise HtmlConditionalComment::ParserError.new('EOF') if @pos >= @max_pos
+      token = @tokens[@pos] || []
+      @symbol = token[0]
+      @value = token[1]
+      token
+    end
+
+    def error()
+      raise HtmlConditionalComment::ParseError.new("Syntax error", @value)
+    end
+  end
+end

data/lib/html-conditional-comment/version.rb

@@ -0,0 +1,3 @@
+module HtmlConditionalComment
+  VERSION = "0.0.1"
+end

data/lib/html-conditional-comment/version_vector.rb

@@ -0,0 +1,42 @@
+module HtmlConditionalComment
+  class VersionVector
+    include Comparable
+
+    DOT = /\./
+    DIGIT = /\d/
+
+    attr_accessor :string
+
+    def initialize(string)
+      @string = string.to_s() unless string.nil?()
+    end
+
+    def <=>(other)
+      #Force comparison class
+      other = VersionVector.new(other) unless other.is_a?(VersionVector)
+
+      return 0 if @string.nil?() || other.string.nil?()
+      return 0 if @string == other.string
+
+      #Normalize version array sizes
+      left, right = self.to_a(), other.to_a()
+      size = [left.size(), right.size()].min()
+      left.slice!(size..-1)
+      right.slice!(size..-1)
+
+      #Compare based on number
+      left.join.to_f() <=> right.join.to_f()
+    end
+
+    ##
+    # Split string into array of version numbers, major can be multiple digits,
+    # minor can only be a single digit
+    #
+    def to_a()
+      major, minors = @string.split(DOT)
+      versions = (minors || '').scan(DIGIT)
+      versions.unshift(major, '.')
+      versions
+    end
+  end
+end

data/lib/html-conditional-comment/visitor.rb

@@ -0,0 +1,99 @@
+module HtmlConditionalComment
+  class VisitError < StandardError
+    def initialize(klass)
+      super("Cannot visit #{klass}")
+    end
+  end
+
+  module Visitors
+    class Visitor
+      def initialize(features, version)
+        @features = features
+        @features = [@features] unless @features.is_a?(Enumerable)
+
+        @version = if version.is_a?(VersionVector)
+          version
+        else
+          VersionVector.new(version)
+        end
+      end
+
+      #Copied from https://blog.bigbinary.com/2013/07/07/visitor-pattern-and-double-dispatch.html
+      def visit(subject)
+        method_name = :"visit_#{(subject.class.name || '').gsub('::', '_')}"
+        __send__(method_name, subject)
+      end
+
+      #Provide method missing for better interpretation
+      def method_missing(method, args)
+        if method.to_s() =~ /^visit\_(.+)/
+          raise VisitError.new($1)
+        else
+          super(method, args)
+        end
+      end
+    end
+
+    ##
+    # Evaluates conditions to boolean
+    #
+    class Eval < Visitor
+    protected
+      def visit_HtmlConditionalComment_Nodes_True(subject)
+        true
+      end
+      def visit_HtmlConditionalComment_Nodes_False(subject)
+        false
+      end
+      def visit_HtmlConditionalComment_Nodes_Browser(subject)
+        @features.include?(subject.feature)
+      end
+
+      def visit_HtmlConditionalComment_Nodes_Equal(subject)
+        subject.child.accept(self) && @version == subject.child.version_vector
+      end
+      def visit_HtmlConditionalComment_Nodes_LessThan(subject)
+        subject.child.accept(self) && @version < subject.child.version_vector
+      end
+      def visit_HtmlConditionalComment_Nodes_LessThanEqual(subject)
+        subject.child.accept(self) && @version <= subject.child.version_vector
+      end
+      def visit_HtmlConditionalComment_Nodes_GreaterThan(subject)
+        subject.child.accept(self) && @version > subject.child.version_vector
+      end
+      def visit_HtmlConditionalComment_Nodes_GreaterThanEqual(subject)
+        subject.child.accept(self) && @version >= subject.child.version_vector
+      end
+
+      def visit_HtmlConditionalComment_Nodes_Or(subject)
+        subject.left.accept(self) || subject.right.accept(self)
+      end
+      def visit_HtmlConditionalComment_Nodes_And(subject)
+        subject.left.accept(self) && subject.right.accept(self)
+      end
+      def visit_HtmlConditionalComment_Nodes_Not(subject)
+        !subject.child.accept(self)
+      end
+    end
+
+    ##
+    # Converts parser nodes to a string by evaluating each conditional comment
+    #
+    class ToString < Visitor
+    protected
+      def visit_HtmlConditionalComment_Nodes_Nodes(subject)
+        subject.map{|node| node.accept(self)}.join
+      end
+
+      def visit_HtmlConditionalComment_Nodes_Condition(subject)
+        if subject.left.accept(Eval.new(@features, @version))
+          subject.right.accept(self)
+        end
+      end
+
+      def visit_HtmlConditionalComment_Nodes_Html(subject)
+        subject.content
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: html-conditional-comment
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Carson Reinke
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- carson@reinke.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- html-conditional-comment.gemspec
+- lib/html-conditional-comment.rb
+- lib/html-conditional-comment/lexer.rb
+- lib/html-conditional-comment/nodes.rb
+- lib/html-conditional-comment/parser.rb
+- lib/html-conditional-comment/version.rb
+- lib/html-conditional-comment/version_vector.rb
+- lib/html-conditional-comment/visitor.rb
+homepage: https://github.com/carsonreinke/html-conditional-comment
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Parse HTML conditional comments
+test_files: []