prism_checker 0.0.1

data/lib/prism_checker/check_dispatcher.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative 'item_classifier'
+require_relative 'expectation_classifier'
+require_relative 'item_checker/array'
+require_relative 'item_checker/element'
+require_relative 'item_checker/elements'
+require_relative 'item_checker/image'
+require_relative 'item_checker/input'
+require_relative 'item_checker/checkbox'
+require_relative 'item_checker/any'
+require_relative 'item_checker/page'
+require_relative 'item_checker/string'
+require_relative 'item_checker/textarea'
+require_relative 'item_checker/nil'
+require_relative 'node/bad_expectation'
+
+module PrismChecker
+  class CheckDispatcher
+    @check_map = {
+      page: {
+        string: [ItemChecker::Page::Loaded, ItemChecker::Page::String],
+        regexp: [ItemChecker::Page::Loaded, ItemChecker::Page::Regexp],
+        hash: [ItemChecker::Page::Loaded]
+      },
+
+      section: {
+        string: [ItemChecker::Element::Visible, ItemChecker::Element::String],
+        empty: [ItemChecker::Element::Visible, ItemChecker::Element::Empty],
+        regexp: [ItemChecker::Element::Visible, ItemChecker::Element::Regexp],
+        hash: [ItemChecker::Element::Visible],
+        visible: [ItemChecker::Element::Visible],
+        invisible: [ItemChecker::Element::Invisible]
+      },
+
+      sections: {
+        string: [ItemChecker::Elements::String],
+        regexp: [ItemChecker::Elements::Regexp],
+        array: [ItemChecker::Elements::Array],
+        number: [ItemChecker::Elements::Number]
+      },
+
+      element: {
+        string: [ItemChecker::Element::Visible, ItemChecker::Element::String],
+        empty: [ItemChecker::Element::Visible, ItemChecker::Element::Empty],
+        regexp: [ItemChecker::Element::Visible, ItemChecker::Element::Regexp],
+        hash: [ItemChecker::Element::Visible],
+        visible: [ItemChecker::Element::Visible],
+        invisible: [ItemChecker::Element::Invisible]
+      },
+
+      elements: {
+        string: [ItemChecker::Elements::String],
+        empty: [ItemChecker::Elements::Empty],
+        regexp: [ItemChecker::Elements::Regexp],
+        array: [ItemChecker::Elements::Array],
+        number: [ItemChecker::Elements::Number]
+      },
+
+      image: {
+        string: [ItemChecker::Element::Visible, ItemChecker::Image::String],
+        regexp: [ItemChecker::Element::Visible, ItemChecker::Image::Regexp],
+        hash: [ItemChecker::Element::Visible],
+        visible: [ItemChecker::Element::Visible],
+        invisible: [ItemChecker::Element::Invisible]
+      },
+
+      input: {
+        string: [ItemChecker::Element::Visible, ItemChecker::Input::String],
+        empty: [ItemChecker::Element::Visible, ItemChecker::Input::Empty],
+        regexp: [ItemChecker::Element::Visible, ItemChecker::Input::Regexp],
+        hash: [ItemChecker::Element::Visible],
+        visible: [ItemChecker::Element::Visible],
+        invisible: [ItemChecker::Element::Invisible]
+      },
+
+      textarea: {
+        string: [ItemChecker::Element::Visible, ItemChecker::Textarea::String],
+        empty: [ItemChecker::Element::Visible, ItemChecker::Textarea::Empty],
+        regexp: [ItemChecker::Element::Visible, ItemChecker::Textarea::Regexp],
+        hash: [ItemChecker::Element::Visible],
+        visible: [ItemChecker::Element::Visible],
+        invisible: [ItemChecker::Element::Invisible]
+      },
+
+      select: {
+        string: [ItemChecker::Element::Visible, ItemChecker::Input::String],
+        empty: [ItemChecker::Element::Visible, ItemChecker::Input::Empty],
+        regexp: [ItemChecker::Element::Visible, ItemChecker::Input::Regexp],
+        hash: [ItemChecker::Element::Visible],
+        visible: [ItemChecker::Element::Visible],
+        invisible: [ItemChecker::Element::Invisible]
+      },
+
+      checkbox: {
+        hash: [ItemChecker::Element::Visible],
+        visible: [ItemChecker::Element::Visible],
+        invisible: [ItemChecker::Element::Invisible],
+        boolean: [ItemChecker::Element::Visible, ItemChecker::Checkbox::Boolean]
+      },
+
+      radio: {
+        string: [ItemChecker::Element::Visible, ItemChecker::Input::String],
+        regexp: [ItemChecker::Element::Visible, ItemChecker::Input::Regexp],
+        hash: [ItemChecker::Element::Visible],
+        visible: [ItemChecker::Element::Visible],
+        invisible: [ItemChecker::Element::Invisible],
+        boolean: [ItemChecker::Element::Visible, ItemChecker::Checkbox::Boolean]
+      },
+
+      array: {
+        string: [ItemChecker::Array::String],
+        empty: [ItemChecker::Array::String],
+        regexp: [ItemChecker::Array::Regexp],
+        number: [ItemChecker::Elements::Number]
+      },
+
+      boolean: {
+        boolean: [ItemChecker::Any::Any]
+      },
+
+      number: {
+        number: [ItemChecker::Any::Any]
+      },
+
+      string: {
+        string: [ItemChecker::String::String],
+        empty: [ItemChecker::String::Empty],
+        regexp: [ItemChecker::String::Regexp]
+      },
+
+      nil: {
+        string: [ItemChecker::Nil::String],
+        regexp: [ItemChecker::Nil::Regexp]
+      }
+    }
+
+    def self.checkers(_node, element, expectation, item_type)
+      expectation_type = ExpectationClassifier.classify(expectation)
+
+      element_expectations = @check_map[item_type]
+
+      raise_bad_element(element) unless element_expectations
+
+      checkers = element_expectations[expectation_type]
+
+      raise_bad_expectation(element, expectation) unless checkers
+
+      checkers
+    end
+
+    def self.raise_bad_element(element)
+      error = "Don't know how to check #{element.class.name}"
+      raise Node::BadExpectation, error
+    end
+
+    def self.raise_bad_expectation(element, expectation)
+      element_class = element.class.name || element.class.ancestors.map(&:name).compact.first || '<Unknown>'
+      error = "Don't know how to compare #{element_class} with #{expectation.class.name}"
+      raise Node::BadExpectation, error
+    end
+
+    def self.add(element_type, check_type, checks)
+      @check_map[element_type] ||= {}
+      @check_map[element_type][check_type] = checks
+    end
+  end
+end

