hatemile 2.0

data/lib/hatemile/helper.rb

@@ -0,0 +1,58 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+##
+# The Hatemile module contains the interfaces with the acessibility solutions.
+module Hatemile
+  ##
+  # Helper methods of HaTeMiLe for Ruby.
+  module Helper
+    ##
+    # Error class for nil arguments.
+    class NotNilError < StandardError; end
+
+    ##
+    # Checks that the specified objects references is not nil and throws a
+    # TypeError if it is.
+    #
+    # @param values [Array<Object>] The objects.
+    # @return [void]
+    def self.require_not_nil(*values)
+      values.each do |value|
+        if value.nil?
+          raise NotNilError.new('The value of parameter not be nil.')
+        end
+      end
+    end
+
+    ##
+    # Checks that the specified object reference is instance of classes and
+    # TypeError
+    #
+    # @param value [Object] The object.
+    # @param classes [Array<Class>] The classes.
+    # @return [void]
+    def self.require_valid_type(value, *classes)
+      return if value.nil?
+
+      valid = false
+      classes.each do |auxiliar_class|
+        if value.is_a?(auxiliar_class)
+          valid = true
+          break
+        end
+      end
+
+      raise TypeError.new('Wrong type of argument.') unless valid
+    end
+  end
+end

data/lib/hatemile/implementation/accessible_association_implementation.rb

