searchlink 2.3.59

data/lib/searchlink/curl/html.rb

@@ -0,0 +1,482 @@
+# frozen_string_literal: true
+
+module Curl
+  # String helpers
+  class ::String
+    def remove_entities
+      gsub(/ /, ' ')
+    end
+  end
+
+  # Class for CURLing an HTML page
+  class Html
+    attr_reader :url, :code, :headers, :meta, :links, :head, :body,
+                :source, :title, :description, :body_links, :body_images
+
+    ##
+    ## Create a new page object from a URL
+    ##
+    ## @param      url           [String] The url
+    ## @param      headers       [Hash] The headers to use in the curl call
+    ## @param      headers_only  [Boolean] Return headers only
+    ## @param      compressed    [Boolean] Expect compressed result
+    ##
+    ## @return     [HTMLCurl] new page object
+    ##
+    def initialize(url, headers: nil, headers_only: false, compressed: false)
+      @curl = TTY::Which.which('curl')
+      res = curl_html(url, headers: headers, headers_only: headers_only, compressed: compressed)
+      @url = res[:url]
+      @code = res[:code]
+      @headers = res[:headers]
+      @meta = res[:meta]
+      @links = res[:links]
+      @head = res[:head] unless res[:head].nil?
+      @body = reencode(res[:body])
+      @source = res[:source]
+      @title = @meta['og:title'] || @meta['title'] unless @meta.nil?
+      @description = @meta['og:description'] || @meta['description'] unless @meta.nil?
+      @body_links = content_links
+      @body_images = content_images
+    end
+
+    ##
+    ## Extract text between two regular expressions
+    ##
+    ## @param      before  [String, Regexp] The before
+    ## @param      after   [String, Regexp] The after
+    ##
+    ## @return     [Array] array of matches
+    ##
+    def extract(before, after)
+      before = /#{Regexp.escape(before)}/ unless before.instance_of?(Regexp)
+      after = /#{Regexp.escape(after)}/ unless after.instance_of?(Regexp)
+      @body.scan(/#{before.source}(.*?)#{after.source}/)
+    end
+
+    ##
+    ## Extract an array of tags or tag attributes
+    ##
+    ## @param      tag        [String] The tag
+    ## @param      attribute  [String] The attribute
+    ## @param      source     [Boolean] Return full tag source
+    ##                        (negates attribute if true)
+    ## @param      content    [Boolean] Return only tag
+    ##                        contents
+    ##
+    ## @return     [Hash, Array] if source, return array of full
+    ##             tags, if content, return array of tag contents,
+    ##             otherwise, return a hash of tags including
+    ##             attributes and content
+    ##
+    ## If attribute is not given, tag contents will be returned
+    ##
+    ## @example    page.extract_tag('h1') => [Array of h1 tag
+    ## contents]
+    ## @example    page.extract_tag('img', 'src') => [Array of img
+    ## src attributes]
+    ##
+    def extract_tag(tag, attribute = nil, source: false, content: false)
+      res = extract_tag_contents(tag, source: true)
+
+      return res if source
+
+      res.map! do |tag_source|
+        m = tag_source.to_enum(:scan, /(\S+)=(['"])(.*?)\2/).map { Regexp.last_match }
+        attrs = m.each_with_object({}) { |at, a| a[at[1]] = at[3] }
+        tags = tag_source.match(/<.*?>(?<content>.*?)</)
+        contents = tags.nil? ? nil : tags['content']
+        {
+          tag: tag,
+          source: tag_source,
+          attrs: attrs,
+          content: contents
+        }
+      end
+
+      return res.map { |r| r[:content] } if content
+
+      return res if attribute.nil?
+
+      res.map { |r| r[:attrs][attribute] }
+    end
+
+    ##
+    ## Extract tag contents or full tag source
+    ##
+    ## @param      tag     The tag
+    ## @param      source  [Boolean] Return full tag instead of contents
+    ##
+    def extract_tag_contents(tag, source: false)
+      return @body.scan(%r{<#{tag}.*?>(?:.*?</#{tag}>)?}) if source
+
+      @body.scan(/<#{tag}.*?>(.*?)</).map { |t| t[0] }
+    end
+
+    ##
+    ## Return all tags in body, or a specific tag
+    ##
+    ## @param      tag   [String, Array] The tag to return,
+    ##                   can be an array
+    ##
+    ## @return     [Array] Array of tags. If no tag is specified, a
+    ##             hierarchical array of all tags in the document
+    ##             is returned. If one or more tags are specified,
+    ##             return a flattened list in document order.
+    ##
+    def tags(tag = nil)
+      tags = content_tags(@body)
+      return tags if tag.nil?
+
+      tag = [tag] unless tag.is_a?(Array)
+      tag.map!(&:downcase)
+      flatten_tags(tags).dup.delete_if { |t| !tag.include?(t[:tag].downcase) }
+    end
+
+    ##
+    ## Get all images from the page
+    ##
+    ## @return     [Array] Array of images, both from picture sources and img tags
+    ##
+    def images
+      output = []
+      %w[og:image twitter:image].each do |src|
+        next unless @meta.key?(src)
+
+        output << {
+          type: 'opengraph',
+          attrs: nil,
+          src: @meta[src]
+        }
+      end
+      images = tags(%w[img source])
+      images.each do |img|
+        case img[:tag].downcase
+        when /source/
+          srcsets = img[:attrs].filter { |k| k[:key] =~ /srcset/i }
+          if srcsets.count.positive?
+            srcset = []
+            srcsets.each do |src|
+              src[:value].split(/ *, */).each do |s|
+                image, media = s.split(/ /)
+                srcset << {
+                  src: image,
+                  media: media
+                }
+              end
+            end
+            output << {
+              type: 'srcset',
+              attrs: img[:attrs],
+              images: srcset
+            }
+          end
+        when /img/
+          output << {
+            type: 'img',
+            src: img[:attrs].filter { |a| a[:key] =~ /src/i }.first[:value],
+            attrs: img[:attrs]
+          }
+        end
+      end
+      output
+    end
+
+    def to_s
+      headers = @headers.nil? ? 0 : @headers.count
+      meta = @meta.nil? ? 0 : @meta.count
+      links = @links.nil? ? 0 : @links.count
+      [
+        %(<HTMLCurl: @code="#{@code}" @url="#{@url}" @title="#{@title}"),
+        %(@description=#{@description} @headers:#{headers} @meta:#{meta} @links:#{links}>)
+      ].join(' ')
+    end
+
+    ##
+    ## Return all headers of given level
+    ##
+    ## @param      level  [Number] The level (1-6)
+    ##
+    ## @return [Array] array of headers with text and all tag attributes as symbols
+    ##
+    def h(level = '\d')
+      res = []
+      headlines = @body.to_enum(:scan, %r{<h(?<level>#{level})(?<tag> .*?)?>(?<text>.*?)</h#{level}>}i).map { Regexp.last_match }
+      headlines.each do |m|
+        headline = { level: m['level'] }
+        if m['tag'].nil?
+          attrs = nil
+        else
+          attrs = m['tag'].to_enum(:scan, /(?<attr>\w+)=(?<quot>["'])(?<content>.*?)\k<quot>/).map { Regexp.last_match }
+          attrs.each { |a| headline[a['attr'].to_sym] = a['content'] }
+        end
+        headline[:text] = m['text'].remove_entities
+        res << headline
+      end
+      res
+    end
+
+    private
+
+    ##
+    ## Flatten the array of tags
+    ##
+    ## @param      tags  [Array] Document tags
+    ##
+    def flatten_tags(tags)
+      flattened = []
+
+      tags.each do |t|
+        flattened << { tag: t[:tag], attrs: t[:attrs], content: t[:content] }
+        flattened.concat(flatten_tags(t[:tags])) unless t[:tags].nil?
+      end
+
+      flattened
+    end
+
+    ##
+    ## Return an array of all tags in the content
+    ##
+    ## @param      content  [String] The content to parse
+    ##
+    def content_tags(content)
+      return nil if content.nil?
+
+      res = content.to_enum(:scan, %r{(?mix)
+        <(?<tag>(?!</)[a-z0-9]+)(?<attrs>\s[^>]+)?
+        (?:\s*/>|>(?<content>.*?)</\k<tag>>)}).map { Regexp.last_match }
+      res.map do |tag|
+        if tag['attrs'].nil?
+          attrs = nil
+        else
+          attrs = tag['attrs'].strip.to_enum(:scan, /(?ix)
+                                             (?<key>[@a-z0-9-]+)(?:=(?<quot>["'])
+                                             (?<value>[^"']+)\k<quot>|[ >])?/i).map { Regexp.last_match }
+          attrs.map! { |a| { key: a['key'], value: a['key'] =~ /^(class|rel)$/ ? a['value'].split(/ /) : a['value'] } }
+        end
+        {
+          tag: tag['tag'],
+          source: tag.to_s,
+          attrs: attrs,
+          content: tag['content'],
+          tags: content_tags(tag['content'])
+        }
+      end
+    end
+
+    ##
+    ## Extract all meta tags from the document head
+    ##
+    ## @param      head [String] The head content
+    ##
+    ## @return     [Hash] hash of meta tags and values
+    ##
+    def meta_tags(head)
+      meta = {}
+      title = head.match(%r{(?<=<title>)(.*?)(?=</title>)})
+      meta['title'] = title.nil? ? nil : title[1]
+      refresh = head.match(/http-equiv=(['"])refresh\1(.*?)>/)
+      url = refresh.nil? ? nil : refresh[2].match(/url=(.*?)['"]/)
+      meta['refresh_url'] = url
+      meta_tags = head.scan(/<meta.*?>/)
+      meta_tags.each do |tag|
+        meta_name = tag.match(/(?:name|property|http-equiv)=(["'])(.*?)\1/)
+        next if meta_name.nil?
+
+        meta_value = tag.match(/(?:content)=(['"])(.*?)\1/)
+        next if meta_value.nil?
+
+        meta[meta_name[2].downcase] = meta_value[2]
+      end
+      meta
+    rescue StandardError => e
+      warn e
+      {}
+    end
+
+    ##
+    ## Extract all <link> tags from head
+    ##
+    ## @param      head  [String] The head content
+    ##
+    ## @return     [Array] Array of links
+    ##
+    def link_tags(head)
+      links = []
+      link_tags = head.scan(/<link.*?>/)
+      link_tags.each do |tag|
+        link_rel = tag.match(/rel=(['"])(.*?)\1/)
+        link_rel = link_rel.nil? ? nil : link_rel[2]
+
+        next if link_rel =~ /preload/
+
+        link_href = tag.match(/href=(["'])(.*?)\1/)
+        next if link_href.nil?
+
+        link_href = link_href[2]
+
+        link_title = tag.match(/title=(['"])(.*?)\1/)
+        link_title = link_title.nil? ? nil : link_title[2]
+
+        link_type = tag.match(/type=(['"])(.*?)\1/)
+        link_type = link_type.nil? ? nil : link_type[2]
+
+        links << { rel: link_rel, href: link_href, type: link_type, title: link_title }
+      end
+      links
+    end
+
+    ##
+    ## Get all links in the body of the page
+    ##
+    ## @return     [Array] array of links with href, title,
+    ##             rel, text and class
+    ##
+    def content_links
+      links = []
+      link_tags = @body.to_enum(:scan, %r{<a (?<tag>.*?)>(?<text>.*?)</a>}).map { Regexp.last_match }
+      link_tags.each do |m|
+        href = m['tag'].match(/href=(["'])(.*?)\1/)
+        href = href[2] unless href.nil?
+        title = m['tag'].match(/title=(["'])(.*?)\1/)
+        title = title[2] unless title.nil?
+        rel = m['tag'].match(/rel=(["'])(.*?)\1/)
+        rel = rel[2] unless rel.nil?
+        link_class = m['tag'].match(/class=(["'])(.*?)\1/)
+        link_class = link_class[2] unless link_class.nil?
+        text = m['text'].remove_entities
+        link = {
+          href: href,
+          title: title,
+          rel: rel,
+          text: text,
+          class: link_class
+        }
+        links << link
+      end
+      links
+    end
+
+    ##
+    ## Get all img tags in the body of the page
+    ##
+    ## @return     [Array] array of images with src and all attributes
+    ##
+    def content_images
+      images = []
+      image_tags = @body.to_enum(:scan, %r{<img (?<tag>.*?)/?>}).map { Regexp.last_match }
+      image_tags.each do |m|
+        attrs = m['tag'].to_enum(:scan, /(?<attr>\w+)=(?<quot>["'])(?<content>.*?)\k<quot>/).map { Regexp.last_match }
+        image = {}
+        attrs.each { |a| image[a['attr'].to_sym] = a['content'] }
+        images << image
+      end
+      images
+    end
+
+
+
+    ##
+    ## Curls the html for the page
+    ##
+    ## @param      url           [String] The url
+    ## @param      headers       [Hash] The headers
+    ## @param      headers_only  [Boolean] Return headers only
+    ## @param      compressed    [Boolean] expect compressed results
+    ##
+    ## @return     [Hash] hash of url, code, headers, meta, links, head, body, and source
+    ##
+    def curl_html(url, headers: nil, headers_only: false, compressed: false)
+      flags = 'SsL'
+      flags += headers_only ? 'I' : 'i'
+      agent = ['Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_3_3 like Mac OS X; en-us)',
+               'AppleWebKit/533.17.9 (KHTML, like Gecko)',
+               'Version/5.0.2 Mobile/8J2 Safari/6533.18.5'].join(' ')
+      headers = headers.nil? ? '' : headers.map { |h, v| %(-H "#{h}: #{v}") }.join(' ')
+      compress = compressed ? '--compressed' : ''
+      source = `#{@curl} -#{flags} #{compress} #{headers} '#{url}' 2>/dev/null`
+      source = `#{@curl} -#{flags} #{compress} -A "#{agent}" #{headers} '#{url}' 2>/dev/null` if source.nil? || source.empty?
+
+      return false if source.nil? || source.empty?
+
+      source.strip!
+
+      headers = {}
+      lines = source.split(/\r\n/)
+      code = lines[0].match(/(\d\d\d)/)[1]
+      lines.shift
+      lines.each_with_index do |line, idx|
+        if line =~ /^([\w-]+): (.*?)$/
+          m = Regexp.last_match
+          headers[m[1]] = m[2]
+        else
+          source = lines[idx..].join("\n")
+          break
+        end
+      end
+
+      if headers['content-type'] =~ /json/
+        return { url: url, code: code, headers: headers, meta: nil, links: nil, head: nil, body: source.strip, source: source.strip, body_links: nil, body_images: nil }
+      end
+
+      head = source.match(%r{(?<=<head>)(.*?)(?=</head>)}mi)
+
+      if head.nil?
+        { url: url, code: code, headers: headers, meta: nil, links: nil, head: nil, body: source.strip, source: source.strip, body_links: nil, body_images: nil }
+      else
+        meta = meta_tags(head[1])
+        links = link_tags(head[1])
+        body = source.match(%r{<body.*?>(.*?)</body>}mi)[1]
+        { url: url, code: code, headers: headers, meta: meta, links: links, head: head[1], body: body, source: source.strip, body_links: body_links, body_images: body_images }
+      end
+    end
+
+    ##
+    ## Reencode the content (borrowed from Nokogiri)
+    ##
+    ## @param      body          [String] The body
+    ## @param      content_type  [String] Force content type
+    ##
+    def reencode(body, content_type = nil)
+      if body.encoding == Encoding::ASCII_8BIT
+        encoding = nil
+
+        # look for a Byte Order Mark (BOM)
+        initial_bytes = body[0..2].bytes
+        if initial_bytes[0..2] == [0xEF, 0xBB, 0xBF]
+          encoding = Encoding::UTF_8
+        elsif initial_bytes[0..1] == [0xFE, 0xFF]
+          encoding = Encoding::UTF_16BE
+        elsif initial_bytes[0..1] == [0xFF, 0xFE]
+          encoding = Encoding::UTF_16LE
+        end
+
+        # look for a charset in a content-encoding header
+        if content_type
+          encoding ||= content_type[/charset=["']?(.*?)($|["';\s])/i, 1]
+        end
+
+        # look for a charset in a meta tag in the first 1024 bytes
+        unless encoding
+          data = body[0..1023].gsub(/<!--.*?(-->|\Z)/m, "")
+          data.scan(/<meta.*?>/im).each do |meta|
+            encoding ||= meta[/charset=["']?([^>]*?)($|["'\s>])/im, 1]
+          end
+        end
+
+        # if all else fails, default to the official default encoding for HTML
+        encoding ||= Encoding::ISO_8859_1
+
+        # change the encoding to match the detected or inferred encoding
+        body = body.dup
+        begin
+          body.force_encoding(encoding)
+        rescue ArgumentError
+          body.force_encoding(Encoding::ISO_8859_1)
+        end
+      end
+
+      body.encode(Encoding::UTF_8)
+    end
+  end
+end

data/lib/searchlink/curl/json.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Curl
+  # Class for CURLing a JSON response
+  class Json
+    attr_reader :url, :code, :json, :headers
+
+    ##
+    ## Create a new Curl::Json page object
+    ##
+    ## @param      url         [String] The url to curl
+    ## @param      headers     [Hash] The headers to send
+    ## @param      compressed  [Boolean] Expect compressed results
+    ##
+    ## @return     [Curl::Json] Curl::Json object with url, code, parsed json, and response headers
+    ##
+    def initialize(url, headers: nil, compressed: false, symbolize_names: false)
+      @curl = TTY::Which.which('curl')
+      page = curl_json(url, headers: headers, compressed: compressed, symbolize_names: symbolize_names)
+      @url = page[:url]
+      @code = page[:code]
+      @json = page[:json]
+      @headers = page[:headers]
+    end
+
+    def path(path, json = @json)
+      parts = path.split(/./)
+      target = json
+      parts.each do |part|
+        if part =~ /(?<key>[^\[]+)\[(?<int>\d+)\]/
+          target = target[key][int.to_i]
+        else
+          target = target[part]
+        end
+      end
+
+      target
+    end
+
+    private
+
+    ##
+    ## Curl the JSON contents
+    ##
+    ## @param      url         [String] The url
+    ## @param      headers     [Hash] The headers to send
+    ## @param      compressed  [Boolean] Expect compressed results
+    ##
+    ## @return     [Hash] hash of url, code, headers, and parsed json
+    ##
+    def curl_json(url, headers: nil, compressed: false, symbolize_names: false)
+      flags = 'SsLi'
+      agent = ['Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_3_3 like Mac OS X; en-us)',
+               'AppleWebKit/533.17.9 (KHTML, like Gecko)',
+               'Version/5.0.2 Mobile/8J2 Safari/6533.18.5'].join(' ')
+      headers = headers.nil? ? '' : headers.map { |h, v| %(-H "#{h}: #{v}") }.join(' ')
+      compress = compressed ? '--compressed' : ''
+      source = `#{@curl} -#{flags} #{compress} #{headers} '#{url}' 2>/dev/null`
+      source = `#{@curl} -#{flags} #{compress} -A "#{agent}" #{headers} '#{url}' 2>/dev/null` if source.nil? || source.empty?
+
+      return false if source.nil? || source.empty?
+
+      source.strip!
+
+      headers = {}
+      lines = source.split(/\r\n/)
+      code = lines[0].match(/(\d\d\d)/)[1]
+      lines.shift
+      lines.each_with_index do |line, idx|
+        if line =~ /^([\w-]+): (.*?)$/
+          m = Regexp.last_match
+          headers[m[1]] = m[2]
+        else
+          source = lines[idx..].join("\n")
+          break
+        end
+      end
+
+      json = source.strip.force_encoding('utf-8')
+
+      json.gsub!(/[\u{1F600}-\u{1F6FF}]/, '')
+
+      { url: url, code: code, headers: headers, json: JSON.parse(json, symbolize_names: symbolize_names) }
+    rescue StandardError => e
+      warn e
+      warn e.backtrace
+      nil
+    end
+  end
+end

data/lib/searchlink/curl.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# import
+require_relative 'curl/html'
+
+# import
+require_relative 'curl/json'

data/lib/searchlink/help.rb

@@ -0,0 +1,103 @@
+module SL
+  class SearchLink
+    def help_css
+      <<~ENDCSS
+        body{-webkit-font-smoothing:antialiased;font-family:"Avenir Next",Avenir,"Helvetica Neue",Helvetica,Arial,Verdana,sans-serif;
+        margin:30px 0 0;padding:0;background:#fff;color:#303030;font-size:16px;line-height:1.5;text-align:center}h1{color:#000}
+        h2{color:#111}p,td,div{color:#111;font-family:"Avenir Next",Avenir,"Helvetica Neue",Helvetica,Arial,Verdana,sans-serif;
+        word-wrap:break-word}a{color:#de5456;text-decoration:none;-webkit-transition:color .2s ease-in-out;
+        -moz-transition:color .2s ease-in-out;-o-transition:color .2s ease-in-out;-ms-transition:color .2s ease-in-out;
+        transition:color .2s ease-in-out}a:hover{color:#3593d9}h1,h2,h3,h4,h5{margin:2.75rem 0 2rem;font-weight:500;line-height:1.15}
+        h1{margin-top:0;font-size:2em}h2{font-size:1.7em}ul,ol,pre,table,blockquote{margin-top:2em;margin-bottom:2em}
+        caption,col,colgroup,table,tbody,td,tfoot,th,thead,tr{border-spacing:0}table{border:1px solid rgba(0,0,0,0.25);
+        border-collapse:collapse;display:table;empty-cells:hide;margin:-1px 0 1.3125em;padding:0;table-layout:fixed;margin:0 auto}
+        caption{display:table-caption;font-weight:700}col{display:table-column}colgroup{display:table-column-group}
+        tbody{display:table-row-group}tfoot{display:table-footer-group}thead{display:table-header-group}
+        td,th{display:table-cell}tr{display:table-row}table th,table td{font-size:1.2em;line-height:1.3;padding:.5em 1em 0}
+        table thead{background:rgba(0,0,0,0.15);border:1px solid rgba(0,0,0,0.15);border-bottom:1px solid rgba(0,0,0,0.2)}
+        table tbody{background:rgba(0,0,0,0.05)}table tfoot{background:rgba(0,0,0,0.15);border:1px solid rgba(0,0,0,0.15);
+        border-top:1px solid rgba(0,0,0,0.2)}p{font-size:1.1429em;line-height:1.72em;margin:1.3125em 0}dt,th{font-weight:700}
+        table tr:nth-child(odd),table th:nth-child(odd),table td:nth-child(odd){background:rgba(255,255,255,0.06)}
+        table tr:nth-child(even),table td:nth-child(even){background:rgba(200,200,200,0.25)}
+        input[type=text] {padding: 5px;border-radius: 5px;border: solid 1px #ccc;font-size: 20px;}
+      ENDCSS
+    end
+
+    def help_js
+      <<~EOJS
+        function filterTable() {
+          let input, filter, table, tr, i, txtValue;
+          input = document.getElementById("filter");
+          filter = input.value.toUpperCase();
+          table = document.getElementById("searches");
+          table2 = document.getElementById("custom");
+
+          tr = table.getElementsByTagName("tr");
+
+          for (i = 0; i < tr.length; i++) {
+              txtValue = tr[i].textContent || tr[i].innerText;
+              if (txtValue.toUpperCase().indexOf(filter) > -1) {
+                tr[i].style.display = "";
+              } else {
+                tr[i].style.display = "none";
+              }
+          }
+
+          tr = table2.getElementsByTagName("tr");
+
+          for (i = 0; i < tr.length; i++) {
+              txtValue = tr[i].textContent || tr[i].innerText;
+              if (txtValue.toUpperCase().indexOf(filter) > -1) {
+                tr[i].style.display = "";
+              } else {
+                tr[i].style.display = "none";
+              }
+          }
+        }
+      EOJS
+    end
+
+    def help_text
+      text = <<~EOHELP
+        -- [Available searches] -------------------
+        #{SL::Searches.available_searches}
+      EOHELP
+
+      if SL.config['custom_site_searches']
+        text += "\n-- [Custom Searches] ----------------------\n"
+        SL.config['custom_site_searches'].sort_by { |l, s| l }.each { |label, site| text += "!#{label}#{label.spacer} #{site}\n" }
+      end
+      text
+    end
+
+    def help_html
+      out = ['<input type="text" id="filter" onkeyup="filterTable()" placeholder="Filter searches">']
+      out << '<h2>Available Searches</h2>'
+      out << SL::Searches.available_searches_html
+      out << '<h2>Custom Searches</h2>'
+      out << '<table id="custom">'
+      out << '<thead><td>Shortcut</td><td>Search Type</td></thead>'
+      out << '<tbody>'
+      SL.config['custom_site_searches'].each { |label, site| out << "<tr><td><code>!#{label}</code></td><td>#{site}</td></tr>" }
+      out << '</tbody>'
+      out << '</table>'
+      out.join("\n")
+    end
+
+    def help_dialog
+      text = ["<html><head><style>#{help_css}</style><script>#{help_js}</script></head><body>"]
+      text << '<h1>SearchLink Help</h1>'
+      text << "<p>[#{SL.version_check}] [<a href='https://github.com/ttscoff/searchlink/wiki'>Wiki</a>]</p>"
+      text << help_html
+      text << '<p><a href="https://github.com/ttscoff/searchlink/wiki">Visit the wiki</a> for additional information</p>'
+      text << '</body>'
+      html_file = File.expand_path('~/.searchlink_searches.html')
+      File.open(html_file, 'w') { |f| f.puts text.join("\n") }
+      `open #{html_file}`
+    end
+
+    def help_cli
+      $stdout.puts help_text
+    end
+  end
+end