raakt 0.1

data/lib/raakt.rb

@@ -0,0 +1,454 @@
+#Ruby Accessibility Analysis Kit
+
+module Raakt
+  require 'rubyful_soup'
+  
+  MESSAGES = {
+    "missingtitle"    => "The title element is missing. Provide a descriptive title for your document.",
+    "emptytitle"      => "The title element is empty. Provide a descriptive title for your document.",  
+    "missingalt"      => "Missing alt attribute for image (with src '%s').",
+    "missingheading"  => "Missing first level heading (h1). Provide at least one first level heading describing document content.",
+    "wronghstructure" => "Document heading structure is wrong.",
+    "firsthnoth1"     => "The first heading is not h1.",
+    "hasnestedtables" => "You have one or more nested tables.",
+    "missingsemantics"=> "You have used <font>, <b> or <i> for visual formatting. Use CSS instead.",
+    "hasflicker"      => "You have used <blink> or <marquee>. These may create accessibility issues and should be avoided.",
+    "missinglanginfo" => "Document language information is missing. Use the lang attribute on the html element.",
+    "missingth"       => "Missing table headings (th) for table #%s.",
+    "ambiguouslinktext" => "One or more links have the same link text ('%s'). Make sure each link is unambiguous.",
+    "fieldmissinglabel" => "A field (with id/name '%s') is missing a corresponding label element. Make sure a label exists for all visible fields.",
+    "missingframetitle" => "Missing title attribute for frame with url %s",
+    "hasmetarefresh"  => "Client side redirect (meta refresh) detected. Use server side redirection instead."
+  }
+  
+  VERSION = "0.1"
+
+  class ErrorMessage
+  
+    attr_reader :eid, :text, :note
+  
+    def initialize(eid, note=nil)
+      @eid = eid
+      if note
+        @text = MESSAGES[eid].sub(/%s/, note)
+      else
+        @text = MESSAGES[eid]
+      end
+      @note = note
+    end
+  
+    def to_s
+      @eid + ": " + @text
+    end
+  end
+
+
+  class Test
+
+  
+    def initialize()
+    end
+    
+    
+    def all(html)
+      #Do all checks
+      messages = []
+      
+      self.methods.each do |method|
+        if method[0..5] == "check_"
+          messages += self.send(method, html)
+        end
+      end
+      
+      return messages
+    end
+
+  
+    def check_images(html)
+      soup = BeautifulSoup.new(html)
+      images = soup.find_all("img")
+      messages = []
+    
+      for image in images:
+          if image["alt"] == nil:
+            img_src = image["src"] || ""
+            messages << ErrorMessage.new("missingalt", img_src)
+          end
+      end
+      
+      return messages  
+    end
+
+  
+    def check_title(html)
+      soup = BeautifulSoup.new(html)
+      title = soup.find("title")
+      messages = []
+    
+      if title
+        titletext = normalize_text(title.string)
+        if titletext.length == 0
+          messages << ErrorMessage.new("emptytitle")
+        end
+      else
+        messages << ErrorMessage.new("missingtitle")
+      end
+      
+      return messages 
+    end
+
+  
+    def check_has_heading(html)
+      soup = BeautifulSoup.new(html)
+      messages = []  
+      
+      if soup.find_all("h1").length == 0
+        messages << ErrorMessage.new("missingheading")
+      end
+      
+      return messages
+    end
+
+
+    def headings(html)
+      soup = BeautifulSoup.new(html)
+      headings = []
+      headings.push(soup.find_all("h1")) if soup.find_all("h1").length > 0
+      headings.push(soup.find_all("h2")) if soup.find_all("h2").length > 0
+      headings.push(soup.find_all("h3")) if soup.find_all("h3").length > 0
+      headings.push(soup.find_all("h4")) if soup.find_all("h4").length > 0
+      headings.push(soup.find_all("h5")) if soup.find_all("h5").length > 0
+      headings.push(soup.find_all("h6")) if soup.find_all("h6").length > 0
+      
+      return headings.flatten
+    end
+
+    
+    def level(heading)
+      Integer(heading[1,1])
+    end
+
+    
+    def check_document_structure(html)
+      messages = []
+      currentitem = 0
+      docheadings = headings(html)
+      
+      for heading in docheadings
+        if currentitem == 0
+          if level(heading.name) != 1
+            messages << ErrorMessage.new("firsthnoth1", "h" + heading.name[1,1])
+          end
+        else
+          if level(heading.name) - level(docheadings[currentitem - 1].name) > 1
+            messages << ErrorMessage.new("wronghstructure")
+            break
+          end  
+        end
+        
+        currentitem += 1
+        
+      end
+      
+      return messages
+    end
+
+    
+    def check_for_nested_tables(html)
+      soup = BeautifulSoup.new(html)
+      messages = []  
+      tables = soup.find_all("table")
+      
+      for table in tables
+        if table.find_all("table").length > 0
+          messages << ErrorMessage.new("hasnestedtables")
+          break
+        end
+      end
+      
+      return messages
+    end
+
+    
+    def check_tables(html)
+      soup = BeautifulSoup.new(html)
+      messages = []  
+      tables = soup.find_all("table")   
+      hasth = false
+      currenttable = 1
+      
+      for table in tables     
+        if table.thead
+          if table.thead.tr
+            if table.thead.tr.th   
+              hasth = true
+            end
+          end
+        end
+        
+        if table.tr
+          if table.tr.th
+            hasth = true
+          end
+        end
+        
+        unless hasth
+          messages << ErrorMessage.new("missingth", currenttable.to_s)
+        end
+        
+        currenttable += 1
+      end
+      
+      return messages
+    end
+    
+    
+    def check_for_formatting_elements(html)
+      soup = BeautifulSoup.new(html)
+      messages = []  
+      formatting_items = soup.find_all(["font", "b", "i"])
+      flicker_items = soup.find_all(["blink", "marquee"])
+      
+      if formatting_items.length > 0
+          messages << ErrorMessage.new("missingsemantics")  
+      end
+
+      if flicker_items.length > 0
+          messages << ErrorMessage.new("hasflicker")  
+      end
+            
+      return messages   
+    end
+    
+    
+    def check_for_language_info(html)
+      soup = BeautifulSoup.new(html)
+      messages = []
+      
+      langelements = soup.find_all(Proc.new { |element| langinfo(element).length > 1 })
+      
+      if langelements.length == 0
+        messages << ErrorMessage.new("missinglanginfo")
+      end
+      
+      return messages
+    end
+    
+    
+    def check_link_text(html)
+      messages = []
+      links = get_links(html)
+      linktexts = links.collect { |el| el[3] }
+      
+      for link_a in links
+        #compare to other links in collection
+        for link_b in links
+          if link_a[0] != link_b[0]
+            if is_ambiguous_link(link_a, link_b)
+              #add message if not added already for link text
+              unless find_errormsg_with_text(messages, link_a[3])
+                messages << ErrorMessage.new("ambiguouslinktext", link_a[3])
+              end
+            end
+          end
+        end
+      end
+      
+      return messages      
+    end
+        
+    
+    def check_form(html)
+      messages = []
+      labels = get_labels(html)
+      fields = get_editable_fields(html)
+      
+      #make sure all fields have associated labels
+      
+      label_for_ids = []
+      for label in labels
+        if label["for"]
+          label_for_ids << label["for"]
+        end
+      end
+      
+      field_id = nil
+      
+      for field in fields
+        field_id = (field["id"] || "")
+        field_identifier = (field["id"] || field["name"] || "unknown")
+        if not label_for_ids.include?(field_id)
+          messages << ErrorMessage.new("fieldmissinglabel", field_identifier)
+        end
+      end   
+      
+      return messages
+    end
+    
+    
+    def check_frames(html)
+      #Verify frame titles
+      soup = BeautifulSoup.new(html)
+      messages = []  
+      if is_frameset(html)
+        frames = soup.find_all("frame")
+        frame_title = ""
+      
+        for frame in frames
+          frame_title = frame["title"] || ""
+          if normalize_text(frame_title).length == 0
+            messages << ErrorMessage.new("missingframetitle", frame["src"])
+          end
+        end
+      end
+      
+      return messages            
+    end
+    
+    
+    def check_refresh(html)
+      soup = BeautifulSoup.new(html)
+      messages = []
+      meta_elements = soup.find_all("meta")
+      
+      for element in meta_elements
+        if element["http-equiv"] == "refresh"
+          messages << ErrorMessage.new("hasmetarefresh")
+        end
+      end
+      
+      return messages
+    end
+    
+    
+    #Utility methods    
+    
+    def is_ambiguous_link(link_a, link_b)
+      #Link A and B are ambiguous if:
+      #1. The url differs
+      #2. The link text is identical
+      #3. The title text is identical (if present)
+      if link_a[1] != link_b[1] and 
+         normalize_text(link_a[2]) == normalize_text(link_b[2]) and
+         normalize_text(link_a[3]) == normalize_text(link_b[3]) then
+         return true
+      end
+      
+      return false
+    end
+    
+    
+    def find_errormsg_with_text(messages, text)
+      for errormessage in messages
+        if errormessage.note == text
+          return errormessage
+        end
+      end
+      
+      return nil
+    end
+    
+    
+    def get_links(html)
+      soup = BeautifulSoup.new(normalize_text(html))
+      messages = []
+      
+      linkelements = soup.find_all("a")
+      links = []
+      currentlink = 0
+      
+      for element in linkelements
+        title = (element['title'] || "").strip
+        linktext = (elements_to_text(element) || "").strip
+        url = element['href']
+        links << [currentlink, url, title, linktext]
+        currentlink += 1
+      end      
+      
+      return links
+    end
+
+
+    def langinfo(element)
+      langval = ""
+      if element['lang']
+        langval = element['lang']
+      end
+      
+      return langval
+    end    
+    
+    
+    def img_to_text(imgtag)
+      return (imgtag['alt'] || "")
+    end
+    
+    
+    def elements_to_text(element)
+      retval = ""
+      
+      for el in element.contents
+        if el.class.to_s == 'NavigableString'
+          retval += el
+        else
+          if el.name == "img"
+            retval += img_to_text(el)
+          else
+            retval += elements_to_text(el)
+          end
+        end        
+      end
+      
+      return retval
+    end
+    
+    
+    def normalize_text(text)
+      text = (text || "")
+      retval = text.gsub(/&nbsp;/, " ")
+      retval = retval.gsub(/&#160;/, " ")
+      retval = retval.gsub(/\n/, "")
+      retval = retval.gsub(/\r/, "")
+      retval = retval.gsub(/\t/, "")
+      while /  /.match(retval) do
+        retval = retval.gsub(/  /, " ")
+      end
+      
+      retval = retval.strip
+      
+      return retval
+    end
+    
+    
+    def get_labels(html)
+      soup = BeautifulSoup.new(html)
+      return soup.find_all("label")
+    end
+
+
+    def get_editable_fields(html)
+      soup = BeautifulSoup.new(html)
+      allfields = soup.find_all(["textarea", "select", "input"])
+      fields = []
+      field_type = ""
+      
+      for field in allfields do
+        field_type = field["type"] || ""
+        unless ["button", "submit", "hidden", "image"].include?(field_type)
+          fields << field
+        end
+        
+      end
+      
+      return fields
+    end
+        
+        
+    def is_frameset(html)
+      soup = BeautifulSoup.new(html)
+      return (soup.find("frameset") != nil)
+    end    
+    
+  end
+
+end