data/lib/prism_checker/checker.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'node/hash'
+require_relative 'node/array'
+require_relative 'node/expectation'
+require_relative 'report_builder'
+
+module PrismChecker
+  class Checker
+    attr_reader :item, :root, :result
+
+    def initialize
+      @item = nil
+      @expectation = nil
+      @root = nil
+      @result = nil
+    end
+
+    def check(item, expectation)
+      prepare(item, expectation)
+
+      walk_through do |node|
+        node.check
+      end
+
+      @result = true
+    rescue Node::CheckFail
+      # puts report
+      @result = false
+      # rescue Node::BadExpectation => e
+      #   # raise
+      #   raise e.class, report + "\n" + e.message
+    rescue StandardError => e
+      # puts '---------------------'
+      # puts e.class
+      # puts e.message
+      # pp e.backtrace
+      # puts '---------------------'
+      raise e.class, report + "\n" + e.message
+    end
+
+    def report
+      ReportBuilder.new(@root).build
+    end
+
+    private
+
+    def walk_through(&block)
+      @root.walk_through(&block)
+    end
+
+    def build_node(expectation, parent, key)
+      klass = case expectation
+              when Hash then Node::Hash
+              when Array then Node::Array
+              else Node::Expectation
+              end
+
+      klass.new(self, parent, key, expectation)
+    end
+
+    def prepare(item, expectation)
+      @item = item
+      @expectation = expectation
+      @root = build_node(expectation, self, :root)
+
+      build_tree(expectation, @root)
+    end
+
+    def build_tree(expectation, parent)
+      enumerator = case expectation
+                   when Hash then expectation.each_key
+                   when Array then expectation.each_index
+                   else return
+                   end
+
+      enumerator.each do |key|
+        child = parent.add_child(key, build_node(expectation[key], parent, key))
+        build_tree(expectation[key], child)
+      end
+    end
+  end
+end

