lazy-check 1.0.0

data/lib/lazy/check/checked_tag.rb

@@ -0,0 +1,337 @@
+module Lazy
+class Checker
+class CheckedTag
+
+  class CheckCaseError < StandardError; end
+
+  attr_reader :data
+  
+  # Instanciation
+  # 
+  # 
+  def initialize(data)
+    @data = data
+    parse_tag
+    check_data
+    @error = nil
+  end
+
+  # @return les erreurs rencontrées
+  def errors
+    err = []
+    # err << "Erreur avec #{data.inspect}" # Pour obtenir précisément les données
+    err << @error.strip unless @error.nil?
+    err << @errors.join("\n") unless @errors.empty?
+    err << @sub_errors.join("\n") unless @sub_errors.empty?
+    return err.join("\n")
+  end
+
+  def message
+    MESSAGES[4999] % {tag: tag, f_data: formated_data}
+  end
+
+  # @return [String] les données formatées pour un message de
+  # succès (et peut-être même à l'avenir un message de failure)
+  def formated_data
+    ds = []
+    ds << "#{MESSAGES[10]}: #{count}" if count
+    ds << "#{MESSAGES[12]}: #{min_length}" if min_length
+    ds << "#{MESSAGES[13]}: #{max_length}" if max_length
+    ds << "#{MESSAGES[20]}" if direct_child_only?
+    ds << "#{MESSAGES[15]}" if must_not_be_empty?
+    ds << "#{MESSAGES[14]}" if must_be_empty?
+    ds << "#{MESSAGES[16]} #{contains}" if must_have_content?
+    ds << "#{MESSAGES[17]} #{text.inspect}" if must_have_text?
+    ds << "#{MESSAGES[21]} #{attributes.inspect}" if must_have_attributes?
+    #
+    # On les répartit sur plusieurs lignes
+    # 
+    max_line = 70
+    lines = []
+    line  = []
+    while seg = ds.shift
+      curline = line.join(', ')
+      if curline.length + seg.length > max_line
+        lines << curline
+        line = []
+      end
+      line << seg
+    end
+    lines << line.join(', ') unless line.empty?
+    lines.join("\n")
+  end
+  
+  # --- TESTS METHODS ---
+
+  # =main=
+  # 
+  # @return true si le checked-tag se trouve dans le XML::Element
+  # Nokogiri +noko+
+  # 
+  # @param noko [Nokogiri::XML::Element] L'élément qui doit contenir le checked-tag courant
+  # 
+  def is_in?(noko)
+
+    # puts "is_in? avec noko : #{noko.inspect}".bleu
+    #
+    # Array dans lequel seront placés tous les candidats, jusqu'aux
+    # derniers
+    # 
+    founds = []
+
+    #
+    # Pour mettre les erreurs
+    # 
+
+    @errors = []
+
+    #
+    # Traitement différent en fonction du fait qu'il s'agisse d'un
+    # document Nokogiri ou d'un XML::Element Nokogiri
+    # 
+    if noko.document?
+      # 
+      # <= L'élément envoyé est un document Nokogiri
+      #    Nokogiri::HTML4/5::Document
+      # 
+      if direct_child_only?
+        noko.children.first.children.each do |child|
+          founds << child if tagname_id_class_ok?(child)
+        end
+      else       
+        founds = noko.css("//#{data[:tag]}")
+      end
+    elsif direct_child_only?
+      #
+      # Si on ne doit pas traverser toutes les générations d'éléments
+      # 
+      noko.children.each do |child|
+        founds << child if tagname_id_class_ok?(child)
+      end
+    else
+      #
+      # Si on peut traverser toutes les générations d'éléments
+      # 
+      #
+      # <= L'élément envoyé est un node (un XML::Element)
+      # => On doit chercher dans les enfants
+      # 
+      noko.traverse_children do |child|
+        # puts "child: #{child.inspect}".bleu
+        founds << child if tagname_id_class_ok?(child)
+      end
+    end
+
+    #
+    # Pour mettre toutes les sous-erreurs rencontrées
+    # 
+    @sub_errors = []
+
+    # On boucle sur les éléments trouvés.
+    # 
+    # Noter que +founds+ peut être vide, mais peu importe, on 
+    # passera simplement la boucle. C'est pour ne pas répéter le
+    # code en [1]
+    founds = founds.select do |found|
+      begin
+        check_emptiness_of(found)
+        check_containess_of(found)
+        check_attributes_of(found)
+        check_lengths_of(found)
+        # S'il n'a pas raisé jusque-là, c'est qu'il est bon
+        true
+      rescue CheckCaseError => e
+        @sub_errors << e.message
+        false
+      end
+    end
+
+    # [1] Si aucun élément n'a passé le test
+    if founds.empty?
+      if count === 0
+        return true
+      else
+        _raise(4999, count || 'un nombre indéfini')
+      end
+    end
+
+    founds_count = founds.count
+    # puts "Il en reste : #{founds_count}".bleu
+
+    # 
+    # Propriété :count
+    # 
+    if must_have_count? && ( founds_count != count )
+      _raise(5000, count, founds_count, :count)
+    end
+
+
+    # 
+    # Sinon, c'est un plein succès
+    # 
+
+
+  rescue CheckCaseError => e
+    @error = e.message
+    return false
+  else
+    return true
+  end
+
+  def tagname_id_class_ok?(child)
+    name_ok = child.node_name == tag_name
+    id_ok   = id.nil? ? true : child.id == id
+    css_ok  = css.nil? ? true : child_has_css?(child.classes, css)
+    return name_ok && id_ok && css_ok
+  end
+
+  # --
+  # -- Check précis d'un node (Nokogiri::XML::Element) trouvé
+  # -- correspond à la recherche
+  # --
+  # @note
+  #   Il existe deux sorte d'emptiness :
+  #   1. l'absence de texte (mais le node peut contenir d'autres nodes)
+  #   2. la vrai emptiness quand le node ne contient vraiment rien
+  def check_emptiness_of(found)
+    # puts "must_be_empty? #{must_be_empty?.inspect}".jaune
+    # puts "found.empty? #{found.empty?.inspect}".bleu
+    if must_be_empty? && not(found.empty?)
+      _raise(5001, nil, found.content)
+    elsif must_not_be_empty? && found.empty?
+      _raise(5002)
+    elsif must_have_no_text? && (found.has_text?)
+      _raise(5003, nil, found.text)
+    elsif must_have_text? && (found.has_no_text?)
+      _raise(5004)
+    end
+  end
+
+  def check_containess_of(found)
+    if must_have_text? && not(found.match?(text))
+      _raise(5011, text.inspect)
+    end
+    if must_have_content? && not(found.contains?(contains))
+      _raise(5010, data[:contains].inspect, found.errors.pretty_join)
+    end
+  end
+
+  # --
+  # -- Vérifie que +found+ contienne bien les attributs 
+  # -- attendu par le check
+  # --
+  def check_attributes_of(found)
+    if must_have_attributes? 
+      missing_attrs = found.attributes?(attributes)
+      if missing_attrs.empty?
+        return true # ne sert pas vraiment
+      else
+        # Il y a des attributs manquants
+        _raise(5031, missing_attrs.inspect)
+      end
+    end
+  end
+
+  # --
+  # -- Vérifie la longueur du contenu si :max_length ou 
+  # -- :min_length ont été définis
+  # --
+  def check_lengths_of(found)
+    if must_have_lengths?
+      len = found.length.freeze
+      if min_length && len < min_length
+        _raise(5032, min_length, len)
+      end
+      if max_length && len > max_length
+        _raise(5033, max_length, len)
+      end
+    end
+  end
+
+  # @return true si les +child_css+ contiennent toutes les +css+
+  # 
+  def child_has_css?(child_css, csss)
+    csss.each do |css|
+      return false if not(child_css.include?(css))
+    end
+  end
+
+
+  # -- Predicate Methods --
+
+  def direct_child_only?
+    :TRUE == @directchild ||= true_or_false((data[:direct_child_only]||data[:direct_child]) === true)    
+  end
+  def must_have_text?
+    :TRUE == @mhtxt ||= true_or_false(notext === false || not(text.nil?))
+  end
+  def must_have_no_text?
+    :TRUE == @mhnotxt ||= true_or_false(notext === true)
+  end
+  def must_be_empty?
+    :TRUE == @mbempty ||= true_or_false(empty === true)
+  end
+  def must_not_be_empty?
+    :TRUE == @mnbempty ||= true_or_false(empty === false)
+  end
+  def must_have_content?
+    :TRUE == @mhcontent ||= true_or_false(not(contains.nil?))
+  end
+  def must_have_count?
+    :TRUE == @mhcount ||= true_or_false(not(count.nil?))
+  end
+  def must_have_attributes?
+    :TRUE == @mhattrs ||= true_or_false(not(attributes.nil?))
+  end
+  def must_have_lengths?
+    :TRUE == @mhlens ||= true_or_false(not(min_length.nil? && max_length.nil?))
+  end
+
+  # -- Data Methods --
+
+  def name        ; data[:name]       end
+  def tag_name    ; @tag_name         end
+  def id          ; @id               end
+  def css         ; @css              end
+  def tag         ; data[:tag]        end
+  def text        ; data[:text]       end
+  def count       ; data[:count]      end
+  def empty       ; data[:empty]      end
+  def notext      ; data[:notext]     end
+  def contains    ; data[:contains]   end
+  def max_length  ; data[:max_length] end
+  def min_length  ; data[:min_length] end
+  def attributes  ; data[:attrs]      end
+
+  private
+
+    def _raise(errno, expected = nil, actual = nil, property = nil)
+      derror = {tag: tag, e: expected, a:actual}
+      raise CheckCaseError.new(ERRORS[errno].strip % derror)
+    end
+
+    # Méthode qui décompose la donnée :tag pour en tirer le nom
+    # de la balise (@tag_name), l'identifiant (@tag_id) et les
+    # classes css (@tag_classes)
+    def parse_tag
+      tag = data[:tag].downcase
+      found = tag.match(REG_TAG)
+      @tag_name = found[:tag_name]
+      @id   = found[:tag_id].to_s.strip
+      @id   = nil if @id.to_s.empty?
+      @css  = found[:tag_classes].to_s.split('.')
+      @css  = nil if @css.empty?
+    end
+    REG_TAG = /^(?<tag_name>[a-z_\-]+)(\#(?<tag_id>[a-z0-9_\-]+))?(\.(?<tag_classes>[a-z0-9_\-\.]+))?$/.freeze
+
+    def check_data
+      # id || css || raise(ArgumentError.new(ERRORS[1003] % {a: tag}))
+      if count
+        count.is_a?(Integer) || raise(ArgumentError.new(ERRORS[1004] % {a: count.inspect, c: count.class.name}))
+      end 
+    end
+
+
+end #/class CheckedTag
+end #/class Checker
+end #/module Lazy

data/lib/lazy/check/checked_url.rb

@@ -0,0 +1,81 @@
+#
+# Class Lazy::Checker::CheckedUrl
+# 
+# Quand c'est la redirection ou la réponse qu'il faut checker. Donc
+# quand il n'y a pas de :checks dans la définition du test.
+# 
+module Lazy
+class Checker
+class CheckedUrl
+
+  attr_reader :data
+
+  # [String] L'erreur éventuelle à écrire
+  attr_reader :error
+  
+  # Instanciation
+  # 
+  # 
+  def initialize(data)
+    @data = data
+  end
+
+  # @return les erreurs rencontrées
+  def errors
+    @errors.join("\n") + "Sous-erreurs : #{@sub_errors.join("\n")}"
+  end
+  
+  # --- TESTS METHODS ---
+
+  def check(**options)
+    urler.readit
+    if test_redirection?
+      if urler.redirection? && urler.redirect_to == data[:redirect_to]
+        reporter.add_success(self)
+      elsif urler.redirect_to.nil?
+        @error = ERRORS[5500] % {e:data[:redirect_to]}
+        reporter.add_failure(self)
+      else
+        @error = ERRORS[5501] % {a:urler.redirect_to, e:data[:redirect_to]}
+        reporter.add_failure(self)
+      end
+    elsif test_response?
+      # STDOUT.write("\nurler.rvalue = #{urler.rvalue.inspect}".jaune)
+      if urler.rvalue == data[:response]
+        reporter.add_success(self)
+      else
+        case urler.rvalue
+        when 404
+          @error = ERRORS[5503] % {e: urler.url}
+        else
+          @error = ERRORS[5502] % {a:urler.rvalue, e:data[:response]}
+        end
+        reporter.add_failure(self)
+      end
+    end
+  end
+
+
+  # -- Predicate Methods --
+
+  def test_response?
+    data.key?(:response) && not(data[:response].nil?)
+  end
+
+  def test_redirection?
+    data.key?(:redirect_to) && not(data[:redirect_to].nil?)
+  end
+
+  # -- Data Methods --
+
+  def urler     ; data[:urler]      end
+  def name      ; data[:name]       end
+  alias :message :name
+  def reporter  ; data[:reporter]   end
+
+  private
+
+
+end #/class CheckedUrl
+end #/class Checker
+end #/module Lazy

data/lib/lazy/check/checker.rb

@@ -0,0 +1,82 @@
+module Lazy
+class Checker
+
+  class RecipeError < StandardError; end
+
+  attr_reader :recipe_path
+
+  attr_reader :reporter
+
+  def initialize(recipe_path = nil)
+    recipe_path ||= File.expand_path('.', 'recipe.yaml')
+    File.exist?(recipe_path) || raise(ERRORS[200] % {path: recipe_path})
+    @recipe_path = recipe_path
+    recipe_valid?
+  end
+
+  def check(**options)
+    @options = options || {}
+    proceed_check(**options)
+  end
+
+  # = main =
+  # 
+  # La méthode (silencieuse) qui produit le check
+  # ("silencieuse" parce qu'elle ne produit que des raises)
+  def proceed_check(**options)
+    @reporter = Reporter.new(self)
+    @reporter.start
+    recipe[:tests].collect do |dtest|
+      Test.new(self, dtest)
+    end.each do |test|
+      test.check(**options)
+    end
+    @reporter.end
+    if options[:return_result]
+      return @reporter
+    else
+      @reporter.display unless no_output?
+    end
+  end
+
+  # -- Predicate Methods --
+
+  def base?
+    not(base.nil?)
+  end
+
+  def recipe_valid?
+    not(recipe.nil?)            || raise(RecipeError, ERRORS[202])
+    recipe.is_a?(Hash)          || raise(RecipeError, ERRORS[203] % {c: recipe.class.name})
+    unless recipe.key?(:name) && name.is_a?(String) && not(name.empty?)
+      raise(RecipeError, ERRORS[206])
+    end
+    recipe.key?(:tests)         || raise(RecipeError, ERRORS[204] % {ks: recipe.keys.pretty_inspect})
+    recipe[:tests].is_a?(Array) || raise(RecipeError, ERRORS[205] % {c: recipe[:tests].class.name})
+  end
+
+  def no_output?
+    @options[:output] === false
+  end
+
+  # --- Données ---
+
+  def name
+    @name ||= recipe[:name]
+  end
+
+  # [String] La base pour l'url
+  def base
+    @base ||= recipe[:base]
+  end
+
+  # [Hash] Les données de la recette, ou simplement "la recette"
+  # 
+  def recipe
+    @recipe ||= YAML.safe_load(File.read(recipe_path), **YAML_OPTIONS)
+  end
+  alias :data :recipe
+
+
+end #/class Checker
+end #/module Lazy

data/lib/lazy/check/checker_case.rb

@@ -0,0 +1,111 @@
+#
+# Un cas de test
+# --------------
+# 
+# C'est un cas absolument unique, par exemple on cherche :
+# 
+#   Un div d'identifiant #mondiv qui n'est pas vide
+# ou
+#   Un div d'identifiant #mondiv qui contient le texte "Coucou"
+# ou
+#   Un div d'identifiant #mondiv qui contient une balise <li>
+# *MAIS*
+#   pas les trois en même temps, même s'ils sont définis dans le
+#   même 'check'
+# 
+module Lazy
+class Checker
+class CheckCase
+
+  attr_reader :urler
+  attr_reader :data
+  attr_reader :reporter
+
+  # Instanciation d'un cas de test
+  # 
+  # @param urler [Hash] Checker::Url parsé à utiliser
+  # 
+  # @param data [Hash]  Les données du check, tels que définis dans
+  #                     la recette du test. Sera transformé en une
+  #                     CheckedTag
+  # 
+  #   :tag          [String] [Requis] La balise, l'identifiant et les classes. Par exemple "div#mondiv.maclasse.autreclasse"
+  #   :count        [Integer] Nombre d'éléments à trouver
+  #   :empty        [Boolean] true si doit être vide, false si ne doit pas être vide
+  #   :direct_child [Boolean] true si doit être un enfant direct (mais sert plutôt pour les sous-éléments à checker)
+  #   :attrs        [Hash]    Attributs à trouver
+  #   :contains     [Array|String] Ce que doit contenir le noeud
+  # 
+  def initialize(urler, data, reporter = nil)
+    urler.is_a?(Lazy::Checker::Url) || raise(ArgumentError.new(ERRORS[1000] % {a:urler,c:urler.class.name}))
+    @data   = data
+    check_data
+    @urler  = urler
+    @reporter = reporter
+  end
+
+  # La nouvelle façon de checker
+  def check
+    ctag = CheckedTag.new(data)
+    if ctag.is_in?(noko)
+      # reporter.add_success(self) if reporter
+      reporter.add_success(ctag) if reporter
+      return true
+    else
+      # reporter.add_failure(self) if reporter
+      reporter.add_failure(ctag) if reporter
+      return false
+    end
+  end
+
+  # -- Data / Predicate de check --
+
+  # -- Données / Predicate utiles pour checker --
+  # (noter que toutes ces valeurs ne sont estimées que si elles
+  #  sont utilisées)
+
+  # @return true si la balise contient quelque chose
+  def has_content?
+    not(content.empty?)
+  end
+
+  # @return true si la balise ne contient rien
+  def not_has_content?
+    content.empty?
+  end
+
+  # @return le contenu de la balise, sous forme de string
+  # 
+  def content
+    tag.content
+  end
+
+
+  # -- Données du Case --
+
+  def tag
+    data[:tag]
+  end
+
+  def noko
+    @noko ||= urler.nokogiri
+  end
+
+  attr_reader :debug
+
+  private 
+
+    #
+    # Vérification de la donnée de check transmise à l'instanciation
+    # 
+    # @note
+    #   C'est elle qui va servir à l'instanciation du CheckedTag
+    # 
+    def check_data
+      data.is_a?(Hash)  || raise(ArgumentError.new(ERRORS[1001] % {a: data, c:data.class.name}))
+      data.key?(:tag)   || raise(ArgumentError.new(ERRORS[1002] % {ks: data.keys.collect{|k|":#{k}"}.join(', ')}))
+    end
+
+end #/class CheckCase
+end #/class Checker
+end #/module Lazy

data/lib/lazy/check/checker_code.rb

@@ -0,0 +1,108 @@
+#
+# Lazy::Checker::Code
+# -------------------
+# Classe pour utiliser Lazy::Check directement avec du code, sans
+# passer par une URL ou une recette
+# 
+# @usage
+# 
+#   Lazy::Checker.check(<code html>, {<rechercher>})
+# 
+module Lazy
+class Checker
+  class << self
+    
+    # = main =
+    # 
+    # Pour une utilisation du gem avec :
+    # 
+    #   Lazy::Checker.check(<code XML>, {<données check>})
+    # 
+    # … qui produit un rapport.
+    # 
+    # Les données check doivent être conformes, c'est-à-dire contenir
+    # au moins la propriété :tag qui définit une balise à trouver 
+    # dans le code XML.
+    # 
+    # @param options [Hash] Cf. Lazy::Checker::Code#check_against
+    # 
+    def check(xml_code, data_check, **options)
+      @xml_code   = check_xml_code(xml_code)
+      @data_check = check_data_check(data_check)
+      checker = Lazy::Checker::Code.new(@xml_code)
+      checker.check_against(@data_check, **options)
+    end
+
+
+    private
+
+      # Méthode qui vérifie la conformité de la donnée
+      def check_xml_code(xml)
+        xml                   || raise(ArgumentError, ERRORS[6003])
+        xml.is_a?(String)     || raise(ArgumentError, ERRORS[6001] % {c: xml.class.name, a: xml.inspect})
+        xml = is_rooted?(xml) || raise(ArgumentError, ERRORS[6002] % {a: xml.inspect})
+        return xml
+      rescue ArgumentError => e
+        raise ArgumentError.new(ERRORS[6000] % {se: e.message})
+      end
+
+      def is_rooted?(xml_ini)
+        xml = xml_ini.dup
+        xml = xml.gsub(/\r?\n/,'')
+        xml = xml.gsub(/^<\?xml version.+\?>/,'')
+        xml = xml.strip
+        if xml.match?(REG_ROOT)
+          return xml
+        else
+          return nil
+        end
+      end
+
+      REG_ROOT = /^<([a-zA-Z0-9:\-_]+)( .+?)?>.*<\/\1>$/.freeze
+
+      # Méthode qui s'assure que les données de check (choses à
+      # vérifier) est valide
+      def check_data_check(dch)
+        dch                   || raise(ArgumentError, ERRORS[6003])
+        dch.is_a?(Hash)       || raise(ArgumentError, ERRORS[6011] % {c: dch.class.name, a: dch.inspect})
+        dch.key?(:tag)        || raise(ArgumentError, ERRORS[1002] % {ks: dch.keys.pretty_join})
+        return dch
+      rescue ArgumentError => e
+        raise ArgumentError.new(ERRORS[6010] % {se: e.message})
+      end
+  end #/<< self
+
+  class Code
+
+    attr_reader :urler
+
+    # Le rapport courant (pour pouvoir être modifié en cours
+    # de test)
+    attr_reader :report
+
+    def initialize(xml_code)
+      @xml_code = xml_code
+      @urler = Checker::Url.new(xml_code)
+    end
+
+    # Méthode qui procède au check
+    # 
+    # @param options [Hash] 
+    #   :return_result   Si true, on retourne les données au lieu de les afficher
+    # 
+    def check_against(data_check, **options)
+      @report = Reporter.new(self)
+      @report.start
+      check_case = Checker::CheckCase.new(urler, data_check, @report)
+      check_case.check
+      @report.end
+      if options[:return_result]
+        return report
+      else
+        report.display
+      end
+    end
+
+  end #/class Code
+end #/class Checker
+end #/module Lazy