gsc-cli 2.1.0 → 2.2.2

data/lib/gsc/serp_feature_detector.rb

@@ -0,0 +1,359 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+require 'time'
+require_relative 'google_suggest' if File.exist?(File.expand_path('google_suggest.rb', __dir__))
+
+module GSC
+  class SerpFeatureDetector
+    attr_reader :query, :options
+
+    def initialize(query, options = {})
+      @query = query.to_s.dup.force_encoding('UTF-8').scrub.strip
+      @options = options
+    end
+
+    def detect
+      intent = classify_intent(@query)
+      paa_questions = extract_live_paa_questions(@query)
+      live_serp = sample_live_serp(@query)
+
+      ai_overview = detect_ai_overview(@query, intent)
+      featured_snippet = detect_featured_snippet(@query, intent)
+      local_pack = detect_local_pack(@query)
+      video_carousel = detect_video_carousel(@query, live_serp)
+      forum_discussions = detect_forum_discussions(@query, live_serp)
+      shopping_pack = detect_shopping_pack(@query, intent)
+      sitelinks = detect_sitelinks(@query, intent)
+
+      zero_click = calculate_zero_click_risk(
+        ai_overview: ai_overview,
+        featured_snippet: featured_snippet,
+        paa_count: paa_questions.size,
+        local_pack: local_pack,
+        shopping_pack: shopping_pack,
+        video_carousel: video_carousel
+      )
+
+      playbook = generate_capture_playbook(
+        query: @query,
+        intent: intent,
+        ai_overview: ai_overview,
+        featured_snippet: featured_snippet,
+        paa_questions: paa_questions
+      )
+
+      {
+        query: @query,
+        timestamp: Time.now.utc.iso8601,
+        intent: intent,
+        zero_click_threat: zero_click,
+        features: {
+          ai_overview: ai_overview,
+          featured_snippet: featured_snippet,
+          people_also_ask: {
+            detected: !paa_questions.empty?,
+            count: paa_questions.size,
+            questions: paa_questions
+          },
+          local_3_pack: local_pack,
+          video_carousel: video_carousel,
+          discussions_and_forums: forum_discussions,
+          shopping_pack: shopping_pack,
+          sitelinks: sitelinks
+        },
+        serp_sampling: live_serp,
+        playbook: playbook
+      }
+    end
+
+    private
+
+    def classify_intent(query)
+      q = query.downcase
+
+      if q =~ /\b(near me|in [a-z]+|city|store|repair|dentist|plumber|gym|shop|restaurant|agency)\b/i
+        { primary: 'Local', secondary: 'Commercial', description: 'User seeking physical or regional local service' }
+      elsif q =~ /\b(buy|order|purchase|coupon|discount|deal|cheap|for sale|pricing|price|cost)\b/i
+        { primary: 'Transactional', secondary: 'Commercial', description: 'User is ready to make an immediate purchase' }
+      elsif q =~ /\b(best|top|review|vs|versus|compare|alternative|alternatives|software|tool|app|guide)\b/i
+        { primary: 'Commercial', secondary: 'Informational', description: 'User evaluating products or services before purchasing' }
+      elsif q =~ /\b(login|portal|website|account|dashboard|sign in|app\.|\.com)\b/i
+        { primary: 'Navigational', secondary: 'Brand', description: 'User navigating to a specific brand destination' }
+      else
+        { primary: 'Informational', secondary: 'Research', description: 'User seeking knowledge, definitions, answers or tutorials' }
+      end
+    end
+
+    def extract_live_paa_questions(query)
+      suggest = GSC::GoogleSuggest.new(query)
+      raw = suggest.fetch(questions: true)
+      extracted = []
+
+      if raw.is_a?(Hash)
+        raw.each_value do |items|
+          Array(items).each do |item|
+            term = item.is_a?(Hash) ? item[:term] : item.to_s
+            clean = term.to_s.strip
+            extracted << clean if !clean.empty? && !extracted.include?(clean)
+          end
+        end
+      elsif raw.is_a?(Array)
+        raw.each do |entry|
+          if entry.is_a?(Array) && entry[1].is_a?(Array)
+            entry[1].each do |item|
+              term = item.is_a?(Hash) ? item[:term] : item.to_s
+              clean = term.to_s.strip
+              extracted << clean if !clean.empty? && !extracted.include?(clean)
+            end
+          elsif entry.is_a?(Hash) && entry[:term]
+            term = entry[:term].to_s.strip
+            extracted << term if !term.empty? && !extracted.include?(term)
+          end
+        end
+      end
+
+      # Filter for relevance to query tokens
+      tokens = query.downcase.split(/\s+/).reject { |t| t.length < 3 }
+      relevant = if tokens.empty?
+                   extracted
+                 else
+                   matched = extracted.select { |q| tokens.any? { |t| q.downcase.include?(t) } }
+                   matched.empty? ? extracted : matched
+                 end
+
+      relevant.first(8)
+    rescue StandardError
+      []
+    end
+
+    def sample_live_serp(query)
+      results = []
+      uri = URI("https://www.bing.com/search?q=#{URI.encode_www_form_component(query)}&setlang=en-US&cc=US")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = 3
+      http.read_timeout = 3
+      req = Net::HTTP::Get.new(uri.request_uri)
+      req['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36'
+      req['Accept-Language'] = 'en-US,en;q=0.9'
+
+      res = http.request(req)
+      if res.is_a?(Net::HTTPSuccess)
+        body = res.body.to_s.dup.force_encoding('UTF-8').scrub
+        matches = body.scan(/<li class="b_algo"[^>]*>.*?<h2><a[^>]*href="([^"]+)"[^>]*>(.*?)<\/a><\/h2>(?:.*?<p[^>]*>(.*?)<\/p>)?/im)
+        matches.first(6).each_with_index do |(url, raw_title, raw_snippet), idx|
+          title = raw_title.to_s.gsub(/<[^>]+>/, '').strip
+          snippet = raw_snippet.to_s.gsub(/<[^>]+>/, '').strip
+          domain = URI.parse(url).host rescue url
+          results << {
+            position: idx + 1,
+            title: title,
+            url: url,
+            domain: domain,
+            snippet: snippet[0..140]
+          }
+        end
+      end
+      results
+    rescue StandardError
+      []
+    end
+
+    def detect_ai_overview(query, intent)
+      q = query.downcase
+      triggers = []
+      probability = 15
+
+      if intent[:primary] == 'Informational'
+        probability += 40
+        triggers << 'Informational search intent'
+      end
+
+      if q =~ /^(what is|how to|why does|how do|what are|difference between|steps to|guide to)\b/i
+        probability += 35
+        triggers << 'Interrogative / procedural query prefix'
+      elsif q.include?(' vs ') || q.include?(' versus ')
+        probability += 30
+        triggers << 'Direct comparative product/concept syntax'
+      end
+
+      if q.split(/\s+/).size >= 4
+        probability += 10
+        triggers << 'Long-tail semantic query depth'
+      end
+
+      probability = [probability, 95].min
+      detected = probability >= 60
+
+      {
+        detected: detected,
+        probability_pct: probability,
+        triggers: triggers,
+        displacement_pixels: detected ? 850 : 0,
+        impact: detected ? 'Severe: Google Gemini AI Overview displaces Top 1 organic result below the viewport fold.' : 'Low: Traditional organic listings occupy top positions.',
+        counter_strategy: 'Structure content with direct 40–50 word definition answer, bulleted takeaways, and FAQPage/Question JSON-LD markup.'
+      }
+    end
+
+    def detect_featured_snippet(query, intent)
+      q = query.downcase
+      format = :none
+      probability = 10
+      target_recipe = ''
+
+      if q =~ /^(how to|steps to|guide|tutorial|how do i)\b/i
+        format = :ordered_list
+        probability = 90
+        target_recipe = 'Use an ordered list (<ol><li>) with 5–8 actionable sequential steps directly under an H2 heading.'
+      elsif q.include?(' vs ') || q.include?('difference between') || q =~ /\b(pricing|cost|plans|tiers|specs)\b/i
+        format = :table
+        probability = 75
+        target_recipe = 'Provide a structured HTML <table> with clear column headers (<th>) comparing key attributes and metrics.'
+      elsif q =~ /\b(best|top|types of|examples of|list of)\b/i
+        format = :unordered_list
+        probability = 80
+        target_recipe = 'Use an unordered bullet list (<ul><li>) highlighting 5–10 items with bold introductory headers.'
+      elsif q =~ /^(what is|who is|definition of|meaning of|what does)\b/i || intent[:primary] == 'Informational'
+        format = :paragraph
+        probability = 85
+        target_recipe = 'Place target query in <h2>, followed immediately by a concise 42–55 word direct definition answer block.'
+      end
+
+      {
+        detected: format != :none,
+        target_format: format.to_s,
+        probability_pct: probability,
+        optimal_length: format == :paragraph ? '40–60 words (~280–350 chars)' : '5–8 structured items',
+        capture_prescription: target_recipe
+      }
+    end
+
+    def detect_local_pack(query)
+      q = query.downcase
+      is_local = q =~ /\b(near me|in [a-z]+|city|store|repair|dentist|plumber|gym|shop|restaurant|agency|services|near)\b/i
+      {
+        detected: !!is_local,
+        probability_pct: is_local ? 90 : 5,
+        notes: is_local ? 'Triggers Google Maps 3-Pack; local organic listings appear below maps.' : 'No local intent detected.'
+      }
+    end
+
+    def detect_video_carousel(query, live_serp)
+      q = query.downcase
+      has_video_kw = q =~ /\b(how to|tutorial|review|walkthrough|guide|setup|install|demo|video|diy|unboxing)\b/i
+      serp_has_youtube = live_serp.any? { |r| r[:url].to_s.include?('youtube.com') }
+      detected = !!(has_video_kw || serp_has_youtube)
+
+      {
+        detected: detected,
+        probability_pct: detected ? 80 : 15,
+        notes: detected ? 'Video carousel likely above or between organic results. YouTube videos dominate.' : 'Low video intent.'
+      }
+    end
+
+    def detect_forum_discussions(query, live_serp)
+      q = query.downcase
+      has_forum_kw = q =~ /\b(reddit|quora|worth it|opinions|review|anyone tried|experiences|recommendations|issues)\b/i
+      serp_has_forum = live_serp.any? { |r| r[:url].to_s =~ /(reddit\.com|quora\.com|community\.)/i }
+      detected = !!(has_forum_kw || serp_has_forum)
+
+      {
+        detected: detected,
+        probability_pct: detected ? 85 : 20,
+        notes: detected ? 'Google "Discussions and Forums" module active. Authentic first-person experiences prioritized.' : 'Standard commercial/informational listings dominate.'
+      }
+    end
+
+    def detect_shopping_pack(query, intent)
+      q = query.downcase
+      is_shopping = (intent[:primary] == 'Transactional') || (q =~ /\b(buy|price|cost|cheap|best|discount|sale|store|deals|shop|coupon)\b/i)
+      {
+        detected: !!is_shopping,
+        probability_pct: is_shopping ? 85 : 10,
+        notes: is_shopping ? 'Product grid / Google Shopping carousels occupy top above-the-fold position.' : 'Non-e-commerce SERP.'
+      }
+    end
+
+    def detect_sitelinks(query, intent)
+      is_brand = (intent[:primary] == 'Navigational') || (query.split(/\s+/).size <= 2 && query =~ /^[A-Z][a-zA-Z0-9]+$/)
+      {
+        detected: !!is_brand,
+        probability_pct: is_brand ? 90 : 15,
+        notes: is_brand ? 'Expanded 6-pack or 4-pack branded sitelinks trigger for primary domain.' : 'Standard single-line snippets.'
+      }
+    end
+
+    def calculate_zero_click_risk(ai_overview:, featured_snippet:, paa_count:, local_pack:, shopping_pack:, video_carousel:)
+      score = 10
+      score += 35 if ai_overview[:detected]
+      score += 25 if featured_snippet[:detected]
+      score += 15 if paa_count >= 3
+      score += 10 if local_pack[:detected]
+      score += 10 if shopping_pack[:detected]
+      score += 5  if video_carousel[:detected]
+
+      score = [score, 100].min
+
+      level = case score
+              when 0..30   then 'LOW'
+              when 31..55  then 'MODERATE'
+              when 56..79  then 'HIGH'
+              else              'SEVERE'
+              end
+
+      ctr_drop = case level
+                 when 'LOW'      then '-5% to -10%'
+                 when 'MODERATE' then '-15% to -25%'
+                 when 'HIGH'     then '-30% to -45%'
+                 when 'SEVERE'   then '-50% to -65%'
+                 end
+
+      {
+        score: score,
+        level: level,
+        estimated_organic_ctr_suppression: ctr_drop,
+        summary: "Zero-Click Threat is #{level} (#{score}/100). SERP features push standard organic rankings down."
+      }
+    end
+
+    def generate_capture_playbook(query:, intent:, ai_overview:, featured_snippet:, paa_questions:)
+      playbook = []
+
+      if featured_snippet[:detected]
+        playbook << {
+          target: "Featured Snippet (#{featured_snippet[:target_format].capitalize})",
+          action: featured_snippet[:capture_prescription],
+          priority: 'P1 - High Impact'
+        }
+      end
+
+      if ai_overview[:detected]
+        playbook << {
+          target: 'Google Gemini AI Overview Citation',
+          action: 'Provide authoritative factual statistics with citability markers (author bio, published date, quantitative percentages).',
+          priority: 'P1 - High Impact'
+        }
+      end
+
+      if !paa_questions.empty?
+        playbook << {
+          target: 'People Also Ask (PAA) Inclusion',
+          action: "Inject H3 headings answering top questions: \"#{paa_questions.first(3).join('", "')}\" using Schema.org FAQPage JSON-LD.",
+          priority: 'P2 - Traffic Expansion'
+        }
+      end
+
+      playbook << {
+        target: 'Entity Disambiguation',
+        action: 'Include sameAs Wikidata / Wikipedia references and Organization structured data to anchor topical authority.',
+        priority: 'P3 - Topical Authority'
+      }
+
+      playbook
+    end
+  end
+end