data/lib/prism_checker/colorizer.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  class Colorizer
+    def self.colorize(text, _code)
+      text
+    end
+  end
+end

data/lib/prism_checker/config.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'colorizer'
+
+module PrismChecker
+  class Config
+    attr_accessor :string_comparison, :colorizer
+
+    def initialize
+      @string_comparison = :inclusion
+      @colorizer = PrismChecker::Colorizer
+    end
+  end
+end

data/lib/prism_checker/element_wrapper.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'prism_checker/item_classifier'
+
+module PrismChecker
+  class ElementWrapper
+    def initialize(element)
+      @element = element
+    end
+
+    def class
+      @element[:class]
+    end
+
+    def checked
+      @element.checked?
+    end
+
+    def disabled
+      @element.disabled?
+    end
+
+    def multiple
+      @element.multiple?
+    end
+
+    def readonly
+      @element.readonly?
+    end
+
+    def selected
+      @element.selected?
+    end
+
+    def method_missing(method, *args)
+      if @element.respond_to?(method)
+        return @element.send(method, *args)
+      end
+
+      # if (ItemClassifier.element_checkbox?(@element) || ItemClassifier.element_radio?(@element)) && method == :checked
+      #   return @element.checked?
+      # end
+
+      ret = @element[method]
+
+      if ret.nil? && !method.start_with?('data-')
+        # return '' if method.start_with?('data-')
+
+        raise NoMethodError, "unknown attribute '#{method}'"
+      end
+
+      ret
+    end
+
+    def respond_to_missing?(*_args)
+      true
+    end
+  end
+end

data/lib/prism_checker/expectation_classifier.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  class ExpectationClassifier
+    @expectations_map = [
+      %i[invisible invisible?],
+      %i[visible visible?],
+      %i[empty empty?],
+      %i[string string?],
+      %i[regexp regexp?],
+      %i[array array?],
+      %i[hash hash?],
+      %i[boolean boolean?],
+      %i[number number?]
+    ]
+
+    def self.classify(expectation)
+      @expectations_map.each do |data|
+        type = data[0]
+        probe = data[1]
+        if probe.is_a? Symbol
+          return type if send(probe, expectation)
+        elsif probe.call(expectation)
+          return type
+        end
+      end
+
+      :other
+    end
+
+    def self.invisible?(expectation)
+      expectation == :invisible
+    end
+
+    def self.visible?(expectation)
+      expectation == :visible
+    end
+
+    def self.empty?(expectation)
+      expectation == :empty
+    end
+
+    def self.string?(expectation)
+      expectation.is_a?(String)
+    end
+
+    def self.regexp?(expectation)
+      expectation.is_a?(Regexp)
+    end
+
+    def self.array?(expectation)
+      expectation.is_a?(Array)
+    end
+
+    def self.hash?(expectation)
+      expectation.is_a?(Hash)
+    end
+
+    def self.boolean?(expectation)
+      expectation.is_a?(TrueClass) || expectation.is_a?(FalseClass)
+    end
+
+    def self.number?(expectation)
+      expectation.is_a?(Integer)
+    end
+
+    def self.add(type, probe, position = 0)
+      @expectations_map.insert(position, [type, probe])
+    end
+  end
+end