@@ -0,0 +1,346 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require File.join(
+  File.dirname(File.dirname(__FILE__)),
+  'accessible_association'
+)
+require File.join(File.dirname(File.dirname(__FILE__)), 'helper')
+require File.join(
+  File.dirname(File.dirname(__FILE__)),
+  'util',
+  'common_functions'
+)
+require File.join(File.dirname(File.dirname(__FILE__)), 'util', 'id_generator')
+require File.join(
+  File.dirname(File.dirname(__FILE__)),
+  'util',
+  'html',
+  'html_dom_parser'
+)
+
+##
+# The Hatemile module contains the interfaces with the acessibility solutions.
+module Hatemile
+  ##
+  # The Hatemile::Implementation module contains the official implementation of
+  # interfaces solutions.
+  module Implementation
+    ##
+    # The AccessibleAssociationImplementation class is official implementation
+    # of AccessibleAssociation.
+    class AccessibleAssociationImplementation < AccessibleAssociation
+      public_class_method :new
+
+      protected
+
+      ##
+      # Returns a list that represents the table.
+      #
+      # @param part [Hatemile::Util::Html::HTMLDOMElement] The table header,
+      #   table footer or table body.
+      # @return [Array<Array<Hatemile::Util::Html::HTMLDOMElement>>] The list
+      #   that represents the table.
+      def get_model_table(part)
+        rows = @parser.find(part).find_children('tr').list_results
+        table = []
+        rows.each do |row|
+          table.push(
+            get_model_row(@parser.find(row).find_children('td,th').list_results)
+          )
+        end
+        get_valid_model_table(table)
+      end
+
+      ##
+      # Returns a list that represents the table with the rowspans.
+      #
+      # @param table [Array<Array<Hatemile::Util::Html::HTMLDOMElement>>] The
+      #   list that represents the table without the rowspans.
+      # @return [Array<Array<Hatemile::Util::Html::HTMLDOMElement>>] The list
+      #   that represents the table with the rowspans.
+      def get_valid_model_table(table)
+        new_table = []
+        unless table.empty?
+          length_table = table.size
+          (0..length_table - 1).each do |row_index|
+            cells_added = 0
+            original_row = [].concat(table[row_index])
+            new_table[row_index] = [] if new_table.size <= row_index
+            length_row = original_row.size
+            (0..length_row - 1).each do |cell_index|
+              cell = original_row[cell_index]
+              new_cell_index = cell_index + cells_added
+              new_row = new_table[row_index]
+              until new_row[new_cell_index].nil?
+                cells_added += 1
+                new_cell_index = cell_index + cells_added
+              end
+              new_row[new_cell_index] = cell
+
+              next unless cell.has_attribute?('rowspan')
+
+              rowspan = cell.get_attribute('rowspan').to_i
+
+              next unless rowspan > 1
+
+              (1..rowspan - 1).each do |rowspan_index|
+                new_row_index = row_index + rowspan_index
+                new_table[new_row_index] = [] if new_table[new_row_index].nil?
+                new_table[new_row_index][new_cell_index] = cell
+              end
+            end
+          end
+        end
+        new_table
+      end
+
+      ##
+      # Returns a list that represents the line of table with the colspans.
+      #
+      # @param row [Array<Hatemile::Util::Html::HTMLDOMElement>] The list that
+      #   represents the line of table without the colspans.
+      # @return [Array<Hatemile::Util::Html::HTMLDOMElement>] The list that
+      #   represents the line of table with the colspans.
+      def get_model_row(row)
+        new_row = [].concat(row)
+        size = row.size
+        (0..size - 1).each do |i|
+          cell = row[i]
+
+          next unless cell.has_attribute?('colspan')
+
+          colspan = cell.get_attribute('colspan').to_i
+
+          next unless colspan > 1
+
+          (1..colspan - 1).each do |j|
+            new_row.insert(i + j, cell)
+          end
+        end
+        new_row
+      end
+
+      ##
+      # Validate the list that represents the table header.
+      #
+      # @param header [Array<Array<Hatemile::Util::Html::HTMLDOMElement>>] The
+      #   list that represents the table header.
+      # @return [Boolean] True if the table header is valid or false if the
+      #   table header is not valid.
+      def valid_header?(header)
+        return false if header.empty?
+        length = -1
+        header.each do |row|
+          return false if row.empty?
+          length = row.size if length == -1
+          return false if row.size != length
+        end
+        true
+      end
+
+      ##
+      # Returns a list with ids of rows of same column.
+      #
+      # @param header [Array<Array<Hatemile::Util::Html::HTMLDOMElement>>] The
+      #   list that represents the table header.
+      # @param index [Integer] The index of columns.
+      # @return [Array<String>] The list with ids of rows of same column.
+      def get_cells_headers_ids(header, index)
+        ids = []
+        header.each do |row|
+          if row[index].has_attribute?('scope') &&
+             row[index].get_attribute('scope') == 'col'
+            ids.push(row[index].get_attribute('id'))
+          end
+        end
+        ids
+      end
+
+      ##
+      # Associate the data cell with header cell of row.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The table body or
+      #   table footer.
+      # @return [void]
+      def associate_data_cells_with_header_cells_of_row(element)
+        table = get_model_table(element)
+        headers_ids = []
+        table.each do |row|
+          headers_ids.clear
+          row.each do |cell|
+            next unless cell.get_tag_name == 'TH' &&
+                        Hatemile::Util::CommonFunctions.is_valid_element?(cell)
+
+            @id_generator.generate_id(cell)
+            headers_ids.push(cell.get_attribute('id'))
+            cell.set_attribute('scope', 'row')
+          end
+
+          next if headers_ids.empty?
+
+          row.each do |cell|
+            next unless cell.get_tag_name == 'TD' &&
+                        Hatemile::Util::CommonFunctions.is_valid_element?(cell)
+
+            headers = cell.get_attribute('headers')
+            headers_ids.each do |header_id|
+              headers = Hatemile::Util::CommonFunctions.increase_in_list(
+                headers,
+                header_id
+              )
+            end
+            cell.set_attribute('headers', headers)
+          end
+        end
+      end
+
+      ##
+      # Set the scope of header cells of table header.
+      #
+      # @param table_header [Hatemile::Util::Html::HTMLDOMElement] The table
+      #   header.
+      # @return [void]
+      def prepare_header_cells(table_header)
+        cells = @parser.find(table_header).find_children('tr').find_children(
+          'th'
+        ).list_results
+        cells.each do |cell|
+          next unless Hatemile::Util::CommonFunctions.is_valid_element?(cell)
+
+          @id_generator.generate_id(cell)
+          cell.set_attribute('scope', 'col')
+        end
+      end
+
+      public
+
+      ##
+      # Initializes a new object that improve the accessibility of associations
+      # of parser.
+      #
+      # @param parser [Hatemile::Util::Html::HTMLDOMParser] The HTML parser.
+      def initialize(parser)
+        Hatemile::Helper.require_not_nil(parser)
+        Hatemile::Helper.require_valid_type(
+          parser,
+          Hatemile::Util::Html::HTMLDOMParser
+        )
+
+        @parser = parser
+        @id_generator = Hatemile::Util::IDGenerator.new('association')
+      end
+
+      ##
+      # @see Hatemile::AccessibleAssociation#associate_data_cells_with_header_cells
+      def associate_data_cells_with_header_cells(table)
+        header = @parser.find(table).find_children('thead').first_result
+        body = @parser.find(table).find_children('tbody').first_result
+        footer = @parser.find(table).find_children('tfoot').first_result
+        unless header.nil?
+          prepare_header_cells(header)
+
+          header_rows = get_model_table(header)
+          if !body.nil? && valid_header?(header_rows)
+            length_header = header_rows.first.size
+            fake_table = get_model_table(body)
+            unless footer.nil?
+              fake_table = fake_table.concat(get_model_table(footer))
+            end
+            fake_table.each do |row|
+              next unless row.size == length_header
+
+              row.each_with_index do |cell, index|
+                unless Hatemile::Util::CommonFunctions.is_valid_element?(cell)
+                  next
+                end
+
+                headers_ids = get_cells_headers_ids(header_rows, index)
+                headers = cell.get_attribute('headers')
+                headers_ids.each do |headers_id|
+                  headers = Hatemile::Util::CommonFunctions.increase_in_list(
+                    headers,
+                    headers_id
+                  )
+                end
+                cell.set_attribute('headers', headers)
+              end
+            end
+          end
+        end
+        associate_data_cells_with_header_cells_of_row(body) unless body.nil?
+        associate_data_cells_with_header_cells_of_row(footer) unless footer.nil?
+      end
+
+      ##
+      # @see Hatemile::AccessibleAssociation#associate_all_data_cells_with_header_cells
+      def associate_all_data_cells_with_header_cells
+        tables = @parser.find('table').list_results
+        tables.each do |table|
+          if Hatemile::Util::CommonFunctions.is_valid_element?(table)
+            associate_data_cells_with_header_cells(table)
+          end
+        end
+      end
+
+      ##
+      # @see Hatemile::AccessibleAssociation#associate_label_with_field
+      def associate_label_with_field(label)
+        return unless label.get_tag_name == 'LABEL'
+
+        if label.has_attribute?('for')
+          field = @parser.find("##{label.get_attribute('for')}").first_result
+        else
+          field = @parser.find(label).find_descendants(
+            'input,select,textarea'
+          ).first_result
+
+          unless field.nil? ||
+                 !Hatemile::Util::CommonFunctions.is_valid_element?(field)
+            @id_generator.generate_id(field)
+            label.set_attribute('for', field.get_attribute('id'))
+          end
+        end
+
+        return if field.nil?
+        return unless Hatemile::Util::CommonFunctions.is_valid_element?(field)
+
+        unless field.has_attribute?('aria-label')
+          field.set_attribute(
+            'aria-label',
+            label.get_text_content.gsub(/[ \n\r\t]+/, ' ').strip
+          )
+        end
+
+        @id_generator.generate_id(label)
+        field.set_attribute(
+          'aria-labelledby',
+          Hatemile::Util::CommonFunctions.increase_in_list(
+            field.get_attribute('aria-labelledby'),
+            label.get_attribute('id')
+          )
+        )
+      end
+
+      ##
+      # @see Hatemile::AccessibleAssociation#associate_all_labels_with_fields
+      def associate_all_labels_with_fields
+        labels = @parser.find('label').list_results
+        labels.each do |label|
+          if Hatemile::Util::CommonFunctions.is_valid_element?(label)
+            associate_label_with_field(label)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hatemile/implementation/accessible_css_implementation.rb