data/lib/gsc/serp_preview.rb

@@ -1,54 +1,140 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
+require 'uri'
+
 module GSC
   class SerpPreview
-    attr_reader :url, :data
+    attr_reader :url, :title, :desc, :data
+
+    DESKTOP_TITLE_PIXEL_LIMIT = 580.0
+    MOBILE_TITLE_PIXEL_LIMIT  = 650.0
+    DESKTOP_DESC_PIXEL_LIMIT  = 960.0
+    MOBILE_DESC_PIXEL_LIMIT   = 680.0
 
-    def initialize(url)
-      @url = url.to_s.strip
+    def initialize(url = nil, title: nil, desc: nil)
+      @url = url.to_s.dup.force_encoding('UTF-8').scrub.strip
+      @custom_title = title ? title.to_s.dup.force_encoding('UTF-8').scrub : nil
+      @custom_desc = desc ? desc.to_s.dup.force_encoding('UTF-8').scrub : nil
     end
 
     def generate
+      if @custom_title || @custom_desc
+        generate_custom
+      elsif !@url.empty? && @url.start_with?('http://', 'https://')
+        generate_from_url
+      else
+        generate_custom
+      end
+    end
+
+    def self.estimate_pixel_width(str)
+      width = 0.0
+      str.to_s.each_char do |ch|
+        width += case ch
+                 when /[WMwm]/ then 13.5
+                 when /[ABCDEFGHKNOPQRSTUVXYZ]/ then 10.5
+                 when /[abcdeghnopqrsuvxyz]/ then 8.5
+                 when /[fIjt1l\|\ \.\:\;]/ then 4.5
+                 else 9.0
+                 end
+      end
+      width.round(1)
+    end
+
+    private
+
+    def generate_from_url
       pa = GSC::PageAnalyzer.new(@url)
       @data = pa.fetch_and_analyze
 