data/lib/prism_checker/item_checker/any.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'item_check/string'
+require_relative 'item_check/regexp'
+require_relative 'item_value/elements'
+
+module PrismChecker
+  module ItemChecker
+    module Any
+      class Any
+        def self.value(value)
+          value
+        end
+
+        def self.check(_checkbox, value, expectation)
+          value == expectation
+        end
+
+        def self.error_message(_checkbox, value, expectation)
+          "Expected: #{expectation}\nGot: #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/array.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'item_check/string'
+require_relative 'item_check/regexp'
+require_relative 'item_check/empty_array'
+require_relative 'item_value/array'
+
+module PrismChecker
+  module ItemChecker
+    module Array
+      class String
+        extend ItemValue::Array
+        extend ItemCheck::String
+      end
+
+      class Empty
+        extend ItemValue::Array
+        extend ItemCheck::EmptyArray
+      end
+
+      class Regexp
+        extend ItemValue::Array
+        extend ItemCheck::Regexp
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/checkbox.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'item_check/string'
+require_relative 'item_check/regexp'
+require_relative 'item_value/elements'
+
+module PrismChecker
+  module ItemChecker
+    module Checkbox
+      class Boolean
+        def self.value(checkbox)
+          checkbox.checked?
+        end
+
+        def self.check(_checkbox, value, expectation)
+          value == expectation
+        end
+
+        def self.error_message(_checkbox, value, expectation)
+          if expectation
+            'Expected to be checked'
+          else
+            'Expected to be unchecked'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/element.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'item_value/element'
+require_relative 'item_check/regexp'
+require_relative 'item_check/string'
+require_relative 'item_check/empty'
+
+module PrismChecker
+  module ItemChecker
+    module Element
+
+      class String
+        extend ItemValue::Element
+        extend ItemCheck::String
+      end
+
+      class Empty
+        extend ItemValue::Element
+        extend ItemCheck::Empty
+      end
+
+      class Regexp
+        extend ItemValue::Element
+        extend ItemCheck::Regexp
+      end
+
+      class Visible
+        def self.value(_element); end
+
+        def self.check(element, _value, _expectation)
+          element.visible?
+        end
+
+        def self.error_message(_element, _value, _expectation)
+          'Element is not visible'
+        end
+      end
+
+      class Invisible
+        def self.value(_element); end
+
+        def self.check(element, _value, _expectation)
+          !element.visible?
+        end
+
+        def self.error_message(_element, _value, _expectation)
+          'Element is visible'
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/elements.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'item_check/string'
+require_relative 'item_check/regexp'
+require_relative 'item_check/number'
+require_relative 'item_check/empty_array'
+require_relative 'item_value/elements'
+
+module PrismChecker
+  module ItemChecker
+    module Elements
+      class String
+        extend ItemValue::Elements
+        extend ItemCheck::String
+      end
+
+      class Regexp
+        extend ItemValue::Elements
+        extend ItemCheck::Regexp
+      end
+
+      class Array
+        def self.value(elements)
+          elements
+        end
+
+        def self.check(elements, _value, expectation)
+          elements.size == expectation.size
+        end
+
+        def self.error_message(elements, _value, expectation)
+          "Wrong elements count\nActual: #{elements.size}\nExpected: #{expectation.size}"
+        end
+      end
+
+      class Number
+        def self.value(elements)
+          elements.size
+        end
+
+        extend ItemCheck::Number
+      end
+
+      class Empty
+        def self.value(elements)
+          elements
+        end
+
+        extend ItemCheck::EmptyArray
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/image.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'item_value/element'
+require_relative 'item_value/image'
+require_relative 'item_check/regexp'
+require_relative 'item_check/string'
+
+module PrismChecker
+  module ItemChecker
+    module Image
+      class String
+        extend ItemValue::Image
+        extend ItemCheck::String
+      end
+
+      class Regexp
+        extend ItemValue::Image
+        extend ItemCheck::Regexp
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/input.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'item_value/input'
+require_relative 'item_check/string'
+require_relative 'item_check/empty'
+require_relative 'item_check/regexp'
+
+module PrismChecker
+  module ItemChecker
+    module Input
+      class String
+        extend ItemValue::Input
+        extend ItemCheck::String
+      end
+
+      class Empty
+        extend ItemValue::Input
+        extend ItemCheck::Empty
+      end
+
+      class Regexp
+        extend ItemValue::Input
+        extend ItemCheck::Regexp
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_check/empty.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemCheck
+      module Empty
+        def check(_element, value, _expectation)
+          value.empty?
+        end
+
+        def error_message(_element, value, _expectation)
+          "Expected '#{value}' to be empty"
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_check/empty_array.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemCheck
+      module EmptyArray
+        def check(_element, value, _expectation)
+          value.empty?
+        end
+
+        def error_message(_element, _value, _expectation)
+          'Expected to be empty'
+        end
+      end
+    end
+  end
+end

data/lib/prism_checker/item_checker/item_check/number.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module PrismChecker
+  module ItemChecker
+    module ItemCheck
+      module Number
+        def check(_elements, value, expectation)
+          value == expectation
+        end
+
+        def error_message(_elements, value, expectation)
+          "Wrong elements count\nActual: #{value}\nExpected: #{expectation}"
+        end
+      end
+    end
+  end
+end