@@ -0,0 +1,772 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require File.join(File.dirname(File.dirname(__FILE__)), 'accessible_css')
+require File.join(File.dirname(File.dirname(__FILE__)), 'helper')
+require File.join(
+  File.dirname(File.dirname(__FILE__)),
+  'util',
+  'common_functions'
+)
+require File.join(File.dirname(File.dirname(__FILE__)), 'util', 'configure')
+require File.join(File.dirname(File.dirname(__FILE__)), 'util', 'id_generator')
+require File.join(
+  File.dirname(File.dirname(__FILE__)),
+  'util',
+  'css',
+  'style_sheet_parser'
+)
+require File.join(
+  File.dirname(File.dirname(__FILE__)),
+  'util',
+  'html',
+  'html_dom_parser'
+)
+require File.join(
+  File.dirname(File.dirname(__FILE__)),
+  'util',
+  'html',
+  'html_dom_text_node'
+)
+
+##
+# The Hatemile module contains the interfaces with the acessibility solutions.
+module Hatemile
+  ##
+  # The Hatemile::Implementation module contains the official implementation of
+  # interfaces solutions.
+  module Implementation
+    ##
+    # The AccessibleCSSImplementation class is official implementation of
+    # AccessibleCSS.
+    class AccessibleCSSImplementation < AccessibleCSS
+      public_class_method :new
+
+      ##
+      # The name of attribute for identify isolator elements.
+      DATA_ISOLATOR_ELEMENT = 'data-auxiliarspan'.freeze
+
+      ##
+      # The name of attribute for identify the element created or modified to
+      # support speak property.
+      DATA_SPEAK = 'data-cssspeak'.freeze
+
+      ##
+      # The name of attribute for identify the element created or modified to
+      # support speak-as property.
+      DATA_SPEAK_AS = 'data-cssspeakas'.freeze
+
+      ##
+      # The valid element tags for inherit the speak and speak-as properties.
+      VALID_INHERIT_TAGS = %w[
+        SPAN A RT DFN ABBR Q CITE EM TIME VAR SAMP I B SUB SUP SMALL STRONG
+        MARK RUBY INS DEL KBD BDO CODE P FIGCAPTION FIGURE PRE DIV OL UL LI
+        BLOCKQUOTE DL DT DD FIELDSET LEGEND LABEL FORM BODY ASIDE ADDRESS H1 H2
+        H3 H4 H5 H6 SECTION HEADER NAV ARTICLE FOOTER HGROUP CAPTION SUMMARY
+        DETAILS TABLE TR TD TH TBODY THEAD TFOOT
+      ].freeze
+
+      ##
+      # The valid element tags for speak and speak-as properties.
+      VALID_TAGS = %w[
+        SPAN A RT DFN ABBR Q CITE EM TIME VAR SAMP I B SUB SUP SMALL STRONG MARK
+        RUBY INS DEL KBD BDO CODE P FIGCAPTION FIGURE PRE DIV LI BLOCKQUOTE DT
+        DD FIELDSET LEGEND LABEL FORM BODY ASIDE ADDRESS H1 H2 H3 H4 H5 H6
+        SECTION HEADER NAV ARTICLE FOOTER CAPTION SUMMARY DETAILS TD TH
+      ].freeze
+
+      protected
+
+      ##
+      # The operation method of _speak_as method for spell-out.
+      #
+      # @param content [String] The text content of element.
+      # @param index [Integer] The index of pattern in text content of element.
+      # @param children [Array<Hatemile::Util::Html::HTMLDOMElement>] The
+      #   children of element.
+      # @return [Array<Hatemile::Util::Html::HTMLDOMElement>] The new children
+      #   of element.
+      def operation_speak_as_spell_out(content, index, children)
+        children.push(
+          create_content_element(content[0..index], 'spell-out')
+        )
+
+        children.push(create_aural_content_element(' ', 'spell-out'))
+
+        children
+      end
+
+      ##
+      # The operation method of _speak_as method for literal-punctuation.
+      #
+      # @param content [String] The text content of element.
+      # @param index [Integer] The index of pattern in text content of element.
+      # @param children [Array<Hatemile::Util::Html::HTMLDOMElement>] The
+      #   children of element.
+      # @return [Array<Hatemile::Util::Html::HTMLDOMElement>] The new children
+      #   of element.
+      def operation_speak_as_literal_punctuation(content, index, children)
+        data_property_value = 'literal-punctuation'
+        unless index.zero?
+          children.push(
+            create_content_element(content[0..(index - 1)], data_property_value)
+          )
+        end
+        children.push(
+          create_aural_content_element(
+            " #{get_description_of_symbol(content[index..index])} ",
+            data_property_value
+          )
+        )
+
+        children.push(
+          create_visual_content_element(
+            content[index..index],
+            data_property_value
+          )
+        )
+
+        children
+      end
+
+      ##
+      # The operation method of _speak_as method for no-punctuation.
+      #
+      # @param content [String] The text content of element.
+      # @param index [Integer] The index of pattern in text content of element.
+      # @param children [Array<Hatemile::Util::Html::HTMLDOMElement>] The
+      #   children of element.
+      # @return [Array<Hatemile::Util::Html::HTMLDOMElement>] The new children
+      #   of element.
+      def operation_speak_as_no_punctuation(content, index, children)
+        unless index.zero?
+          children.push(
+            create_content_element(content[0..(index - 1)], 'no-punctuation')
+          )
+        end
+        children.push(
+          create_visual_content_element(
+            content[index..index],
+            'no-punctuation'
+          )
+        )
+
+        children
+      end
+
+      ##
+      # The operation method of _speak_as method for digits.
+      #
+      # @param content [String] The text content of element.
+      # @param index [Integer] The index of pattern in text content of element.
+      # @param children [Array<Hatemile::Util::Html::HTMLDOMElement>] The
+      #   children of element.
+      # @return [Array<Hatemile::Util::Html::HTMLDOMElement>] The new children
+      #   of element.
+      def operation_speak_as_digits(content, index, children)
+        data_property_value = 'digits'
+        unless index.zero?
+          children.push(
+            create_content_element(content[0..(index - 1)], data_property_value)
+          )
+        end
+        children.push(create_aural_content_element(' ', data_property_value))
+
+        children.push(
+          create_content_element(
+            content[index..index],
+            data_property_value
+          )
+        )
+
+        children
+      end
+
+      ##
+      # Load the symbols with configuration.
+      #
+      # @param file_name [String] The file path of symbol configuration.
+      def set_symbols(file_name)
+        @symbols = []
+        if file_name.nil?
+          file_name = File.join(
+            File.dirname(File.dirname(File.dirname(__FILE__))),
+            'symbols.xml'
+          )
+        end
+        document = REXML::Document.new(File.read(file_name))
+        document.elements.each('symbols/symbol') do |symbol_xml|
+          symbol = {}
+          symbol[:symbol] = symbol_xml.attribute('symbol').value
+          symbol[:description] = @configure.get_parameter(
+            symbol_xml.attribute('description').value
+          )
+          @symbols.push(symbol)
+        end
+      end
+
+      ##
+      # Returns the description of symbol.
+      #
+      # @param symbol [String] The symbol.
+      # @return [String] The description of symbol.
+      def get_description_of_symbol(symbol)
+        @symbols.each do |dict_symbol|
+          return dict_symbol[:description] if dict_symbol[:symbol] == symbol
+        end
+        nil
+      end
+
+      ##
+      # Returns the regular expression to search all symbols.
+      #
+      # @return [String] The regular expression to search all symbols.
+      def get_regular_expression_of_symbols
+        regular_expression = nil
+        @symbols.each do |symbol|
+          formated_symbol = Regexp.escape(symbol[:symbol])
+          regular_expression = if regular_expression.nil?
+                                 "(#{formated_symbol})"
+                               else
+                                 "#{regular_expression}|(#{formated_symbol})"
+                               end
+        end
+        Regexp.new(regular_expression)
+      end
+
+      ##
+      # Check that the children of element can be manipulated to apply the CSS
+      # properties.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      # @return [Boolean] True if the children of element can be manipulated to
+      #   apply the CSS properties or false if the children of element cannot be
+      #   manipulated to apply the CSS properties.
+      def is_valid_inherit_element?(element)
+        VALID_INHERIT_TAGS.include?(element.get_tag_name) &&
+          Hatemile::Util::CommonFunctions.is_valid_element?(element)
+      end
+
+      ##
+      # Check that the element can be manipulated to apply the CSS properties.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      # @return [Boolean] True if the element can be manipulated to apply the
+      #   CSS properties or False if the element cannot be manipulated to apply
+      #   the CSS properties.
+      def is_valid_element?(element)
+        VALID_TAGS.include?(element.get_tag_name)
+      end
+
+      ##
+      # Isolate text nodes of element nodes.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def isolate_text_node(element)
+        unless element.has_children_elements? && is_valid_element?(element)
+          return
+        end
+
+        element.get_children.each do |child_node|
+          next unless child_node.is_a?(Hatemile::Util::Html::HTMLDOMTextNode)
+
+          span = @html_parser.create_element('span')
+          span.set_attribute(DATA_ISOLATOR_ELEMENT, 'true')
+          span.append_text(child_node.get_text_content)
+
+          child_node.replace_node(span)
+        end
+        element.get_children_elements.each do |child|
+          isolate_text_node(child)
+        end
+      end
+
+      ##
+      # Replace the element by own text content.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def replace_element_by_own_content(element)
+        if element.has_children_elements?
+          element.get_children_elements.each do |child|
+            element.insert_before(child)
+          end
+          element.remove_node
+        elsif element.has_children?
+          element.replace_node(element.get_first_node_child)
+        end
+      end
+
+      ##
+      # Visit and execute a operation in element and descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      # @param operation [Method] The operation to be executed.
+      def visit(element, operation)
+        return unless is_valid_inherit_element?(element)
+
+        if element.has_children_elements?
+          element.get_children_elements.each do |child|
+            visit(child, operation)
+          end
+        elsif is_valid_element?(element)
+          operation.call(element)
+        end
+      end
+
+      ##
+      # Create a element to show the content.
+      #
+      # @param content [String] The text content of element.
+      # @param data_property_value [String] The value of custom attribute used
+      #   to identify the fix.
+      # @return [Hatemile::Util::Html::HTMLDOMElement] The element to show the
+      #   content.
+      def create_content_element(content, data_property_value)
+        content_element = @html_parser.create_element('span')
+        content_element.set_attribute(DATA_ISOLATOR_ELEMENT, 'true')
+        content_element.set_attribute(DATA_SPEAK_AS, data_property_value)
+        content_element.append_text(content)
+        content_element
+      end
+
+      ##
+      # Create a element to show the content, only to aural displays.
+      #
+      # @param content [String] The text content of element.
+      # @param data_property_value [String] The value of custom attribute used
+      #   to identify the fix.
+      # @return [Hatemile::Util::Html::HTMLDOMElement] The element to show the
+      #   content.
+      def create_aural_content_element(content, data_property_value)
+        content_element = create_content_element(content, data_property_value)
+        content_element.set_attribute('unselectable', 'on')
+        content_element.set_attribute('class', 'screen-reader-only')
+        content_element
+      end
+
+      ##
+      # Create a element to show the content, only to visual displays.
+      #
+      # @param content [String] The text content of element.
+      # @param data_property_value [String] The value of custom attribute used
+      #   to identify the fix.
+      # @return [Hatemile::Util::Html::HTMLDOMElement] The element to show the
+      #   content.
+      def create_visual_content_element(content, data_property_value)
+        content_element = create_content_element(content, data_property_value)
+        content_element.set_attribute('aria-hidden', 'true')
+        content_element.set_attribute('role', 'presentation')
+        content_element
+      end
+
+      ##
+      # Speak the content of element only.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_normal(element)
+        return unless element.has_attribute?(DATA_SPEAK)
+
+        if element.get_attribute(DATA_SPEAK) == 'none' &&
+           !element.has_attribute?(DATA_ISOLATOR_ELEMENT)
+          element.remove_attribute('role')
+          element.remove_attribute('aria-hidden')
+          element.remove_attribute(DATA_SPEAK)
+        else
+          replace_element_by_own_content(element)
+        end
+      end
+
+      ##
+      # Speak the content of element and descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_normal_inherit(element)
+        visit(element, method(:speak_normal))
+
+        element.normalize
+      end
+
+      ##
+      # No speak any content of element only.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_none(element)
+        element.set_attribute('role', 'presentation')
+        element.set_attribute('aria-hidden', 'true')
+        element.set_attribute(DATA_SPEAK, 'none')
+      end
+
+      ##
+      # No speak any content of element and descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_none_inherit(element)
+        isolate_text_node(element)
+
+        visit(element, method(:speak_none))
+      end
+
+      ##
+      # Execute a operation by regular expression for element only.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      # @param regular_expression [Regexp] The regular expression.
+      # @param data_property_value [String] The value of custom attribute used
+      #   to identify the fix.
+      # @param operation [Method] The operation to be executed.
+      def speak_as(element, regular_expression, data_property_value, operation)
+        children = []
+        content = element.get_text_content
+        until content.empty?
+          index = content.index(regular_expression)
+
+          break if index.nil?
+
+          children = operation.call(content, index, children)
+
+          new_index = index + 1
+          content = content[new_index..-1]
+        end
+
+        return if children.empty?
+
+        unless content.empty?
+          children.push(create_content_element(content, data_property_value))
+        end
+        element.get_first_node_child.remove_node while element.has_children?
+        children.each do |child|
+          element.append_element(child)
+        end
+      end
+
+      ##
+      # Revert changes of a speak_as method for element and descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      # @param data_property_value [String] The value of custom attribute used
+      #   to identify the fix.
+      def reverse_speak_as(element, data_property_value)
+        data_property = "[#{DATA_SPEAK_AS}=\"#{data_property_value}\"]"
+
+        auxiliar_elements = @html_parser.find(element).find_descendants(
+          "#{data_property}[unselectable=\"on\"]"
+        ).list_results
+        auxiliar_elements.each(&:remove_node)
+
+        content_elements = @html_parser.find(element).find_descendants(
+          "#{data_property}[#{DATA_ISOLATOR_ELEMENT}=\"true\"],
+          #{data_property}[aria-hidden]"
+        ).list_results
+        content_elements.each do |content_element|
+          replace_element_by_own_content(content_element)
+        end
+        element.normalize
+      end
+
+      ##
+      # Use the default speak configuration of user agent for element and
+      # descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_normal(element)
+        reverse_speak_as(element, 'spell-out')
+        reverse_speak_as(element, 'literal-punctuation')
+        reverse_speak_as(element, 'no-punctuation')
+        reverse_speak_as(element, 'digits')
+      end
+
+      ##
+      # Speak one letter at a time for each word for element only.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_spell_out(element)
+        speak_as(
+          element,
+          /[a-zA-Z]/,
+          'spell-out',
+          method(:operation_speak_as_spell_out)
+        )
+      end
+
+      ##
+      # Speak one letter at a time for each word for elements and descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_spell_out_inherit(element)
+        reverse_speak_as(element, 'spell-out')
+
+        isolate_text_node(element)
+
+        visit(element, method(:speak_as_spell_out))
+      end
+
+      ##
+      # Speak the punctuation for elements only.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_literal_punctuation(element)
+        speak_as(
+          element,
+          get_regular_expression_of_symbols,
+          'literal-punctuation',
+          method(:operation_speak_as_literal_punctuation)
+        )
+      end
+
+      ##
+      # Speak the punctuation for elements and descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_literal_punctuation_inherit(element)
+        reverse_speak_as(element, 'literal-punctuation')
+        reverse_speak_as(element, 'no-punctuation')
+
+        isolate_text_node(element)
+
+        visit(element, method(:speak_as_literal_punctuation))
+      end
+
+      ##
+      # No speak the punctuation for element only.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_no_punctuation(element)
+        escape_punctuation = Regexp.escape('!"#$%&\'()*+,-./:;<=>?@[]^_`{|}~\\')
+        speak_as(
+          element,
+          Regexp.new("[#{escape_punctuation}]"),
+          'no-punctuation',
+          method(:operation_speak_as_no_punctuation)
+        )
+      end
+
+      ##
+      # No speak the punctuation for element and descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_no_punctuation_inherit(element)
+        reverse_speak_as(element, 'literal-punctuation')
+        reverse_speak_as(element, 'no-punctuation')
+
+        isolate_text_node(element)
+
+        visit(element, method(:speak_as_no_punctuation))
+      end
+
+      ##
+      # Speak the digit at a time for each number for element only.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_digits(element)
+        speak_as(element, /[0-9]/, 'digits', method(:operation_speak_as_digits))
+      end
+
+      ##
+      # Speak the digit at a time for each number for element and descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_digits_inherit(element)
+        reverse_speak_as(element, 'digits')
+
+        isolate_text_node(element)
+
+        visit(element, method(:speak_as_digits))
+      end
+
+      ##
+      # Speaks the numbers for element and descendants as a word number.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_as_continuous_inherit(element)
+        reverse_speak_as(element, 'digits')
+      end
+
+      ##
+      # The cells headers will be spoken for every data cell for element and
+      # descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_header_always_inherit(element)
+        speak_header_once_inherit(element)
+
+        cell_elements = @html_parser.find(element).find_descendants(
+          'td[headers],th[headers]'
+        ).list_results
+        accessible_display = AccessibleDisplayImplementation(
+          @html_parser,
+          @configure
+        )
+        cell_elements.each do |cell_element|
+          accessible_display.display_cell_header(cell_element)
+        end
+      end
+
+      ##
+      # The cells headers will be spoken one time for element and descendants.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      def speak_header_once_inherit(element)
+        header_elements = @html_parser.find(element).find_descendants(
+          "[#{DATA_ATTRIBUTE_HEADERS_OF}]"
+        ).list_results
+        header_elements.each(&:remove_node)
+      end
+
+      ##
+      # Provide the CSS features of speaking and speech properties in element.
+      #
+      # @param element [Hatemile::Util::Html::HTMLDOMElement] The element.
+      # @param rule [Hatemile::Util::Css::StyleSheetRule] The stylesheet rule.
+      def provide_speak_properties_with_rule(element, rule)
+        if rule.has_property?('speak')
+          declarations = rule.get_declarations('speak')
+          declarations.each do |declaration|
+            property_value = declaration.get_value
+            if property_value == 'none'
+              speak_none_inherit(element)
+            elsif property_value == 'normal'
+              speak_normal_inherit(element)
+            elsif property_value == 'spell-out'
+              speak_as_spell_out_inherit(element)
+            end
+          end
+        end
+        if rule.has_property?('speak-as')
+          declarations = rule.get_declarations('speak-as')
+          declarations.each do |declaration|
+            speak_as_values = declaration.get_values
+            speak_as_normal(element)
+            speak_as_values.each do |speak_as_value|
+              if speak_as_value == 'spell-out'
+                speak_as_spell_out_inherit(element)
+              elsif speak_as_value == 'literal-punctuation'
+                speak_as_literal_punctuation_inherit(element)
+              elsif speak_as_value == 'no-punctuation'
+                speak_as_no_punctuation_inherit(element)
+              elsif speak_as_value == 'digits'
+                speak_as_digits_inherit(element)
+              end
+            end
+          end
+        end
+        if rule.has_property?('speak-punctuation')
+          declarations = rule.get_declarations('speak-punctuation')
+          declarations.each do |declaration|
+            property_value = declaration.get_value
+            if property_value == 'code'
+              speak_as_literal_punctuation_inherit(element)
+            elsif property_value == 'none'
+              speak_as_no_punctuation_inherit(element)
+            end
+          end
+        end
+        if rule.has_property?('speak-numeral')
+          declarations = rule.get_declarations('speak-numeral')
+          declarations.each do |declaration|
+            property_value = declaration.get_value
+            if property_value == 'digits'
+              speak_as_digits_inherit(element)
+            elsif property_value == 'continuous'
+              speak_as_continuous_inherit(element)
+            end
+          end
+        end
+
+        return unless rule.has_property?('speak-header')
+
+        declarations = rule.get_declarations('speak-header')
+        declarations.each do |declaration|
+          property_value = declaration.get_value
+          if property_value == 'always'
+            speak_header_always_inherit(element)
+          elsif property_value == 'once'
+            speak_header_once_inherit(element)
+          end
+        end
+      end
+
+      public
+
+      ##
+      # Initializes a new object that improve the accessibility of associations
+      # of parser.
+      #
+      # @param html_parser [Hatemile::Util::Html::HTMLDOMParser] The HTML
+      #   parser.
+      # @param css_parser [Hatemile::Util::Css::StyleSheetParser] The CSS
+      #   parser.
+      # @param configure [Hatemile::Util::Configure] The configuration of
+      #   HaTeMiLe.
+      # @param symbol_file_name [String] The file path of symbol configuration.
+      def initialize(html_parser, css_parser, configure, symbol_file_name = nil)
+        Hatemile::Helper.require_not_nil(html_parser, css_parser, configure)
+        Hatemile::Helper.require_valid_type(
+          html_parser,
+          Hatemile::Util::Html::HTMLDOMParser
+        )
+        Hatemile::Helper.require_valid_type(
+          css_parser,
+          Hatemile::Util::Css::StyleSheetParser
+        )
+        Hatemile::Helper.require_valid_type(
+          configure,
+          Hatemile::Util::Configure
+        )
+        Hatemile::Helper.require_valid_type(symbol_file_name, String)
+
+        @html_parser = html_parser
+        @css_parser = css_parser
+        @configure = configure
+        @id_generator = Hatemile::Util::IDGenerator.new('css')
+        set_symbols(symbol_file_name)
+      end
+
+      ##
+      # @see Hatemile::AccessibleCSS#provide_speak_properties
+      def provide_speak_properties(element)
+        rules = @css_parser.get_rules(
+          %w[speak speak-punctuation speak-numeral speak-header speak-as]
+        )
+        rules.each do |rule|
+          speak_elements = @html_parser.find(rule.get_selector).list_results
+          if speak_elements.include?(element)
+            provide_speak_properties_with_rule(element, rule)
+          end
+        end
+      end
+
+      ##
+      # @see Hatemile::AccessibleCSS#provide_all_speak_properties
+      def provide_all_speak_properties
+        selector = nil
+        rules = @css_parser.get_rules(
+          %w[speak speak-punctuation speak-numeral speak-header speak-as]
+        )
+        rules.each do |rule|
+          selector = if selector.nil?
+                       rule.get_selector
+                     else
+                       "#{selector},#{rule.get_selector}"
+                     end
+        end
+
+        return if selector.nil?
+
+        @html_parser.find(selector).list_results.each do |element|
+          if Hatemile::Util::CommonFunctions.is_valid_element?(element)
+            provide_speak_properties(element)
+          end
+        end
+      end
+    end
+  end
+end