-      title = @data.dig(:title, :text) || 'Untitled Page'
-      desc = @data.dig(:meta_description, :text) || 'No meta description found.'
+      title = @custom_title || @data.dig(:title, :text) || 'Untitled Page'
+      desc = @custom_desc || @data.dig(:meta_description, :text) || 'No meta description found.'
       canonical = @data.dig(:canonical, :url) || @url
 
-      # SERP pixel calculation approximation:
-      # ~10px per character average for Arial 18px title
-      title_chars = title.length
-      is_truncated = title_chars > 60
-
-      desktop_title = is_truncated ? "#{title[0..56]}..." : title
-      desktop_snippet = desc.length > 155 ? "#{desc[0..152]}..." : desc
-
       og = @data[:open_graph] || {}
       twitter = @data[:twitter_card] || {}
 
-      {
+      build_result(
         url: @url,
         canonical: canonical,
         title: title,
+        desc: desc,
+        og_title: og['og:title'],
+        og_description: og['og:description'],
+        og_image: og['og:image'],
+        twitter_card: twitter['twitter:card']
+      )
+    end
+
+    def generate_custom
+      url = @url.empty? ? (Config.default_domain ? "https://#{Config.default_domain}/page" : '/') : @url
+      title = @custom_title || 'Untitled Page'
+      desc = @custom_desc || ''
+
+      build_result(
+        url: url,
+        canonical: url,
+        title: title,
+        desc: desc
+      )
+    end
+
+    def build_result(url:, canonical:, title:, desc:, og_title: nil, og_description: nil, og_image: nil, twitter_card: nil)
+      t_px = self.class.estimate_pixel_width(title)
+      d_px = self.class.estimate_pixel_width(desc)
+
+      title_truncated = t_px > DESKTOP_TITLE_PIXEL_LIMIT
+      desc_truncated  = d_px > DESKTOP_DESC_PIXEL_LIMIT
+
+      desktop_title = title_truncated ? truncate_to_pixels(title, DESKTOP_TITLE_PIXEL_LIMIT) : title
+      desktop_desc  = desc_truncated  ? truncate_to_pixels(desc, DESKTOP_DESC_PIXEL_LIMIT)  : desc
+
+      {
+        url: url,
+        canonical: canonical,
+        title: title,
         meta_description: desc,
-        truncation_risk: is_truncated,
+        metrics: {
+          title_chars: title.length,
+          title_pixel_est: t_px,
+          title_desktop_limit: DESKTOP_TITLE_PIXEL_LIMIT,
+          title_truncated: title_truncated,
+          desc_chars: desc.length,
+          desc_pixel_est: d_px,
+          desc_desktop_limit: DESKTOP_DESC_PIXEL_LIMIT,
+          desc_truncated: desc_truncated
+        },
         desktop_serp: {
+          breadcrumb: format_breadcrumb(canonical),
           title: desktop_title,
-          snippet: desktop_snippet,
-          breadcrumb: format_breadcrumb(canonical)
+          snippet: desktop_desc
+        },
+        mobile_serp: {
+          breadcrumb: format_breadcrumb(canonical),
+          title: t_px > MOBILE_TITLE_PIXEL_LIMIT ? truncate_to_pixels(title, MOBILE_TITLE_PIXEL_LIMIT) : title,
+          snippet: d_px > MOBILE_DESC_PIXEL_LIMIT ? truncate_to_pixels(desc, MOBILE_DESC_PIXEL_LIMIT) : desc
         },
         social: {
-          og_title: og['og:title'] || title,
-          og_description: og['og:description'] || desc,
-          og_image: og['og:image'],
-          twitter_card: twitter['twitter:card'] || 'summary_large_image'
+          og_title: og_title || title,
+          og_description: og_description || desc,
+          og_image: og_image,
+          twitter_card: twitter_card || 'summary_large_image'
         }
       }
     end
 
-    private
+    def truncate_to_pixels(str, limit)
+      return str if self.class.estimate_pixel_width(str) <= limit
+
+      chars = []
+      str.each_char do |c|
+        candidate = "#{chars.join}#{c}..."
+        break if self.class.estimate_pixel_width(candidate) > limit
+        chars << c
+      end
+      "#{chars.join}..."
+    end
 
     def format_breadcrumb(url_str)
       uri = URI.parse(url_str) rescue nil

data/lib/gsc/site_crawler.rb

@@ -26,18 +26,53 @@ module GSC
       urls = urls.first(@options[:limit]) if @options[:limit] && @options[:limit] > 0
 
       total = urls.size
-      urls.each_with_index do |url, idx|
-        progress_block.call(url, idx + 1, total) if block_given?
-
-        analyzer = PageAnalyzer.new(url)
-        page_data = analyzer.fetch_and_analyze(
-          check_links: @options[:check_links] || false,
-          gsc_api: @options[:gsc_api],
-          active_domain: @options[:active_domain]
-        )
-
-        @results << page_data
-        categorize_page_issues(page_data)
+      concurrency = (@options[:concurrency] || 5).to_i
+      concurrency = 1 if concurrency < 1
+      concurrency = [concurrency, 20].min
+      concurrency = [concurrency, total].min if total > 0
+
+      if concurrency <= 1 || total <= 1
+        urls.each_with_index do |url, idx|
+          progress_block.call(url, idx + 1, total) if block_given?
+
+          page_data = safe_analyze_page(url)
+          @results << page_data
+          categorize_page_issues(page_data)
+        end
+      else
+        require 'thread'
+        queue = Queue.new
+        urls.each_with_index { |url, idx| queue << [url, idx] }
+
+        indexed_results = []
+        mutex = Mutex.new
+        completed_count = 0
+
+        workers = Array.new(concurrency) do
+          Thread.new do
+            loop do
+              item = begin
+                queue.pop(true)
+              rescue ThreadError
+                nil
+              end
+              break unless item
+
+              url, idx = item
+              page_data = safe_analyze_page(url)
+
+              mutex.synchronize do
+                completed_count += 1
+                indexed_results << [idx, page_data]
+                categorize_page_issues(page_data)
+                progress_block.call(url, completed_count, total) if block_given?
+              end
+            end
+          end
+        end
+
+        workers.each(&:join)
+        @results = indexed_results.sort_by(&:first).map(&:last)
       end
 
       aggregate_summary
@@ -157,7 +192,7 @@ module GSC
     end
 
     def aggregate_summary
-      critical_errors = @broken_links.size + @results.count { |r| r[:indexability][:noindex] }
+      critical_errors = @broken_links.size + @results.count { |r| r.dig(:indexability, :noindex) || false }
       total_issues = critical_errors + @missing_alts.size + @heading_issues.size + @title_issues.size + @canonical_issues.size
 
       {
@@ -174,6 +209,28 @@ module GSC
 
     private
 
+    def safe_analyze_page(url)
+      analyzer = PageAnalyzer.new(url)
+      analyzer.fetch_and_analyze(
+        check_links: @options[:check_links] || false,
+        gsc_api: @options[:gsc_api],
+        active_domain: @options[:active_domain]
+      )
+    rescue StandardError => e
+      {
+        url: url,
+        http_status: 0,
+        response_time_ms: 0,
+        title: { text: '', length: 0, pixel_est: 0.0, ok: false },
+        meta_description: { text: '', length: 0, ok: false },
+        canonical: { url: nil, self_referencing: false },
+        headings: { count: 0, h1_count: 0, score: 0, grade: 'F', violations: [], list: [] },
+        images: { total: 0, missing_alt_count: 0, missing_alt: [] },
+        links: { total: 0, internal_count: 0, external_count: 0, internal: [], external: [] },
+        issues: [{ level: :error, type: :network, message: "Crawl failure: #{e.message}" }]
+      }
+    end
+
     def discover_urls(target)
       if target.end_with?('.xml') || target.include?('sitemap')
         SitemapLoader.load_urls(target)
@@ -217,18 +274,42 @@ module GSC
       end
 
       # Headings
-      h1_count = data.dig(:headings, :h1_count) || 0
+      headings_obj = data[:headings]
+      h1_count = if headings_obj.is_a?(Hash)
+                   headings_obj[:h1_count] || headings_obj['h1_count'] || 0
+                 elsif data[:h1].is_a?(Array)
+                   data[:h1].size
+                 else
+                   0
+                 end
+
       if h1_count == 0
         @heading_issues << { page_url: page_url, issue: "Missing <h1> tag (0 found)" }
       elsif h1_count > 1
         @heading_issues << { page_url: page_url, issue: "Multiple <h1> tags (#{h1_count} found)" }
       end
 
-      # Title & Meta
-      title_chars = data.dig(:title, :length) || 0
-      meta_chars = data.dig(:meta_description, :length) || 0
-      title_text = data.dig(:title, :text) || ''
-      meta_text = data.dig(:meta_description, :text) || ''
+      # Title
+      title_obj = data[:title]
+      title_text, title_chars = if title_obj.is_a?(Hash)
+                                  t = (title_obj[:text] || title_obj['text']).to_s
+                                  [t, (title_obj[:length] || title_obj['length'] || t.length).to_i]
+                                elsif title_obj.is_a?(String)
+                                  [title_obj, title_obj.length]
+                                else
+                                  ['', 0]
+                                end
+
+      # Meta Description
+      meta_obj = data[:meta_description]
+      meta_text, meta_chars = if meta_obj.is_a?(Hash)
+                                m = (meta_obj[:text] || meta_obj['text']).to_s
+                                [m, (meta_obj[:length] || meta_obj['length'] || m.length).to_i]
+                              elsif meta_obj.is_a?(String)
+                                [meta_obj, meta_obj.length]
+                              else
+                                ['', 0]
+                              end
 
       flaws = []
       flaws << "Title > 60 chars" if title_chars > 60
@@ -249,10 +330,21 @@ module GSC
       end
 
       # Canonical
-      if data.dig(:canonical, :url) && !data.dig(:canonical, :self_referencing)
+      canon_obj = data[:canonical]
+      canon_url = nil
+      self_ref = false
+      if canon_obj.is_a?(Hash)
+        canon_url = canon_obj[:url] || canon_obj['url']
+        self_ref = canon_obj[:self_referencing] || false
+      elsif canon_obj.is_a?(String)
+        canon_url = canon_obj
+        self_ref = (canon_url == page_url)
+      end
+
+      if canon_url && !self_ref
         @canonical_issues << {
           page_url: page_url,
-          canonical_url: data[:canonical][:url]
+          canonical_url: canon_url
         }
       end
     end