From 526a0c069101bb54f77e08ba5e85753ec70f3b48 Mon Sep 17 00:00:00 2001 From: Brent Date: Tue, 26 May 2026 11:27:57 +0200 Subject: [PATCH 01/16] Bootstrap Ruby project toolchain - Gemfile with nokolexbor, rspec, rubocop, bundler-audit, lefthook - GitHub Actions CI: security scan, lint, rspec - Dependabot for weekly gem and action updates - Lefthook pre-commit: rubocop on staged files + bundler-audit - Setup RSpec and RuboCop. - /ci command for polling CI status from Claude --- .claude/commands/ci.md | 29 +++++++++++++++ .github/dependabot.yml | 12 ++++++ .github/workflows/ci.yml | 52 ++++++++++++++++++++++++++ .rspec | 3 ++ .rubocop.yml | 12 ++++++ .ruby-version | 1 + Gemfile | 15 ++++++++ Gemfile.lock | 77 ++++++++++++++++++++++++++++++++++++++ README.md | 13 +++++++ bin/bundle-audit | 27 ++++++++++++++ bin/bundler-audit | 27 ++++++++++++++ bin/claudes/ci-status | 80 ++++++++++++++++++++++++++++++++++++++++ bin/rspec | 27 ++++++++++++++ bin/rubocop | 27 ++++++++++++++ lefthook.yml | 10 +++++ spec/spec_helper.rb | 18 +++++++++ 16 files changed, 430 insertions(+) create mode 100644 .claude/commands/ci.md create mode 100644 .github/dependabot.yml create mode 100644 .github/workflows/ci.yml create mode 100644 .rspec create mode 100644 .rubocop.yml create mode 100644 .ruby-version create mode 100644 Gemfile create mode 100644 Gemfile.lock create mode 100755 bin/bundle-audit create mode 100755 bin/bundler-audit create mode 100755 bin/claudes/ci-status create mode 100755 bin/rspec create mode 100755 bin/rubocop create mode 100644 lefthook.yml create mode 100644 spec/spec_helper.rb diff --git a/.claude/commands/ci.md b/.claude/commands/ci.md new file mode 100644 index 00000000..3298f85f --- /dev/null +++ b/.claude/commands/ci.md @@ -0,0 +1,29 @@ +--- +description: Check CI status +skill: NONE +--- + +# /ci + +Check GitHub Actions CI status. Polls until complete. + +Pipeline: rubocop → bundler-audit → rspec. + +## Instructions + +### 1. Run the status script + +```bash +cd ~/projects/serp-van-gogh/serpapi-code-challenge +bin/claudes/ci-status +``` + +### 2. Evaluate output + +**STATUS: no_runs** — No CI runs found. Ask: "Want to push, or check all recent runs?" + +**STATUS: success** — All jobs passed. + +**STATUS: failure** — Failed logs are in the output. Investigate and suggest a fix. + +**STATUS: timeout** — CI still running after 15 minutes. Offer to check again. diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 00000000..91630464 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,12 @@ +version: 2 +updates: + - package-ecosystem: bundler + directory: "/" + schedule: + interval: weekly + open-pull-requests-limit: 1 + - package-ecosystem: github-actions + directory: "/" + schedule: + interval: weekly + open-pull-requests-limit: 1 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 00000000..f67eb39c --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,52 @@ +name: CI + +on: + pull_request: + push: + branches: [ master ] + +jobs: + scan_ruby: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Ruby + uses: ruby/setup-ruby@v1 + with: + bundler-cache: true + + - name: Scan for known security vulnerabilities in gems + run: bin/bundler-audit check --update + + lint: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Ruby + uses: ruby/setup-ruby@v1 + with: + bundler-cache: true + + - name: Lint code for consistent style + run: bin/rubocop -f github + + test: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Ruby + uses: ruby/setup-ruby@v1 + with: + bundler-cache: true + + - name: Run tests + run: bundle exec rspec diff --git a/.rspec b/.rspec new file mode 100644 index 00000000..34c5164d --- /dev/null +++ b/.rspec @@ -0,0 +1,3 @@ +--format documentation +--color +--require spec_helper diff --git a/.rubocop.yml b/.rubocop.yml new file mode 100644 index 00000000..873b5be7 --- /dev/null +++ b/.rubocop.yml @@ -0,0 +1,12 @@ +AllCops: + NewCops: enable + SuggestExtensions: false + Exclude: + - "vendor/**/*" + - "bin/**/*" + +Style/StringLiterals: + EnforcedStyle: double_quotes + +Style/FrozenStringLiteralComment: + Enabled: false diff --git a/.ruby-version b/.ruby-version new file mode 100644 index 00000000..61a52c91 --- /dev/null +++ b/.ruby-version @@ -0,0 +1 @@ +ruby-3.4.9 diff --git a/Gemfile b/Gemfile new file mode 100644 index 00000000..2cff778d --- /dev/null +++ b/Gemfile @@ -0,0 +1,15 @@ +source "https://rubygems.org" + +ruby "3.4.9" + +gem "nokolexbor" + +group :development, :test do + gem "bundler-audit", require: false + gem "lefthook", require: false + gem "rubocop", require: false +end + +group :test do + gem "rspec" +end diff --git a/Gemfile.lock b/Gemfile.lock new file mode 100644 index 00000000..fe9d3f37 --- /dev/null +++ b/Gemfile.lock @@ -0,0 +1,77 @@ +GEM + remote: https://rubygems.org/ + specs: + ast (2.4.3) + bundler-audit (0.9.3) + bundler (>= 1.2.0) + thor (~> 1.0) + diff-lcs (1.6.2) + json (2.19.5) + language_server-protocol (3.17.0.5) + lefthook (2.1.8) + lint_roller (1.1.0) + nokolexbor (0.7.0) + nokolexbor (0.7.0-aarch64-linux) + nokolexbor (0.7.0-arm64-darwin) + nokolexbor (0.7.0-x86_64-darwin) + nokolexbor (0.7.0-x86_64-linux) + parallel (2.1.0) + parser (3.3.11.1) + ast (~> 2.4.1) + racc + prism (1.9.0) + racc (1.8.1) + rainbow (3.1.1) + regexp_parser (2.12.0) + rspec (3.13.2) + rspec-core (~> 3.13.0) + rspec-expectations (~> 3.13.0) + rspec-mocks (~> 3.13.0) + rspec-core (3.13.6) + rspec-support (~> 3.13.0) + rspec-expectations (3.13.5) + diff-lcs (>= 1.2.0, < 2.0) + rspec-support (~> 3.13.0) + rspec-mocks (3.13.8) + diff-lcs (>= 1.2.0, < 2.0) + rspec-support (~> 3.13.0) + rspec-support (3.13.7) + rubocop (1.86.2) + json (~> 2.3) + language_server-protocol (~> 3.17.0.2) + lint_roller (~> 1.1.0) + parallel (>= 1.10) + parser (>= 3.3.0.2) + rainbow (>= 2.2.2, < 4.0) + regexp_parser (>= 2.9.3, < 3.0) + rubocop-ast (>= 1.49.0, < 2.0) + ruby-progressbar (~> 1.7) + unicode-display_width (>= 2.4.0, < 4.0) + rubocop-ast (1.49.1) + parser (>= 3.3.7.2) + prism (~> 1.7) + ruby-progressbar (1.13.0) + thor (1.5.0) + unicode-display_width (3.2.0) + unicode-emoji (~> 4.1) + unicode-emoji (4.2.0) + +PLATFORMS + aarch64-linux + arm64-darwin + ruby + x86_64-darwin + x86_64-linux + +DEPENDENCIES + bundler-audit + lefthook + nokolexbor + rspec + rubocop + +RUBY VERSION + ruby 3.4.9p82 + +BUNDLED WITH + 2.6.9 diff --git a/README.md b/README.md index 4d5a093f..16f6bf66 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,18 @@ # Extract Van Gogh Paintings Code Challenge +[![CI](https://github.com/brentgreeff/serpapi-code-challenge/actions/workflows/ci.yml/badge.svg)](https://github.com/brentgreeff/serpapi-code-challenge/actions/workflows/ci.yml) + +## Dev Setup + +```bash +bundle install +lefthook install +``` + +```bash +bundle exec rspec +``` + Goal is to extract a list of Van Gogh paintings from the attached Google search results page. ![Van Gogh paintings](https://github.com/serpapi/code-challenge/blob/master/files/van-gogh-paintings.png?raw=true "Van Gogh paintings") diff --git a/bin/bundle-audit b/bin/bundle-audit new file mode 100755 index 00000000..a0e7ba0e --- /dev/null +++ b/bin/bundle-audit @@ -0,0 +1,27 @@ +#!/usr/bin/env ruby +# frozen_string_literal: true + +# +# This file was generated by Bundler. +# +# The application 'bundle-audit' is installed as part of a gem, and +# this file is here to facilitate running it. +# + +ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__) + +bundle_binstub = File.expand_path("bundle", __dir__) + +if File.file?(bundle_binstub) + if File.read(bundle_binstub, 300).include?("This file was generated by Bundler") + load(bundle_binstub) + else + abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run. +Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.") + end +end + +require "rubygems" +require "bundler/setup" + +load Gem.bin_path("bundler-audit", "bundle-audit") diff --git a/bin/bundler-audit b/bin/bundler-audit new file mode 100755 index 00000000..334a7378 --- /dev/null +++ b/bin/bundler-audit @@ -0,0 +1,27 @@ +#!/usr/bin/env ruby +# frozen_string_literal: true + +# +# This file was generated by Bundler. +# +# The application 'bundler-audit' is installed as part of a gem, and +# this file is here to facilitate running it. +# + +ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__) + +bundle_binstub = File.expand_path("bundle", __dir__) + +if File.file?(bundle_binstub) + if File.read(bundle_binstub, 300).include?("This file was generated by Bundler") + load(bundle_binstub) + else + abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run. +Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.") + end +end + +require "rubygems" +require "bundler/setup" + +load Gem.bin_path("bundler-audit", "bundler-audit") diff --git a/bin/claudes/ci-status b/bin/claudes/ci-status new file mode 100755 index 00000000..b4cfc9e4 --- /dev/null +++ b/bin/claudes/ci-status @@ -0,0 +1,80 @@ +#!/usr/bin/env bash +# Poll CI status for latest run until complete +set -euo pipefail + +POLL_INTERVAL=30 +MAX_POLLS=10 + +echo "=== CI Status ===" +echo "" + +local_sha=$(git rev-parse --short HEAD 2>/dev/null || echo "unknown") +local_time=$(git log -1 --format='%ar' 2>/dev/null || echo "unknown") +remote_branch=$(git rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null || echo "none") +if [[ "$remote_branch" != "none" ]]; then + remote_sha=$(git rev-parse --short "$remote_branch" 2>/dev/null || echo "unknown") + if [[ "$local_sha" == "$remote_sha" ]]; then + echo "HEAD: $local_sha ($local_time, pushed)" + else + echo "HEAD: $local_sha ($local_time) — remote: $remote_sha (NOT PUSHED)" + fi +else + echo "HEAD: $local_sha ($local_time) — no upstream set (NOT PUSHED)" +fi +echo "" + +poll=0 +while true; do + poll=$((poll + 1)) + + runs=$(gh run list --limit 5 --json name,status,conclusion,databaseId,headSha,createdAt --jq '[.[] | select(.name == "CI")]' 2>/dev/null || echo "[]") + count=$(echo "$runs" | jq 'length') + + if [[ "$count" == "0" ]]; then + echo "No CI runs found" + echo "" + echo "STATUS: no_runs" + exit 0 + fi + + latest=$(echo "$runs" | jq '.[0]') + sha=$(echo "$latest" | jq -r '.headSha[:7]') + status=$(echo "$latest" | jq -r '.status') + conclusion=$(echo "$latest" | jq -r '.conclusion') + run_id=$(echo "$latest" | jq -r '.databaseId') + + if [[ "$status" != "completed" ]]; then + echo "Poll $poll — commit $sha — $status" + gh run view "$run_id" --json jobs --jq '.jobs[] | " \(.name): \(.status) \(.conclusion)"' 2>/dev/null || true + echo "" + + if [[ $poll -ge $MAX_POLLS ]]; then + echo "Gave up after $((poll * POLL_INTERVAL))s" + echo "" + echo "STATUS: timeout" + exit 1 + fi + + echo "Sleeping ${POLL_INTERVAL}s..." + sleep $POLL_INTERVAL + continue + fi + + echo "Commit: $sha" + echo "" + gh run view "$run_id" --json jobs --jq '.jobs[] | " \(.name): \(.conclusion)"' 2>/dev/null || true + echo "" + + if [[ "$conclusion" == "success" ]]; then + echo "STATUS: success" + exit 0 + fi + + echo "=== Failed Logs ===" + echo "" + gh run view "$run_id" --log-failed 2>/dev/null || echo "(could not fetch logs)" + echo "" + + echo "STATUS: failure" + exit 1 +done diff --git a/bin/rspec b/bin/rspec new file mode 100755 index 00000000..cb53ebe5 --- /dev/null +++ b/bin/rspec @@ -0,0 +1,27 @@ +#!/usr/bin/env ruby +# frozen_string_literal: true + +# +# This file was generated by Bundler. +# +# The application 'rspec' is installed as part of a gem, and +# this file is here to facilitate running it. +# + +ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__) + +bundle_binstub = File.expand_path("bundle", __dir__) + +if File.file?(bundle_binstub) + if File.read(bundle_binstub, 300).include?("This file was generated by Bundler") + load(bundle_binstub) + else + abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run. +Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.") + end +end + +require "rubygems" +require "bundler/setup" + +load Gem.bin_path("rspec-core", "rspec") diff --git a/bin/rubocop b/bin/rubocop new file mode 100755 index 00000000..369a05be --- /dev/null +++ b/bin/rubocop @@ -0,0 +1,27 @@ +#!/usr/bin/env ruby +# frozen_string_literal: true + +# +# This file was generated by Bundler. +# +# The application 'rubocop' is installed as part of a gem, and +# this file is here to facilitate running it. +# + +ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__) + +bundle_binstub = File.expand_path("bundle", __dir__) + +if File.file?(bundle_binstub) + if File.read(bundle_binstub, 300).include?("This file was generated by Bundler") + load(bundle_binstub) + else + abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run. +Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.") + end +end + +require "rubygems" +require "bundler/setup" + +load Gem.bin_path("rubocop", "rubocop") diff --git a/lefthook.yml b/lefthook.yml new file mode 100644 index 00000000..51e01461 --- /dev/null +++ b/lefthook.yml @@ -0,0 +1,10 @@ +pre-commit: + commands: + rubocop: + tags: style + glob: "*.rb" + exclude: "^vendor/" + run: bin/rubocop --force-exclusion {staged_files} + audit: + tags: security + run: bin/bundler-audit check --update diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb new file mode 100644 index 00000000..6e872dbf --- /dev/null +++ b/spec/spec_helper.rb @@ -0,0 +1,18 @@ +RSpec.configure do |config| + config.expect_with :rspec do |expectations| + expectations.include_chain_clauses_in_custom_matcher_descriptions = true + end + + config.mock_with :rspec do |mocks| + mocks.verify_partial_doubles = true + end + + config.shared_context_metadata_behavior = :apply_to_host_groups + config.filter_run_when_matching :focus + config.example_status_persistence_file_path = "spec/examples.txt" + config.disable_monkey_patching! + config.order = :random + Kernel.srand config.seed + + config.default_formatter = "doc" if config.files_to_run.one? +end From 73de68cc75d073afc66413d3a737fb71d0afe439 Mon Sep 17 00:00:00 2001 From: Brent Date: Tue, 26 May 2026 11:44:37 +0200 Subject: [PATCH 02/16] Add extract-paintings branch to CI push triggers --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f67eb39c..9166c85a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -3,7 +3,7 @@ name: CI on: pull_request: push: - branches: [ master ] + branches: [ master, extract-paintings ] jobs: scan_ruby: From 3dfa79ba44a05885f2347096e09c6ea1e336db52 Mon Sep 17 00:00:00 2001 From: Brent Date: Tue, 26 May 2026 12:22:19 +0200 Subject: [PATCH 03/16] Add playwright-cli skill, clean HTML util - Bootstrap playwright-cli skill with SKILL.md and full reference docs - Add bin/clean_html script to strip scripts/styles from HTML for inspection - Add van-gogh-paintings-clean.html (cleaned snapshot for selector dev) --- .claude/skills/playwright-cli/SKILL.md | 388 ++++++++++++++++++ .../references/element-attributes.md | 23 ++ .../references/playwright-tests.md | 39 ++ .../references/request-mocking.md | 87 ++++ .../playwright-cli/references/running-code.md | 241 +++++++++++ .../references/session-management.md | 225 ++++++++++ .../references/spec-driven-testing.md | 305 ++++++++++++++ .../references/storage-state.md | 275 +++++++++++++ .../references/test-generation.md | 134 ++++++ .../playwright-cli/references/tracing.md | 139 +++++++ .../references/video-recording.md | 143 +++++++ .gitignore | 1 + README.md | 16 + bin/clean_html | 26 ++ files/van-gogh-paintings-clean.html | 1 + 15 files changed, 2043 insertions(+) create mode 100644 .claude/skills/playwright-cli/SKILL.md create mode 100644 .claude/skills/playwright-cli/references/element-attributes.md create mode 100644 .claude/skills/playwright-cli/references/playwright-tests.md create mode 100644 .claude/skills/playwright-cli/references/request-mocking.md create mode 100644 .claude/skills/playwright-cli/references/running-code.md create mode 100644 .claude/skills/playwright-cli/references/session-management.md create mode 100644 .claude/skills/playwright-cli/references/spec-driven-testing.md create mode 100644 .claude/skills/playwright-cli/references/storage-state.md create mode 100644 .claude/skills/playwright-cli/references/test-generation.md create mode 100644 .claude/skills/playwright-cli/references/tracing.md create mode 100644 .claude/skills/playwright-cli/references/video-recording.md create mode 100755 bin/clean_html create mode 100644 files/van-gogh-paintings-clean.html diff --git a/.claude/skills/playwright-cli/SKILL.md b/.claude/skills/playwright-cli/SKILL.md new file mode 100644 index 00000000..f034c324 --- /dev/null +++ b/.claude/skills/playwright-cli/SKILL.md @@ -0,0 +1,388 @@ +--- +name: playwright-cli +description: Automate browser interactions, test web pages and work with Playwright tests. +allowed-tools: Bash(playwright-cli:*) Bash(npx:*) Bash(npm:*) +--- + +# Browser Automation with playwright-cli + +## Quick start + +```bash +# open new browser +playwright-cli open +# navigate to a page +playwright-cli goto https://playwright.dev +# interact with the page using refs from the snapshot +playwright-cli click e15 +playwright-cli type "page.click" +playwright-cli press Enter +# take a screenshot (rarely used, as snapshot is more common) +playwright-cli screenshot +# close the browser +playwright-cli close +``` + +## Commands + +### Core + +```bash +playwright-cli open +# open and navigate right away +playwright-cli open https://example.com/ +playwright-cli goto https://playwright.dev +playwright-cli type "search query" +playwright-cli click e3 +playwright-cli dblclick e7 +# --submit presses Enter after filling the element +playwright-cli fill e5 "user@example.com" --submit +playwright-cli drag e2 e8 +# drop files or data onto an element (from outside the page) +playwright-cli drop e4 --path=./image.png +playwright-cli drop e4 --data="text/plain=hello world" +playwright-cli hover e4 +playwright-cli select e9 "option-value" +playwright-cli upload ./document.pdf +playwright-cli check e12 +playwright-cli uncheck e12 +playwright-cli snapshot +playwright-cli eval "document.title" +playwright-cli eval "el => el.textContent" e5 +# get element id, class, or any attribute not visible in the snapshot +playwright-cli eval "el => el.id" e5 +playwright-cli eval "el => el.getAttribute('data-testid')" e5 +playwright-cli dialog-accept +playwright-cli dialog-accept "confirmation text" +playwright-cli dialog-dismiss +playwright-cli resize 1920 1080 +playwright-cli close +``` + +### Navigation + +```bash +playwright-cli go-back +playwright-cli go-forward +playwright-cli reload +``` + +### Keyboard + +```bash +playwright-cli press Enter +playwright-cli press ArrowDown +playwright-cli keydown Shift +playwright-cli keyup Shift +``` + +### Mouse + +```bash +playwright-cli mousemove 150 300 +playwright-cli mousedown +playwright-cli mousedown right +playwright-cli mouseup +playwright-cli mouseup right +playwright-cli mousewheel 0 100 +``` + +### Save as + +```bash +playwright-cli screenshot +playwright-cli screenshot e5 +playwright-cli screenshot --filename=page.png +playwright-cli pdf --filename=page.pdf +``` + +### Tabs + +```bash +playwright-cli tab-list +playwright-cli tab-new +playwright-cli tab-new https://example.com/page +playwright-cli tab-close +playwright-cli tab-close 2 +playwright-cli tab-select 0 +``` + +### Storage + +```bash +playwright-cli state-save +playwright-cli state-save auth.json +playwright-cli state-load auth.json + +# Cookies +playwright-cli cookie-list +playwright-cli cookie-list --domain=example.com +playwright-cli cookie-get session_id +playwright-cli cookie-set session_id abc123 +playwright-cli cookie-set session_id abc123 --domain=example.com --httpOnly --secure +playwright-cli cookie-delete session_id +playwright-cli cookie-clear + +# LocalStorage +playwright-cli localstorage-list +playwright-cli localstorage-get theme +playwright-cli localstorage-set theme dark +playwright-cli localstorage-delete theme +playwright-cli localstorage-clear + +# SessionStorage +playwright-cli sessionstorage-list +playwright-cli sessionstorage-get step +playwright-cli sessionstorage-set step 3 +playwright-cli sessionstorage-delete step +playwright-cli sessionstorage-clear +``` + +### Network + +```bash +playwright-cli route "**/*.jpg" --status=404 +playwright-cli route "https://api.example.com/**" --body='{"mock": true}' +playwright-cli route-list +playwright-cli unroute "**/*.jpg" +playwright-cli unroute +``` + +### DevTools + +```bash +playwright-cli console +playwright-cli console warning +playwright-cli requests +playwright-cli request 5 +playwright-cli run-code "async page => await page.context().grantPermissions(['geolocation'])" +playwright-cli run-code --filename=script.js +playwright-cli tracing-start +playwright-cli tracing-stop +playwright-cli video-start video.webm +playwright-cli video-chapter "Chapter Title" --description="Details" --duration=2000 +playwright-cli video-stop + +# launch the dashboard for UI review / design feedback — user annotates the page, you receive the annotated screenshot, snapshot, and notes +playwright-cli show --annotate + +# generate a Playwright locator for an element from its ref or selector +playwright-cli generate-locator e5 --raw + +# show a persistent highlight overlay for an element, optionally with a custom style +playwright-cli highlight e5 +playwright-cli highlight e5 --style="outline: 3px dashed red" +# hide a single element highlight, or all page highlights when no target is given +playwright-cli highlight e5 --hide +playwright-cli highlight --hide +``` + +## Raw output + +The global `--raw` option strips page status, generated code, and snapshot sections from the output, returning only the result value. Use it to pipe command output into other tools. Commands that don't produce output return nothing. + +```bash +playwright-cli --raw eval "JSON.stringify(performance.timing)" | jq '.loadEventEnd - .navigationStart' +playwright-cli --raw eval "JSON.stringify([...document.querySelectorAll('a')].map(a => a.href))" > links.json +playwright-cli --raw snapshot > before.yml +playwright-cli click e5 +playwright-cli --raw snapshot > after.yml +diff before.yml after.yml +TOKEN=$(playwright-cli --raw cookie-get session_id) +playwright-cli --raw localstorage-get theme +``` + +For structured output wrapping every reply as JSON, pass --json +```bash +playwright-cli list --json +``` + +## Open parameters +```bash +# Use specific browser when creating session +playwright-cli open --browser=chrome +playwright-cli open --browser=firefox +playwright-cli open --browser=webkit +playwright-cli open --browser=msedge + +# Use persistent profile (by default profile is in-memory) +playwright-cli open --persistent +# Use persistent profile with custom directory +playwright-cli open --profile=/path/to/profile + +# Connect to browser via Playwright Extension +playwright-cli attach --extension=chrome + +# Connect to a running Chrome or Edge by channel name +playwright-cli attach --cdp=chrome +playwright-cli attach --cdp=msedge + +# Connect to a running browser via CDP endpoint +playwright-cli attach --cdp=http://localhost:9222 + +# Start with config file +playwright-cli open --config=my-config.json + +# Close the browser +playwright-cli close +# Detach from an attached browser (leaves the external browser running) +playwright-cli -s=msedge detach +# Delete user data for the default session +playwright-cli delete-data +``` + +## Snapshots + +After each command, playwright-cli provides a snapshot of the current browser state. + +```bash +> playwright-cli goto https://example.com +### Page +- Page URL: https://example.com/ +- Page Title: Example Domain +### Snapshot +[Snapshot](.playwright-cli/page-2026-02-14T19-22-42-679Z.yml) +``` + +You can also take a snapshot on demand using `playwright-cli snapshot` command. All the options below can be combined as needed. + +```bash +# default - save to a file with timestamp-based name +playwright-cli snapshot + +# save to file, use when snapshot is a part of the workflow result +playwright-cli snapshot --filename=after-click.yaml + +# snapshot an element instead of the whole page +playwright-cli snapshot "#main" + +# limit snapshot depth for efficiency, take a partial snapshot afterwards +playwright-cli snapshot --depth=4 +playwright-cli snapshot e34 + +# include each element's bounding box as [box=x,y,width,height] +playwright-cli snapshot --boxes +``` + +## Targeting elements + +By default, use refs from the snapshot to interact with page elements. + +```bash +# get snapshot with refs +playwright-cli snapshot + +# interact using a ref +playwright-cli click e15 +``` + +You can also use css selectors or Playwright locators. + +```bash +# css selector +playwright-cli click "#main > button.submit" + +# role locator +playwright-cli click "getByRole('button', { name: 'Submit' })" + +# test id +playwright-cli click "getByTestId('submit-button')" +``` + +## Browser Sessions + +```bash +# create new browser session named "mysession" with persistent profile +playwright-cli -s=mysession open example.com --persistent +# same with manually specified profile directory (use when requested explicitly) +playwright-cli -s=mysession open example.com --profile=/path/to/profile +playwright-cli -s=mysession click e6 +playwright-cli -s=mysession close # stop a named browser +playwright-cli -s=mysession delete-data # delete user data for persistent session + +playwright-cli list +# Close all browsers +playwright-cli close-all +# Forcefully kill all browser processes +playwright-cli kill-all +``` + +## Installation + +If global `playwright-cli` command is not available, try a local version via `npx playwright-cli`: + +```bash +npx --no-install playwright-cli --version +``` + +When local version is available, use `npx playwright-cli` in all commands. Otherwise, install `playwright-cli` as a global command: + +```bash +npm install -g @playwright/cli@latest +``` + +## Example: Form submission + +```bash +playwright-cli open https://example.com/form +playwright-cli snapshot + +playwright-cli fill e1 "user@example.com" +playwright-cli fill e2 "password123" +playwright-cli click e3 +playwright-cli snapshot +playwright-cli close +``` + +## Example: Multi-tab workflow + +```bash +playwright-cli open https://example.com +playwright-cli tab-new https://example.com/other +playwright-cli tab-list +playwright-cli tab-select 0 +playwright-cli snapshot +playwright-cli close +``` + +## Example: Debugging with DevTools + +```bash +playwright-cli open https://example.com +playwright-cli click e4 +playwright-cli fill e7 "test" +playwright-cli console +playwright-cli requests +playwright-cli close +``` + +```bash +playwright-cli open https://example.com +playwright-cli tracing-start +playwright-cli click e4 +playwright-cli fill e7 "test" +playwright-cli tracing-stop +playwright-cli close +``` + +## Example: Interactive session + +Ask the user for UI review or design feedback. The user draws boxes on the live page and types comments; you receive the annotated screenshot, the snapshot of the marked region, and the user's notes. Use this whenever the user asks for "UI review", "design feedback", or to "ask the user what they think / want / mean": + +```bash +playwright-cli open https://example.com +playwright-cli show --annotate +``` + +## Specific tasks + +* **Running and Debugging Playwright tests** [references/playwright-tests.md](references/playwright-tests.md) +* **Request mocking** [references/request-mocking.md](references/request-mocking.md) +* **Running Playwright code** [references/running-code.md](references/running-code.md) +* **Browser session management** [references/session-management.md](references/session-management.md) +* **Spec-driven testing (plan / generate / heal)** [references/spec-driven-testing.md](references/spec-driven-testing.md) +* **Storage state (cookies, localStorage)** [references/storage-state.md](references/storage-state.md) +* **Test generation** [references/test-generation.md](references/test-generation.md) +* **Tracing** [references/tracing.md](references/tracing.md) +* **Video recording** [references/video-recording.md](references/video-recording.md) +* **Inspecting element attributes** [references/element-attributes.md](references/element-attributes.md) diff --git a/.claude/skills/playwright-cli/references/element-attributes.md b/.claude/skills/playwright-cli/references/element-attributes.md new file mode 100644 index 00000000..4e9fa6b9 --- /dev/null +++ b/.claude/skills/playwright-cli/references/element-attributes.md @@ -0,0 +1,23 @@ +# Inspecting Element Attributes + +When the snapshot doesn't show an element's `id`, `class`, `data-*` attributes, or other DOM properties, use `eval` to inspect them. + +## Examples + +```bash +playwright-cli snapshot +# snapshot shows a button as e7 but doesn't reveal its id or data attributes + +# get the element's id +playwright-cli eval "el => el.id" e7 + +# get all CSS classes +playwright-cli eval "el => el.className" e7 + +# get a specific attribute +playwright-cli eval "el => el.getAttribute('data-testid')" e7 +playwright-cli eval "el => el.getAttribute('aria-label')" e7 + +# get a computed style property +playwright-cli eval "el => getComputedStyle(el).display" e7 +``` diff --git a/.claude/skills/playwright-cli/references/playwright-tests.md b/.claude/skills/playwright-cli/references/playwright-tests.md new file mode 100644 index 00000000..bec2ec90 --- /dev/null +++ b/.claude/skills/playwright-cli/references/playwright-tests.md @@ -0,0 +1,39 @@ +# Running Playwright Tests + +To run Playwright tests, use the `npx playwright test` command, or a package manager script. To avoid opening the interactive html report, use `PLAYWRIGHT_HTML_OPEN=never` environment variable. + +```bash +# Run all tests +PLAYWRIGHT_HTML_OPEN=never npx playwright test + +# Run all tests through a custom npm script +PLAYWRIGHT_HTML_OPEN=never npm run special-test-command +``` + +# Debugging Playwright Tests + +To debug a failing Playwright test, run it with `--debug=cli` option. This command will pause the test at the start and print the debugging instructions. + +**IMPORTANT**: run the command in the background and check the output until "Debugging Instructions" is printed. Make sure to stop the command after you have finished. + +Once instructions containing a session name are printed, use `playwright-cli` to attach the session and explore the page. + +```bash +# Run the test +PLAYWRIGHT_HTML_OPEN=never npx playwright test --debug=cli +# ... +# ... debugging instructions for "tw-abcdef" session ... +# ... + +# Attach to the test +playwright-cli attach tw-abcdef +``` + +Keep the test running in the background while you explore and look for a fix. +The test is paused at the start, so you should step over or pause at a particular location +where the problem is most likely to be. + +Every action you perform with `playwright-cli` generates corresponding Playwright TypeScript code. +This code appears in the output and can be copied directly into the test. Most of the time, a specific locator or an expectation should be updated, but it could also be a bug in the app. Use your judgement. + +After fixing the test, stop the background test run. Rerun to check that test passes. diff --git a/.claude/skills/playwright-cli/references/request-mocking.md b/.claude/skills/playwright-cli/references/request-mocking.md new file mode 100644 index 00000000..9005fda6 --- /dev/null +++ b/.claude/skills/playwright-cli/references/request-mocking.md @@ -0,0 +1,87 @@ +# Request Mocking + +Intercept, mock, modify, and block network requests. + +## CLI Route Commands + +```bash +# Mock with custom status +playwright-cli route "**/*.jpg" --status=404 + +# Mock with JSON body +playwright-cli route "**/api/users" --body='[{"id":1,"name":"Alice"}]' --content-type=application/json + +# Mock with custom headers +playwright-cli route "**/api/data" --body='{"ok":true}' --header="X-Custom: value" + +# Remove headers from requests +playwright-cli route "**/*" --remove-header=cookie,authorization + +# List active routes +playwright-cli route-list + +# Remove a route or all routes +playwright-cli unroute "**/*.jpg" +playwright-cli unroute +``` + +## URL Patterns + +``` +**/api/users - Exact path match +**/api/*/details - Wildcard in path +**/*.{png,jpg,jpeg} - Match file extensions +**/search?q=* - Match query parameters +``` + +## Advanced Mocking with run-code + +For conditional responses, request body inspection, response modification, or delays: + +### Conditional Response Based on Request + +```bash +playwright-cli run-code "async page => { + await page.route('**/api/login', route => { + const body = route.request().postDataJSON(); + if (body.username === 'admin') { + route.fulfill({ body: JSON.stringify({ token: 'mock-token' }) }); + } else { + route.fulfill({ status: 401, body: JSON.stringify({ error: 'Invalid' }) }); + } + }); +}" +``` + +### Modify Real Response + +```bash +playwright-cli run-code "async page => { + await page.route('**/api/user', async route => { + const response = await route.fetch(); + const json = await response.json(); + json.isPremium = true; + await route.fulfill({ response, json }); + }); +}" +``` + +### Simulate Network Failures + +```bash +playwright-cli run-code "async page => { + await page.route('**/api/offline', route => route.abort('internetdisconnected')); +}" +# Options: connectionrefused, timedout, connectionreset, internetdisconnected +``` + +### Delayed Response + +```bash +playwright-cli run-code "async page => { + await page.route('**/api/slow', async route => { + await new Promise(r => setTimeout(r, 3000)); + route.fulfill({ body: JSON.stringify({ data: 'loaded' }) }); + }); +}" +``` diff --git a/.claude/skills/playwright-cli/references/running-code.md b/.claude/skills/playwright-cli/references/running-code.md new file mode 100644 index 00000000..98b541fb --- /dev/null +++ b/.claude/skills/playwright-cli/references/running-code.md @@ -0,0 +1,241 @@ +# Running Custom Playwright Code + +Use `run-code` to execute arbitrary Playwright code for advanced scenarios not covered by CLI commands. + +## Syntax + +```bash +playwright-cli run-code "async page => { + // Your Playwright code here + // Access page.context() for browser context operations +}" +``` + +You can also load the function from a file: + +```bash +playwright-cli run-code --filename=./my-script.js +``` + + +The code must be a single function expression, it is wrapped in `(...)` and evaluated. +import/export/require syntax is not supported. + +## Geolocation + +```bash +# Grant geolocation permission and set location +playwright-cli run-code "async page => { + await page.context().grantPermissions(['geolocation']); + await page.context().setGeolocation({ latitude: 37.7749, longitude: -122.4194 }); +}" + +# Set location to London +playwright-cli run-code "async page => { + await page.context().grantPermissions(['geolocation']); + await page.context().setGeolocation({ latitude: 51.5074, longitude: -0.1278 }); +}" + +# Clear geolocation override +playwright-cli run-code "async page => { + await page.context().clearPermissions(); +}" +``` + +## Permissions + +```bash +# Grant multiple permissions +playwright-cli run-code "async page => { + await page.context().grantPermissions([ + 'geolocation', + 'notifications', + 'camera', + 'microphone' + ]); +}" + +# Grant permissions for specific origin +playwright-cli run-code "async page => { + await page.context().grantPermissions(['clipboard-read'], { + origin: 'https://example.com' + }); +}" +``` + +## Media Emulation + +```bash +# Emulate dark color scheme +playwright-cli run-code "async page => { + await page.emulateMedia({ colorScheme: 'dark' }); +}" + +# Emulate light color scheme +playwright-cli run-code "async page => { + await page.emulateMedia({ colorScheme: 'light' }); +}" + +# Emulate reduced motion +playwright-cli run-code "async page => { + await page.emulateMedia({ reducedMotion: 'reduce' }); +}" + +# Emulate print media +playwright-cli run-code "async page => { + await page.emulateMedia({ media: 'print' }); +}" +``` + +## Wait Strategies + +```bash +# Wait for network idle +playwright-cli run-code "async page => { + await page.waitForLoadState('networkidle'); +}" + +# Wait for specific element +playwright-cli run-code "async page => { + await page.locator('.loading').waitFor({ state: 'hidden' }); +}" + +# Wait for function to return true +playwright-cli run-code "async page => { + await page.waitForFunction(() => window.appReady === true); +}" + +# Wait with timeout +playwright-cli run-code "async page => { + await page.locator('.result').waitFor({ timeout: 10000 }); +}" +``` + +## Frames and Iframes + +```bash +# Work with iframe +playwright-cli run-code "async page => { + const frame = page.locator('iframe#my-iframe').contentFrame(); + await frame.locator('button').click(); +}" + +# Get all frames +playwright-cli run-code "async page => { + const frames = page.frames(); + return frames.map(f => f.url()); +}" +``` + +## File Downloads + +```bash +# Handle file download +playwright-cli run-code "async page => { + const downloadPromise = page.waitForEvent('download'); + await page.getByRole('link', { name: 'Download' }).click(); + const download = await downloadPromise; + await download.saveAs('./downloaded-file.pdf'); + return download.suggestedFilename(); +}" +``` + +## Clipboard + +```bash +# Read clipboard (requires permission) +playwright-cli run-code "async page => { + await page.context().grantPermissions(['clipboard-read']); + return await page.evaluate(() => navigator.clipboard.readText()); +}" + +# Write to clipboard +playwright-cli run-code "async page => { + await page.evaluate(text => navigator.clipboard.writeText(text), 'Hello clipboard!'); +}" +``` + +## Page Information + +```bash +# Get page title +playwright-cli run-code "async page => { + return await page.title(); +}" + +# Get current URL +playwright-cli run-code "async page => { + return page.url(); +}" + +# Get page content +playwright-cli run-code "async page => { + return await page.content(); +}" + +# Get viewport size +playwright-cli run-code "async page => { + return page.viewportSize(); +}" +``` + +## JavaScript Execution + +```bash +# Execute JavaScript and return result +playwright-cli run-code "async page => { + return await page.evaluate(() => { + return { + userAgent: navigator.userAgent, + language: navigator.language, + cookiesEnabled: navigator.cookieEnabled + }; + }); +}" + +# Pass arguments to evaluate +playwright-cli run-code "async page => { + const multiplier = 5; + return await page.evaluate(m => document.querySelectorAll('li').length * m, multiplier); +}" +``` + +## Error Handling + +```bash +# Try-catch in run-code +playwright-cli run-code "async page => { + try { + await page.getByRole('button', { name: 'Submit' }).click({ timeout: 1000 }); + return 'clicked'; + } catch (e) { + return 'element not found'; + } +}" +``` + +## Complex Workflows + +```bash +# Login and save state +playwright-cli run-code "async page => { + await page.goto('https://example.com/login'); + await page.getByRole('textbox', { name: 'Email' }).fill('user@example.com'); + await page.getByRole('textbox', { name: 'Password' }).fill('secret'); + await page.getByRole('button', { name: 'Sign in' }).click(); + await page.waitForURL('**/dashboard'); + await page.context().storageState({ path: 'auth.json' }); + return 'Login successful'; +}" + +# Scrape data from multiple pages +playwright-cli run-code "async page => { + const results = []; + for (let i = 1; i <= 3; i++) { + await page.goto(\`https://example.com/page/\${i}\`); + const items = await page.locator('.item').allTextContents(); + results.push(...items); + } + return results; +}" +``` diff --git a/.claude/skills/playwright-cli/references/session-management.md b/.claude/skills/playwright-cli/references/session-management.md new file mode 100644 index 00000000..bf39acd5 --- /dev/null +++ b/.claude/skills/playwright-cli/references/session-management.md @@ -0,0 +1,225 @@ +# Browser Session Management + +Run multiple isolated browser sessions concurrently with state persistence. + +## Named Browser Sessions + +Use `-s` flag to isolate browser contexts: + +```bash +# Browser 1: Authentication flow +playwright-cli -s=auth open https://app.example.com/login + +# Browser 2: Public browsing (separate cookies, storage) +playwright-cli -s=public open https://example.com + +# Commands are isolated by browser session +playwright-cli -s=auth fill e1 "user@example.com" +playwright-cli -s=public snapshot +``` + +## Browser Session Isolation Properties + +Each browser session has independent: +- Cookies +- LocalStorage / SessionStorage +- IndexedDB +- Cache +- Browsing history +- Open tabs + +## Browser Session Commands + +```bash +# List all browser sessions +playwright-cli list + +# Stop a browser session (close the browser) +playwright-cli close # stop the default browser +playwright-cli -s=mysession close # stop a named browser + +# Stop all browser sessions +playwright-cli close-all + +# Forcefully kill all daemon processes (for stale/zombie processes) +playwright-cli kill-all + +# Delete browser session user data (profile directory) +playwright-cli delete-data # delete default browser data +playwright-cli -s=mysession delete-data # delete named browser data +``` + +## Environment Variable + +Set a default browser session name via environment variable: + +```bash +export PLAYWRIGHT_CLI_SESSION="mysession" +playwright-cli open example.com # Uses "mysession" automatically +``` + +## Common Patterns + +### Concurrent Scraping + +```bash +#!/bin/bash +# Scrape multiple sites concurrently + +# Start all browsers +playwright-cli -s=site1 open https://site1.com & +playwright-cli -s=site2 open https://site2.com & +playwright-cli -s=site3 open https://site3.com & +wait + +# Take snapshots from each +playwright-cli -s=site1 snapshot +playwright-cli -s=site2 snapshot +playwright-cli -s=site3 snapshot + +# Cleanup +playwright-cli close-all +``` + +### A/B Testing Sessions + +```bash +# Test different user experiences +playwright-cli -s=variant-a open "https://app.com?variant=a" +playwright-cli -s=variant-b open "https://app.com?variant=b" + +# Compare +playwright-cli -s=variant-a screenshot +playwright-cli -s=variant-b screenshot +``` + +### Persistent Profile + +By default, browser profile is kept in memory only. Use `--persistent` flag on `open` to persist the browser profile to disk: + +```bash +# Use persistent profile (auto-generated location) +playwright-cli open https://example.com --persistent + +# Use persistent profile with custom directory +playwright-cli open https://example.com --profile=/path/to/profile +``` + +## Attaching to a Running Browser + +Use `attach` to connect to a browser that is already running, instead of launching a new one. + +### Attach by channel name + +Connect to a running Chrome or Edge instance by its channel name. The browser must have remote debugging enabled — navigate to `chrome://inspect/#remote-debugging` in the target browser and check "Allow remote debugging for this browser instance". + +```bash +# Attach to Chrome +playwright-cli attach --cdp=chrome + +# Attach to Chrome Canary +playwright-cli attach --cdp=chrome-canary + +# Attach to Microsoft Edge +playwright-cli attach --cdp=msedge + +# Attach to Edge Dev +playwright-cli attach --cdp=msedge-dev +``` + +Supported channels: `chrome`, `chrome-beta`, `chrome-dev`, `chrome-canary`, `msedge`, `msedge-beta`, `msedge-dev`, `msedge-canary`. + +When `--session` is not provided, the session is named after the channel (e.g. `--cdp=msedge` creates a session called `msedge`), so parallel attaches to Chrome and Edge don't collide on `default`. Pass `--session=` to override. + +### Attach via CDP endpoint + +Connect to a browser that exposes a Chrome DevTools Protocol endpoint: + +```bash +playwright-cli attach --cdp=http://localhost:9222 +``` + +### Attach via browser extension + +Connect to a browser with the Playwright extension installed: + +```bash +playwright-cli attach --extension +``` + +### Detach + +Tear down an attached session without affecting the external browser: + +```bash +# Detach the default attached session +playwright-cli detach + +# Detach a specific attached session +playwright-cli -s=msedge detach +``` + +`detach` only works on sessions created via `attach`. For sessions created via `open`, use `close`. + +## Default Browser Session + +When `-s` is omitted, commands use the default browser session: + +```bash +# These use the same default browser session +playwright-cli open https://example.com +playwright-cli snapshot +playwright-cli close # Stops default browser +``` + +## Browser Session Configuration + +Configure a browser session with specific settings when opening: + +```bash +# Open with config file +playwright-cli open https://example.com --config=.playwright/my-cli.json + +# Open with specific browser +playwright-cli open https://example.com --browser=firefox + +# Open in headed mode +playwright-cli open https://example.com --headed + +# Open with persistent profile +playwright-cli open https://example.com --persistent +``` + +## Best Practices + +### 1. Name Browser Sessions Semantically + +```bash +# GOOD: Clear purpose +playwright-cli -s=github-auth open https://github.com +playwright-cli -s=docs-scrape open https://docs.example.com + +# AVOID: Generic names +playwright-cli -s=s1 open https://github.com +``` + +### 2. Always Clean Up + +```bash +# Stop browsers when done +playwright-cli -s=auth close +playwright-cli -s=scrape close + +# Or stop all at once +playwright-cli close-all + +# If browsers become unresponsive or zombie processes remain +playwright-cli kill-all +``` + +### 3. Delete Stale Browser Data + +```bash +# Remove old browser data to free disk space +playwright-cli -s=oldsession delete-data +``` diff --git a/.claude/skills/playwright-cli/references/spec-driven-testing.md b/.claude/skills/playwright-cli/references/spec-driven-testing.md new file mode 100644 index 00000000..f37bdb44 --- /dev/null +++ b/.claude/skills/playwright-cli/references/spec-driven-testing.md @@ -0,0 +1,305 @@ +# Spec-driven testing (plan → generate → heal) + +End-to-end workflow for authoring and maintaining Playwright tests using `playwright-cli`. The three sections below can be used independently: + +- **Planning** — explore the app, produce a spec file describing what to test. +- **Generate** — turn a spec into Playwright test files. Update the spec if it's vague or stale. +- **Heal** — diagnose failing tests, fix the code, reconcile the spec with reality. + +All three lean on the same mechanic: run `npx playwright test --debug=cli` in the background, then `playwright-cli attach tw-XXXX` to drive the paused page interactively. See [playwright-tests.md](playwright-tests.md) for the debug/attach mechanics and [test-generation.md](test-generation.md) for how every `playwright-cli` action emits Playwright TypeScript. + +--- + +## 1. Planning + +Goal: produce a spec file (e.g. `specs/.plan.md`) that enumerates the scenarios to test. **Always** write the spec to a file. + +### 1.1 Prerequisite: workspace + +Check the workspace has Playwright installed before anything else: + +```bash +# Either of these confirms a workspace: +test -f playwright.config.ts || test -f playwright.config.js +npx --no-install playwright --version +``` + +If there is no Playwright install, bootstrap one and let the user pick the defaults: + +```bash +npm init playwright@latest +``` + +### 1.2 Prerequisite: seed test + +A **seed test** is a minimal test that lands the page in the state every scenario starts from: navigation to the app, any required login, feature flags, etc. Scenarios assume a fresh start *after* the seed. `--debug=cli` pauses *inside* this test, so the seed is where every planning and generation session begins. + +Minimum viable seed: + +```ts +// tests/seed.spec.ts +import { test } from '@playwright/test'; + +test('seed', async ({ page }) => { + await page.goto('https://example.com/'); +}); +``` + +Preferred — push navigation into a fixture so scenario tests reuse it: + +```ts +// tests/fixtures.ts +import { test as baseTest } from '@playwright/test'; +export { expect } from '@playwright/test'; + +export const test = baseTest.extend({ + page: async ({ page }, use) => { + await page.goto('https://example.com/'); + await use(page); + }, +}); +``` + +```ts +// tests/seed.spec.ts +import { test } from './fixtures'; + +test('seed', async ({ page }) => { + // Fixture already navigates. This empty body tells agents where to start. +}); +``` + +If no seed exists, create one that at least navigates to the app. + +### 1.3 Explore the app + +Launch the app via the seed in the background and attach: + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test tests/seed.spec.ts --debug=cli +# wait for "Debugging Instructions" and the session name tw-XXXX +playwright-cli attach tw-XXXX +``` + +Resume so the seed runs, then probe the app: + +```bash +playwright-cli resume # resume so that seed test runs fully +playwright-cli snapshot # inventory of interactive elements +playwright-cli click e5 # follow a flow +playwright-cli eval "location.href" # read URL / state +playwright-cli show --annotate # ask the user to point at something +``` + +Map out: + +- Interactive surfaces (forms, buttons, lists, filters, modals). +- Primary user journeys end-to-end. +- Edge cases: empty states, validation errors, very long input, boundary values. +- Persistence: reload, local/session storage, URL fragments. +- Navigation: which controls change the URL, back/forward behaviour. + +**Important**: Do not just open the app url with playwright-cli, always go through the test to capture any custom setup done there. +**Important**: Stop the background test when done exploring. + +### 1.4 Write the spec file + +Save under `specs/.plan.md`. Use this structure: + +```markdown +# Test Plan + +## Application Overview + + + +## Test Scenarios + +### 1. + +**Seed:** `tests/seed.spec.ts` + +#### 1.1. + +**File:** `tests//.spec.ts` + +**Steps:** + 1. + - expect: + - expect: + 2. + - expect: + +#### 1.2. +... + +### 2. + +**Seed:** `tests/seed.spec.ts` +... +``` + +Guidelines: + +- Each scenario is independent and starts from the seed's fresh state — never chain scenarios. +- Scenario names are kebab-case and match the test file name (`should-add-single-todo` → `should-add-single-todo.spec.ts`). +- Cover happy path, edge cases, validation, negative flows, persistence. +- Write steps at the user level ("Type 'Buy milk' into the input"), not the API level ("call `fill`"). +- Put observable outcomes in `- expect:` bullets; each becomes an assertion during generation. + +--- + +## 2. Generate + +Goal: take a spec file and produce Playwright test files. Optionally update the spec if it has drifted. + +### 2.1 Inputs + +- **Spec file**, e.g. `specs/basic-operations.plan.md`. +- **Target**: either a single scenario (e.g. `1.2`), a whole group (`1`), or all. +- **Seed file**, read from the `**Seed:**` line of the scenario's group. + +### 2.2 Generate one scenario + +For each target scenario, in sequence (never in parallel — scenarios share the seed session): + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test --debug=cli # background +playwright-cli attach tw-XXXX +# resume +``` + +**Do not** just open the app url with playwright-cli, always go through the test to capture any custom setup done there. + +Walk the scenario's `Steps:` one by one with `playwright-cli`, treating the spec as the plan and the live app as the source of truth. If a step is vague ("click the button" — which button?), references an element that no longer exists, or contradicts the app's actual behaviour, use your judgement: update the spec to match what the app really does, then keep going. Editing the spec mid-generation is expected. + +Every action prints the equivalent Playwright TypeScript (see [test-generation.md](test-generation.md)): + +```bash +playwright-cli snapshot # find refs +playwright-cli fill e3 "John Doe" # -> page.getByRole('textbox', {...}).fill(...) +playwright-cli press Enter +playwright-cli click e7 +``` + +For each `- expect:` bullet, add an explicit assertion. See [test-generation.md](test-generation.md) for details. + +Collect the generated code and write the test file at the path given in the spec: + +```ts +// spec: specs/basic-operations.plan.md +// seed: tests/seed.spec.ts +import { test, expect } from './fixtures'; // or '@playwright/test' if no fixtures file + +test.describe('Singing in and out', () => { + test('should sign in', async ({ page }) => { + // 1. Navigate to the application + // (handled by the seed fixture) + + // 2. Type 'John Doe' into the username field + await page.getByRole('textbox', { name: 'username' }).fill('John Doe'); + + // 3. Type password + await page.getByRole('textbox', { name: 'password' }).fill('TestPassword'); + + // 4. Press Enter to submit + await page.getByRole('textbox', { name: 'password' }).press('Enter'); + + await expect(page.getByRole('heading')).toContainText('Welcome, John Doe!'); + }); +}); +``` + +Rules: + +- **One test per file.** File path, describe name, and test name come verbatim from the spec (minus the ordinal). +- Prefix each numbered step with a `// N. ` comment before its actions. +- Use the describe group name verbatim from the spec (no `1.` ordinal). +- Import from `./fixtures` if the project has one; otherwise `@playwright/test`. +- **Important**: close the CLI session and stop the background test before moving to the next scenario. + +### 2.3 Generate multiple scenarios + +Loop 2.2 over the targeted scenarios one at a time, restarting the seed between each so every test starts from a clean page. This is safe to parallelise due to unique generated session names - just make sure each test run is stopped. + +### 2.4 Run generated tests + +After generation, run the new tests once: + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test tests//.spec.ts +``` + +Any failure goes to Section 3. + +--- + +## 3. Heal + +Goal: fix failing tests, and update the spec if the app's intended behaviour changed. + +### 3.1 Find failing tests + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test +``` + +Record the list of failing `:` entries and process them one at a time. Do not attempt parallel fixes — shared state and the single CLI session make that fragile. + +### 3.2 Debug one failure + +Run the single failing test in debug mode in the background, then attach: + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test tests//.spec.ts: --debug=cli +# wait for "Debugging Instructions" and the tw-XXXX session name +playwright-cli attach tw-XXXX +``` + +The test is paused at the start. Step forward or run to until just before the failing action or assertion, then diagnose: + +```bash +playwright-cli snapshot # did the element change / move / rename? +playwright-cli console # app-side errors? +playwright-cli network # failed request? wrong payload? +playwright-cli show --annotate # ask the user to point somewhere +``` + +Common causes: selector drift, new wrapper element, label/ARIA rename, timing (transition, async load), assertion text updated in the app, test data leaking between runs. + +Rehearse the corrected interaction with `playwright-cli` — the generated code in the output is what you paste back into the test. + +### 3.3 Apply the fix + +Edit the test file: update the locator, assertion, step order, or inputs to match the corrected behaviour. Stop the background debug run. Rerun the single test to confirm green. + +Never skip hooks or add sleeps as a fix. Never use `networkidle`. + +### 3.4 Reconcile with the spec + +Open the spec referenced by the `// spec:` header in the test file and locate the scenario that matches the test. + +- **Fix was purely technical** (locator drift, better assertion shape) and the spec's user-level behaviour still matches the app → leave the spec alone. +- **Fix changed user-visible steps, inputs, order, or expected outcomes** that the spec describes → update the spec to match reality. Keep the scenario id and file path stable; only the step / expect lines change. +- **Unclear whether the app change is intentional** (spec is stale) **or a regression** (test was right, app is wrong) → **stop and ask the user**. Provide: + - the scenario id (e.g. `2.3`), + - the spec lines that no longer match, + - the observed app behaviour (quote a snapshot excerpt or a concrete outcome). + +Only after the user answers, either update the spec (intentional change) or file/flag the test as covering a bug (regression). + +### 3.5 Iteration and giving up + +- Fix failures one at a time; rerun after each. +- If after thorough investigation you are confident the test is correct but the app is wrong *and* the user has confirmed it's a bug: mark the test `test.fixme(...)` with a comment pointing at the user's decision or issue link. Never silently skip. + +--- + +## Cross-references + +| For... | See | +|---|---| +| `--debug=cli` / attach mechanics | [playwright-tests.md](playwright-tests.md) | +| How `playwright-cli` actions become TS | [test-generation.md](test-generation.md) | +| Mocking requests during exploration/generation | [request-mocking.md](request-mocking.md) | +| Managing the CLI browser session | [session-management.md](session-management.md) | diff --git a/.claude/skills/playwright-cli/references/storage-state.md b/.claude/skills/playwright-cli/references/storage-state.md new file mode 100644 index 00000000..c856db5e --- /dev/null +++ b/.claude/skills/playwright-cli/references/storage-state.md @@ -0,0 +1,275 @@ +# Storage Management + +Manage cookies, localStorage, sessionStorage, and browser storage state. + +## Storage State + +Save and restore complete browser state including cookies and storage. + +### Save Storage State + +```bash +# Save to auto-generated filename (storage-state-{timestamp}.json) +playwright-cli state-save + +# Save to specific filename +playwright-cli state-save my-auth-state.json +``` + +### Restore Storage State + +```bash +# Load storage state from file +playwright-cli state-load my-auth-state.json + +# Reload page to apply cookies +playwright-cli open https://example.com +``` + +### Storage State File Format + +The saved file contains: + +```json +{ + "cookies": [ + { + "name": "session_id", + "value": "abc123", + "domain": "example.com", + "path": "/", + "expires": 1735689600, + "httpOnly": true, + "secure": true, + "sameSite": "Lax" + } + ], + "origins": [ + { + "origin": "https://example.com", + "localStorage": [ + { "name": "theme", "value": "dark" }, + { "name": "user_id", "value": "12345" } + ] + } + ] +} +``` + +## Cookies + +### List All Cookies + +```bash +playwright-cli cookie-list +``` + +### Filter Cookies by Domain + +```bash +playwright-cli cookie-list --domain=example.com +``` + +### Filter Cookies by Path + +```bash +playwright-cli cookie-list --path=/api +``` + +### Get Specific Cookie + +```bash +playwright-cli cookie-get session_id +``` + +### Set a Cookie + +```bash +# Basic cookie +playwright-cli cookie-set session abc123 + +# Cookie with options +playwright-cli cookie-set session abc123 --domain=example.com --path=/ --httpOnly --secure --sameSite=Lax + +# Cookie with expiration (Unix timestamp) +playwright-cli cookie-set remember_me token123 --expires=1735689600 +``` + +### Delete a Cookie + +```bash +playwright-cli cookie-delete session_id +``` + +### Clear All Cookies + +```bash +playwright-cli cookie-clear +``` + +### Advanced: Multiple Cookies or Custom Options + +For complex scenarios like adding multiple cookies at once, use `run-code`: + +```bash +playwright-cli run-code "async page => { + await page.context().addCookies([ + { name: 'session_id', value: 'sess_abc123', domain: 'example.com', path: '/', httpOnly: true }, + { name: 'preferences', value: JSON.stringify({ theme: 'dark' }), domain: 'example.com', path: '/' } + ]); +}" +``` + +## Local Storage + +### List All localStorage Items + +```bash +playwright-cli localstorage-list +``` + +### Get Single Value + +```bash +playwright-cli localstorage-get token +``` + +### Set Value + +```bash +playwright-cli localstorage-set theme dark +``` + +### Set JSON Value + +```bash +playwright-cli localstorage-set user_settings '{"theme":"dark","language":"en"}' +``` + +### Delete Single Item + +```bash +playwright-cli localstorage-delete token +``` + +### Clear All localStorage + +```bash +playwright-cli localstorage-clear +``` + +### Advanced: Multiple Operations + +For complex scenarios like setting multiple values at once, use `run-code`: + +```bash +playwright-cli run-code "async page => { + await page.evaluate(() => { + localStorage.setItem('token', 'jwt_abc123'); + localStorage.setItem('user_id', '12345'); + localStorage.setItem('expires_at', Date.now() + 3600000); + }); +}" +``` + +## Session Storage + +### List All sessionStorage Items + +```bash +playwright-cli sessionstorage-list +``` + +### Get Single Value + +```bash +playwright-cli sessionstorage-get form_data +``` + +### Set Value + +```bash +playwright-cli sessionstorage-set step 3 +``` + +### Delete Single Item + +```bash +playwright-cli sessionstorage-delete step +``` + +### Clear sessionStorage + +```bash +playwright-cli sessionstorage-clear +``` + +## IndexedDB + +### List Databases + +```bash +playwright-cli run-code "async page => { + return await page.evaluate(async () => { + const databases = await indexedDB.databases(); + return databases; + }); +}" +``` + +### Delete Database + +```bash +playwright-cli run-code "async page => { + await page.evaluate(() => { + indexedDB.deleteDatabase('myDatabase'); + }); +}" +``` + +## Common Patterns + +### Authentication State Reuse + +```bash +# Step 1: Login and save state +playwright-cli open https://app.example.com/login +playwright-cli snapshot +playwright-cli fill e1 "user@example.com" +playwright-cli fill e2 "password123" +playwright-cli click e3 + +# Save the authenticated state +playwright-cli state-save auth.json + +# Step 2: Later, restore state and skip login +playwright-cli state-load auth.json +playwright-cli open https://app.example.com/dashboard +# Already logged in! +``` + +### Save and Restore Roundtrip + +```bash +# Set up authentication state +playwright-cli open https://example.com +playwright-cli eval "() => { document.cookie = 'session=abc123'; localStorage.setItem('user', 'john'); }" + +# Save state to file +playwright-cli state-save my-session.json + +# ... later, in a new session ... + +# Restore state +playwright-cli state-load my-session.json +playwright-cli open https://example.com +# Cookies and localStorage are restored! +``` + +## Security Notes + +- Never commit storage state files containing auth tokens +- Add `*.auth-state.json` to `.gitignore` +- Delete state files after automation completes +- Use environment variables for sensitive data +- By default, sessions run in-memory mode which is safer for sensitive operations diff --git a/.claude/skills/playwright-cli/references/test-generation.md b/.claude/skills/playwright-cli/references/test-generation.md new file mode 100644 index 00000000..a045c55d --- /dev/null +++ b/.claude/skills/playwright-cli/references/test-generation.md @@ -0,0 +1,134 @@ +# Test Generation + +Generate Playwright test code automatically as you interact with the browser. + +## How It Works + +Every action you perform with `playwright-cli` generates corresponding Playwright TypeScript code. +This code appears in the output and can be copied directly into your test files. + +## Example Workflow + +```bash +# Start a session +playwright-cli open https://example.com/login + +# Take a snapshot to see elements +playwright-cli snapshot +# Output shows: e1 [textbox "Email"], e2 [textbox "Password"], e3 [button "Sign In"] + +# Fill form fields - generates code automatically +playwright-cli fill e1 "user@example.com" +# Ran Playwright code: +# await page.getByRole('textbox', { name: 'Email' }).fill('user@example.com'); + +playwright-cli fill e2 "password123" +# Ran Playwright code: +# await page.getByRole('textbox', { name: 'Password' }).fill('password123'); + +playwright-cli click e3 +# Ran Playwright code: +# await page.getByRole('button', { name: 'Sign In' }).click(); +``` + +## Building a Test File + +Collect the generated code into a Playwright test: + +```typescript +import { test, expect } from '@playwright/test'; + +test('login flow', async ({ page }) => { + // Generated code from playwright-cli session: + await page.goto('https://example.com/login'); + await page.getByRole('textbox', { name: 'Email' }).fill('user@example.com'); + await page.getByRole('textbox', { name: 'Password' }).fill('password123'); + await page.getByRole('button', { name: 'Sign In' }).click(); + + // Add assertions + await expect(page).toHaveURL(/.*dashboard/); +}); +``` + +## Best Practices + +### 1. Use Semantic Locators + +The generated code uses role-based locators when possible, which are more resilient: + +```typescript +// Generated (good - semantic) +await page.getByRole('button', { name: 'Submit' }).click(); + +// Avoid (fragile - CSS selectors) +await page.locator('#submit-btn').click(); +``` + +### 2. Explore Before Recording + +Take snapshots to understand the page structure before recording actions: + +```bash +playwright-cli open https://example.com +playwright-cli snapshot +# Review the element structure +playwright-cli click e5 +``` + +### 3. Add Assertions Manually + +Generated code captures actions but not assertions. Add expectations in your test using one of the recommended matchers: + +- `toBeVisible()` — element is rendered and visible +- `toHaveText(text)` — element text content matches +- `toHaveValue(value) / toBeEmpty()` — input/select value matches +- `toBeChecked() / toBeUnchecked()` — checkbox state matches +- `toMatchAriaSnapshot(snapshot)` — page (or locator) matches a partial accessibility snapshot + +Use `playwright-cli generate-locator ` to produce the locator expression for the assertion, and the snapshot/eval commands to capture the expected value. + +When asserting text content, make sure that generated locator does not contain text from the element itself. `getByTestId()` or `getByLabel()` usually work well with asserting text. When locator is text-based, prefer `toBeVisible()` instead. + +Snapshot to be matched does not have to contain all the information - only capture what's necessary for the assertion. You can use regular expressions for unstable values. + +```bash +# Get a stable locator for an element ref to use in the assertion +playwright-cli --raw generate-locator e5 +# getByRole('button', { name: 'Submit' }) + +# Capture expected text content for toHaveText +playwright-cli --raw eval "el => el.textContent" e5 + +# Capture expected input value for toHaveValue/toBeEmpty +playwright-cli --raw eval "el => el.value" e5 + +# Capture expected aria snapshot for toMatchAriaSnapshot/toBeChecked +# (whole page, or use a ref to scope to a region) +playwright-cli --raw snapshot +playwright-cli --raw snapshot e5 +``` + +```typescript +// Generated action +await page.getByRole('button', { name: 'Submit' }).click(); + +// Manual assertions using the outputs above: +await expect(page.getByRole('alert', { name: 'Success' })).toBeVisible(); +await expect(page.getByTestId('main-header')).toHaveText('Welcome, user'); +await expect(page.getByRole('textbox', { name: 'Email' })).toHaveValue('user@example.com'); +await expect(page.getByRole('checkbox', { name: 'Enable notifications' })).toBeChecked(); + +// toMatchAriaSnapshot on the whole page, finds a matching region +await expect(page).toMatchAriaSnapshot(` + - heading "Welcome, user" + - link /\\d+ new messages?/ + - button "Sign out" +`); + +// toMatchAriaSnapshot scoped to a region +await expect(page.getByRole('navigation')).toMatchAriaSnapshot(` + - link "Home" + - link /\\d+ new messages?/ + - link "Profile" +`); +``` diff --git a/.claude/skills/playwright-cli/references/tracing.md b/.claude/skills/playwright-cli/references/tracing.md new file mode 100644 index 00000000..7ce7babb --- /dev/null +++ b/.claude/skills/playwright-cli/references/tracing.md @@ -0,0 +1,139 @@ +# Tracing + +Capture detailed execution traces for debugging and analysis. Traces include DOM snapshots, screenshots, network activity, and console logs. + +## Basic Usage + +```bash +# Start trace recording +playwright-cli tracing-start + +# Perform actions +playwright-cli open https://example.com +playwright-cli click e1 +playwright-cli fill e2 "test" + +# Stop trace recording +playwright-cli tracing-stop +``` + +## Trace Output Files + +When you start tracing, Playwright creates a `traces/` directory with several files: + +### `trace-{timestamp}.trace` + +**Action log** - The main trace file containing: +- Every action performed (clicks, fills, navigations) +- DOM snapshots before and after each action +- Screenshots at each step +- Timing information +- Console messages +- Source locations + +### `trace-{timestamp}.network` + +**Network log** - Complete network activity: +- All HTTP requests and responses +- Request headers and bodies +- Response headers and bodies +- Timing (DNS, connect, TLS, TTFB, download) +- Resource sizes +- Failed requests and errors + +### `resources/` + +**Resources directory** - Cached resources: +- Images, fonts, stylesheets, scripts +- Response bodies for replay +- Assets needed to reconstruct page state + +## What Traces Capture + +| Category | Details | +|----------|---------| +| **Actions** | Clicks, fills, hovers, keyboard input, navigations | +| **DOM** | Full DOM snapshot before/after each action | +| **Screenshots** | Visual state at each step | +| **Network** | All requests, responses, headers, bodies, timing | +| **Console** | All console.log, warn, error messages | +| **Timing** | Precise timing for each operation | + +## Use Cases + +### Debugging Failed Actions + +```bash +playwright-cli tracing-start +playwright-cli open https://app.example.com + +# This click fails - why? +playwright-cli click e5 + +playwright-cli tracing-stop +# Open trace to see DOM state when click was attempted +``` + +### Analyzing Performance + +```bash +playwright-cli tracing-start +playwright-cli open https://slow-site.com +playwright-cli tracing-stop + +# View network waterfall to identify slow resources +``` + +### Capturing Evidence + +```bash +# Record a complete user flow for documentation +playwright-cli tracing-start + +playwright-cli open https://app.example.com/checkout +playwright-cli fill e1 "4111111111111111" +playwright-cli fill e2 "12/25" +playwright-cli fill e3 "123" +playwright-cli click e4 + +playwright-cli tracing-stop +# Trace shows exact sequence of events +``` + +## Trace vs Video vs Screenshot + +| Feature | Trace | Video | Screenshot | +|---------|-------|-------|------------| +| **Format** | .trace file | .webm video | .png/.jpeg image | +| **DOM inspection** | Yes | No | No | +| **Network details** | Yes | No | No | +| **Step-by-step replay** | Yes | Continuous | Single frame | +| **File size** | Medium | Large | Small | +| **Best for** | Debugging | Demos | Quick capture | + +## Best Practices + +### 1. Start Tracing Before the Problem + +```bash +# Trace the entire flow, not just the failing step +playwright-cli tracing-start +playwright-cli open https://example.com +# ... all steps leading to the issue ... +playwright-cli tracing-stop +``` + +### 2. Clean Up Old Traces + +Traces can consume significant disk space: + +```bash +# Remove traces older than 7 days +find .playwright-cli/traces -mtime +7 -delete +``` + +## Limitations + +- Traces add overhead to automation +- Large traces can consume significant disk space +- Some dynamic content may not replay perfectly diff --git a/.claude/skills/playwright-cli/references/video-recording.md b/.claude/skills/playwright-cli/references/video-recording.md new file mode 100644 index 00000000..ce9ad6a6 --- /dev/null +++ b/.claude/skills/playwright-cli/references/video-recording.md @@ -0,0 +1,143 @@ +# Video Recording + +Capture browser automation sessions as video for debugging, documentation, or verification. Produces WebM (VP8/VP9 codec). + +## Basic Recording + +```bash +# Open browser first +playwright-cli open + +# Start recording +playwright-cli video-start demo.webm + +# Add a chapter marker for section transitions +playwright-cli video-chapter "Getting Started" --description="Opening the homepage" --duration=2000 + +# Navigate and perform actions +playwright-cli goto https://example.com +playwright-cli snapshot +playwright-cli click e1 + +# Add another chapter +playwright-cli video-chapter "Filling Form" --description="Entering test data" --duration=2000 +playwright-cli fill e2 "test input" + +# Stop and save +playwright-cli video-stop +``` + +## Best Practices + +### 1. Use Descriptive Filenames + +```bash +# Include context in filename +playwright-cli video-start recordings/login-flow-2024-01-15.webm +playwright-cli video-start recordings/checkout-test-run-42.webm +``` + +### 2. Record entire hero scripts. + +When recording a video for the user or as a proof of work, it is best to create a code snippet and execute it with run-code. +It allows pulling appropriate pauses between the actions and annotating the video. There are new Playwright APIs for that. + +1) Perform scenario using CLI and take note of all locators and actions. You'll need those locators to request their bounding boxes for highlight. +2) Create a file with the intended script for video (below). Use pressSequentially w/ delay for nice typing, make reasonable pauses. +3) Use playwright-cli run-code --filename your-script.js + +**Important**: Overlays are `pointer-events: none` — they do not interfere with page interactions. You can safely keep sticky overlays visible while clicking, filling, or performing any actions on the page. + +```js +async page => { + await page.screencast.start({ path: 'video.webm', size: { width: 1280, height: 800 } }); + await page.goto('https://demo.playwright.dev/todomvc'); + + // Show a chapter card — blurs the page and shows a dialog. + // Blocks until duration expires, then auto-removes. + // Use this for simple use cases, but always feel free to hand-craft your own beautiful + // overlay via await page.screencast.showOverlay(). + await page.screencast.showChapter('Adding Todo Items', { + description: 'We will add several items to the todo list.', + duration: 2000, + }); + + // Perform action + await page.getByRole('textbox', { name: 'What needs to be done?' }).pressSequentially('Walk the dog', { delay: 60 }); + await page.getByRole('textbox', { name: 'What needs to be done?' }).press('Enter'); + await page.waitForTimeout(1000); + + // Show next chapter + await page.screencast.showChapter('Verifying Results', { + description: 'Checking the item appeared in the list.', + duration: 2000, + }); + + // Add a sticky annotation that stays while you perform actions. + // Overlays are pointer-events: none, so they won't block clicks. + const annotation = await page.screencast.showOverlay(` +
+ ✓ Item added successfully +
+ `); + + // Perform more actions while the annotation is visible + await page.getByRole('textbox', { name: 'What needs to be done?' }).pressSequentially('Buy groceries', { delay: 60 }); + await page.getByRole('textbox', { name: 'What needs to be done?' }).press('Enter'); + await page.waitForTimeout(1500); + + // Remove the annotation when done + await annotation.dispose(); + + // You can also highlight relevant locators and provide contextual annotations. + const bounds = await page.getByText('Walk the dog').boundingBox(); + await page.screencast.showOverlay(` +
+
+
Check it out, it is right above this text +
+ `, { duration: 2000 }); + + await page.screencast.stop(); +} +``` + +Embrace creativity, overlays are powerful. + +### Overlay API Summary + +| Method | Use Case | +|--------|----------| +| `page.screencast.showChapter(title, { description?, duration?, styleSheet? })` | Full-screen chapter card with blurred backdrop — ideal for section transitions | +| `page.screencast.showOverlay(html, { duration? })` | Custom HTML overlay — use for callouts, labels, highlights | +| `disposable.dispose()` | Remove a sticky overlay added without duration | +| `page.screencast.hideOverlays()` / `page.screencast.showOverlays()` | Temporarily hide/show all overlays | + +## Tracing vs Video + +| Feature | Video | Tracing | +|---------|-------|---------| +| Output | WebM file | Trace file (viewable in Trace Viewer) | +| Shows | Visual recording | DOM snapshots, network, console, actions | +| Use case | Demos, documentation | Debugging, analysis | +| Size | Larger | Smaller | + +## Limitations + +- Recording adds slight overhead to automation +- Large recordings can consume significant disk space diff --git a/.gitignore b/.gitignore index fb7a88e1..188d81cd 100644 --- a/.gitignore +++ b/.gitignore @@ -49,3 +49,4 @@ build-iPhoneSimulator/ # unless supporting rvm < 1.11.0 or doing something fancy, ignore this: .rvmrc .DS_Store +.playwright/ diff --git a/README.md b/README.md index 16f6bf66..9d46a333 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,22 @@ lefthook install bundle exec rspec ``` +## Scripts + +### `bin/clean_html` + +Parses a Google search result HTML file with Nokolexbor and strips ` + + + HTML + end + + let(:matching_expected) do + [{ "name" => "The Starry Night", "extensions" => ["1889"], + "link" => "https://www.google.com/search?q=Starry+Night", + "image" => "data:image/jpeg;base64,IMG1==" }] + end + + let(:mismatched_expected) do + [{ "name" => "Wrong Name", "extensions" => ["1889"], + "link" => "https://www.google.com/search?q=Starry+Night", + "image" => "data:image/jpeg;base64,IMG1==" }] + end + + context "when all fields match" do + subject(:comparator) { described_class.new(html, matching_expected) } + + it "reports no mismatches" do + expect(comparator.mismatches).to eq(0) + end + end + + context "when a field does not match" do + subject(:comparator) { described_class.new(html, mismatched_expected) } + + it "reports a mismatch" do + expect(comparator.mismatches).to eq(1) + end + end +end diff --git a/spec/carousel_extractor_spec.rb b/spec/carousel_extractor_spec.rb new file mode 100644 index 00000000..10495ee9 --- /dev/null +++ b/spec/carousel_extractor_spec.rb @@ -0,0 +1,50 @@ +require "spec_helper" +require "carousel_extractor" + +RSpec.describe CarouselExtractor do + let(:html) do + <<~HTML + + + + + + + HTML + end + + subject(:results) { described_class.new(html).extract } + + it "extracts image from script tag for visible items" do + expect(results[0][:image]).to eq("data:image/jpeg;base64,IMG1==") + end + + it "extracts data-src url for lazy-loaded items" do + expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=fake") + end + + it "returns nil image when neither source is available" do + expect(results[2][:image]).to be_nil + end + + it "omits extensions when no date is present" do + expect(results[2]).not_to have_key(:extensions) + end +end diff --git a/spec/carousel_item/basic_spec.rb b/spec/carousel_item/basic_spec.rb new file mode 100644 index 00000000..d21c9fb6 --- /dev/null +++ b/spec/carousel_item/basic_spec.rb @@ -0,0 +1,33 @@ +require "spec_helper" +require "carousel_item" + +RSpec.describe CarouselItem do + let(:html) do + <<~HTML + + HTML + end + + let(:node) { Nokolexbor::HTML(html).css(".iELo6").first } + subject(:item) { described_class.new(node, {}) } + + describe "#to_h" do + it "extracts the name" do + expect(item.to_h[:name]).to eq("The Starry Night") + end + + it "extracts extensions as an array" do + expect(item.to_h[:extensions]).to eq(["1889"]) + end + + it "extracts the link" do + expect(item.to_h[:link]).to include("q=The+Starry+Night") + end + end +end diff --git a/spec/carousel_item/image_spec.rb b/spec/carousel_item/image_spec.rb new file mode 100644 index 00000000..e067cd69 --- /dev/null +++ b/spec/carousel_item/image_spec.rb @@ -0,0 +1,52 @@ +require "spec_helper" +require "carousel_item" + +RSpec.describe CarouselItem do + let(:html) do + <<~HTML +
+ + + +
+ HTML + end + + let(:node) { Nokolexbor::HTML(html).css(".iELo6").first } + + describe "#image" do + context "when img has an id (jpeg via script tag)" do + subject(:item) { described_class.new(node, { "_img1" => "data:image/jpeg;base64,FAKEBASE64==" }) } + + it "returns the base64 jpeg from ImageExtractor" do + expect(item.to_h[:image]).to eq("data:image/jpeg;base64,FAKEBASE64==") + end + end + + context "when img has no id but has data-src (lazy-loaded)" do + let(:html) do + <<~HTML +
+ + + +
+ HTML + end + + subject(:item) { described_class.new(node, {}) } + + it "returns the data-src url" do + expect(item.to_h[:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=fake") + end + end + + context "when img has no id (gif placeholder)" do + subject(:item) { described_class.new(node, {}) } + + it "returns nil" do + expect(item.to_h[:image]).to be_nil + end + end + end +end diff --git a/spec/carousel_item/rel_to_abs_links_spec.rb b/spec/carousel_item/rel_to_abs_links_spec.rb new file mode 100644 index 00000000..3b27ca06 --- /dev/null +++ b/spec/carousel_item/rel_to_abs_links_spec.rb @@ -0,0 +1,21 @@ +require "spec_helper" +require "carousel_item" + +RSpec.describe CarouselItem do + let(:html) do + <<~HTML +
+ +
+ HTML + end + + let(:node) { Nokolexbor::HTML(html).css(".iELo6").first } + subject(:item) { described_class.new(node, {}) } + + describe "link" do + it "converts relative links to absolute" do + expect(item.to_h[:link]).to eq("https://www.google.com/search?q=The+Starry+Night") + end + end +end diff --git a/spec/carousel_item_spec.rb b/spec/carousel_item_spec.rb new file mode 100644 index 00000000..9da34766 --- /dev/null +++ b/spec/carousel_item_spec.rb @@ -0,0 +1,25 @@ +require "spec_helper" +require "carousel_item" + +RSpec.describe CarouselItem do + let(:node) { Nokolexbor::HTML('
').css(".iELo6").first } + subject(:item) { described_class.new(node, {}) } + + describe "#to_h when fields are missing" do + it "returns nil for name" do + expect(item.to_h[:name]).to be_nil + end + + it "omits extensions key when there is no date" do + expect(item.to_h).not_to have_key(:extensions) + end + + it "returns nil for link" do + expect(item.to_h[:link]).to be_nil + end + + it "returns nil for image" do + expect(item.to_h[:image]).to be_nil + end + end +end diff --git a/spec/fixtures/debug/mismatch-fixture.html b/spec/fixtures/debug/mismatch-fixture.html new file mode 100644 index 00000000..99e20f29 --- /dev/null +++ b/spec/fixtures/debug/mismatch-fixture.html @@ -0,0 +1,9 @@ + + + diff --git a/spec/fixtures/debug/mismatch-fixture.json b/spec/fixtures/debug/mismatch-fixture.json new file mode 100644 index 00000000..bce120d0 --- /dev/null +++ b/spec/fixtures/debug/mismatch-fixture.json @@ -0,0 +1,9 @@ +{ + "artworks": [ + { + "name": "Wrong Name", + "extensions": ["1889"], + "link": "https://www.google.com/search?q=The+Starry+Night" + } + ] +} diff --git a/files/expected-array.json b/spec/fixtures/json-result/van-gogh-paintings.json similarity index 100% rename from files/expected-array.json rename to spec/fixtures/json-result/van-gogh-paintings.json diff --git a/files/van-gogh-paintings.html b/spec/fixtures/source-html/van-gogh-paintings.html similarity index 100% rename from files/van-gogh-paintings.html rename to spec/fixtures/source-html/van-gogh-paintings.html diff --git a/spec/image_extractor_spec.rb b/spec/image_extractor_spec.rb new file mode 100644 index 00000000..3d8a2364 --- /dev/null +++ b/spec/image_extractor_spec.rb @@ -0,0 +1,42 @@ +require "spec_helper" +require "image_extractor" + +RSpec.describe ImageExtractor do + let(:html) do + <<~HTML + + + + + HTML + end + + let(:doc) { Nokolexbor::HTML(html) } + subject(:images) { described_class.new(doc) } + + it "looks up an image by id" do + expect(images["_abc123"]).to eq("data:image/jpeg;base64,FAKEBASE64==") + end + + it "looks up a different image by id" do + expect(images["_xyz789"]).to eq("data:image/jpeg;base64,OTHERBASE64==") + end + + it "returns nil for an unknown id" do + expect(images["_unknown"]).to be_nil + end + + context "when the base64 string contains JavaScript hex escapes" do + let(:html) do + <<~HTML + + + + HTML + end + + it "unescapes \\x3d to =" do + expect(images["_esc123"]).to eq("data:image/jpeg;base64,FAKEBASE64==") + end + end +end diff --git a/spec/integration/carousel_extractor_spec.rb b/spec/integration/carousel_extractor_spec.rb new file mode 100644 index 00000000..a045cd14 --- /dev/null +++ b/spec/integration/carousel_extractor_spec.rb @@ -0,0 +1,27 @@ +require "spec_helper" +require "json" +require "carousel_extractor" + +SOURCE_HTML_DIR = File.join(__dir__, "../fixtures/source-html") +JSON_RESULT_DIR = File.join(__dir__, "../fixtures/json-result") + +Dir["#{SOURCE_HTML_DIR}/*.html"].each do |html_file| + basename = File.basename(html_file, ".html") + json_file = "#{JSON_RESULT_DIR}/#{basename}.json" + + RSpec.describe "CarouselExtractor — #{basename}", :integration do + let(:results) { CarouselExtractor.new(File.read(html_file)).extract } + let(:expected) { JSON.parse(File.read(json_file))["artworks"] } + + it "extracts the correct number of artworks" do + expect(results.length).to eq(expected.length) + end + + it "matches each artwork" do + results.each_with_index do |result, i| + exp = expected[i].transform_keys(&:to_sym) + expect(result).to eq(exp) + end + end + end +end diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index 6e872dbf..0670d80d 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -1,4 +1,19 @@ +$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib")) + +require "nokolexbor" + RSpec.configure do |config| + unless config.files_to_run.one? + require "simplecov" + + SimpleCov.start do + track_files "lib/**/*.rb" + enable_coverage :branch + add_group "Lib", "lib" + add_filter "/spec/" + end + end + config.expect_with :rspec do |expectations| expectations.include_chain_clauses_in_custom_matcher_descriptions = true end From 2332c32034847de7c01349bee7ad585db6f63041 Mon Sep 17 00:00:00 2001 From: Brent Date: Tue, 26 May 2026 19:19:59 +0200 Subject: [PATCH 05/16] Add a layout strategy - generalise carousel. - Extract layout-specific CSS selectors into `Layouts::IELo6`, `Layouts::JCuzJd`, and `Layouts::Z8r5Gb` adapter objects so `CarouselExtractor` and `CarouselItem` are decoupled from any single Google CSS class - `CarouselExtractor` auto-detects the layout by probing each adapter's `item_selector` against the document; raises `UnknownLayoutError` if none match - `Layouts::GridTile` base class captures the shared name/extension/image selectors used by the grid-tile family (`jCuzJd`, `Z8r5Gb`) - Add two new HTML + JSON fixtures (Her movie cast, Taylor Swift albums) and expand `carousel_extractor_spec` to run the full integration suite against all three fixtures - Add `bin/generate-fixture` script (preview + `--save` mode) with smoke tests; update `bin/serve-html` to point at `spec/fixtures/source-html/` --- README.md | 41 +- bin/generate-fixture | 40 ++ bin/serve-html | 4 +- lib/carousel_extractor.rb | 15 +- lib/carousel_item.rb | 13 +- lib/layouts/grid_tile.rb | 9 + lib/layouts/i_elo6.rb | 9 + lib/layouts/j_cuz_jd.rb | 8 + lib/layouts/z8r5_gb.rb | 8 + spec/bin/generate_fixture_spec.rb | 16 + spec/carousel_extractor_spec.rb | 137 +++++-- spec/carousel_item/basic_spec.rb | 3 +- spec/carousel_item/image_spec.rb | 9 +- spec/carousel_item/rel_to_abs_links_spec.rb | 3 +- spec/carousel_item_spec.rb | 25 -- .../her-movie-cast-Google-Search.json | 327 +++++++++++++++ .../taylor-swift-albums-Google-Search.json | 388 ++++++++++++++++++ .../her-movie-cast-Google-Search.html | 45 ++ .../taylor-swift-albums-Google-Search.html | 44 ++ spec/layouts/i_elo6_spec.rb | 27 ++ spec/layouts/j_cuz_jd_spec.rb | 9 + spec/layouts/z8r5_gb_spec.rb | 9 + 22 files changed, 1108 insertions(+), 81 deletions(-) create mode 100755 bin/generate-fixture create mode 100644 lib/layouts/grid_tile.rb create mode 100644 lib/layouts/i_elo6.rb create mode 100644 lib/layouts/j_cuz_jd.rb create mode 100644 lib/layouts/z8r5_gb.rb create mode 100644 spec/bin/generate_fixture_spec.rb delete mode 100644 spec/carousel_item_spec.rb create mode 100644 spec/fixtures/json-result/her-movie-cast-Google-Search.json create mode 100644 spec/fixtures/json-result/taylor-swift-albums-Google-Search.json create mode 100644 spec/fixtures/source-html/her-movie-cast-Google-Search.html create mode 100644 spec/fixtures/source-html/taylor-swift-albums-Google-Search.html create mode 100644 spec/layouts/i_elo6_spec.rb create mode 100644 spec/layouts/j_cuz_jd_spec.rb create mode 100644 spec/layouts/z8r5_gb_spec.rb diff --git a/README.md b/README.md index 3dd948c2..34ad8fcb 100644 --- a/README.md +++ b/README.md @@ -63,6 +63,30 @@ the live DOM with Playwright: 3. **No image** — `` has neither `id` nor `data-src`. Returns `nil`. +## Adding a new fixture + +1. Search Google **in an incognito window** for a carousel page (actors, albums, movies, etc.) + Incognito prevents your Google account email and session tokens from being embedded in the saved HTML. +2. `File → Save Page As → Web Page, Complete` — save the `.html` to `spec/fixtures/source-html/.html`. + Delete the companion `_files/` directory — it contains browser assets not needed for parsing. +3. Preview what the extractor finds: + ```bash + bin/generate-fixture + ``` +4. If the output looks correct, write the JSON fixture: + ```bash + bin/generate-fixture --save + ``` +5. Run the integration tests to confirm: + ```bash + bin/rspec spec/integration/ + ``` + +If `bin/generate-fixture` raises `CarouselExtractor::UnknownLayoutError`, the page uses a CSS class +layout not yet recognised. Use `bin/serve-html` + Playwright to inspect the live DOM, identify the +item/name/extension/image selectors, and add a new adapter in `lib/layouts/` +(see [roadmap](../docs/roadmap.md)). + ## Scripts ### `bin/clean-html` @@ -81,16 +105,25 @@ structure without wading through thousands of lines of inline JS. ### `bin/serve-html` -Serves the `files/` directory over HTTP so the HTML fixtures can be opened in a browser -or inspected with Playwright CLI (which blocks the `file://` protocol). +Serves the `spec/fixtures/source-html/` directory over HTTP so HTML fixtures can be opened +in a browser or inspected with Playwright CLI (which blocks the `file://` protocol). ```bash bin/serve-html # → http://localhost:8765 bin/serve-html 9000 # custom port ``` -Open http://localhost:8765/van-gogh-paintings-clean.html for a stripped-down view -suitable for DOM inspection. +Open http://localhost:8765/van-gogh-paintings.html to inspect the live DOM with Playwright. + +### `bin/generate-fixture` + +Runs the extractor against an HTML fixture and prints the results for review. Pass `--save` +to write the output as a JSON fixture, which the integration test will then pick up. + +```bash +bin/generate-fixture her-movie-cast-Google-Search # preview +bin/generate-fixture her-movie-cast-Google-Search --save # write fixture +``` ### `bin/debug-compare` diff --git a/bin/generate-fixture b/bin/generate-fixture new file mode 100755 index 00000000..3b27cadb --- /dev/null +++ b/bin/generate-fixture @@ -0,0 +1,40 @@ +#!/usr/bin/env ruby +# frozen_string_literal: true + +$LOAD_PATH.unshift File.join(__dir__, "../lib") + +require "json" +require "carousel_extractor" + +basename = ARGV[0] +save = ARGV.include?("--save") + +unless basename + warn "Usage: bin/generate-fixture [--save]" + exit 1 +end + +html_file = File.join(__dir__, "../spec/fixtures/source-html/#{basename}.html") +json_file = File.join(__dir__, "../spec/fixtures/json-result/#{basename}.json") + +unless File.exist?(html_file) + warn "HTML fixture not found: #{html_file}" + exit 1 +end + +results = CarouselExtractor.new(File.read(html_file)).extract + +results.each_with_index do |item, i| + puts "\n[#{i + 1}] #{item[:name]}" + puts " extensions: #{item[:extensions].inspect}" if item.key?(:extensions) + puts " link: #{item[:link]}" + puts " image: #{item[:image]&.slice(0, 60)}..." +end + +puts "\n#{results.length} items extracted." + +if save + payload = JSON.pretty_generate({ "artworks" => results.map { |r| r.transform_keys(&:to_s) } }) + File.write(json_file, payload) + puts "Saved → #{json_file}" +end diff --git a/bin/serve-html b/bin/serve-html index 230f8c8b..e9c24d30 100755 --- a/bin/serve-html +++ b/bin/serve-html @@ -6,10 +6,10 @@ require "webrick" port = (ARGV[0] || 8765).to_i -root = File.expand_path("../files", __dir__) +root = File.expand_path("../spec/fixtures/source-html", __dir__) puts "Serving #{root} at http://localhost:#{port}" -puts "Van Gogh page: http://localhost:#{port}/van-gogh-paintings-clean.html" +puts "Van Gogh page: http://localhost:#{port}/van-gogh-paintings.html" puts "Press Ctrl+C to stop." server = WEBrick::HTTPServer.new(Port: port, DocumentRoot: root, AccessLog: []) diff --git a/lib/carousel_extractor.rb b/lib/carousel_extractor.rb index 3656e99d..ad39b4cc 100644 --- a/lib/carousel_extractor.rb +++ b/lib/carousel_extractor.rb @@ -1,15 +1,28 @@ require "nokolexbor" require "carousel_item" require "image_extractor" +require "layouts/i_elo6" +require "layouts/j_cuz_jd" +require "layouts/z8r5_gb" # Parses a Google SERP HTML page and extracts all carousel items. class CarouselExtractor + class UnknownLayoutError < StandardError; end + + LAYOUTS = [Layouts::IELo6.new, Layouts::JCuzJd.new, Layouts::Z8r5Gb.new].freeze + def initialize(html) @doc = Nokolexbor::HTML(html) end def extract + layout = LAYOUTS.find { |l| @doc.css(l.item_selector).any? } + raise UnknownLayoutError, "no recognized carousel layout found — add a new Layouts:: adapter" unless layout + images = ImageExtractor.new(@doc) - @doc.css(".iELo6").map { |node| CarouselItem.new(node, images).to_h } + @doc.css(layout.item_selector).filter_map do |node| + item = CarouselItem.new(node, images, layout).to_h + item if item[:name] || item[:link] + end end end diff --git a/lib/carousel_item.rb b/lib/carousel_item.rb index cd4b5df9..faed70b7 100644 --- a/lib/carousel_item.rb +++ b/lib/carousel_item.rb @@ -1,10 +1,9 @@ -require "nokolexbor" - # Extracts name, extensions, link, and image from a single carousel node. class CarouselItem - def initialize(node, images) - @node = node + def initialize(node, images, layout) + @node = node @images = images + @layout = layout end def to_h @@ -19,11 +18,11 @@ def to_h private def name - @node.css(".pgNMRc").first&.text + @layout.name(@node) end def extensions - ext = @node.css(".cxzHyb").first&.text + ext = @layout.extension(@node) ext.to_s.empty? ? [] : [ext] end @@ -33,7 +32,7 @@ def link end def image - img = @node.css("img.taFZJe").first + img = @node.css(@layout.image_selector).first return unless img @images[img.attr("id")] || img.attr("data-src") diff --git a/lib/layouts/grid_tile.rb b/lib/layouts/grid_tile.rb new file mode 100644 index 00000000..afe5f746 --- /dev/null +++ b/lib/layouts/grid_tile.rb @@ -0,0 +1,9 @@ +module Layouts + # Shared selectors for Google's grid-tile carousel component (actors, albums, etc.). + # Subclasses override item_selector only — Google rotates the wrapper class independently. + class GridTile + def image_selector = "img.d7ENZc" + def name(node) = node.css(".JjtOHd").first&.text + def extension(node) = node.css(".cHaqb").first&.text + end +end diff --git a/lib/layouts/i_elo6.rb b/lib/layouts/i_elo6.rb new file mode 100644 index 00000000..b5f820e2 --- /dev/null +++ b/lib/layouts/i_elo6.rb @@ -0,0 +1,9 @@ +module Layouts + # Google carousel layout used for paintings, artworks, and similar knowledge-panel carousels. + class IELo6 + def item_selector = ".iELo6" + def image_selector = "img.taFZJe" + def name(node) = node.css(".pgNMRc").first&.text + def extension(node) = node.css(".cxzHyb").first&.text + end +end diff --git a/lib/layouts/j_cuz_jd.rb b/lib/layouts/j_cuz_jd.rb new file mode 100644 index 00000000..579f3359 --- /dev/null +++ b/lib/layouts/j_cuz_jd.rb @@ -0,0 +1,8 @@ +require "layouts/grid_tile" + +module Layouts + # Google carousel layout used for movie/show casts and similar entity carousels. + class JCuzJd < GridTile + def item_selector = ".jCuzJd" + end +end diff --git a/lib/layouts/z8r5_gb.rb b/lib/layouts/z8r5_gb.rb new file mode 100644 index 00000000..a88c7740 --- /dev/null +++ b/lib/layouts/z8r5_gb.rb @@ -0,0 +1,8 @@ +require "layouts/grid_tile" + +module Layouts + # Google carousel layout used for albums and similar media carousels. + class Z8r5Gb < GridTile + def item_selector = ".Z8r5Gb" + end +end diff --git a/spec/bin/generate_fixture_spec.rb b/spec/bin/generate_fixture_spec.rb new file mode 100644 index 00000000..411407e0 --- /dev/null +++ b/spec/bin/generate_fixture_spec.rb @@ -0,0 +1,16 @@ +require "spec_helper" +require "carousel_extractor" +require "English" + +RSpec.describe "bin/generate-fixture" do + it "prints extracted results to stdout" do + expect { system "bin/generate-fixture van-gogh-paintings" } + .to output(a_string_including("The Starry Night")) + .to_stdout_from_any_process + end + + it "exits non-zero when the html fixture is missing" do + system "bin/generate-fixture no-such-file" + expect($CHILD_STATUS.exitstatus).to_not eq(0) + end +end diff --git a/spec/carousel_extractor_spec.rb b/spec/carousel_extractor_spec.rb index 10495ee9..7ce2d73b 100644 --- a/spec/carousel_extractor_spec.rb +++ b/spec/carousel_extractor_spec.rb @@ -2,49 +2,112 @@ require "carousel_extractor" RSpec.describe CarouselExtractor do - let(:html) do - <<~HTML - - - - - - - HTML + describe "unknown layout" do + it "raises UnknownLayoutError when no recognized layout is found" do + expect { described_class.new("").extract } + .to raise_error(CarouselExtractor::UnknownLayoutError) + end end - subject(:results) { described_class.new(html).extract } + context "with iELo6 layout (paintings carousel)" do + let(:html) do + <<~HTML + + + + + +
+ + HTML + end - it "extracts image from script tag for visible items" do - expect(results[0][:image]).to eq("data:image/jpeg;base64,IMG1==") - end + subject(:results) { described_class.new(html).extract } - it "extracts data-src url for lazy-loaded items" do - expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=fake") - end + it "filters out blank items (no name or link)" do + expect(results.length).to eq(3) + end + + it "extracts image from script tag for visible items" do + expect(results[0][:image]).to eq("data:image/jpeg;base64,IMG1==") + end - it "returns nil image when neither source is available" do - expect(results[2][:image]).to be_nil + it "extracts data-src url for lazy-loaded items" do + expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=fake") + end + + it "returns nil image when neither source is available" do + expect(results[2][:image]).to be_nil + end + + it "omits extensions when no date is present" do + expect(results[2]).not_to have_key(:extensions) + end end - it "omits extensions when no date is present" do - expect(results[2]).not_to have_key(:extensions) + context "with jCuzJd layout (actors carousel)" do + let(:html) do + <<~HTML + + + + + + HTML + end + + subject(:results) { described_class.new(html).extract } + + it "detects jCuzJd layout and extracts name" do + expect(results[0][:name]).to eq("Joaquin Phoenix") + end + + it "extracts extension (role) for jCuzJd items" do + expect(results[0][:extensions]).to eq(["Theodore"]) + end + + it "extracts base64 image from script tag" do + expect(results[0][:image]).to eq("data:image/jpeg;base64,ACT1==") + end + + it "extracts data-src for lazy-loaded jCuzJd items" do + expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=amy") + end + + it "omits extensions when role is absent" do + expect(results[1]).not_to have_key(:extensions) + end + + it "preserves absolute links unchanged" do + expect(results[0][:link]).to eq("https://www.google.com/search?q=Joaquin+Phoenix") + end end end diff --git a/spec/carousel_item/basic_spec.rb b/spec/carousel_item/basic_spec.rb index d21c9fb6..7c884691 100644 --- a/spec/carousel_item/basic_spec.rb +++ b/spec/carousel_item/basic_spec.rb @@ -1,5 +1,6 @@ require "spec_helper" require "carousel_item" +require "layouts/i_elo6" RSpec.describe CarouselItem do let(:html) do @@ -15,7 +16,7 @@ end let(:node) { Nokolexbor::HTML(html).css(".iELo6").first } - subject(:item) { described_class.new(node, {}) } + subject(:item) { described_class.new(node, {}, Layouts::IELo6.new) } describe "#to_h" do it "extracts the name" do diff --git a/spec/carousel_item/image_spec.rb b/spec/carousel_item/image_spec.rb index e067cd69..84d0699e 100644 --- a/spec/carousel_item/image_spec.rb +++ b/spec/carousel_item/image_spec.rb @@ -1,7 +1,10 @@ require "spec_helper" require "carousel_item" +require "layouts/i_elo6" RSpec.describe CarouselItem do + let(:layout) { Layouts::IELo6.new } + let(:html) do <<~HTML
@@ -16,7 +19,7 @@ describe "#image" do context "when img has an id (jpeg via script tag)" do - subject(:item) { described_class.new(node, { "_img1" => "data:image/jpeg;base64,FAKEBASE64==" }) } + subject(:item) { described_class.new(node, { "_img1" => "data:image/jpeg;base64,FAKEBASE64==" }, layout) } it "returns the base64 jpeg from ImageExtractor" do expect(item.to_h[:image]).to eq("data:image/jpeg;base64,FAKEBASE64==") @@ -34,7 +37,7 @@ HTML end - subject(:item) { described_class.new(node, {}) } + subject(:item) { described_class.new(node, {}, layout) } it "returns the data-src url" do expect(item.to_h[:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=fake") @@ -42,7 +45,7 @@ end context "when img has no id (gif placeholder)" do - subject(:item) { described_class.new(node, {}) } + subject(:item) { described_class.new(node, {}, layout) } it "returns nil" do expect(item.to_h[:image]).to be_nil diff --git a/spec/carousel_item/rel_to_abs_links_spec.rb b/spec/carousel_item/rel_to_abs_links_spec.rb index 3b27ca06..9f086b80 100644 --- a/spec/carousel_item/rel_to_abs_links_spec.rb +++ b/spec/carousel_item/rel_to_abs_links_spec.rb @@ -1,5 +1,6 @@ require "spec_helper" require "carousel_item" +require "layouts/i_elo6" RSpec.describe CarouselItem do let(:html) do @@ -11,7 +12,7 @@ end let(:node) { Nokolexbor::HTML(html).css(".iELo6").first } - subject(:item) { described_class.new(node, {}) } + subject(:item) { described_class.new(node, {}, Layouts::IELo6.new) } describe "link" do it "converts relative links to absolute" do diff --git a/spec/carousel_item_spec.rb b/spec/carousel_item_spec.rb deleted file mode 100644 index 9da34766..00000000 --- a/spec/carousel_item_spec.rb +++ /dev/null @@ -1,25 +0,0 @@ -require "spec_helper" -require "carousel_item" - -RSpec.describe CarouselItem do - let(:node) { Nokolexbor::HTML('
').css(".iELo6").first } - subject(:item) { described_class.new(node, {}) } - - describe "#to_h when fields are missing" do - it "returns nil for name" do - expect(item.to_h[:name]).to be_nil - end - - it "omits extensions key when there is no date" do - expect(item.to_h).not_to have_key(:extensions) - end - - it "returns nil for link" do - expect(item.to_h[:link]).to be_nil - end - - it "returns nil for image" do - expect(item.to_h[:image]).to be_nil - end - end -end diff --git a/spec/fixtures/json-result/her-movie-cast-Google-Search.json b/spec/fixtures/json-result/her-movie-cast-Google-Search.json new file mode 100644 index 00000000..af47caea --- /dev/null +++ b/spec/fixtures/json-result/her-movie-cast-Google-Search.json @@ -0,0 +1,327 @@ +{ + "artworks": [ + { + "name": "Joaquin Phoenix", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Joaquin+Phoenix&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIEsQ0tUpIstISyk6300zJzcsGEVXJicckiVn6v_MTC0sw8hYCM_NS8zAoAixd1wD8AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAC", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "Theodore" + ] + }, + { + "name": "Spike Jonze", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Spike+Jonze&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIAsc0Ksi20hLKTrfTTMnNywYRVcmJxySJW7uCCzOxUBa_8vKpUAIEiN_86AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAE", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "Alien Child" + ] + }, + { + "name": "Scarlett Johansson", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Scarlett+Johansson&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIEsY0MDU1KtISyk6300zJzcsGEVXJicckiVqHg5MSinNSSEgWv_IzEvOLi_DwATsWS_kIAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAG", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "Samantha" + ] + }, + { + "name": "Rooney Mara", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Rooney+Mara&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzTcyTC9OMtYSyk6300zJzcsGEVXJicckiVu6g_Py81EoF38SiRAAOYRLCPAAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAI", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "Catherine Klausen" + ] + }, + { + "name": "Olivia Wilde", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Olivia+Wilde&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIEsU0qDOPLtYSyk6300zJzcsGEVXJicckiVh7_nMyyzESF8MyclFQA78GRqDwAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAK", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "Blind Date" + ] + }, + { + "name": "Lynn A. Freedman", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Lynn+Adrianna+Freedman&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzLSvTy4xztISyk6300zJzcsGEVXJicckiVjGfyrw8BceUoszEvLxEBbei1NSU3MQ8ACXlK29HAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAM", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "Letter Writer #1" + ] + }, + { + "name": "Wendy Leon", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Wendy+Leon&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLVT9c3NMwyyyupSDfP0xLKTrbST8vMyQUTVsmJxSWLWLnCU_NSKhV8UvPzAPQwCp0-AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAO", + "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAH4AAAC9CAMAAABCgTmgAAABO1BMVEUAAAAAAAAxMTEwMDQwMjQwMTQwMTQwMTQwMTQxMTQuMjIzMzMwMTMxMjQzNDcxMjUvMTRAQEAwMTQ0NTgwMTQwMTQwMjMwMTUyMjIwMDQvMDMsLC8sLTAuLzJFR0pQU1ZVWFxWWV1ERkk2NzpSVFhaXWFZXGBRVFhYW19XWl5DREg0NTlERkopKiwwMDQwMDM0NjgwMTNQU1dDRUgpKi02NzsvMDJRU1dXWV1FR0syMzYpKSwrKy4rLC8oKSwtLjE4OTw/QURHSUxHSU0/QERCREhMT1JUVlpUV1pMTlFCREdISk5VV1tZXWFJS080NjktLTA9P0JYXGBTVlpNUFNHSk1JTE9NT1M8PkE5Oj0sLS9ZXGFRVFczNTgqKy41Njk1NzovMTQxMTUuLjMwMDMwMTQwMTMuMzMxMTScPsVLAAAAaXRSTlMAAjSZ3fv//NydOAWb////lwS2//75mv8z3f//////////////////////////////////////////////////////////////////////////////////////////////nP83mrW1N5hkK6orAAACZElEQVR4AcTNgQFAMAwEwIcESoN+0f0XhSGaW+CABmi7XrSqYZzmv24QljWaVmbRtv37w5EorN2/ZToCgCVlqgPmdAKzkeqCvG5MUdSJxA7F6NXTCgZ1JFBXvj0f9usiQY4YhsLwTktrEVYXuaatloeZmZmZ73+JMMPWlWTef4GvwPgP8uDBgwcPHjx48ODBgwcPHjx48ODBgwcPHjx48ODBgwcPHjx48ODBM4kQN8S/opY4J1kzPOdclJUva865AT7vagdV1dDpyhvguR1MvVcLbU7Oc1YHi909z3qjhaLFiXmSUrW3j/r7ulVLocS8OK/+2QAz9XitnCTnK/WDxDz0zKtPzpMMq46MCvX1NvHxuVUEi73PBkeihTrjpzXxiPKxzqdlp93MsjPOvROTfmJquolFl5nymdk8n5vPiTkxz5It8OJSvbxSry5OL2TCyfiP+LO19Y1oGoJa3NzafpYJp+J54dnOrgbV8DHVPa32DxY4Dc+HR1U4Vo0np/tnZ+cXG1HVwu7RIafgeeHS1KxTXHF+PTub5XxVDKupHS1wAp5keM9OjiTLiT9GeSZLJ3ZzK5SAlztvceyeaEA+N0B0/xDVO0nBO6/+0d2577pzjz4db+Z/ySwVH9X0l0xjIr6K/jfFKglP5P5QolVP/hBuuODBgwcPHjx48ODBgwcPHjx48ODBgwcPHjx48ODBgwcPHjx48ODBg39XzF0UAAwDQBDcMjPKKzf+FURCfrkRMm4kqVCi/XRzIuUmfBJeuku5u6WT9AMMr+rR/ioIqNZOsYinz0AAAfxFnqSzR2mSmx0CLI4Rf2zw6HsCAAAAAElFTkSuQmCC" + }, + { + "name": "Chris Pratt", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Chris+Pratt&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIEsc1MKypytYSyk6300zJzcsGEVXJicckiVm7njKLMYoWAosSSEgA5W0wxOwAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAQ", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "Paul" + ] + }, + { + "name": "Matt Letscher", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Matt+Letscher&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIEsVOM4s1ztISyk6300zJzcsGEVXJicckiVl7fxJISBZ_UkuLkjNQiAPnzU0Y9AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAS", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQDBA3C618D3mjLkax-zfxo68EnwtrnuIPzeZzi0-_9bU8aCLuvpjAwskMU&s=10", + "extensions": [ + "Charles" + ] + }, + { + "name": "Brian Cox", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Brian+Cox+(actor)&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIEsdMNLZNLtISyk6300zJzcsGEVXJicckiVkGnoszEPAXn_AoFjcTkkvwiTQDdjKMFQQAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAU", + "image": "https://encrypted-tbn0.gstatic.com/licensed-image?q=tbn:ANd9GcTP-9X8oXeWuYL-qw8y86WPNvHYqR5-Ysz4Yz9Fg97umdckkgIzdBkIVhLuD2sbM0dExmvLYfGyvw&s=19", + "extensions": [ + "Alan Watts" + ] + }, + { + "name": "Lil Buck", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Lil+Buck&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzs4xTStKKtYSyk6300zJzcsGEVXJicckiVg6fzBwFp9LkbACEnKO0OQAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAW", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTTF0HUk1O1yWTS3_kynIQMa2xN9SL0zRqLxcku00aCe9u-_-jbt8qmrRLQ&s=10", + "extensions": [ + "Busker" + ] + }, + { + "name": "Gracie Prewitt", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Gracie+Prewitt&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLVT9c3NEwzqCzJK7LM0RLKTrbST8vMyQUTVsmJxSWLWPncixKTM1MVAopSyzNLSgCUt5VjQgAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAY", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSkjKHNumMKVFVpFkI89NIHZmRzNSFcw2-vW7sY0Ogl28CIqQvcBPxOc7Zq&s=10", + "extensions": [ + "Jocelyn" + ] + }, + { + "name": "Kristen Wiig", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Kristen+Wiig&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIEsS3KiixNtISyk6300zJzcsGEVXJicckiVh7vosziktQ8hfDMzHQAL3WtcDwAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAa", + "image": "https://encrypted-tbn0.gstatic.com/licensed-image?q=tbn:ANd9GcTiIh67Toi0SjY2Tn32cW4dRr_oSwcA2xJqt6YOcmohK9cQnFsCi4uE1oXXcA8dqUSF1K-ztXDU&s=19", + "extensions": [ + "SexyKitten" + ] + }, + { + "name": "Laura Kai Chen", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Laura+Kai+Chen&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKz01Oyk02TtYSyk6300zJzcsGEVXJicckiVj6fxNKiRAXvxEwF54zUPAAhnQfjPwAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAc", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSck7UUNrGxWRnrdaPv0oq6vtpboIVKn9WuI-RgqeEAY0-VQe36B9Xwk2iUqA&s=10", + "extensions": [ + "Tatiana" + ] + }, + { + "name": "Laura Meadows", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Laura+Meadows&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzM0wLDM0KtISyk6300zJzcsGEVXJicckiVl6fxNKiRAXf1MSU_PJiAN8sZqg-AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAe", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQBjE3rCp5XJ1HZDVrlAv-7miTd9xN66oyaaQqS_abm&s=10", + "extensions": [ + "Dream Sequence" + ] + }, + { + "name": "Soko", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Soko+(singer)&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzjTOqinKKtYSyk6300zJzcsGEVXJicckiVt7g_Ox8BY3izLz01CJNAAJqQZQ-AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAg", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSrQVKxsmQijzrN8Otvbarv-WE8WwtRZkkdBpi-Jh_B-Sy8Z6Zk1-bnOvTQ&s=10", + "extensions": [ + "Surrogate Date Isabella" + ] + }, + { + "name": "Rachel Ann Mullins", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Rachel+Ann+Mullins&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzLcuKytPjtYSyk6300zJzcsGEVXJicckiVqGgxOSM1BwFx7w8Bd_SnJzMvGIA5nDlDEMAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAi", + "image": "https://encrypted-tbn0.gstatic.com/licensed-image?q=tbn:ANd9GcS8CuPVXWDfuSBmHTpG2qGVbujWfbbtM1KigAdaYIhyasBhK_6Emv1i-QHZf36Q0YRKN6i0_U9h&s=19", + "extensions": [ + "Giselle" + ] + }, + { + "name": "Jen Kuhn", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Jen+Kuhn&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKz44vSDfKStISyk6300zJzcsGEVXJicckiVg6v1DwF79KMPABlPyb3OQAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAk", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSu3JWbIslE3oa3QWQ-QZBUnp7IfkwjUH74tjgoCspjsJgoPorGKF_5tz1f&s=10", + "extensions": [ + "Kathy C." + ] + }, + { + "name": "Richard Allan Jones", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Richard+Allan+Jones&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzS3KyMyyMtYSyk6300zJzcsGEVXJicckiVuGgzOSMxKIUBcecnMQ8Ba_8vNRiABKGLCVEAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAm", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQxyEqWa6k-zylWABu7PAoDVOpYLOjOGCYm836jQ_TLfOoggtxiw14rM2BC&s=10" + }, + { + "name": "Carol McFadden", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Carol+McFadden&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzq4yTsyxytYSyk6300zJzcsGEVXJicckiVj7nxKL8HAXfZLfElJTUPAD9wZE0PwAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAo", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcREOPir_KEbop4QpboQ3zWdd7hvh3WwME13M9UpqUBEZjLGPXSy85smR0gW&s=10" + }, + { + "name": "Amy Adams", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Amy+Adams&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIEsZOMTMvStYSyk6300zJzcsGEVXJicckiVk7H3EoFx5TE3GIAd0qlYTkAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAq", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTVksW1yWUHjMTwctUqihALT_0yvKr6JRt97dyYAXaE32sKrMGb2BswLtn2&s=10", + "extensions": [ + "Amy" + ] + }, + { + "name": "Portia Doubleday", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Portia+Doubleday&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzLcvMcixytISyk6300zJzcsGEVXJicckiVoGA_KKSzEQFl_zSpJzUlMRKAOEtak1BAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAs", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcROiyK6nAOYLI6ph6TOr0t4QiqIx7arWIkWlhxv_hS4CRscnVk6y_TDFdKB&s=10", + "extensions": [ + "Surrogate Date Isabella" + ] + }, + { + "name": "Evelyn Edwards", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Evelyn+Edwards&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKz05OTC43KtYSyk6300zJzcsGEVXJicckiVj7XstScyjwF15TyxKKUYgC6cTjmPwAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAu", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQKbtkILFlSYLVc6BPUDhTApwFlNJc76elONhNbw3Qm9AvBZpyhUoYtu1dn&s=10", + "extensions": [ + "Mother Who Dated Pricks" + ] + }, + { + "name": "Bill Hader", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Bill+Hader&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIEsS3M8nLMtYSyk6300zJzcsGEVXJicckiVi6nzJwcBY_ElNQiAN550k06AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAw", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQsgysfHF2xhFREMMzNxZFZVWOfcx2YxjTpr2rpwua2FWCa-hZaQnHfr1Xe&s=10", + "extensions": [ + "Chat Room Friend #2" + ] + }, + { + "name": "Luka Jones", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Luka+Jones&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzs41zik1ztYSyk6300zJzcsGEVXJicckiVi6f0uxEBa_8vNRiAFqAjgk7AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRAy", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQUPvxSOeUuwp0l6n6-zEu7AgIg0y6L20n4qxF68ixHxsq3Y5Vais5QHSsV&s=10", + "extensions": [ + "Mark Lewman" + ] + }, + { + "name": "Steve Zissis", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Steve+Zissis&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzTXJLKszLtISyk6300zJzcsGEVXJicckiVp7gktSyVIWozOLizGIAdvT59j0AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRA0", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTvyzjBjb18Jp5HAPIqjydDkeV3m43gGnyv1Dj587QvQZlbv3VvCTyT4qqM&s=10", + "extensions": [ + "New Sweet Boyfriend of Mother Who Dated Pricks" + ] + }, + { + "name": "Pramod Kumar", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Pramode+Kumar&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzi0xzyowMtISyk6300zJzcsGEVXJicckiVt6AosTc_JRUBe_S3MQiAC1eVNE-AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRA2", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSzEpYxVYcxyqNn3UatEawCCr9Usl9dt3Yy9fgL7lY5WLtfTE2jLWXrXwp9&s=10", + "extensions": [ + "Pizza Vendor" + ] + }, + { + "name": "Lisa Renee Pitts", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Lisa+Renee+Pitts&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLVT9c3NEw2KMgqMTEo0BLKTrbST8vMyQUTVsmJxSWLWAV8MosTFYJS81JTFQIyS0qKAYM-8G5EAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRA4", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQXAGIuIjqwfatlFQlXViU7edaOQKiyjjNukoe-goN5p1YKcUZtppPh06FV&s=10", + "extensions": [ + "Letter Writer #2" + ] + }, + { + "name": "Claudia Choi", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Claudia+Choi&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKz09PTS0zNtISyk6300zJzcsGEVXJicckiVh7nnMTSlMxEBeeM_EwAA2S5oD0AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRA6", + "image": "https://encrypted-tbn0.gstatic.com/licensed-image?q=tbn:ANd9GcTlTiPIQPNuG_3JseOBPp6QznDMl9dzyR4bdCaeTd4t2JXsFCEKxX8mNKWw6Yt8NU5Fbzab3GwcXQ&s=19", + "extensions": [ + "Uncomfortable Waitress" + ] + }, + { + "name": "Gabe Gomez", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Gabe+Gomez&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLVT9c3NEzLKKrKSKso0RLKTrbST8vMyQUTVsmJxSWLWLncE5NSFdzzc1OrAJIedWE-AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRA8", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSvyTOxLtAuwkkW9Y89Mk1e5pRNagrNCgBbaY4hi2xydAqEvO-CsuZNwmS1&s=10", + "extensions": [ + "Letter Writer #3" + ] + }, + { + "name": "May Lindstrom", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=May+Lindstrom&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLVT9c3NEwzMzYoLM421hLKTrbST8vMyQUTVsmJxSWLWHl9EysVfDLzUopLivJzAW_MSitBAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRA-", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTsEXwWr6tnWnZFJk5NGYip05iEPCVKBvgV55ifGLOduRfDuaryLqtJsp24&s=10", + "extensions": [ + "Sexy Pregnant TV Star" + ] + }, + { + "name": "Brian D. Johnson", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Brian+D.+Johnson&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKz03Ozy9PLtISyk6300zJzcsGEVXJicckiVgGnoszEPAUXPQWv_Iy84vw8AKQjp3VBAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBA", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTIXN19wdrmMNzHRHyonBUVnLN6qmDeJ9vD9GPJsK8ZkyHo5C7JdDBHtvSr&s=10", + "extensions": [ + "OS1 Commercial Lead" + ] + }, + { + "name": "Lisa Cohen", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Lisa+Cohen&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzK1PiK5INtISyk6300zJzcsGEVXJicckiVi6fzOJEBef8jNQ8ANvE_0U7AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBC", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRFtYpIENBXJGk4f4sL78y4SYZnIFZT0dlvAFMgftpWLNkA1A2wN4eiTfvb&s=10", + "extensions": [ + "Michael Wadsworth's Wife" + ] + }, + { + "name": "Katherine Boecher", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Katherine+Boecher&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzzatyKwoqtISyk6300zJzcsGEVXJicckiVkHvxJKM1KLMvFQFp_zUZCATANSonqBCAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBE", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcR3I70YifJwZEYRHjVsaJPYcEHuwCYTATjLJ3bnP6Uiz6OI_I1JmPEBYqEo&s=10" + }, + { + "name": "Cassandra Starr", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Cassandra+Starr&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzK7PKywwstYSyk6300zJzcsGEVXJicckiVn7nxOLixLyUokSF4JLEoiIAptS1kkAAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBG", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRWfRLdBmRLn6nCkXopORd4bu9RtKlOyOKH3S7dY_CWEM-FBP1Xt5CuNRbL&s=10" + }, + { + "name": "Sam Jaeger", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Sam+Jaeger&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzjVMMjCyrtISyk6300zJzcsGEVXJicckiVq7gxFwFr8TU9NQiAIe0PEM7AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBI", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSt92WL_a7NMWhPyeRKAVM6s31dY23o7VW-b8TK7WWtvVT6dUJUDRlUSVc6&s=10", + "extensions": [ + "Dr. Johnson" + ] + }, + { + "name": "Sam Hargrave", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Sam+Hargrave&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKz05NNigyStISyk6300zJzcsGEVXJicckiVp7gxFwFj8Si9KLEslQAGB5oAz0AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBK", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRfk3sCKpb_9YhqYwtUC2hSi95TQDh9ng2INNxHPJYaY2CYU_aJ2qxauzBv&s=10" + }, + { + "name": "Jade Quon", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Jade+Quon&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKzKwuTLI2TtISyk6300zJzcsGEVXJicckiVk6vxJRUhcDS_DwA8s7FOjoAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBM", + "image": "https://encrypted-tbn0.gstatic.com/licensed-image?q=tbn:ANd9GcQJxtv74RH-DuijwmjY69fs63jgDwt2sfKkBzDyM2e_nQmb3rtPjUbNVonh&s=19" + }, + { + "name": "Marian Saastad Ottesen", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Marian+Saastad+Ottesen&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKz05NzCk1KtISyk6300zJzcsGEVXJicckiVjHfxKLMxDyF4EQgNzFFwb-kJLU4NQ8APyyrw0cAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBO", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcS64DPJ-HQOQoVE9BwiEIAOFqzlYs-sN6frnkImnvfxmOgc4Gr8Aca13Bfz&s=10" + }, + { + "name": "Seth Carr", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Seth+Carr&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLVT9c3NMxIzjLKSyk01BLKTrbST8vMyQUTVsmJxSWLWDmDU0syFJwTi4oAGLYa_j0AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBQ", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSo2WwdG_rBD8cdZxGA91Af4s4qD4fN_KgqLhHvf0FmRQu-6ojyXqM1jDEw&s=10" + }, + { + "name": "Pamela Roylance", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Pamela+Roylance&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVQKz05PKiyxNtISyk6300zJzcsGEVXJicckiVv6AxNzUnESFoPzKnMS85FQA3-L3V0AAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBS", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSF4nEixkX6aftRqyWeX7b4K1vHen7Acng0O1j_9fSdlQ2wRzNedU9mXzL9&s=10" + }, + { + "name": "Ramilya Iskander", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Ramilya+Iskander&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLWT9c3NDIqyylLrtASyk620k_LzMkFE1bJicUli1gFghJzM3MqExU8i7MT81JSiwBamFGnQgAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBU", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSWLbH5XqB-pT6DEpTlVEJEAl3ZeEj5COKIzcSlmA&s=0" + }, + { + "name": "Diomid Vinogradov", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Diomid+Vinogradov&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLVT9c3NEwqySkoMDVM0hLKTrbST8vMyQUTVsmJxSWLWAVdMvNzM1MUwjLz8tOLElPyywADSSwmRQAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBW", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTKmNlRVRACBD5fe0fVXulWIi9iR4zE-BOO_xq6OCgS5U2lcw3XFe-7lB78&s=10" + }, + { + "name": "Nico David", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Nico+David&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLVT9c3NEw2KrAwyytK0hLKTrbST8vMyQUTVsmJxSWLWLn8MpPzFVwSyzJTAGWWjIA-AAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBY", + "image": "https://encrypted-tbn0.gstatic.com/licensed-image?q=tbn:ANd9GcQHmd9MyKXGsX_LjmFi_-Uz7_QM1UzdQHcPy3BekzuxSTl7rvAekesY2k9lvi80-FyE-HznyRxj&s=19" + }, + { + "name": "Vasiliy Dakhnenko", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Vasily+Dakhnenko&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeLWT9c3NDJMMrc0NNASyk620k_LzMkFE1bJicUli1gFwhKLM3MqFVwSszPyUvOy8wHPWXwyQgAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBa", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSvDluGWW4ijYzZPobkuQtZur6N7DfA9kxIbKmstA&s=0" + }, + { + "name": "Paul Darnell", + "link": "https://www.google.com/search?sca_esv=0716f69066676062&rlz=1C5CHFA_enGE1115GE1118&q=Paul+Darnell&stick=H4sIAAAAAAAAAONgFuLSz9U3yCk0S0syVeIGsQ0NTS0L05K1hLKTrfTTMnNywYRVcmJxySJWnoDE0hwFl8SivNScHACqeayiPgAAAA&sa=X&ved=2ahUKEwja3sOMt9eUAxWxQEEAHXcJMYYQ9OUBegQIIRBc", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTKTjJNtBh4-z_c2CZoZOFHVAK74VdgmDnoYwXJ87-5dbhjS_cJbAXYD2nJ&s=10" + } + ] +} \ No newline at end of file diff --git a/spec/fixtures/json-result/taylor-swift-albums-Google-Search.json b/spec/fixtures/json-result/taylor-swift-albums-Google-Search.json new file mode 100644 index 00000000..9fd024c6 --- /dev/null +++ b/spec/fixtures/json-result/taylor-swift-albums-Google-Search.json @@ -0,0 +1,388 @@ +{ + "artworks": [ + { + "name": "The Life of a Showgirl", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+The+Life+of+a+Showgirl&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0rMwoTrLMNsrWEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqHJJYmZNfpBBcnplWohCSkargk5mWqpCfppCoEJyRX56eWZQDANnkUZRbAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAD", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2025" + ] + }, + { + "name": "Lover", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Lover&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0TMspLjI3y8nSEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsQqFJJYmZNfpBBcnplWouCTX5ZaBAAEtqTTSgAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAF", + "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBwgHBgkIBwgKCgkLDRYPDQwMDRsUFRAWIB0iIiAdHx8kKDQsJCYxJx8fLT0tMTU3Ojo6Iys/RD84QzQ5OjcBCgoKDQwNGg8PGjclHyU3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3N//AABEIAFoAWgMBIgACEQEDEQH/xAAbAAACAwEBAQAAAAAAAAAAAAAABQIEBgMBB//EADsQAAEDAgMFBAUKBwAAAAAAAAEAAgMEEQUSIQYiMUFRE2FxkhQygcHRFTNDU3ORk6Gx8BY0QlJicqL/xAAYAQADAQEAAAAAAAAAAAAAAAACAwQAAf/EACYRAAICAQMEAQUBAAAAAAAAAAABAgMREiExBBNBUTIiUmGR8AX/2gAMAwEAAhEDEQA/APuKEJRJtLhcbsr53g/ZO+CKMJS4QMpxj8ngboSb+J8J+vf+E74KQ2kws/Tv/Cd8EXan6YHeq+5fsboVGDFaSf5t7jz1YQp/KVL9YfKUGl+hyTksotoVI4rRjjIfKV6zE6R5s2Q+UrNY5C7c/RcQoRyskF2G/sU0KafADWAQhC6YFgcRpfSKw9jGcjR0W+WVBfryTqbHBtoOPSx6iLi2LH4O5kRe2QOsL2sqpgytLiNALlaNrS5pu69xwVKqpu0Y6KNg3mluYi4HLh7U+N8sNyE2/wCdWrEoceSxQvbHSsEz2MeRwJsuHpcRdeN/aMLQbgetfhb981N8UbHuldd8jnB2Y8iBbTpoq+S2oY0W0FhwCTBNvLL3KEfpXg9c/TmO5dKYnMuABcVZp27wQ3/EprkmhvFWtpI2OkaS1xykjkmscjJWB8bg5p4EJBVtaaVmc2Adf8l5hFZKypy5T6O7Q35d4UfT/EinVOUnJLY0SEITycFkw7M43WsWMaLOvqii8Mv6JZ1F6Ft+CnK3KwuLgANVyp3WPcqu0Ujo8JnMR1LSB4nRde4Vz0vYpVmKQRTtY+VuvK/BXYHslu0HeAv7Oq+YVUj5ZJ5XNlMRls6NzeZ1JaVstkqgyQQb+fiwO5loB991yFmXghlGUXlmhEdiu0LdeCk0X5LtE3VDZLKLKnsV8axCkwugjmrjZhkytHU2KzM+1JqP5SJ2XlYWW2noqWsgaysgjmY12ZokbcA9VyZhtCzSOlhaO5qX08Uk2SWX2Rlpilj+/Bb2frHV+D01RI3K9zbOHeDb3Jiq9DEyKnDY2hrbnQKwmC0CzgpwL3WjSN7mt1de3giiU9PJrOCsGFu7bRLtoml2Hlg1aScw/wAbFMzPG4kByX19SAyRnZOeQ3kNEck2grX7MJPSVNZ6BTZo4xKczzfeA1BP/Lk02Zf2deyCJoEURyMb3dfz/d1CqpZA6edsnZvkb2bJHj5sHjYdT71VwmtihxiQNIAduMaTYkDS3ilRpsTTwT2WxezZ9HjCsRsCSUVdLILSQyRkcS6wBTanfdoPVcuTjyHRLUtiONSuhooywkEvtceBS6kxKTM2OQFxcbC3G6v47vUUX2nuK9wHCi14rKhtj9G0/ql1NuOCa6GqeR7CzJE1p4gaqaEJoYJC+DOTqR7U+XD0SLofvXHnwNqs0CN9O1lze/ilziHSyM6LVOoYHcQ771XGB0QlMoEmYi3rpsJ45NdNWIx9ZSwzZBITuaht9L9UrnwOjklbKc2YHW4BDh0IPFfQXbP0LjciW/8AuvBs9QD+mTzp66jBFKnJmIC0MDRcBosE6w14lia4dFf+QaH+2TzrtTYVTUwAiz2HAFymuamtiih9vk9ghjly9qwOyG4vyKuqDI2s9W6mk1xcY4YUnl5BCEJgIIQhYwIQhYwIQhYwIQhYwIQhYwIQhYx//9k=", + "extensions": [ + "2019" + ] + }, + { + "name": "1989", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+1989&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4gYxDQ1zcrMN8rTEs5Ot9HNLizOT9ROLSjKLS6wSc5JKc4sXsQqGJFbm5BcpBJdnppUoGFpaWAIAvFC_3EcAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAH", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2014" + ] + }, + { + "name": "Red", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Red&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4gIxcyxyM8wrtcSzk630c0uLM5P1E4tKMotLrBJzkkpzixexCoQkVubkFykEl2emlSgEpaYAAJe856FFAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAJ", + "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBwgHBgkIBwgKCgkLDRYPDQwMDRsUFRAWIB0iIiAdHx8kKDQsJCYxJx8fLT0tMTU3Ojo6Iys/RD84QzQ5OjcBCgoKDQwNGg8PGjclHyU3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3N//AABEIAFoAWgMBIgACEQEDEQH/xAAbAAACAwEBAQAAAAAAAAAAAAAEBgIDBQEAB//EAD0QAAIBAwIDBgIFCgcBAAAAAAECAwAEERIhBTFBBhMiUWFxMpEUgcHw8RUjNDVCUnKhscIzQ2Jjc5LRB//EABgBAAMBAQAAAAAAAAAAAAAAAAACAwEE/8QAIxEAAgICAQQCAwAAAAAAAAAAAAECEQMhBBIxQVEiMsHR8f/aAAwDAQACEQMRAD8A+XF0FRMxIwNh5VVXa66MslqY9a9nNXIBj0NdCoaywopCk13QasfblVeGY0WFHgldK4q1YzioyKRRZtFPWugZomKzmkUukbMBzOKJTh0rxLJChbOxHUGsc0g6WZ6rnlU9FTkgkQFihAzua53rfvj/AK0XYUDqjNyqz6LMeSj51uWfZu/fcJijG7McRA6UjyxvuFMWlhdFw21dijwTTFc9nLm3hR5D4WcKT5ZoTiXCZ+GSRidCFkXKt0PpQsiYyRm6BUglTwucA7+1WIh6ihsaivTRFnZiYCVsEasAfL/2rYbOafaGJ3P+lc0bZWk8Dm3uoniz4lyNyORqc560Oo+xi4dw9CCAAAVwR7ip29l9GeZCB+8PtFRs79baNGmOGHgf19fv515uJLIVbqCVLY+VcW7HBLrh1vPLLrUEsMZ9QaCTsihRSZmyRv4a0LiTM+wChtqNF2QMbbU6nKPZmONmzZDSm4GaJbdaBjvY2UFeVTN2o6fzrCNFk9utzA8MnwuuPb1pM7fTsthYwSN+dV2142zgYzTiLtDsBk+9IP8A9Al77iEQA+FMVTD90DMfhlxZxkyXgeTH+WraQfXVv8sVv2nE7OaImy7OJ6TS3JIB+sb0oQv3UiuUD4/ZbkaYeCC+41epBbqFiUgyO3JBXRlj5LYpQr5DhZXF3HGq3scS5AKmI+H5dKxu1Nyy3FtPGcFVb7KaX4eIYQXfOBSP2rvImkS3iILhsVx4vlMZtUemdpbZJUJxpwRjcV7h7mQhV6kf1rQhtAsUkA3AXnQlrEbafJ2AIp7VNGUHSjDxA5A5fWPwrjFtR8Q5127cMyY6EH+WatbBYnVjJ5VMY0eFIhs1JGTiiHCBfhoASPDweZ42KusRII6HFZ8lzeQImu6aQTWhlGVA0HHSqVbDFxpZVaZvWWjvTsKUu20Zk4gCi7AY296ME13FaRyrdvqldADpHhyD86C46Z47uaKefvmjIGsgDIIz9tNDUrGnxXGLladfwWHtpRII9B1MMgDrRPDeK3fC9Yt2wHOWHrXQzyXMen4laipeDSPD30R5g6Uxua6ZSj2kcii/B277XcTuITGXAyMEgVmWSNc3kfeEnxAmqJEw24wa2+DRJGPpBGfL3oajCLpArk9jjw1FeSQu2AymsjiarDOEQ5LNkj+QFStLxoy8jEhQN/Wg445rmWS4YZbBb2+4xXClu2dByW6zMqDy+ZrSE2oau9XffnWLcwlbudFPiiAI9cc6mHjIySuTVHH0YmMc+Rwm4H+0f6Vm3ERgSHMjS97YkjWc6NuS+lH2txFMyRToXgc6XVWwSD600ydm+HTB0VZdcc0lpCHcfCFIGdurjH10di/H5EcUel+xE7tI7KF1YktLGWBbIHOqe0pVrq/cEHDxgEfw04fkDg6yHRHLJb93cSMBJgv3TlRg42z7UP2w7M2dj2fuHtUlRopfCSRpkIkdNPLOQFzz61sXsfLyYSi0rt/mv0fPOHL3kyeZbTTfcR4e3jHTyrQ4b2T4UbyzW3muizxCZZCymOVdUIZlIXAx3kg05JBQE899lOzlt387M11NNAhXukdRqOksAPDsSNPzoyvqdo4otI+R8UUNezsB+2f602dnuHWdxwJGEjNOG8ceMafL3zVvEOCWSWdjNbR3Cy3cfeS97IrBSGK4GFH7ua1bbhYhgF1b4BiGMdGHWjJlTSig6a2LcltIzFFBwo1HHL7861Q8MVtEqqBjC+52qd24gUsv7QNYUMrSEZO4NS+yKItjBNw90RkMd/bH40Z+R438S4w243quxQtAYmOCMAj2roeRBpJbI25mht2aketJNGk7ZBzTG3aq416vo8Gnvu+xjfV3vec+fpjypUi5Ve3w1ZkUMHCeLhYYoHtInEayRlizAsjkkjn5nn6UTxniUl/bTwSRoO+wGIzt+cZ/7jWBwv4q0JfiHvU2Z5IXPaS4huUEdtCrLFLG2C3jLoiavTaNdvOj/wAvyXT3MdxDEXvmxIozgDuwhx9QpZu/1rD9+tXW36wh/gH21kiqigu8vTJDFBpAFspjTHXLFv7qbLJYbTs0ZbshYxCzu3kPwpEP6Sf+Smvt4SvYO6CnGViG3lrXalgrZmTSQpR3JvrRc+GRQDpPTO+DQ9pDi4aPbPMeorvLiUwGw0dKuH+Oh666eWtI2L0aH0Q282ceCQggjz61Z3DNuF2O9G3X6Mn8VU1zt+Rkz//Z", + "extensions": [ + "2012" + ] + }, + { + "name": "reputation", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+reputation&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0TDMwy07PNTfTEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsQqHpJYmZNfpBBcnplWolCUWlBakliSmZ8HAG6csxdPAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAL", + "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBwgHBgkIBwgKCgkLDRYPDQwMDRsUFRAWIB0iIiAdHx8kKDQsJCYxJx8fLT0tMTU3Ojo6Iys/RD84QzQ5OjcBCgoKDQwNGg8PGjclHyU3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3N//AABEIAFoAWgMBIgACEQEDEQH/xAAcAAACAwEBAQEAAAAAAAAAAAAFBgMEBwACAQj/xABAEAACAQIEAwYDBQUFCQAAAAABAgMEEQAFEiEGMUEHEyJRYZEycaEUM4Gx0UJicsHhFSMk8PEWJTQ2Q4KSk6P/xAAUAQEAAAAAAAAAAAAAAAAAAAAA/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8A3HHw4pZpDXSqP7PqRCwR9iBZmI8N7qeW/wDXlgU9Jn00cqtmJQFpwF0C5UgiI6gm1tmOAYsdgC9LnJneVa8XudCFSFAsbAjR5kG/oOeL2WwZhTNKcxrRUJoQIdIUggHUTYDnt/TALfHfHcHDqrS0YjnzGVtCRlvh8yR6epHPGeUuUZ9nGe1FcFnqAEL/AOImYsCx5AHa3LawFumJ+F8jp+MePsyzbvHkyiBvCQ+8rn15+p9Tbpja6aGKnhSKGNY40FlVRYDAZLIeNMhp5JGoO9htsI3EmkD9w8vw8unUrwrxpBnFYcsq1EGYgFlUKVSUb8r8iPL026gO2bOqixQNe4FzjD+0pZqKspsxoZVjqaeQyRb87MDa9/MXscBqlfdqlf4B+ZxThlgkkZI54ZXjNnVJASnzsdse2r6fMoKKtWoEKVdLHLC5HhOo7A8ze7AcuZGBNNDTzVoNJnUFWztK6R2JAZh0bwnbTbqPO5wHsq0ToHdUa4+ORBfc+Z9ce41l7tbRIRYWPfLv9cVZaGq+0sXc6wNJKbhLjlsjAGxHkcMkFeTDHZ8qtpHM26fMYBwx2Ox2A7C72hVr5fwPndVEzJIlG4RlO4JFgfrhiwodqkif7F1VNIDoq5IoGI/ZUuNR9gcAmdhbyDhPMpoIWcpUaFRNi1lBsPfBqmqOIM1zinamyjMcuVT/AHk08loiP4dRv7X3xZ4Jok4VhqMtWn7mN5zIqrqKglVuFLbsAdr+mHV5WkpHaAoJNBKl9lvba/pgMx7VqXOsxzWgostqHipWiaSVUfSzEEDn5WP1xj2dRZo0ksM0DQwxavC8gbkd9+pxpGbHOZOMaGpfPsuzeGKEh4oJVVlGkhmCX8/U7DC/x/xLN3By+mlbS7HWQzcuRHxYBv7M6ijfgGhnzEoZYZJKZO9kcXUSahsD01CxtcbDBqGkoXqFajp0qYng0CKOVkVUUBRbqQFNtr9Op3ReyuprpOF8xWWqjWigqVWnRpihDHxPsOY3Xn54dcvggqGiWQQ1BAc953jsFJI9d97bHAfaamIYzf2Yjshco32gDUQWUCw2BH+bYkSGRUVUyKHSBYWrnG3tj3HS5cHP+FJ7y6sWDbAk/vY8rSZdpF8pgvbfdv1wGj47HY7AdjM+2HMKlRl9DShlAfvnkAuB0HtcnD/U5pTU8rQsxaVV1FVBNr8ve2Ml7SuIJatZNSrBFHBJG4vdmvsPkd7/APaeW2As8L8bzV+c0+T5rTQiGOFjBVqTd2BHhPQbX9sOnE2VniDIp8ugqZYhKOUT6RJ+6x56T1sR/LGJ8D1qVGcUBqYV7mqqWgXfkHBVgfp+ODWd5rxRwZWvTCqkkpQbRSsoYFel/XACM47O88yx1qVyqmo4oWDGWKsu9vTxbYW80M2bZslFSpqmkmCKNVxqY2G/lc4u53xVmubxPHX5hNJGxuUB0g+2GTscyI1+dPm80ZFJl/3QA2eYgi/rpFz82GA0SDIIOGOC4croat5NBLuZFHjZiSTsNvrsBjqN1+3R2mkeTuzfVYW5dMEM8q6V6WaKSoMNiAT3RaxAF/na4vbAqKto46szmtRlFk3p9FmYmwvgC1RLL3Dsk2mQKSvxGx6bDn8sZvbMl8LVk4I2N8jLn/y7k3+dzfD7NmlLKmiKrgLyK2kkEpsCTcgcsBmqYAxAGVWB6tY/lgNVwLznNBQ6I0R2lkNlCoT+WCZNhfAaplYPpdkEzi5uR4BfYc/rgAGYUFVmRkeKmqIJJfvZmYX5AXAvp6D+uE/P+A63MKqIVtVL9hjGpled5Wc+nIDr8Ixo0FM3eCokZh0Go/F8xy/0wuceZhUUWXiWjkjjYkqzXsTfpc3sPkOduWAXoeGcnp8tgWnLD7DOgZCwJJL6ib8+fUeXsQ49ldYXg1JUQkW8fxr+uF/KHaqq5J8vdp4gkKyzEbSNqJYL8ioH44Gcc1lWHTXqXvDy64BEzJFjmYKtsbN2WcTcPy8P0GURTJTV0KaZIZV0969ySynk1yb+eMSzMyRvpcFWIvY+WBxPt5YD9a1uW0M3eCopYCzAFi0e97Lz235D2wrVnEOW0VQUjy6KIqiuyLpFiWsg5c7k2xmHAfaNX5NVx0ebVEtXlchCnvWLNBfbUrc7DqvlythxzCGGarmfv1Ru7p2JVWP/AFDbcDcnkMAZHEdG8iRUtDEsheRI+6ZFIK/FpOna17YqDOa63wV3up+oG+KUNFEK2ECdXtNVDRoazWtcbi1he364tHL4CbmGnufOIfpgNic2UnFGfRbWygkcicRZ/DLWUE9NTSvFMyXR0bSQwNxv+H1xFWMyx77mw3PXAD8wqZO6ZgfCp36YX5Y1q1KVKq1m1KGFwD8sX6qU/YK8j9hRKPW3PA7WF7s7kMLqR1wFeuhGXU6TUaCML+ygACkEH2sTirmYoM3NGasRqVe5LHT05DzwRqGLaQo2BP43xQejje4iIVTsVtce38hbAIHaLkkCZjPVJqj8SqinYBQo6fO+EJ6WUAkKSB5DG11FFMsTRwECID4Y5jGPYKfzwmZrQTyzNFKxc6iL6pG/MD88AhhGB3HvjXcimFTw/SykSvaihDuiIbGJgeu5I298Z1WZf3UjAcvTGn9l3DeX5zwxLLWSTpLFI8ACyyKGF9QFg4Xr9MAxDJ5KepSoEy2imqJbKovaQDYbeYviYuQbGV7j0GIM1qqfKcvzGuzIVCUsLmKApIHeqkvbSqBtt7jfyPTEX+8W8R4ezRSdyC9Lt/8AXAaRO398xHMH+WK85SVefht54lm/4t8D5fuKsdAzWwC9QT01bU1cdHVR1MLrJCXjOwI5j54DmoZcnyydiAWGg28w2n+eAPZEzCszdAxCCsay32GDFf8A8u0/pmE1v/bgCbNZQWW/y2xVkfawP1xPV/cKfUYpH4V/HARTylV1atuZF9sB6h3qHKIrNfmoHLBKp+4b+HA/Kd5qgnmLWPlzwC3nccdJIY3RtbEC1uRIB88NvZnmcmWyT5U6a46movBbodID39OR/A+eFzj0Bc3p9It4o+X8Awf4U2zPIANtTTFrdT64A5xc/CVFmS1ubZq71dPJ3sWXJMZVExAs3dC9m9hffrgLU8TVMlRK6ZbxeVZyRZNO1/K+3yw7cYQQxPS1kUSJVGQRmdVAfR4fDq529MXn3dr+eA//2Q==", + "extensions": [ + "2017" + ] + }, + { + "name": "The Tortured Poets Department", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+The+Tortured+Poets+Department&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zEmxNM2yzKjUEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqFZJYmZNfpBBcnplWohCSkaoQkl9UUlqUmqIQkJ9aUqzgkloA1JKbmlcCAOaU815iAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAN", + "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBwgHBgkIBwgKCgkLDRYPDQwMDRsUFRAWIB0iIiAdHx8kKDQsJCYxJx8fLT0tMTU3Ojo6Iys/RD84QzQ5OjcBCgoKDQwNGg8PGjclHyU3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3N//AABEIAFoAWgMBIgACEQEDEQH/xAAbAAADAAMBAQAAAAAAAAAAAAAAAQMFBgcCBP/EADcQAAEDAgEICAUEAwEAAAAAAAEAAgMEEQUGEhMhMUFRkSMzYXFysdHhIlOBocEyQmKCFFKSB//EABYBAQEBAAAAAAAAAAAAAAAAAAABAv/EABURAQEAAAAAAAAAAAAAAAAAAAAR/9oADAMBAAIRAxEAPwDmiaFRjG5hc8m17ABYaTQq9D/Ln7I6Hi/n7IJJqnQ8X8/ZHQ8X8/ZWiaFToeLufsn0X8ufsgkkq9Dxdz9kZkbmuzCbgX1oIoQhQO6oOo/t6KSq3qPqfwg8tIa65aHDgV7EjC/XEwDhrU0KixfF8tlj36kw+L/Rgv36luWQ+HYQzDZa/F4WyvkkzWOe0OZC0DbY7yTt17N2/I1WR+EY3FJPgcoje3rGN2t7bbCO0KDngfELnRx8bfF2akGWMHVEx3P1X24vgNdhUhE8ecwfvZs9lilR7e4OtZgbbgnFsf3HyKmqQ7H+E+RUE0IQrAlVvUHv9FJVb1H1P4UHhCEKjdMnYjW5Ox0lNcOdUPbO4XOaDaxtwsTyKz9Th8lC6jqMCrmmaii0Re6QfFrsGlu+52jt3WWkZJSYjHijX4bHJI1pBmDf05uz4vutlp5aHEq+tiZ0VexrJIDJ+nPa6+reb6r9ig2WhxTBcq4308xFJXBvSU7tuza3iPuN65Ni8MUVZIIG5rWvII+qzOUNFV4ZjDMViZa0rZ9He+iIN809n4WOx+ppq3EZaqk1Rz/GWEa2HeEGJVIdj+4+RU1SHY/wnyKCaEIVCVB1B8Xopqo6g+L0UE0ITG3XsVHTv/OKOGbJvEKYkaeoAkb2gXH4WoYzC+nqmuOdnRu+Fw/Uw7rFZjI7EjT19LGx7AWjOkJ2Nbqu3/kbe1ZvLzAWRn/Kivo5d43FQazgtdNW09fFiAEhjgMjXHjuutamYI87VvIutiwmF9PhGJ1EoI0pbEwnfa5PmFgaktMbteu6D4lWHY/wnyKmqQ/v8J8ig8IQhUeVUdR/b0UlZma6ItzgDe+v6KCSapoh8xvMeqNEPmN5j1VGw5D07q2vmgYzOOjBI7Ab6+y9vsur4vUUb4IqXEHjMqGgCR1mgO777SeC57kflFgOT2GOjlp6qatmdnTStDABa+aGnPvYD7kpYvlZQ4he9PI7cNKWmw7g5QQx3Pp4n0gbaOnBZfibk3+61Kd24LK1+L1FZCIZajSMafhLg0Hu1FYp7A49Y3mPVURVIf3+E+RT0Q+Y3mPVNrRG1xLwbiwAUEkk0lQkwkmFA00kKgQhCASQhSgQhCoEkykoP//Z", + "extensions": [ + "2024" + ] + }, + { + "name": "Midnights", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Midnights&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LDa3SLI0zTLREs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsQqFpJYmZNfpBBcnplWouCbmZKXmZ5RUgwAMbtWt04AAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAP", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2022" + ] + }, + { + "name": "folklore", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+folklore&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zDbNqsgqNzTSEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsQqGpJYmZNfpBBcnplWopCWn5MN5KUCAOK10xlNAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAR", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2020" + ] + }, + { + "name": "Speak Now", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Speak+Now&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4gIxk3NTyiwqtcSzk630c0uLM5P1E4tKMotLrBJzkkpzixexioUkVubkFykEl2emlSgEF6QmZiv45ZcDAG3-ht1LAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAT", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2010" + ] + }, + { + "name": "1989 (Taylor's Version)", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+1989+(Taylor%27s+Version)&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LDNLKy83yCjREs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqEpJYmZNfpBBcnplWomBoaWGpoAERUi9WCEstKs7Mz9MEAO1oDN5cAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAV", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2023" + ] + }, + { + "name": "Fearless", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Fearless&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4gIxTdJziiqytMSzk630c0uLM5P1E4tKMotLrBJzkkpzixexioYkVubkFykEl2emlSi4pSYW5aQWFwMAQQ09x0oAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAX", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2008" + ] + }, + { + "name": "evermore", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+evermore&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zDArSU5Jy0nTEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsQqGpJYmZNfpBBcnplWopBallqUm1-UCgCTYfYDTQAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAZ", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2020" + ] + }, + { + "name": "Fearless (Taylor's Version)", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Fearless+(Taylor%27s+Version)&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LIw3saysyCjWEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqEZJYmZNfpBBcnplWouCWmliUk1pcrAAVVi9WCEstKs7Mz9MEAM-mFg1gAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAb", + "image": null, + "extensions": [ + "2021" + ] + }, + { + "name": "Red (Taylor's Version)", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Red+(Taylor%27s+Version)&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zMsrSTHJNknTEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqHJJYmZNfpBBcnplWohCUmqKgARFRL1YISy0qzszP0wQArSMO31sAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAd", + "image": null, + "extensions": [ + "2021" + ] + }, + { + "name": "Speak Now (Taylor's Version)", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Speak+Now+(Taylor%27s+Version)&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LKkwLLEsr0jXEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqGZJYmZNfpBBcnplWohBckJqYreCXX66gARFXL1YISy0qzszP0wQAt0wbA2EAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAf", + "image": null, + "extensions": [ + "2023" + ] + }, + { + "name": "Lover (Live from Paris)", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Lover+(Live+from+Paris)&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zE5KyjBKTzHVEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqEpJYmZNfpBBcnplWouCTX5ZapKDhk1mWqpBWlJ-rEJBYlFmsCQC_14wrXAAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAh", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRYWEf7Ujugt9wPgB6TXZgHQHb9l0qWwlo8FAOZ&s=0", + "extensions": [ + "2020" + ] + }, + { + "name": "Speak Now World Tour Live", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Speak+Now+World+Tour+Live&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4gIxM8xMKkoqtcSzk630c0uLM5P1E4tKMotLrBJzkkpzixexqoUkVubkFykEl2emlSgEF6QmZiv45ZcrhOcX5aQohOSXFin4ZJalAgCWPdLgWwAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAj", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRIdIijWjNyKOQ-d-RNkqtQXo0NU0QjjS86Xut5&s=0", + "extensions": [ + "2011" + ] + }, + { + "name": "Live from Clear Channel Stripped 2008", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Live+from+Clear+Channel+Stripped+2008&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zEo3MEwyyzXWEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqFJJYmZNfpBBcnplWouCTWZaqkFaUn6vgnJOaWKTgnJGYl5eaoxBcUpRZUJCaomBkYGABAFwYMl1qAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAl", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQiX7V4x2sjH5LU_oWEYxh7m5wXm5rztvGFtaX0&s=0", + "extensions": [ + "2020" + ] + }, + { + "name": "Love Story (Pop Mix)", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Love+Story+(Pop+Mix)&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0TLcwN84prirTEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqGJJYmZNfpBBcnplWouCTX5aqEFySX1SpoBGQX6Dgm1mhCQDPdibRWQAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAn", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcROz9kOAZmHsmevXeIqUtbH3P-OmwF6IOWa-cH57FM&s=10", + "extensions": [ + "2009" + ] + }, + { + "name": "CMT Crossroads", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+CMT+Crossroads&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4gIxq0rMy3MytMSzk630c0uLM5P1E4tKMotLrBJzkkpzixexSockVubkFykEl2emlSg4-4YoOBflFxcX5SemFAMAHsJJhFAAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAp", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcStThrHEvJlr-ODahXB46bBvg9rPXWz8JzC59X6ToU&s=10", + "extensions": [ + "2009" + ] + }, + { + "name": "Folklore: The Long Pond Studio Sessions", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Folklore:+The+Long+Pond+Studio+Sessions&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LMwrNy0pLCjTEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqEpJYmZNfpBBcnplWouCWn5MN5KVaKYRkpCr45OelKwTk56UoBJeUpmTmKwSnFhdn5ucVAwAs9R1ubAAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAr", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSs5y_ocBzofS73k0hBilgjtzvDu-LwALZhCK8Z&s=0", + "extensions": [ + "2020" + ] + }, + { + "name": "Fearless (International Version)", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Fearless+(International+Version)&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0TKowMU1Ot8zREs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqG5JYmZNfpBBcnplWouCWmliUk1pcrKDhmVeSWpSXWJKZn5eYoxCWWlQMZGkCADmj2DBlAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAt", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQjPC2sYJsI4GZx8grINx5kc7cAnwXodLcumOBiXak&s=10", + "extensions": [ + "2008" + ] + }, + { + "name": "Beautiful Eyes", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Beautiful+Eyes&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4gIxTdKqcsxMtMSzk630c0uLM5P1E4tKMotLrBJzkkpzixexSockVubkFykEl2emlSg4pSaWlmSmleYouFamFgMASUyQ8lAAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAv", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQDduhn_Vw6CY2ZErvvQ-dVmTidkyuI7iqZEX-U&s=0", + "extensions": [ + "2008, EP" + ] + }, + { + "name": "Sounds of the Season: The Taylor Swift Holiday Collection", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Sounds+of+the+Season:+The+Taylor+Swift+Holiday+Collection&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4gIxjZNzzMwMtcSzk630c0uLM5P1E4tKMotLrBJzkkpzixexuoUkVubkFykEl2emlSgE55fmpRQr5KcplGSkKgSnJhbn51kphADZKMo88nMyUxIrFZzzc3JSk0sy8_MAP1PlvXsAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAx", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRkuLVZCWvPbtEYnoG9faAetpgcoFKKR67k0t-m&s=0", + "extensions": [ + "2007, EP" + ] + }, + { + "name": "The More Lover Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+The+More+Lover+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zM4oyrVMKUvSEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqHJJYmZNfpBBcnplWohCSkargm1-UquCTX5ZapOCckVhQkloEAPk3mZpbAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhAz", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcT0Wq7E-XWiZdIDdQ9Xfd3Xl5rACg3SpvWtlw1k6Vo&s=10", + "extensions": [ + "2023, EP" + ] + }, + { + "name": "iTunes Live From SoHo", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+iTunes+Live+From+SoHo&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tFP1zc0ygACQ_MkLfHsZCv93NLizGT9xKKSzOISq8ScpNLc4kWsSiGJlTn5RQrB5ZlpJQqZIaV5qcUKPpllqQpuRfm5CsH5HvkAGXYHpVkAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhA1", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSTwuTl2MzxgulON4i3D1QiHBlAKelWiS6bvnH6CaU&s=10", + "extensions": [ + "2008, EP" + ] + }, + { + "name": "Rhapsody Originals", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Rhapsody+Originals&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4gIxyw3Tk0zytMSzk630c0uLM5P1E4tKMotLrBJzkkpzixexyockVubkFykEl2emlSgEZSQWFOenVCr4F2WmZ-Yl5hQDAKL4YP9UAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhA3", + "image": "//www.gstatic.com/knowledgecard/album-95.png", + "extensions": [ + "2007, EP" + ] + }, + { + "name": "reputation Stadium Tour Surprise Song Playlist", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+reputation+Stadium+Tour+Surprise+Song+Playlist&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zIg3N8kwLTLQEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqHZJYmZNfpBBcnplWolCUWlBakliSmZ-nEFySmJJZmqsQkl8KlC0tKijKLE5VCM7PS1cIyAHqARoCAP9gZwZzAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhA5", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTqHxPkIO6e8zKVv-ggoCvnmwds3AtWvMPZ29aUEZU&s=10", + "extensions": [ + "2018" + ] + }, + { + "name": "The More Fearless (Taylor’s Version) Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+The+More+Fearless+(Taylor%E2%80%99s+Version)+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LKkwjS8sSqnSEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqHZJYmZNfpBBcnplWohCSkargm1-UquCWmliUk1pcrKABkX_UMLNYISy1qDgzP09TwTkjsaAktQgAUo10fnMAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhA7", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQzzZ4yZv63ftfvtvAi-dtgd8Ed_2Tims5J2mw9ZNw&s=10", + "extensions": [ + "2021, EP" + ] + }, + { + "name": "folklore: the yeah I showed up at your party chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+folklore:+the+yeah+I+showed+up+at+your+party+chapter&stick=H4sIAAAAAAAAAA3MIQ9CIRAA4ODcNFgs1pvRchLUjWY0a3cn7xAGDAbH3vg7_lJf_Mq3We23mPA8xcv1dtzhF5UK7xSUsuF0CEZj6s0bpCq-iab46an91vcXjZgrPGdvBWyOYRFrEMcwmBw8oLk88wS9AAmM3CuUJRlgHBXh-geTzUEqeQAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhA9", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQR4XNxiAm-BXdv_L7lobphpuwtI_Lf4Zt3wG7gOOQ&s=10", + "extensions": [ + "2020, EP" + ] + }, + { + "name": "the \"ladies lunching\" chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+the+%22ladies+lunching%22+chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zIlPjy_MLTfTEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqFZJYmZNfpBBcnplWolCSkaqglJOYkplarJBTmpeckZmXrqSQnJFYUJJaBADQmVXBYgAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhA_", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQj2GgFmdJJ6ma0fGACMtfVMmOTtQJR-TU0x8kPQkE&s=10", + "extensions": [ + "2021, EP" + ] + }, + { + "name": "Red (Taylor’s Version): Could You Be The One Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Red+(Taylor%E2%80%99s+Version):+Could+You+Be+The+One+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LM4tKKywNE3XEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsTqHJJYmZNfpBBcnplWohCUmqKgARF51DCzWCEstag4Mz9P00rBOb80J0UhMr9UwSlVISQjVcE_L1XBOSOxoCS1CADJ_1pPewAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBB", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQPYyvQxQQ55eqlf7fL_bONh1YNrPCohm-puNrWrNA&s=10", + "extensions": [ + "2022, EP" + ] + }, + { + "name": "Complete Album Collection", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Complete+Album+Collection&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LC40NakwMTLXEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqFpJYmZNfpBBcnplWouCcn1uQk1qSquAIkgZyc3JSk0sy8_MAa1c10l4AAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBD", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTFjbLZacEYUqS9rT51tiIQmNa4BSLqys0j280eyV8&s=10", + "extensions": [ + "2013" + ] + }, + { + "name": "Fearless (Taylor’s Version): The From The Vault Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Fearless+(Taylor%E2%80%99s+Version):+The+From+The+Vault+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LDQsTkmxyErXEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsTqFpJYmZNfpBBcnplWouCWmliUk1pcrKABEX7UMLNYISy1qDgzP0_TSiEkI1XBrSg_F8wISyzNKVFwzkgsKEktAgD7W8AvfgAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBF", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcScQ5kPmQIPlZFYbponmK0JjhyHJ9GwNGXRHfuYXvw&s=10", + "extensions": [ + "2021, EP" + ] + }, + { + "name": "folklore: the escapism chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+folklore:+the+escapism+chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zMgpyqmwMMvQEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsSqHZJYmZNfpBBcnplWopCWn5MN5KVaKZRkpCqkFicnFmQW5yokZyQWlKQWAQDGgUorYwAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBH", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcS_lUYmNE6c6I49A3ry5zM2xnxmOq51OGY9yn3ICdg&s=10", + "extensions": [ + "2020, EP" + ] + }, + { + "name": "Fearless (Taylor's Version): The Kissing In The Rain Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Fearless+(Taylor%27s+Version):+The+Kissing+In+The+Rain+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LDQsTskuL8_WEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsTqGZJYmZNfpBBcnplWouCWmliUk1pcrKABEVYvVghLLSrOzM_TtFIIyUhV8M4sLs7MS1fwzANzgxIz8xScMxILSlKLANuFKzOBAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBJ", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQEHvcAQSuoDdsS2cz0Ksm0eqwWdyqU2ze78fejO_U&s=10", + "extensions": [ + "2021, EP" + ] + }, + { + "name": "Fearless (Taylor’s Version): The I Remember What You Said Last Night Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Fearless+(Taylor%E2%80%99s+Version):+The+I+Remember+What+You+Said+Last+Night+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LEq2rEhLN7TUEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsQaHZJYmZNfpBBcnplWouCWmliUk1pcrKABEX7UMLNYISy1qDgzP0_TSiEkI1XBUyEoNTc1Nym1SCE8I7FEITK_VCE4MTNFwSexuETBLzM9o0TBOSOxoCS1CABpxzuFkwAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBL", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcR8mU26OWCPs299e1z-PfrEZ6FzbgA_5G-ftiKTAFA&s=10", + "extensions": [ + "2021, EP" + ] + }, + { + "name": "The More Red (Taylor’s Version) Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+The+More+Red+(Taylor%E2%80%99s+Version)+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zM4oyjWtNErXEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqFpJYmZNfpBBcnplWohCSkargm1-UqhCUmqKgAZF61DCzWCEstag4Mz9PU8E5I7GgJLUIALBQdENuAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBN", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRYG4kvm4cDJ4kmGN_Jm74K1nsVY01TLwhPncDr_Oc&s=10", + "extensions": [ + "2021, EP" + ] + }, + { + "name": "Fearless (Taylor's Version): The Halfway Out The Door Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Fearless+(Taylor%27s+Version):+The+Halfway+Out+The+Door+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LEoqN6hKKy7SEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsTqFZJYmZNfpBBcnplWouCWmliUk1pcrKABEVYvVghLLSrOzM_TtFIIyUhV8EjMSStPrFTwLy0B813ygXqdMxILSlKLAHI-9EeCAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBP", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTT7tt6gjq69EnumWcmIJ39Lu_nEzPgbZFu2Lyr2as&s=10", + "extensions": [ + "2021, EP" + ] + }, + { + "name": "Red (Taylor’s Version): She Wrote A Song About Me Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Red+(Taylor%E2%80%99s+Version):+She+Wrote+A+Song+About+Me+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LMoztUixTC7WEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsTqEZJYmZNfpBBcnplWohCUmqKgARF51DCzWCEstag4Mz9P00ohOCNVIbwovyRVwVEhOD8vXcExKb-0RME3VcE5I7GgJLUIANFiZaiAAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBR", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTSqX6Es0oSQzpiUFEKFZmWSCvVVB8oNMTdGjqPCOw&s=10", + "extensions": [ + "2022, EP" + ] + }, + { + "name": "folklore: the sleepless nights chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+folklore:+the+sleepless+nights+chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zKo0MCsvjs_TEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqHJJYmZNfpBBcnplWopCWn5MN5KVaKZRkpCoU56SmFuSkFhcr5GWmZ5QUKyRnJBaUpBYBAGFKTfBrAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBT", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTd_2PZ_yqu5YpBXDzbw2GHXksN-m5xrzz4XGnPRKs&s=10", + "extensions": [ + "2020, EP" + ] + }, + { + "name": "folklore: the saltbox house chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+folklore:+the+saltbox+house+chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zMguMUrJMMrREs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqEJJYmZNfpBBcnplWopCWn5MN5KVaKZRkpCoUJ-aUJOVXKGTklxanKiRnJBaUpBYBAMQxLqpoAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBV", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRWUcheOu3p5l7bd9nQOraN90u81eEuW1HY63g7fXw&s=10", + "extensions": [ + "2020, EP" + ] + }, + { + "name": "Red (Taylor’s Version): From The Vault Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Red+(Taylor%E2%80%99s+Version):+From+The+Vault+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LMrLKzQxzTPQEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqG5JYmZNfpBBcnplWohCUmqKgARF51DCzWCEstag4Mz9P00rBrSg_VyEkI1UhLLE0p0TBOSOxoCS1CACB1Oc0dQAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBX", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQem-BKDDfhDSwfrjoE-BI8loxfiSEtQ1DeemjRSIM&s=10", + "extensions": [ + "2022, EP" + ] + }, + { + "name": "THE TORTURED POETS DEPARTMENT | TS The Eras Tour Setlist", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+THE+TORTURED+POETS+DEPARTMENT+%7C+TS+The+Eras+Tour+Setlist&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LM8yLagyNU7WEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsTqGpJYmZNfpBBcnplWohDi4aoQ4h8UEhrk6qIQ4O8aEqzg4hrgGBTi6-oXolCjAOSHZKQquBYlFiuE5JcCtaWW5ACNAwCIoQpBfQAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBZ", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQbGAmiERJX_XUyaPX5VrpZc28bmcoKyu-3w6aeszQ&s=10", + "extensions": [ + "2024, EP" + ] + }, + { + "name": "Napster Live", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Napster+Live&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LDapMk3OszDQEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsQqGZJYmZNfpBBcnplWouCXWFBcklqk4JNZlgoA7gsxQlEAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBb", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcT9-us6QfsSTEDLcQsar9eiCSTx-1RHpciQ0qme&s=0", + "extensions": [ + "2006, EP" + ] + }, + { + "name": "the \"forever is the sweetest con\" chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+the+%22forever+is+the+sweetest+con%22+chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0zEtOM7LIKqzUEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqFpJYmZNfpBBcnplWolCSkaqglJZflFqWWqSQWQzmF5enppakFpcoJOfnKSkkZyQWlKQWAQAdVO5vbgAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBd", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRz9xKcEY_CUL1NZXyFokrm_xHtBCIwUccEK5t8Lb8&s=10", + "extensions": [ + "2021, EP" + ] + }, + { + "name": "the \"dropped your hand while dancing\" chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+the+%22dropped+your+hand+while+dancing%22+chapter&stick=H4sIAAAAAAAAAAXBOw4CIRAA0MKYaGFjYzuhtBm3WDfhGnqBEXAhDp8MkA0ex5P63mF3PmLEm-X5vqgTrjhNaa6J4_heLx-jMfYaDJK0UJsmfvVYf3v9pMFZ4LGFd4PmHSgruRRnYeQu4ClZ2HxgB5aSCWlVYDyV5uQPbg273HIAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBf", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQBSiBDlfcnzs_nJXH0s1TrYZqna69EMTbd0i29LJ8&s=10", + "extensions": [ + "2021, EP" + ] + }, + { + "name": "Red (Taylor’s Version): The Slow Motion Chapter", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Taylor+Swift+Red+(Taylor%E2%80%99s+Version):+The+Slow+Motion+Chapter&stick=H4sIAAAAAAAAAONgFuLUz9U3SMkxNTNX4tVP1zc0LChLtkyxtIzXEs9OttLPLS3OTNZPLCrJLC6xSsxJKs0tXsRqF5JYmZNfpBBcnplWohCUmqKgARF51DCzWCEstag4Mz9P00ohJCNVITgnv1zBN78EKKLgnJFYUJJaBAD6OMUtdgAAAA&sa=X&ved=2ahUKEwixkZDft9eUAxWYQEEAHZTjAtUQ9OUBegQILhBh", + "image": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQEE87XXwQu8usSxlCOIj9bIuDxyHpAeVWv-Y_kkKE&s=10", + "extensions": [ + "2022, EP" + ] + } + ] +} \ No newline at end of file diff --git a/spec/fixtures/source-html/her-movie-cast-Google-Search.html b/spec/fixtures/source-html/her-movie-cast-Google-Search.html new file mode 100644 index 00000000..546b5a12 --- /dev/null +++ b/spec/fixtures/source-html/her-movie-cast-Google-Search.html @@ -0,0 +1,45 @@ + + +her movie cast - Google Search
Quick Settings

Search Results

Her
2013 ‧ Sci-fi/Romance ‧ 2h 6m
Watch movie
EDIT SERVICES
Watched
Already watched
About
85% liked this film
Google users
Feedback
People also search for
Google apps
\ No newline at end of file diff --git a/spec/fixtures/source-html/taylor-swift-albums-Google-Search.html b/spec/fixtures/source-html/taylor-swift-albums-Google-Search.html new file mode 100644 index 00000000..73a1b24d --- /dev/null +++ b/spec/fixtures/source-html/taylor-swift-albums-Google-Search.html @@ -0,0 +1,44 @@ + + +taylor swift albums - Google Search
Quick Settings

Search Results

Taylor Swift
American singer-songwriter
About
Feedback
People also search for
Google apps
\ No newline at end of file diff --git a/spec/layouts/i_elo6_spec.rb b/spec/layouts/i_elo6_spec.rb new file mode 100644 index 00000000..d356b298 --- /dev/null +++ b/spec/layouts/i_elo6_spec.rb @@ -0,0 +1,27 @@ +require "spec_helper" +require "layouts/i_elo6" + +RSpec.describe Layouts::IELo6 do + subject(:layout) { described_class.new } + + it { expect(layout.item_selector).to eq(".iELo6") } + it { expect(layout.image_selector).to eq("img.taFZJe") } + + describe "#name" do + let(:node) { Nokolexbor::HTML('
The Starry Night
').css(".iELo6").first } + + it { expect(layout.name(node)).to eq("The Starry Night") } + end + + describe "#extension" do + let(:node) { Nokolexbor::HTML('
1889
').css(".iELo6").first } + + it { expect(layout.extension(node)).to eq("1889") } + end + + describe "#extension when absent" do + let(:node) { Nokolexbor::HTML('
').css(".iELo6").first } + + it { expect(layout.extension(node)).to be_nil } + end +end diff --git a/spec/layouts/j_cuz_jd_spec.rb b/spec/layouts/j_cuz_jd_spec.rb new file mode 100644 index 00000000..3b892608 --- /dev/null +++ b/spec/layouts/j_cuz_jd_spec.rb @@ -0,0 +1,9 @@ +require "spec_helper" +require "layouts/j_cuz_jd" + +RSpec.describe Layouts::JCuzJd do + subject(:layout) { described_class.new } + + it { expect(layout.item_selector).to eq(".jCuzJd") } + it { expect(layout).to be_a(Layouts::GridTile) } +end diff --git a/spec/layouts/z8r5_gb_spec.rb b/spec/layouts/z8r5_gb_spec.rb new file mode 100644 index 00000000..a9245390 --- /dev/null +++ b/spec/layouts/z8r5_gb_spec.rb @@ -0,0 +1,9 @@ +require "spec_helper" +require "layouts/z8r5_gb" + +RSpec.describe Layouts::Z8r5Gb do + subject(:layout) { described_class.new } + + it { expect(layout.item_selector).to eq(".Z8r5Gb") } + it { expect(layout).to be_a(Layouts::GridTile) } +end From 07595a9777174c875f8233e45b366fa3661faced Mon Sep 17 00:00:00 2001 From: Brent Date: Tue, 26 May 2026 19:49:53 +0200 Subject: [PATCH 06/16] Add `KlitemTr` layout and auto-discover layouts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add `Layouts::KlitemTr` for movies/filmography carousels (`a.klitem-tr`) - Add `lib/layouts.rb` registry — auto-requires all layout files and exposes `Layouts.detect(doc)`, removing the hardcoded `LAYOUTS` constant from `CarouselExtractor` - Move `link` resolution into each layout adapter (previously inline in `CarouselItem`) - Add Terry Gilliam movies fixture (HTML + JSON) as a third carousel test case - Split monolithic `carousel_extractor_spec.rb` into per-layout specs under `spec/carousel_extractor/` - Add `spec/layouts/klitem_tr_spec.rb` covering name, extension, link, and image selectors --- lib/carousel_extractor.rb | 8 +- lib/carousel_item.rb | 3 +- lib/layouts.rb | 14 ++ lib/layouts/grid_tile.rb | 1 + lib/layouts/i_elo6.rb | 11 +- lib/layouts/klitem_tr.rb | 11 + spec/carousel_extractor/i_elo6_spec.rb | 57 +++++ spec/carousel_extractor/j_cuz_jd_spec.rb | 53 +++++ spec/carousel_extractor/klitem_tr_spec.rb | 50 ++++ .../carousel_extractor/unknown_layout_spec.rb | 11 + spec/carousel_extractor/z8r5_gb_spec.rb | 53 +++++ spec/carousel_extractor_spec.rb | 113 --------- spec/carousel_item/rel_to_abs_links_spec.rb | 22 -- ...rected-by-Terry-Gilliam-Google-Search.json | 220 ++++++++++++++++++ ...rected-by-Terry-Gilliam-Google-Search.html | 95 ++++++++ spec/layouts/i_elo6_spec.rb | 8 + spec/layouts/j_cuz_jd_spec.rb | 8 + spec/layouts/klitem_tr_spec.rb | 70 ++++++ 18 files changed, 662 insertions(+), 146 deletions(-) create mode 100644 lib/layouts.rb create mode 100644 lib/layouts/klitem_tr.rb create mode 100644 spec/carousel_extractor/i_elo6_spec.rb create mode 100644 spec/carousel_extractor/j_cuz_jd_spec.rb create mode 100644 spec/carousel_extractor/klitem_tr_spec.rb create mode 100644 spec/carousel_extractor/unknown_layout_spec.rb create mode 100644 spec/carousel_extractor/z8r5_gb_spec.rb delete mode 100644 spec/carousel_extractor_spec.rb delete mode 100644 spec/carousel_item/rel_to_abs_links_spec.rb create mode 100644 spec/fixtures/json-result/movies-directed-by-Terry-Gilliam-Google-Search.json create mode 100644 spec/fixtures/source-html/movies-directed-by-Terry-Gilliam-Google-Search.html create mode 100644 spec/layouts/klitem_tr_spec.rb diff --git a/lib/carousel_extractor.rb b/lib/carousel_extractor.rb index ad39b4cc..c6ffd971 100644 --- a/lib/carousel_extractor.rb +++ b/lib/carousel_extractor.rb @@ -1,22 +1,18 @@ require "nokolexbor" require "carousel_item" require "image_extractor" -require "layouts/i_elo6" -require "layouts/j_cuz_jd" -require "layouts/z8r5_gb" +require "layouts" # Parses a Google SERP HTML page and extracts all carousel items. class CarouselExtractor class UnknownLayoutError < StandardError; end - LAYOUTS = [Layouts::IELo6.new, Layouts::JCuzJd.new, Layouts::Z8r5Gb.new].freeze - def initialize(html) @doc = Nokolexbor::HTML(html) end def extract - layout = LAYOUTS.find { |l| @doc.css(l.item_selector).any? } + layout = Layouts.detect(@doc) raise UnknownLayoutError, "no recognized carousel layout found — add a new Layouts:: adapter" unless layout images = ImageExtractor.new(@doc) diff --git a/lib/carousel_item.rb b/lib/carousel_item.rb index faed70b7..3f5c527d 100644 --- a/lib/carousel_item.rb +++ b/lib/carousel_item.rb @@ -27,8 +27,7 @@ def extensions end def link - href = @node.css("a").first&.attr("href") - href&.start_with?("/") ? "https://www.google.com#{href}" : href + @layout.link(@node) end def image diff --git a/lib/layouts.rb b/lib/layouts.rb new file mode 100644 index 00000000..9ca1367a --- /dev/null +++ b/lib/layouts.rb @@ -0,0 +1,14 @@ +Dir[File.join(__dir__, "layouts", "*.rb")].each { |f| require f } + +# Registry of known Google carousel layout adapters. +module Layouts + def self.klasses + constants + .map { |c| const_get(c) } + .select { |c| c.is_a?(Class) && c.method_defined?(:item_selector, false) } + end + + def self.detect(doc) + klasses.map(&:new).find { |l| doc.css(l.item_selector).any? } + end +end diff --git a/lib/layouts/grid_tile.rb b/lib/layouts/grid_tile.rb index afe5f746..18b06aef 100644 --- a/lib/layouts/grid_tile.rb +++ b/lib/layouts/grid_tile.rb @@ -5,5 +5,6 @@ class GridTile def image_selector = "img.d7ENZc" def name(node) = node.css(".JjtOHd").first&.text def extension(node) = node.css(".cHaqb").first&.text + def link(node) = node.css("a").first&.attr("href") end end diff --git a/lib/layouts/i_elo6.rb b/lib/layouts/i_elo6.rb index b5f820e2..5be91be6 100644 --- a/lib/layouts/i_elo6.rb +++ b/lib/layouts/i_elo6.rb @@ -1,9 +1,14 @@ module Layouts # Google carousel layout used for paintings, artworks, and similar knowledge-panel carousels. class IELo6 - def item_selector = ".iELo6" - def image_selector = "img.taFZJe" - def name(node) = node.css(".pgNMRc").first&.text + def item_selector = ".iELo6" + def image_selector = "img.taFZJe" + def name(node) = node.css(".pgNMRc").first&.text def extension(node) = node.css(".cxzHyb").first&.text + + def link(node) + href = node.css("a").first&.attr("href") + href&.start_with?("/") ? "https://www.google.com#{href}" : href + end end end diff --git a/lib/layouts/klitem_tr.rb b/lib/layouts/klitem_tr.rb new file mode 100644 index 00000000..5008c87a --- /dev/null +++ b/lib/layouts/klitem_tr.rb @@ -0,0 +1,11 @@ +module Layouts + # Google carousel layout used for movies and filmography carousels. + # The item is the anchor itself — name comes from aria-label, year from last .FozYP. + class KlitemTr + def item_selector = "a.klitem-tr" + def image_selector = "img.VeBrne" + def name(node) = node.attr("aria-label") + def extension(node) = node.css(".FozYP").last&.text + def link(node) = node.attr("href") + end +end diff --git a/spec/carousel_extractor/i_elo6_spec.rb b/spec/carousel_extractor/i_elo6_spec.rb new file mode 100644 index 00000000..db58b893 --- /dev/null +++ b/spec/carousel_extractor/i_elo6_spec.rb @@ -0,0 +1,57 @@ +require "spec_helper" +require "carousel_extractor" + +RSpec.describe CarouselExtractor do + context "with iELo6 layout (paintings carousel)" do + let(:html) do + <<~HTML + + + + + +
+ + HTML + end + + subject(:results) { described_class.new(html).extract } + + it "filters out blank items (no name or link)" do + expect(results.length).to eq(3) + end + + it "extracts image from script tag for visible items" do + expect(results[0][:image]).to eq("data:image/jpeg;base64,IMG1==") + end + + it "extracts data-src url for lazy-loaded items" do + expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=fake") + end + + it "returns nil image when neither source is available" do + expect(results[2][:image]).to be_nil + end + + it "omits extensions when no date is present" do + expect(results[2]).not_to have_key(:extensions) + end + end +end diff --git a/spec/carousel_extractor/j_cuz_jd_spec.rb b/spec/carousel_extractor/j_cuz_jd_spec.rb new file mode 100644 index 00000000..78fa45f4 --- /dev/null +++ b/spec/carousel_extractor/j_cuz_jd_spec.rb @@ -0,0 +1,53 @@ +require "spec_helper" +require "carousel_extractor" + +RSpec.describe CarouselExtractor do + context "with jCuzJd layout (actors carousel)" do + let(:html) do + <<~HTML + + + + + + HTML + end + + subject(:results) { described_class.new(html).extract } + + it "detects jCuzJd layout and extracts name" do + expect(results[0][:name]).to eq("Joaquin Phoenix") + end + + it "extracts extension (role) for jCuzJd items" do + expect(results[0][:extensions]).to eq(["Theodore"]) + end + + it "extracts base64 image from script tag" do + expect(results[0][:image]).to eq("data:image/jpeg;base64,ACT1==") + end + + it "extracts data-src for lazy-loaded jCuzJd items" do + expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=amy") + end + + it "omits extensions when role is absent" do + expect(results[1]).not_to have_key(:extensions) + end + + it "preserves absolute links unchanged" do + expect(results[0][:link]).to eq("https://www.google.com/search?q=Joaquin+Phoenix") + end + end +end diff --git a/spec/carousel_extractor/klitem_tr_spec.rb b/spec/carousel_extractor/klitem_tr_spec.rb new file mode 100644 index 00000000..4399f9f4 --- /dev/null +++ b/spec/carousel_extractor/klitem_tr_spec.rb @@ -0,0 +1,50 @@ +require "spec_helper" +require "carousel_extractor" + +RSpec.describe CarouselExtractor do + context "with klitem-tr layout (movies carousel)" do + let(:html) do + <<~HTML + + + +
+ +
Brazil
+
1985
+
+
+ +
+ +
12 Monkeys
+
1995
+
+
+ + HTML + end + + subject(:results) { described_class.new(html).extract } + + it "detects klitem-tr layout and extracts name from aria-label" do + expect(results[0][:name]).to eq("Brazil") + end + + it "extracts extension from last FozYP" do + expect(results[0][:extensions]).to eq(["1985"]) + end + + it "extracts link from the item anchor href" do + expect(results[0][:link]).to eq("https://www.google.com/search?q=Brazil") + end + + it "extracts base64 image from script tag" do + expect(results[0][:image]).to eq("data:image/jpeg;base64,MOV1==") + end + + it "extracts data-src for lazy-loaded items" do + expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=monkeys") + end + end +end diff --git a/spec/carousel_extractor/unknown_layout_spec.rb b/spec/carousel_extractor/unknown_layout_spec.rb new file mode 100644 index 00000000..a42228cc --- /dev/null +++ b/spec/carousel_extractor/unknown_layout_spec.rb @@ -0,0 +1,11 @@ +require "spec_helper" +require "carousel_extractor" + +RSpec.describe CarouselExtractor do + describe "unknown layout" do + it "raises UnknownLayoutError when no recognized layout is found" do + expect { described_class.new("").extract } + .to raise_error(CarouselExtractor::UnknownLayoutError) + end + end +end diff --git a/spec/carousel_extractor/z8r5_gb_spec.rb b/spec/carousel_extractor/z8r5_gb_spec.rb new file mode 100644 index 00000000..1f3e732e --- /dev/null +++ b/spec/carousel_extractor/z8r5_gb_spec.rb @@ -0,0 +1,53 @@ +require "spec_helper" +require "carousel_extractor" + +RSpec.describe CarouselExtractor do + context "with Z8r5Gb layout (albums carousel)" do + let(:html) do + <<~HTML + + + + + + HTML + end + + subject(:results) { described_class.new(html).extract } + + it "detects Z8r5Gb layout and extracts name" do + expect(results[0][:name]).to eq("Fearless") + end + + it "extracts extension (year) for Z8r5Gb items" do + expect(results[0][:extensions]).to eq(["2008"]) + end + + it "extracts base64 image from script tag" do + expect(results[0][:image]).to eq("data:image/jpeg;base64,ALB1==") + end + + it "extracts data-src for lazy-loaded Z8r5Gb items" do + expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=1989") + end + + it "omits extensions when year is absent" do + expect(results[1]).not_to have_key(:extensions) + end + + it "preserves absolute links unchanged" do + expect(results[0][:link]).to eq("https://www.google.com/search?q=Fearless") + end + end +end diff --git a/spec/carousel_extractor_spec.rb b/spec/carousel_extractor_spec.rb deleted file mode 100644 index 7ce2d73b..00000000 --- a/spec/carousel_extractor_spec.rb +++ /dev/null @@ -1,113 +0,0 @@ -require "spec_helper" -require "carousel_extractor" - -RSpec.describe CarouselExtractor do - describe "unknown layout" do - it "raises UnknownLayoutError when no recognized layout is found" do - expect { described_class.new("").extract } - .to raise_error(CarouselExtractor::UnknownLayoutError) - end - end - - context "with iELo6 layout (paintings carousel)" do - let(:html) do - <<~HTML - - - - - -
- - HTML - end - - subject(:results) { described_class.new(html).extract } - - it "filters out blank items (no name or link)" do - expect(results.length).to eq(3) - end - - it "extracts image from script tag for visible items" do - expect(results[0][:image]).to eq("data:image/jpeg;base64,IMG1==") - end - - it "extracts data-src url for lazy-loaded items" do - expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=fake") - end - - it "returns nil image when neither source is available" do - expect(results[2][:image]).to be_nil - end - - it "omits extensions when no date is present" do - expect(results[2]).not_to have_key(:extensions) - end - end - - context "with jCuzJd layout (actors carousel)" do - let(:html) do - <<~HTML - - - - - - HTML - end - - subject(:results) { described_class.new(html).extract } - - it "detects jCuzJd layout and extracts name" do - expect(results[0][:name]).to eq("Joaquin Phoenix") - end - - it "extracts extension (role) for jCuzJd items" do - expect(results[0][:extensions]).to eq(["Theodore"]) - end - - it "extracts base64 image from script tag" do - expect(results[0][:image]).to eq("data:image/jpeg;base64,ACT1==") - end - - it "extracts data-src for lazy-loaded jCuzJd items" do - expect(results[1][:image]).to eq("https://encrypted-tbn0.gstatic.com/images?q=amy") - end - - it "omits extensions when role is absent" do - expect(results[1]).not_to have_key(:extensions) - end - - it "preserves absolute links unchanged" do - expect(results[0][:link]).to eq("https://www.google.com/search?q=Joaquin+Phoenix") - end - end -end diff --git a/spec/carousel_item/rel_to_abs_links_spec.rb b/spec/carousel_item/rel_to_abs_links_spec.rb deleted file mode 100644 index 9f086b80..00000000 --- a/spec/carousel_item/rel_to_abs_links_spec.rb +++ /dev/null @@ -1,22 +0,0 @@ -require "spec_helper" -require "carousel_item" -require "layouts/i_elo6" - -RSpec.describe CarouselItem do - let(:html) do - <<~HTML -
- -
- HTML - end - - let(:node) { Nokolexbor::HTML(html).css(".iELo6").first } - subject(:item) { described_class.new(node, {}, Layouts::IELo6.new) } - - describe "link" do - it "converts relative links to absolute" do - expect(item.to_h[:link]).to eq("https://www.google.com/search?q=The+Starry+Night") - end - end -end diff --git a/spec/fixtures/json-result/movies-directed-by-Terry-Gilliam-Google-Search.json b/spec/fixtures/json-result/movies-directed-by-Terry-Gilliam-Google-Search.json new file mode 100644 index 00000000..13c0223e --- /dev/null +++ b/spec/fixtures/json-result/movies-directed-by-Terry-Gilliam-Google-Search.json @@ -0,0 +1,220 @@ +{ + "artworks": [ + { + "name": "Brazil", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Brazil+1985&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVECs7LKcwu0FLKTrfTTMnNy9VMyi1KTS_KLrEC8YgUINzXlEaMvt8DLH_eEpVwmrTl5jdGOi6AWITEuNte8ksySSiEeKS4uuLVVTBwMPItYuZ2KEqsycxQMLS1MJ7AxAgBWJdeRmQAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEA4&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "1985" + ] + }, + { + "name": "Monty Python and the Holy Grail", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Monty+Python+and+the+Holy+Grail&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVECs0yqciy0FLKTrfTTMnNy9VMyi1KTS_KLrEC8YgUINzXlEaMvt8DLH_eEpVwmrTl5jdGOi6AWITEuNte8ksySSiEeKS4uuLVVTBwMPItY5X3z80oqFQIqSzLy8xQS81IUSjJSFTzycyoV3IsSM3MmsDECACtC8datAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEBM&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBwgHBgkIBwgKCgkLDRYPDQwMDRsUFRAWIB0iIiAdHx8kKDQsJCYxJx8fLT0tMTU3Ojo6Iys/RD84QzQ5OjcBCgoKDQwNGg8PGjclHyU3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3N//AABEIALcAeAMBEQACEQEDEQH/xAAcAAABBQEBAQAAAAAAAAAAAAAFAAIDBAYBBwj/xAA7EAACAQMDAgQEBAUDAwUBAAABAgMABBEFEiExQQYTUWEUInGBFTKRoQcjscHRM0JyUmLwU3WCsvFD/8QAGgEAAgMBAQAAAAAAAAAAAAAAAAQCAwUBBv/EADcRAAEEAQMCBAMHAwQDAQAAAAEAAgMRBBIhMUFRBRNhcSKBkRQyobHB0fBS4fEjQnLCMzSSBv/aAAwDAQACEQMRAD8AxlehWKuj0oQidhpi3umzSD5LhXHklmwkgAJcZPQgc/rWdlZpx52g/dI37jgA7bmyaTcOP50biOenqrN5o8NvE0sIln2RQsI8EFg6kl8dcA4GB680tDnyyP0OIbZcOhqqodrPX8O6ufisaLFu2B97vfvX8K5JplksLuzyws3k7ZH5WF3QkxyEDtgDI6bhkVJudOXANAd97YcuAI+Jt+/BPQ0VF0EYaSTXHyvofp77hO/DLY3GoQfCzeZZ2xlO2XdlvlwvA92/So/bZfKjl1inurcVtZF7n+dVLyI/MczSbaL59AfzVdrW0fSG1CG3mAVzCULkjccbWDY6AZz749auE+Q3JbjOcCSLuq2HIqybO1V79FVoidCZA0itufp+trsFlZfhEN9deaokkkjLrnqBlcDGOpwckd6Jsmf7UYYqOwNfOjvd8dgV2OKHyPMftuRfyXLy2s7eztbwW07R3SEohcgoVyCCcc5bGPauQz5Esz4dYtnJq7B42uxQu/VD44mRiTSad0v+deFcOkWg1K6svh7j+Xa+eshYnPyKcYx6kjj0pV3iEwxhPrafi01Q/qq7vtvSuGNGZfK0ni7s9vbuojpMB0+C6iEkjtbGXyhkeafM2HHHQL82Pf0q77fJ5zonED4gL7W296NbnYcfXZR+zM8sPAvYmh13rb81xNNsjZ/EXHnwbod7KFLG3O8qCw6lWHPrwetdObkCTy2aXb0Omr4bodiOPpdI+zR6C82Nvet6v2Q/VbUWc0MWF3GEMxSQOrZJwQR2wAfvTmHOZmuceAaFiiKA2PqDaWyIwwtA7e6pU4l0qEJwoQlQhFtA06DVJZoZLmaCSOIygooIIGMj685rJ8VnkxYxO1gdVDkg7n06LRwCZHeVqrrwDx7pmg2cOp6qln588JlJ8lwASCFLfN+mOK7n6sbGMugO0jcWfw/uu4075ZQzWRfBofz6KKWwuPiGFqkzxFisbMQC2Cqn92Xj3FTikhMYdLQdVkAk1tf5D8D0XHyZIeQw7ezd/wAO6s6JpXx2oWdvdyyRpctJgJjdlED856ZBFU58rYceSSFtlgvcnqSP09FPGkmfI1r3bOPYdK9PVVBYXrw+bGGYnaFQEFiGXcCB9O3WmS7GD6P136UP12VXm5WmwfwH7f3Ss7G5u78WqMEfaWdmOQiAZLEjsB+/HU0TPx4oTMRYHa7N7UEMmyXyCO9/YfXjspIIrC4nWCO5uYGdgqXEoGxj2LKOVHvk4qgx5LG63Rg92gm/qdnH5D0UxktcdAefem19KtU7hHguJYSxJjkZT9QetORRxSRteByAeT1HuqX5U7Xlurjbgfso9zbtwYg+tWHHiOxH4n91AZk4/wB34D9lZigMljdXRuEDQFAImb5pN5I4+mOfrS8giZLHFoJ1XvvQoX+KtbkTuY52ritqG97dlZ1uxhshYmCSVxcWyzEyDB+bnp2qvw+Z8jpmPAGl1bWeg7rmZu2N13YvoOvohlaSSSoQu0ISoQtD4IIGrXJIyPgpcjOO61jePAnCIH9TfzT/AIb/AOyPYp3hCeyfxFYLBYGGQltshuS207G7YGap8UhzRhyF8wIr+iv+ylhvgMzdLCD7/wBlUEbx6feai7uwS78iFC7BQfzEkAjp8uB6/SmSWmSKAbEt1E0L2AHX39dlE3UkvZ1cnv8Az5ovosEf474fvLcyLDdxznyWcsI3RHVgMnOCRmkcxzhi5cD6toG4AFg7i6AFjdXwAGaGQcEnazsR2+qFRQxz+GjcWqSNd206xzL5z8q2QmBnAzyv2p9znszmscRoeCRsORvzzxv8ks0NdjEt+80jqeOFf01YpF8UfCKci22x5cucA88nk8gUnll0ceL5h2LxewHXbj3TEFOfNo7GuvvygWkaeNUvEshOsUkvypuUsGODwcdOlbGXkuxozIG2BzRAr6rPgjErgzVVorZ2unraaxPqMct29jPEDIjlTJvchhg+64z7npWTPkZbjj/ZyGCS9iAa+Ekbj613+adZFCBL5m5bW426gf29k3TLbTb7UYIrewklt5bgpM0rkbFJwgU7uuMk5ye31tmfkxRf60oa7TtQBsjmxR29q/JRYyF7/gZbb69B0rfnlQ/AWo0rW3KFriynijjlLH8rOw6euE/epjKmfLiuumyA2PZpPPPyUTCwMlsbtqj8wE7xKP5Wj/8At0P/ANRUvDv/ADZP/P8A6hRyf/FD/wAf1QOtVJpUIXaEJUIRLQ9VXSZppja/EPJH5QzLsCqTk/7TnoP3rO8TwpM2IRNfpF2dr43HUfNNYmQ2B+stspaTqUGlaoL6K0eTys+TG0wG0lcEk7ecAnHAqWZiz5WKYXPALuTV/QX7dVyCWOGXzA0kDgWnDVYfIvLV7V1s7mQTbBMC0Mg7qSvOeAQR2qk4UzRHJrBfGCONiK4IvbvfelYJ2OLm0dLjfPB7jZTWWt/h99aSC0MqWEckdvEZtuC+7czHac53HjHpXMjw9+TBI0PAMlWa6AbAC/zKlHktilb8Ozbr+65o9+bJ9TubWJo7Y2xDI7b9rFhswcDPze3TNdy8bzoooZjbtQ3G3G56mthvuowS+XI98Y2rr68fiqWj6jNpF4s8AVhtKPG35ZFPY/sfsKazcSPMhMT+D17HuqMeZ0Dw9qsW+pWdhere6bZyJMpPlrNMGSIkY4AGWx7kUs7FzJ4vJnkGk8kA2fqaBPzV4mgjf5kbTfYkUP1TLfVFj0/UbWW3MrX7o7yCXbtKkkYXae7HPNWS4TnSwvjeAI+lXdiubFbfuoMyAGvDxZd+99u6ms9aS3tNOiNkJJrCdpopPNIUknPKgc4wB1qMuDK/IdIx4Ac2iKs/I39dl2OdjYgwtsg3zS4+rwmDVIUsmC6hIkhPxH+ntyVx8vPLHPT096rZ4fM37P8A6g/0r/282CP6ttvx39FN2Ux3mfCfj9eN77KHVdRXUI7VVtzD8NCsKky796qAAfyjB4/emMTFfBJI9zr1m+Krau5vhUzTNkYxoFaRXKHmnlQuULi7QhKhCVCF0ggAkHB6GuWF2imsyrt3sFDMFBPqTgf1qL3hgt3C61rnGm8qh+M+eXaUItwJjGYx3AHBH3HNIsyaFAJ12PZslEofONt0ZVIUuqtkE8/rjn9avjma9w1DcJZzC0Gjsm00qUqEJUISoQl2JqJNEBSAsE9v8fqlUqUbCVCEqEJUISoQlQhVRL5eoNE6sElTcjdtw6/2/Sly4tlqtimQ0Phu92qh4luDFGsCsG80ZYdCuCMH7/2pbLeb09FdisGnX1WcXeZBsyWJ4x1JpMcppbzRDcacqWeoq7tOSUc8BV2jqT7nGKsbsRagWA7hIdBWyslKhCVCFzPNC6nKSGwOlYvi8hGlgPcr0f8A+fhBL5COwH5/std4YtFl5lRXXHIYZBry2RM9htriPmtrNawtohDfF9vp1tqKQ6bGI3C/zkUnap4xj04z+1ep8DmypscvnNjoevW77+nzXjc1kbJdLEKgsru5Utb20sijglEJxWnJlQRO0veAfdUNhkc3U1ppV6vVaXWhcUT/AMyJjGS4I4UdyOf/AD6VTIbFg8q5mxpw/wAdU+4XzIUuYg22NgeeuMf4z+lQ1am+vKsDdLyCdjt/PwQvxBps10yPBtYx7geeo9qryInSAOapQyCO2P5tC/DYB1iDcM4OQKRan2r0LxHAVTT2YGQojgSMOckj+wp7GANk8rOyHODq6IP9KdSqVCEqEJCuBdVe4vI7RfNmchScKAMms7Kx4nv8yU+lLWw8+eCPyoQL5JPqjdnrmo2KILYQNuAIEo4wfXFZ+R4ZhywGSNpVsfiGRLOI5nCvZTaq3xMUl1Jgu7luB0rKxJ5cZ+lhpegkxceeMCQA11/uqNo4wFN7Nb/8QxGffBr0EXnEFxh1E8k0CflX7LzmYzHDgxktAbACyBueXeqVta/Gx+Xaxn4mNSxQcmZe5HuB27jntWoXaTvwsitXHKqVNRVcO0LGGVFS3Zz5cinox559Of7Um4GN5J+6nWua9gDfvDv/ADsjllHGujXBIJDyDduzgZ9++M9vpVDnEOsK/SHANI6Krd2jQRqqkuCAN5GD0AximYHAiuwS2SDq1dCVhNLlFtqUTnorVngUaWk0fHS9cv8AbeeG2YfmjAkUjtggH9iaYx3VIEhlN5WWhUzTeSn5zGzhR324zj7Zp1z9LgD1VEceuN7u1fqm5z0qxUpUITWZY4y78BRuPtUHu0sJUmjU8BDNKDXm+W7iL7W/l7wNoHfA/vSmLql+J+46JrK0xnSzY9VcFnJJNvaZ5pMfKpOBjsOPaouhZC4HXRPAVsDZskFscd1yf87KZMZ5Dfcf3p1rj1tZ7gOlJ/fNWKKltpntriOeJirxsGBFRc0OGkroJabC7HefG3Fw1yqEiTh2O3IzzyO9Z7ZHt4K0ZIWOolN1eyV7WZLaYPlPyk5K571cZPMaW1uVU2EsIcTsE7whrIkkuLLYiF13xI2fzj8w+/8AalAn3MDmhyK6jLBMJII5My52iMKchsBv6GrYXaXgpaWNzoyFh7rQ5XluLqBx5anftA6cZ/zUZotLyrMZ4ewE8rU6f4hT4KXSYoJbmV7dt7wjOzj07/aqGZAZICRsrcjG81p0ndCIJpl1qzuYphFDwFlwGGT7fpTuRZcHDhL4VaXMPPUIvq5H4hLkAMMbyF2hmwMnA6ZpmK9AJWdJWsgIXPKyFIk/M/8ASk8rIla7yohZIWnhYkL2edO6hddl15QwaNo5SMquFTJbPoO9Q+1PMemRvvanJhQ+Y4xPBB+6B/Om6PXthAlqDDFPHII1fMgK7+m4YPpmpQ5uuQNPVKS4hYzULtCrRwt1v7DoazQHSOOQfug/yl7aExY5bgtNPLa2HG3J/dJEJdY+5rZfmRNAcDdryGN4NlTSuiI0lve/w5v5J0kZjYg847hSP6irmytdx+YSsmHJF94H/wCXfqAmY5q1KLMao5a/khkIVGPX/NZswAdS1IXWwWtFowtp7WMRk+eItgBPJAOcGuRkNcCrZQXRub3CpaPpd3carPHAwMkLCVlDbWYc8r9M1x40PoqUUrHRgrZ2VtaOtvMBtuY3CMAP9RADtJ9xkj6VDqomwD2U66Ctre39xbylkuipEWP9PA7fqamSSbUGNa0UED8G6jbaKNQsbkW3nQ3K4e6OISu4H0wGBUH7cCsnIa4OocLRiLS0lU/EqoloF0+SN1MjTIQ2Mq0hOOe4wB9q0IsgCAMcd0n9nd9oMjRso9Wa6ubzdCyRRuV3EjJxx0rQGosGlZz9DZHauUxHJnWNpIjKz/LGGJOOwAAz0qEk7Y61n6LseO6Vvwj6rRpodlc6RbX7Mkhgjea7SQ5jA3KmCO2NzH/4Vn5OS+VhCaxYvKm+Pbfr7frsrgezZoLe1ksfiplJma2wVC7QmTj9h7UjAXAlxHCfynAjSFn1tLhEMirgIcHAz7VuGXFyG+UDY9FlQzZWHOJx9716+6hY5PIwc1ZjYcePZabv2V3iPi8+fpEgAA7fRcJJGCSfqaa0jss0yPIouP1XK6oKvc2NrdtuniDNjAYHBqt8TH8hWMlczYK34T8E+Ib4S3emm1FvG+2OS4kZd5xzjCnpmsuU+S/S5akTvOZYCWbnTNWSHUInttXtiRI4PyyqfysPqM+xqXmeYFNkYbYHBWm0q60+1VZ9QljRBnaXOAWxml8h7mM+HlWNZqdRRXxFqH4fY215AkMsJw1044+GDHCnjhhkEEZyKUgme07lWviBGwWWtrOzuIha6fFP5hXY6GWOMybevB69Cevcmr3vaPicogFo5UXgfwlZa/pC6nqTTXcspdfLWcRrFg4XIALc4HPQA96WfIGP0gKxoc9luKoeKobfw5c6vpCxlmjEbWj78lVcDI9wMsPsKegke6MAOqv1SU0bRLZbypvAmrWnh64vFe5EMsmFV4rIzSqQFOev5eW7daVy2u8010TMDtUdnlFJbllufGGlpGZI77Z5U+QMb8tz2538VyFwIBRkROoOKb4U8P74Bb6YxkvVdiHEZMURyfmdsYyOwzn261cSeiXA7qPXDpunTrFYajcPIhMbzSPj4iTuQBjAzn17dKdx3tADHCwlMhhdbhyhVaqQSoQlQhRXE5tl885MSjDptzuz/SqZrA1BXQ0TpI5XpvgfXYT4PtfhQA63IgK7+VLy5yc9CQ1YeW5xkvutjGjDWaeyzH8ThbLDFO1/C2p2TrHJBEjNw/JBkP5iOD+vA4qOM8g6Vc7jUsfqF75vhth+cpIj4JBA+buO45pmXcKDtviRPWfGI1bw/dQPcmCOQeXb6ZHblY8cckgYODkjnggcck1mshexwB39Va+VpBpd0Gxu9Rg0a/02Yy31tcATwyjaEQD8xJ6ggFfuKsleyNpDzQUKLwKUPhm58QaLf3enW+lyNatIx8m4tGlCegyvtj24FVSmJ7RIDv7qyLW06DwicXhXUfEfie91DXUuILYqoXCBC+FAAC5O0DFQOaIWtLBZQ+HU9w6IFrHhzWNGv7poIL+XgBL2FCVYEc5C57f0ptskWSLJA9Cl2h0GwW28H6oDpOo3HkmGMzxs8RXClRGExlsd1J+3PaqjGY2lmrjr+KdA84tcBytnoWqRT2UllaAQiOMpEgUL5R28Djt0x9vaiKR1lrkvNCANQXzxqF38TbRzyyZuAAFRRxHjGSfrjpTjSlSOi1CMHRXHRgDW8DYtYxFGl2uriVCEvrQhTRWN1qNnd2kNxNbWzqrXDRwvICVOUBCqT+bp96zvEQ0MBPPQe6fwC7WR06/JT/w/8Fatf67a3GrWhl0aBnZ1vAwEuVOMIeT82DyMVkhzRwKK0n3wTYW+8e+G7Ox0Jr3R7S1tYYCpuYI4VCuhIGeO4JB+mahI5zhqB3CsgIJ0uCwNta6XaQwXEqN5+1hLIHZGRs4xkkhgeo44qk5bjfw+3r/hSfCGu5R3RryKJnXT7fYHIJZ+p+3akZ3uk++nYImdEfjuXKjzZSeO1K2mNA6BT28xLZYP9hRai5itGXaM5kU/Q121Vo70o3gt79dl5bwzgnPzLzn1z96sZO5q4Wad2mkP8ZW+praC98PW8bXkUXlSJkh3jGMBexxjuM4JA61ow5TXmnbFIvY5o23Xhms6q+pzNPNBHDO5zKYiQHPqV9a0QUmtBormTS4Cew2/oSP7VtYxuJtrLnFSFXavVKVCEqEL1T+Fl5YmwvNOhyt1EVllJGDIGHUeoGMfp615/JmdLK69q2C2oYBFE0jrutBql0mnxyyAq0gX/T3AHJ4HX1NZc8/kt9f5/Nk3FH5hAWQ8W+MvLs5dOitoZprlCjKG8wKpHI6cnFL488s1uqm/z9VcYmM3BWAtxvbzLhY3UKwxL+Vcjr9RVhNbNUwzUbKvabeJIVjsk3+ruMD7CqpGEbuTcJb/ALVqrSGQgGRyc9hxSZKZJFIrb2yBcbRQN0u96jv4DGgaKR4zn/YxFSIpET9RoqzaCUxgltx9xzXBZUJNIVuN8NtI57VJo3pUuG1rzT+JHhzT/wAWjuEj2PdIXfZxhgcE/evU+FgZMFP5b1WDmOdDLbeqBWlulpbpBFnavqeT3rajYI2hoWe9xe7UVLU1BcoQu5oQrOlXNxZ38dxaStDPH80ci9vUH1BHasHxWIxu85vXlbfhkoe0wu6LZeIfHOmX2iwo/wAuqqd3komfLZccknjaf1IPbmsuVjZmbhaDGGN5XnHxDi7a4kkI4yNrcqTnj61PR8OkI/3aij1hYfiEYaXAUfljHRaUe7QaCaawOG6lsYhp1+Y2GF521U8622pxjSaWxtXVlBBpUq4olAeKAqHhNvuUUe4qTyiHlT2wwgFTjCrlO6evzOzfapBupxUCaasJ4/njk1mOJCS8MID89CTkftj9a9V4Kwtxy49T+Wy8/wCJPBmAHQLM4rYWfaWKEWm0ISoQugkcg4NVyxtlYWO4KsjkdG8PbyEy8aOW2SJLXEgbdLPs5b0GfQVgyYBhJcL0hbMOd5xAJ3KoPZvdOhibaUJOAOCaU8zSN0+6Mu46LRaLfrF8jZGOKTlj6hMRu6Irqca3MKyxn515FLN+E0riLCsaLqAcBWNQeylNjtQWkglBAIOarUXNUkzb3RfvQTaixtWVbj+VAam00FS4WU25uobCykubhsJGMn3PYD37U1ixuleGMG5S+RI2Npc7heVXlxJeXUtzNjzJWLNjt7V7iKNsTAxvAXlXyF7i48lRYqxQSxQhRUKSVCE5RzXFwqUKCCD0NcIsUVwO0mwqBT8PcZLFCflY/wDnWvOZuG+J233V6bBzWSso7O6hOlZH/mRMAw/ekQK2KecAdwpLbW2hPlSP9jXH497hdZOAaKe1/wCW/mQng9s1ARE7KfmBu4R/Rdcebaoy3sOaVlh0pljw8LS217uBllVkXoNykE1SGEmguvAAR20UXSq+Cg7Ajmno8LUPiKzJJw3jdYrxs1+moi1u8LbqN0ITO1x6n36j2r0vheLDDHqbu48lee8QyJJJKdsFnNtaiz7XdlCFzbQhVK6rF2uITlri4VYjrqgVKyLIrK6hlbqCMg1wgEUeFwEg2OUIutDbJexuGjP/AKb/ADL/AJFIS+Hsdu3ZaMXiMjdnbqhFpzveeTesEZecxnPX3rMmjdCdJWziubkND0esfD1jdKFN1cxtngkgj9MUrrNpsxNpdt9NvNLvFjd451PAMLE49PlHP9veqpG6+F1gcxbrQLORgst7GVbGQHbIH0qcUTW9FCeUngrSx3cEJwWUBR61frbdJV0biLQT+IixS6bZTjBkWUqp/wC0jJ/oK1fDydTh6LHz20B7rCBa01mpwFCFx1ANCAhtdVy5XEJy0IKsxUKsqyqgiilAlOK8dKEWhGswILqJ1kZJpeNoGQQO/t1/pWdnMZWs8rX8LlksxjhXIrWOGEsl7MGxxjb/AIrGPsvQBO0rV7CzG4u8k7EeZK7Zzj26UOB6Bc55Ksaz43wgjs2w59KBG9y4SxnqnaJd6prVwkUUbCJiPMkb09qgImtPqpuksWtz4y0+aXRraaM7ltSfMQdcNgZ+2P0NbWC8NcWnqvN+INLgHDosRsrUWTaWyhdtN2VxFoTXUwuUIThXEFWYRXVWVeiU4oVZUwSuKKFa/p0lxElxbsBJAGJUnG5TjP34FK5UJe2x0WhgZAieWu4KE2Vtd3G1vNCjp3NYT3tC9Q1jlX1bSTYuS0m4Nyu09akySwoPZW6J6d4ajutLllUObhU3qVBOe+OnPFKOyS2T0TEcAMdlbD+H1xB5KKvFWg0/dVTAlmy9GDJJEY3AZGGGB7g9aaDq3CzXR3yvLZoTFNJEedjFc+uDjNegBsWvNEUaXI4JJX2RRu7f9KDJ/Suk0gAnhOntJbdws8TRsRuAb0rjXB3C65rm8hZypWmEq4hPjXLAVxcKO2mjXbIHCfKe+Kh5jQo6HFW106ZByua7rCgWFMeIxnDDFSBtRIpNaFJEZGGVYEH6UEWKQ06TYWWu9Kv9KgeYXMb26EAnBDYJxyOn71jZGF5bS7kL0mL4mJXiMiifor8V1p7WmyVFe4IwjMNxJrKcDRta5q1vPCtpGLSIjgoTjFZzjZUpXECghniHQ59Fu31bSUJtG+aaJf8A+R9QB/t/p9OjbH6hR5VcbwfhKuaV4mZ7cyMu4gfKPen8OOSaTT07pTPfFjx6jz0CDldzbm5JOSfU16UCtl5DleheFYLeLSLcxohdgSzHrk9eay8hzjIVr4zQIxSn1HR7LUJIpblS5jY4VeA3sfUVBkzowQFOSFklaui8OrYWcpra2luZNkSFj7VwkDlHsj1l4Yu2lXzMKAeaXdO0bKQicVubWJYrYLj8vH1pIvspwMoKJoVcHeoz2qQkUCxB9R0rzX3q5WmY5qS8kF7hUTbNFwe1MBwKWcykySJJEZJFDIwwwYZBFSIB5XASDY5WU0PRlutWl1CGLbZiQ+Sp4RVHGcngZryedkM1FrOF7DDhkDA6Q7re6Tq9lpttsnmDt/0xDd+/SsyjadfG53CIQ+J7d/lFrcuP+K8/vXQ4gqJxHHcEKj+G6fcyj4FHtA7EvG6YA/44yP1ra8MzGxksPVZPimHJI1riRsi0GkaV5+6RHIwMLu+Uf/tahnkqgsoY8V7o9arFEAkW1YyMYA4pZ1ncptoA4V8KvC57VClJfPaDLc1urIK3nhmO1tYQUQNK3qKQncSUxABVrUwvbFWLwYP/AG0oSU2KXWnjkiwMjHYDFRXVALYPFuDEeldtFKnLEwON5qxpUC1DbqEqx3HNORvtKyMQfVblbeLYF3M/Y9Md80r4lO5kQY3YnqmvC8Zskpe/hvRD4vMuFCySEqv5UHCr9B0FeZLdPC9W02r1tbQgl5DgAVDcqwkBE7S/sTtjt1Lt67cf1q5mK9x3SkmRpWjsLZ5v9qq1a2PjNh3O5WLPO6U10VqXR3WPeH+br1psSJUxp9npU4QM1wBnoPSuF4XWxnup3ea0cK7bgTwRXNiu7hf/2Q==", + "extensions": [ + "1975" + ] + }, + { + "name": "12 Monkeys", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=TWELVE+MONKEYS&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVGCsLLMyrUUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64tVVMHAw8i1j5QsJdfcJcFXz9_bxdI4MnsDECACCBYeycAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEBg&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBwgHBgkIBwgKCgkLDRYPDQwMDRsUFRAWIB0iIiAdHx8kKDQsJCYxJx8fLT0tMTU3Ojo6Iys/RD84QzQ5OjcBCgoKDQwNGg8PGjclHyU3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3N//AABEIALcAeAMBIgACEQEDEQH/xAAcAAAABwEBAAAAAAAAAAAAAAAAAQIDBAUGBwj/xAA9EAACAQMCAwUFBwIEBwEAAAABAgMABBEFEgYhMRMiQVFhB3GBkaEUFTJCUrHRwfAjcuHxM1NjkqLC0iT/xAAZAQEBAQEBAQAAAAAAAAAAAAAAAQIDBAX/xAAoEQEAAgEDAwMDBQAAAAAAAAAAARECAxIhBDHwE1FhQaHRFCJxgcH/2gAMAwEAAhEDEQA/AOJ5oZouXj0p+S2lhR2dcBcfHPlUtccZntBsKxGQpI88UZjcDJRgPHI6VMTt40kgAVjFkcskncQOVdQ4F4FSe5abiKPMyJHMLTGVActjd5nKdP3qbpt2nSxjH58/1z/h7hHWdfAksrbbbE4+0Td1Ph5/CuiaX7IbJFH3lfT3D46RDs1H7mugG7igshcRWskp7U28cEe0MzBiuBkgAd0nrVwgDxq4BUMAcEYI94q25zjOMXMOdSezDhxEwbaf/Mbhsj61ndW9mFngNpmovGx6LPh1PlzGP611HiOWGOyEU8M0wmfaEhOGOMt5jwU1TypDb30Nusczb1BDgrtURrtx1z0YfOszlTpjp3jbiWr8JazpaM8tr20Cn/iwNvHyHMfKqNUZhlVJHoK9ArLbTi6j2ygRIeZAO4BmyQAfAgjnWb4l4a0y9huLnTyIZ41EzSKMpJzbl/4kU3tRoc825BQzUnU7CbTrtra5Qq4APpTFvD28wj3bcgncfDAzW74t59kzltjuLY2AdpwQTn3UCGCk7TjzxUp+1hSWIlSIAUPI8wx/0pVyWYpG8iYnCkkKe7jkP79KzbvOjEX55yg5oUu4TspnjDBtpxkUK088xMTUmqnXl2s1lFCCd6gZ5eQqDV7wVoR4h4gtrEqTDnfOw8EHX59PjUmInlvDUyxicY+reezvhWfto+I5oO2jklzDAxCkphsPzP6tuPTnXUIYJodcmuFh3QTwRJvDAdmUMh5jxzvHSiBSKNIoQFRAFUDwAp1bxQe8wA8qzEOmWrM3fnNoz6dP90SW32a3uXa5kk7KViFKtKzDBxyYAg+8VZRdtDZQJK2+ZI1V2/UQACaYbUoEzl/rVTf6xCgyJwg9TV4YyznKKkzxK09zZmONY2YE43ttKHBAIPgQSPhmq66vV+128gx3EcHnk8yv8VVarrUAjYbwTk/m64rK3urhFMpXw5eNSljVmMaj5+7WQX5t7qd5NmxshCDndl2bmPD8VZ+PUodN0+a2hkGJF2nx/Lg/1PxrI33EE0mdrdPhVVJfSyDvMaRpw1PVanP9fbs2OtT6brGnKgZUkX8GSSVNYyBjZ3jFyQyBl5eeDimzMw6E+6hcSGVlc9SMGt1FU5RqZRnvjuNZswzrISXkKnJ9OtHLKrNARnuIA3LyJpiiNSoX1cqrzvZ25YSXEsi9GYkUVN0KsMTNzcjNdW9ilvDDBqF9IR2kjLEufADn9c/SuU1fcO67NpRWNCwRnPQ+NSSHdGv1KusZztznnWV1fiD7I3eclgeik/vTUF00hCxlWaQBiAaXc8M3F7h37EA9R1x8OlYbZS846kaRleNWGf79ap7/AIpa7Y//AI40HQYkk/8AqtTrXs9VbczwTgN4gjpXP9SsJdPnMcvMZIBrcUxJc+pPLnau0eHeb+ajy3M0vJ5CR60yKPFVBUKPbRUAoUKFAKFCgaAqFGKFAmnIyAhORkHpikYqbpUKyzNuGQozRW44QaW4hZ4YiX5DkeWat9W4puNAj2XMXaMx5c8A/KstBxNJw9o4tLBEN1cZd5GH4ATgfSstNPd38he4nklY+LHNYb5niGqX2g3KOWWyt3UjGyVA2PXJyajx6jZ8RXkUGpmO3aQtmcRhQvl0/rWYkgZfdTY5HPiK1FJlExNS3XEmhcPaFpMUVnffeOqSPueWNu5GnkBWR2jwAApBlbshzpkyN51WTzLTLriiLMfE0VAKcihaRu6KQg3MBVrZ3NtaqC+Wc/lAqSKqRDG5QjGKJRlsVI1CZLi7eWNSqsByPhypqEZkFULuoOy2EfmFCpupJi1ibzOBQoGNFSyk1a0TVC62RkAmKddtdG404Y0fR1tNT0IqLG7HZlFcsNw5hlz8c1nZtEtxHyIJ9KiaNDeTpd6dJcFobYqVUElQxz0rN2tKbWMDUJAOgAH0FS9OjXsy2ASKt9c4ZY2M2o27f4keMwhfxL0JHurMW10YcY5is5xOWPD1dJq46OrGWccLW8jXsiSOdVllZzahqMFlarunuJBHGPUmlT3pkGCa1vsc0xr7jOK7Yf4NhG0zn1IKqPmc/Cpp4zjjy31+vp62peEKvizhW74XnS2vZIpe0XcjxZwfPr0rNV1H2xX9te6rDBCwaSAEMR4ZxXNDHnOOtdXhNUKMrik0EiDC288hGW7qL6Zzn9qKCGWQPJEu7s9ufPmcClWamYSwL1ddy+pXJ/atBw1p8LWdxPId0gZSqZx0z86DOXErzzF5fxnkeXlSc7GAHWjl7tzJu8JDk/GnTA4umiI5B/8Aagdv45o7S1aWXekm8rlcEEEA0KseK8CPTl/6bn6j+KFA/ZS3E0yiMszA5A88U3w80unyXL3ZMUkjqrxuuCeROfnT+hXS299G7nAVsk+laz2m61awaPDo88EU2puEmS6iAwqhsgHx/DWfhqWU1biSSMolu2SQdw8BzrKu292bAGTnA6CjlbfIzUirSWB6V13hCfTOB+D/ALZeTqdS1RRJ2KnLBBnYvp1yff6VyPHKlvLI5BdyxAwM8+VVF1Pcpd3U9y65aVixyelQriNVw6Hu+IqOs57MgsQfSkiVtgXm3jk0AlFNUpmzSaB20lMF1FKPyMDWs05WsjeS5xGi5Oaz+jaXJqlw0cciRhMFmb18qtNdkls7B7ORwZZn7/uHP+PnUGbYmSTcw5sSSPfWi7KKWWDY2XdRvGPwkfzWeQEsNpwfMmrfTHezuBLJJHIqgudrZ8KoTxTKH1UwqcpbxrGPfjJ/f6UVVbu0jtJIcuxyx9aFBaRwyJINvhV+sCy2Ba4sBd3HJI2LYKA8ifXlTOlqk794VZ31ykMJhHlWLapgLlFjuJI1Odh29c5xTVSL45vJWAwCc/SmK2yPNDrRU4u0DvUCMYoU+ZIuoQ5ptmB6DBoEUYoqUASeVBZ6HfNZXhlWF3Ur3gvUY8aa1u6a81CR2PJe6P6/WrHTJ2stNmuZUA7mxOXXPKqDn1PU+PnQLhjEjgEkDxxU3U7pHXs4VCrgLgeQqCGwOVIPM0BUKOhQXmnXTRnAqVcySPzYcqRpqQi5XfjGa09xFp7xjDKT5YrMtOeagm2UNjrUYVr9YsLVrYlWBxmseOg91WGZHTisB1FNUYqiR9oA5BBimmfdRbaTQGKftJuwmEgGSvSo9HQW2vahHeTRxwLtiiGOXQt4/wB++qqioUB0KKhQHQoqFBYRSMrE5NPi6lPRzUdFDvtiYOxPJV5k10GLhW04f4Um1jVXja9Me6GGXoG8OXjUaZawtptR3h5Vgt41zJLLyUenqfSsrjHI+FaDTPvXirWbW0LvKocEoi4SNR1OB0qr1q3Nrq15ARjZKwH70REzQzRUKqFZJo0271352Z72OuKRmhmhaQzQGEBUIlxzPh1/ilB7XIzG+M9M+GP5qPQqU3v+EhWtcDcj57ufrn+lNqYuyIZT2nn65H9M09a2bXCM6yIgBx3vGjuLGSCPtC8bDxAPMfClE5mw1thcxvyQA8/HBz/6/KjD2vPMb9fPwx/NR6FKN8+xUhUsSgIHl8KFIoVWJej+FuAND0JIJUthPeIuGml7xLeJA8K5J7U9RGtcbTQWSySCHbbqv6nHXA95xXocHlnlXKrLhsRe2F7q6ixbTK91bD9TAAHPqD+4oNTwRwjbcLaEqbA19MgNxKRzJ8h6DOK4x7R7AWfEssiHuT97HkcAV6NvpVigJavOXtEvhe69KQwIU4G3yqDK0dCiqg6NSoILZx448qKhjNC16ILRJWzbgr2atnqB/qai6XDDdS3AZOWP8PP5cnlTa6pcKuAI+gH4f9aj2t1Jas3ZFQWxnPpXHZlU8vpz1PT+phNfti74XYsLQzMBECGITn+XkTn9qRHZW3YW7iJC52Z+PWq2PUbiNnYMpL4zkeXIUlNQnjYFSmRtxkdNvT96z6efu9H67pO+z3+ke6ymggV7hxDDtjjUpu5A5JzTUUNmy27GNQZQcDJwGXlz+NRF1KURmNkikUgDDL5fGm4bx4dm3YwQMACMgg9a1GGVU459VoTlExHH8fP44JvUEdzIgRowrfgJzihSJ5WnlaRyCzHJxQrtEcPmZzE5Tt7PSejcS2WraWGtblS5XkZCFOaw+rcT61o+pWqvpd5NtRo3eRjgnH4o39fXFcmjklicNHI6MOhVsYrTaLxvqukquwrcPu5vcEt3QPwjnyqMuvff+kPo4uZ9YkQunaG2J3SAnnsxnw6cqw1/oWn61B94aWY2d1DTJMADHzxgkeP81E1Xi0a1bLJPwvoxmmQhZpBzHyGfrUHT9aXRrWULotoxlXbcDJ7Nx/lNVVbqGlpp80i2qWl6hIAZHwc48j08fGmozIVYvpVqABuy+D4jpgVM1TVNPubOIwcPWNs0xChoyAQc/Sq+XsknjUadHvkV9qiQHoPP4H50QmWCSKVWXT4XYczskyPqMc6kfZmaNlNjZc+veIIBPh3fCo0zwxRAPpaAlgAwIP7UYuYN+fudj3cAdn7/AE9fpVDqQu8ePu+zXYNuSebjzHL06mnCs1uQn3faSkEsdrYyM555Hr9KgxW8dzskj0+Ta5PeMmF60+ul4JDWoyn4gbgjr/sfpQPW6Ts0faWNquxcDtGHfzjyHUY+tBI7hMzmCzkUKhEeevIjly9aTbxpIUX7piUBeZkYDPQ+VNPYqo7VrFSSwwO1wOfPpjyoHA112rONPgwFxt3ry9afkE+ctDYclJ2kkhgc+GKEtqQCPuyzGSPwsDj6VFxHbmKJ7C0ztzl3XJ8jzFBVX0jSXcryRiNyeaL0HKhSbna0zMiKik8lUggfKhQS9W06XS7xre4wWHMMvRh51E5UKFQGDjoSPcTRF38Xb5mhQqobx7qMd3BBIx5HFChQGzu3VifIkmhvf9bY/wAxoUKAB3HJWKjyBo+1f9bfOhQoAJH/AFtj30RdiQdzcunPpQoUB9rJ/wAx/wDuNJLserMT4EnpQoUBZoUKFFf/2Q==", + "extensions": [ + "1995" + ] + }, + { + "name": "Fear and Loathing in Las Vegas", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Fear+and+Loathing+in+Las+Vegas&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLHSLLIMjbUUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1jl3FITixQS81IUfPITSzIy89IVMvMUfBKLFcJS0xOLJ7AxAgDjxeHjrQAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEB0&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "1998" + ] + }, + { + "name": "Time Bandits", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Time+Bandits&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLEMTfKSirUUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1h5QjJzUxWcEvNSMkuKJ7AxAgAwsivwmwAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbECI&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "1981" + ] + }, + { + "name": "The Man Who Killed Don Quixote", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Man+Who+Killed+Don+Quixote&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLHMyspMq7QUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1jlQjJSFXwT8xTCM_IVvDNzclJTFFzy8xQCSzMr8ktSJ7AxAgDvaJD5rQAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbECc&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2018" + ] + }, + { + "name": "The Fisher King", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Fisher+King&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLEMzapMjLUUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1j5QzJSFdwyizNSixS8M_PSJ7AxAgChYLrnngAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbECw&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "1991" + ] + }, + { + "name": "The Imaginarium of Doctor Parnassus", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Imaginarium+of+Doctor+Parnassus&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiArGMiswt4zO0FLKTrfTTMnNy9VMyi1KTS_KLrEC8YgUINzXlEaMvt8DLH_eEpVwmrTl5jdGOi6AWITEuNte8ksySSiEeKS4uuMVVTBwMPItYlUMyUhU8cxPTM_MSizJLcxXy0xRc8kHmKAQkFuUlFheXFk9gYwQADm-i2rMAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEDE&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2009" + ] + }, + { + "name": "The Adventures of Baron Munchausen", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Adventures+of+Baron+Munchausen&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLEMTSvMTbQUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1iVQjJSFRxTylLzSkqLUosV8tMUnBKL8vMUfEvzkjMSS4tT8yawMQIA7tNICbEAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEDY&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "1988" + ] + }, + { + "name": "The Zero Theorem", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Zero+Theorem&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiArHyTEsqS3K1FLKTrfTTMnNy9VMyi1KTS_KLrEC8YgUINzXlEaMvt8DLH_eEpVwmrTl5jdGOi6AWITEuNte8ksySSiEeKS4uuMVVTBwMPItYeaJSi_IVQjJS84tScyewMQIA-jBThZwAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEDs&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "2013" + ] + }, + { + "name": "Jabberwocky", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Jabberwocky+1977&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLGMLSoKcrUUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1gFvBKTklKLyvOTsysVDC3NzSewMQIAy0RVRp8AAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEEA&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBwgHBgkIBwgKCgkLDRYPDQwMDRsUFRAWIB0iIiAdHx8kKDQsJCYxJx8fLT0tMTU3Ojo6Iys/RD84QzQ5OjcBCgoKDQwNGg8PGjclHyU3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3N//AABEIALcAeAMBIgACEQEDEQH/xAAcAAAABwEBAAAAAAAAAAAAAAAAAQIDBAUGBwj/xAA7EAACAQIEBAQEAwgCAQUAAAABAgMEEQAFEiEGMUFREyJhcQcUgZEVMkIWM1JiobHR8CPxclOCosHh/8QAGAEBAQEBAQAAAAAAAAAAAAAAAAECAwT/xAAlEQACAgEEAQMFAAAAAAAAAAAAAQIRIQMSMUFRFDLRBCJicfH/2gAMAwEAAhEDEQA/AOoKoGFAYIYUDjgdAiN8A7W2wbqGUq3I9jY/fGO4sz/MODpaerqIpMyyaZtEz2VZaZum/JgelwOXPcYVYNlELsTg5AAMVnD+eZbn1D85lFStRFezAbMh7Mp3BxYOSR64AQRfBBQdsGLnYc8KW3PEAVgMGfMMHt1N8HZcUCPTBjCvKMGCGHlGAAT5cN36YQtVCal6USK06KGdBuVB5X7X6d8KJvvigBwMETgYAVv9MLQYIb4WLDEAVu2Oe/G3MGpuF4cvWwavnAYH+BLObfUJ98buujqpqdkoKuGmmI2klhMoH0DDHnjj+XiR87aHiZy1REP+HSoEWg23S3Q2363540kErZS5JnOY8OZglflU5hnGzAi6yL1Vh1B/6x6B4J4yoeLqJnhHgVsQHzFMTfT6g9Vx5wcnSA1rjEnI83rMkzKHMMumaKeI7EHYjqD6Y01ZqUaPVJGm+FBGttig4T4npuJspSrhtHKotLET+Rr2+17/AO870M45oPcHHMyK0tbcYAC8ibHA1s3piJm2ZUuU5fNW1p0wwi7Hqb8gO5J2AwArNMwosnoJK/MalYaWIXZzv7ADqT0GMblHEmc8Y180GTKcry2CwmqyA83oFuNIb03tzv0xzLifiHMeI6/5mvkKhWJghBvHAOw7nux+m2OyfDijSk4JylVTSZYTM/8AMXYtf+uKdJabjG2XlFRwUNKtNTAhFuTqYszMeZYnck9zh08sGWINibjAI64lnMRgYPBYoHAd9sGG7gYR02wmIJrKhvMOd98QEkWbkpJ9MYr4w0NPUcEVNVMiCekeN4HPManVWAPqCfsMbQKw6tb32xkeLeDq7i2KNK7PflIUJZaWCnDoG7sxILH7egxpA88M5YDvff1wAqnzM1hyBC42vFPw0znh6lmrvEiraCEXeWIaWUd2Q9OXIm2MUDsCQABsfvjR3tSN58LInmzz5eGeQwTjVKv5Qyqwv19CPX6Y70rliQw2/ixxf4HwQ/iVZVTSnW0YSIWJuQN/sOX1+nZx4fRyR2A5Yx2cZDVLZlEh8zSG/sOgHsMcP424kqs5qVpKwIrU3kEMclwrqSrte3MsDbnZe1zfUcdccvkJosqonSOeKMfM7G9xsACOXK/Pe4xiM9y6mzTJn4lykNG8b3rY1bVuzAawOm5ufe+BvSkoytlI6IbGRGv1IN8d+4IrhV8P0cDU1RTzUsSQyQyxNGwIFgRqG4Nuf+Djl3wnyxM5z75qe/hUBWYoN9bG4QfcE/T1x2mZ5Z5PAU+GoXU+g7gHYC/c2P2xEqO31M4yktouNzKniclJOkemAb98IFw6LEFWMCxX+1sK58+mB5Qjf0GBgtvf3wMUCnfQB1vthcQTmq2vhrR4jDVcKOg64koBbthQFchzNu2DHZfL74ULdRg20hRcm59MCFTxLl9bmWRVtBRSRJLUxGLxJPyoG2J5b7XsO+OC8WcBZnw7VQpLLBPTzm0dUDoBe26leYNr972x6OKEjd9scv8AjZnYhoqbIYFVnqT8xM7D92qEabHoSRz7AjrjSNJvo5tlmV59RVbCiRxJGfNuVAtvfcDGzjzjjWlp2mmzeTUDpERjRwN7dV6c999r8ueUjWpzjTGlS0OZRoLSJNpFTGCT+n9SkE/X2xqMiymWCiilMM7w7g+S/mBN+tzv9OfLHHUm4neKbeSBl2QrV1dTV8UO9XUa2N3YgtcE7j6H2I7HEX4eukzZjw5WuFStiKgdmtY2/pjX5lSxzcOVVVNOKGiiABZ4y3iFiPKo57X3tf672r8k4TNLTmnrYpJa/NDEUqY10mimQm6kgkgFS2+1ypXnbCFtXI5y28I1/COQZfksEDZDBapamVKyaSQvHI1gdx1YEnZbAXIJxradFiB1uXcm7O3NsZXhbN0oKCekzyaCjekYidnfyI92BsTzB0sw9Ld8XWR57RZ7Ck1HcRyBjHq2LWJB26cuWOjfk5lk8ifpB2w02/5gDfD3hm5BAAHI98E6i3PADN9rDSMFgyAO31wMALTbrbDovhoc99vQjDgvz6YAdW/8N8De9kNz/bCQdrXb2HM4ALX8qgAem+BCr4rzc5Fw7mGZlkVqeElC3LWdlH3Ix5yrlrZc+QZlUS1FSdAnkclzcqDa/pe3bY47j8T80yROGK/Ls2qwJJlUpBEwErsrBlAHQXAuT0xyPh400EEmd5nJG4D2YNckvsbAeoP9DyxbqJ001my+hoKLI8x8bLyslTDSF5YS2xkuSnt5Qx9vfGvyurp5qNtCrO1O5jYIGDgWsupl2AIsf9OMFk0uY/gNfV1NLWSGaFkFUsDGNbi7MWPXkPS3PFtwdXNSNmTTupqDHTBFFrJLpIZvoCtvX7488tHd7ujTlnAri12zHP8AJsqo6eaWLLyxkiB/e7qWAuDbzK4JPQYhVdXLJW5loqJ2FQyVUCABUijX95dtmDKVNhtyBHO2IY+YfiGnXLK6SgmpoCrVITxGZ9TbWPTYi/fbkcSMkgqaevFPKry1NJRv85c7x3jXVv1Nywx6HXRzRo4KfLpMnqcwzPLagUUkiVDR1TvG9ZMRsLsdRFyd+Vh2vibBSSZCaQU0iQtWhqhaeNAFhAcACP38UbddPviZDmBz7P8AK8ulCiGlgEjx3t4j2PS38ikdLFu2F8eavxnI0opF/EnMixK26hdrG3L8/h7nttjLVqiF7k+dRZiqReMnzRjDlByYfxL3H9r/AHsWUA+Ylm98YHLPlqDjc0Eci+SslSKNSbqhjD2BPOw5j0IHLHQG7Kukf1xQNle4t7YGCbV/2MDADyqT0v8AXCl5/qv3IwXT1w4oUWUn0xSFRxLn9Bw5lbZhmDsBe0caHzzN/Cv+emON8Q/ETiHNnKpUNl1Ix0rFSNZj/wCT8/tbEviaqfijPqqt0ySQU7mloIYVN9QOm/uzW35W9sbThj4Y5VQQCfPYo8yrSbuH/dIeVgv6vc9sVNG62nDFD1E2qzTSO25BLsxv19cajLeGZ6J6eXiOmnSmmikqKeCby/u7atS8xswAv7csd4EWWZHQlkio6CjjtcgLEiXNh6c7Y5VnefS8V8XwrkGWVFXSZfHIsciIdMjsR5j0Augte17YO2huNHx9+0eY065DlmTVBgkltJUwOvhPEDdQDcEDkCDbra4xOzLhkw0VFSUsEQnkKxeMRqs7EyO3soU2B53ttjRUDJSCgy2plQ1j07P5DtaPSGt6XYDE+aBZE0yEkXBB6gg7EHEM2YLPeEEyemhrcphjqIqVAjxzQgyxpclnWQb7klmBB5m3bB5Hl+UyRpmOSU16pJGdqbxtXiwnUrohJI/XqtfdgL26boVSirNMx0yFAyE7BhyNvUYw/FWVVWX57FmGXTLS0lUBHOKe6OsgudY6X033t0xl4yOqJ0OQZfJUw5rHWVUQgjtDPTkh1FtrqQQQVY3BHXFXPDPW8XS53PBLDltNGkcLyxt4lU0YLWSMLq3du2+kW2ONJS5rS0jeFNEA1gPEjG21xc3O3LEj9pMsPPMIbH1Me+/P7HCM4yWBRQcIcLvTsc3zqFafMJapqnwSbmMlWFuZt+dr29O2Nczxn92GODj8NkV44tSsLh0YNqHcYNmH/py37Ff8Y0wNXPa2Bg2k/lI9xgYgHlG4O/0OHBcWIDNbf64SvuB64UCBvrfbfbbFByv4SRLNT5aW2KRtKdr3O4ufW7X+mOpsUvvz9DzxyXKpouEuNJsvqSYqWKrJTbZoZQdJ7WBYb/yntjrJFidJBHbqMYSqzUsnFviHWZlmnFOaZTNXSjKYZIh4GoKg/wCNG3HM+Yk73+mNjw/V0PBnDmWU88gEcsEtVNLdb3uLLbqfMFA7DGR+INFUZfxRXVk0Tilq5A8coHOQQ20W/VyBvyHLnthufOIoayWDN6aoPg0lPR1MS2ABWzkWBvfcj0ufXHQiQ/QZ9U+O/Ek7TzlUMg5ARKzM/hpvvfyryF2A546BwxxRDnFfWJKPBSJVAWVgrahq1bHpa32OOa0mZUOdZdHQUVVTw08bkRxy6lQMWZ117eW3QnY8vQ3VZR0TVktPUk0cMtKmhogQ7qFCvp38pO1yRsD16RtFrwScmki4qzYz1Es0yOz+GsJYLJGumzt/Lq1Wt3sQSMbzOMjps4oPlJy8AVtSPCQrRnlcdOV8c3r6uh4ezWirMoF2p0MlX5y2mLSQAxY33Cg+ptjo+SZ1TZxl0dbT6o0k3CyWDWJ2++IZKOo4Hmhp3egz2ueoUXRKsRtE/KytpQG2w5cjuMVVBw9nwraRqjw6VFYukcoE5UjeyyKQV3vz7DnuMSeIOPqrIs6qsuqcs1gBvAkie5GwKsw/h337EEY0eUZ2K2iD1jLT1Mar8xHq8qMex5EXH9vTEpJlcZJWydR/MijiEsUUThbMke4B9MKYyH8xwsMQdzgMbg3H1xSDLX/VgYIqDyOBiAkbX3wq1mBtq9MNSMI42dr2Aw4pNrggYoMl8QuE14joFnpCsOY0qsI2k8qSofzI/p2PQ/XGFh+I9fTZfBl9UpiraZtLykeaVQLBW7EfxDmADi9+JfFQkE+RUbuCbeNLE1ipBDc+g2F+4PtfmlaZGolBohJTayFmYHUzc2IY/wD2ew99rjJpIuqzjA1FMstZDHWZnHIZI6ir5QAkCy29FH16dcZF6nMcylmqCpdWlMk7xppS57225C2IrqzFIYS1RI+yxaSx9gP/AM74neFWK60UTyrGg1yh4Svhk7kW6+mNcE7NDR1NBS5kMzo6eyiljNTFGQkUjXBuByXkCbevfDdRnD5zPLW1M7pKxDeLGL+HYWsu/lG52979cVPyrSUuqoqzEGsViW1yOnWw232G2G66KCKmjSgq1kie6vFUWjaJh33sQeYI+oGIqNO0ibl+bGKWrM1S8zVDjVIYQTtYCwvbp6/512X8STcP+HTVVKGNJTu8cmu/i6wfDuR0Jbp2PK2MfkfDdRX1KxPKYQHOufWGRAOqkcz9bY0PGdBURZlDlWW0dbmFFQxgeJCWkZ5NIJNl7AgDba7d8MN0Z/ZT5jnlTW5j83mcyz1M8qs3hpbSqiwCjpyGNTwZCDnkU1bUExKCfDKBtShW8pvtuLi56f0j/D+PJpMlz+mzek0kFWSeWMCVWN1Kqx5EMF2v198WPDdFSGctSrO6hvDRpJBsTfa/rvv6DvjnJnacrddG+TO5aph4UUVPTDYMd5G25L0B78wBi1pnD06G3fa5P9Tv98ZTLsqrMxmjmqWaGCO4VWjAJ7WBG2NYECIFXewsCcRZOLCYdhbAwViRgYEF14Hyco1KupebGwHv6Yx/7bw0WUSpWRSU1UkTMkoj1oex2N9ri/bGj4kLDKqlwqgCJryNzHp/vpimzjLsqrM6Z8+q4YYYoljp4fmQhkHMlgLHnyHpjRuG2nZxgyJKZHXM6aolm3dp+bP1J5/277YvKaripKGppK2WF6epZQ0tQSynkdwRe9tVhbawPvtON+GqKkycZxk4RhTEO66taOvK49R6Y5nxZPTvk0Cw+Iky1Xhz3YtrspKsAf5bDawve2K6k6R0SUdPe3Y5Pn+UZIs34FD4mYyqFaqChERb3YIOfW1/TrbFVl0VZm9dT03iyI1RIENlJC36sOvoO2EZHkU9cwSngkmqZP07WQd9+v8AQfTG64LyeSkrqFvBhMzxSSJI7k2KtpKsLXBUnvz9sYnOME/JI6c5dYLyq4IyaTKYYMwQCeGPQKxG8N2t6339jfGGpeDKnMTIcuhklhW41Mh1Xudt+ux3GOjVGbQ1kdMskDmuaoemSk1gIzi2pi1tWkCxuLc98P19HmVM1DAK9KSnnqlhC0EYj8hVifzarG4G46Y8ulqTSyzrLRzVUYzI81bKqJ51yGB2hcqGBYgyA6QtmJsb7dLe2LLL+JI+HWlaojmqKqcFzOwNjc7lj0uT/QDbFdmOVQw8VTOApqKatgSaoa7RyGRfK7L/ABcw3Q8++NbSQJWZ5mNHnNXLUGgjRzchUFwS+w52uv3x0lJB6M4q2ZitmXPEfNPCSSkdw0kUcmkCTlzH5dVrG4/NbvjbfhsUXDk0mW0661iWWB1uSbDV/a4xmRlUudZXmk1K3yk1JFpMkMaqZnK6mRwBYqoNhtfVc3xc8K53mFJkGT5dMtNWZlVhjS+CzKpiG+qQkeUixGwPLF9y5My05cJGvyurTMaCCshtomjD9+mJL7czjN8Jr+EQjh6cSRz04lmS51IYjM+kBuewIG4H+NBHJDMiSwMJ0YXVlbykeh646JJcHCSa5DYjAwNJ5bKP5dzgYpkpeN6o02SVDaBstkZvyg9WO3IDr64yOXVsVFTZe7UdDN88GlqJcyILP5ypQMdgRa5542HEcckuXVK1QjaCRCp1Gyhe7XGwHbv17YigzSoyyGOM0MeYZVVSk06VcG7G97g8tzbna/PfDs7RcdlDlG0FLknFTUCMmSadNKCto2YncoO2/wDQYqOGaWlr6qtWalgqaeCCNiagFkjbSzggkXvbnbo2NBntPxJxLDHQ/hXydEpBK3CBj0vYkkDnYDE/J+HajKNNN4YAlkjeZzIbOysSD5beXkLb7KPTBJ3k25xWnS8kfIsnqaXPY4YKOmyesaiMshW0wsZRtb0UaRfrfEfKIZKjN6LK0nNLPRpVxPVU6AlyJo2L2a4u24PucaCSkrqysSol8RK54jD40MjIqpckfl5d+V+XfC6fhQQyLLEWpnii8NGgmkXYnU1yGBJJJJJ64y4lWvGs+PkytJTj9qssp2nkVKesq6f56ILqklK6rtqBGohtPLptbF/xJRtDV5NTrX1TvU11laZlJitE4uLAW33xM/Z0LRfh0sNO1IW1q0etGR7lterVq1XPO9/phNRwv8zUQVLZjVCogkEiy+MSdQFhzBAFr8u5xNhp68ZST8FPLldJVcG5xR2KZxCddaHl1u0qnWG1Hcqy30+jH1wx8pVGbhqpZleTN45Ia5m66z4h/wDjqHsBjWz5SaivFeZAlR4Rido2YCRD0ccj19r4UmXyRvSh0gaOjt8tuRp8hS9wLnZrYuwnqaVc/wAoz3BN6fKM+iqNpKerm8Yt/wCN74peCaSqy3iDIVqmJ+ay6RoVf9Ny7aR9Bf8A93tjX1mQJVT1UrFo1rNIq4Y5isdRp5axa/obEXGxviTVZOtUIGk0LUQNrhmjchojax03BABG1rWxNhr1S+78vgo+IPEbithJG7UfySfO+HfX4Ws8u4vbVb9N8T8yrpcsz3KainqIlyutBheNZNUatbyMo6X25bWGHqHKXoszarnkepqmjaPXLUaroWLWICC1jsLAC1hv1q5crWql/B46cCjaUVc0GsFaZQSAiWXbWdRt21W9dVRzjOMmr6RoMvzGWvnqiQPk0cCnmS//ADbeYgdgdgeuBh2nkqjoDQpHGeVzYIB0t9rYGKedtN4GOKsuqM1ySqpaZ1Lug/42Ng9mvYn1tbEXJ4GzKnl+doFp6YODHDruyuDubA+W3bnzvi7lUyJa4vz364gJIkEjLEyllc6tTW2sL3+p9eWDKuCZHC0TxKhYQoD5Sb+3qfviSVW4YAahyOGUYlFJIJIubG4wsHlfEMjsaRoulQFH8owiXVyj1EDvgG2CYkAbnADd2YWbnhKbXwmWoCSFAoLqoZgWtYEm39j9sNiqIkKSRBT10SBhuduYHcffAtMfvtgXBw2amNADKphHUybAe55YAqU8UIF2PJ+a/f8A3pgKY4o1Dy4PQ1+uDBCgnYDucMzVL2Ap4/GN7NvYD64ooeESiXWHa5NyL7HpuMVGTTo9LJX3bxKuQys6oSNHJB9EA27k4sTG0lmlfb+FSdI9++I9Ky0Efy06qsUW0chFkK9ATyBF7b8+nbENLhkiOokkn0qo0AXOsWJ7EDr74GGvHSWVGiN0UG7dDfsev07YGBKJMpfw28K2u21zYXw0kKpI7nzO+xuABy/2+BgYEHUew2UAYPXfAwMABSXAJ5jCied8DAwA08UbMrOisw5Egfb2wGRC2rQpYdbYGBgAeUsLi9t98B442WzRoR1uoOBgYAZeCHxfF8JbgWVdIth0FzazWB6YGBgAwSNumDYgDrgsDAoYTULvvgsDAwIf/9k=", + "extensions": [ + "1977" + ] + }, + { + "name": "Monty Python's The Meaning of Life", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Monty+Python%27s+The+Meaning+of+Life&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLEMU0xSirQUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1iVfPPzSioVAipLMvLz1IsVQjJSFXxTE_My89IV8tMUfDLTUiewMQIAyGn8iLEAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEEU&tbs=kac:1,kac_so:0", + "image": "data:image/jpeg;base64,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", + "extensions": [ + "1983" + ] + }, + { + "name": "Tideland", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Tideland+(film)&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLHSTIrK0rQUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1j5QzJTUnMS81IUNED6NCewMQIASsloBZ4AAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEEo&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "2005" + ] + }, + { + "name": "The Brothers Grimm", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Brothers+Grimm+(film)&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLFMqoxMzbUUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1glQzJSFZyK8ksyUouKFdyLMnNzFTRAJmhOYGMEAIBXqc-oAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEE8&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "2005" + ] + }, + { + "name": "And Now for Something Completely Different", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=And+Now+for+Something+Completely+Different&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLGMiityy7UUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1i1HPNSFPzyyxXS8osUgvNzU0syMvPSFZzzcwtyUktScyoVXDLT0lKLUvNKJrAxAgB7coaNuQAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEFQ&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "1971" + ] + }, + { + "name": "The Carnival at the End of Days", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Carnival+at+the+End+of+Days&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHi1U_XNzQsKzEpyElKqdJSyE620k_LzMnVT8ksSk0uyS-yAvGKFSDc1JRHjL7cAi9_3BOWcpm05uQ1RjsuglqExLjYXPNKMksqhXikuLjgdlcxcTDwLGKVD8lIVXBOLMrLLEvMUUgsUSgB8l3zUhTy0xRcEiuLJ7AxAgDOfEXCsgAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEFk&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "the End of Days" + ] + }, + { + "name": "The Holy Grail", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Holy+Grail+Film&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHi1U_XNzQsSS42MzSNN9dSyE620k_LzMnVT8ksSk0uyS-yAvGKFSDc1JRHjL7cAi9_3BOWcpm05uQ1RjsuglqExLjYXPNKMksqhXikuLjgdlcxcTDwLGIVDslIVfDIz6lUcC9KzMxRcANqnsDGCACaeQUUpgAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEF4&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "The Holy Grail" + ] + }, + { + "name": "The Crimson Permanent Assurance", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Crimson+Permanent+Assurance&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiBLGMjXIqzbUUspOt9NMyc3L1UzKLUpNL8ousQLxiBQg3NeURoy-3wMsf94SlXCatOXmN0Y6LoBYhMS4217ySzJJKIR4pLi64vVVMHAw8i1jlQzJSFZyLMnOL8_MUAlKLchPzUvNKFByLi0uLEvOSUyewMQIA9kujqa4AAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEGM&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "1983" + ] + }, + { + "name": "Story Time", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Story+Time+(film)&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiArGyzLNycrK0FLKTrfTTMnNy9VMyi1KTS_KLrEC8YgUINzXlEaMvt8DLH_eEpVwmrTl5jdGOi6AWITEuNte8ksySSiEeKS4uuMVVTBwMPItYBYOBWioVQjJzUxU0QDo1J7AxAgAdctWboQAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEGg&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "1979" + ] + }, + { + "name": "The Wholly Family", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Wholly+Family&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiArEycpOzs0q0FLKTrfTTMnNy9VMyi1KTS_KLrEC8YgUINzXlEaMvt8DLH_eEpVwmrTl5jdGOi6AWITEuNte8ksySSiEeKS4uuMVVTBwMPItYBUMyUhXCM_JzcioV3BJzM3MqJ7AxAgBQZoLpoQAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEG0&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "2011" + ] + }, + { + "name": "Miracle of Flight", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Miracle+of+Flight&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiArHSs6uScsu0FLKTrfTTMnNy9VMyi1KTS_KLrEC8YgUINzXlEaMvt8DLH_eEpVwmrTl5jdGOi6AWITEuNte8ksySSiEeKS4uuMVVTBwMPItYBX0zixKTc1IV8tMU3HIy0zNKJrAxAgCCGVlloQAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEHI&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "1974" + ] + }, + { + "name": "The Legend of Hallowdega", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=The+Legend+of+Hallowdega&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHiArEyDPPKDUy1FLKTrfTTMnNy9VMyi1KTS_KLrEC8YgUINzXlEaMvt8DLH_eEpVwmrTl5jdGOi6AWITEuNte8ksySSiEeKS4uuMVVTBwMPItYJUIyUhV8UtNT81IU8tMUPBJzcvLLU1LTEyewMQIAPk27fKgAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEHc&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "2010" + ] + }, + { + "name": "Джаббервоки", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=terry+gilliam+%D0%B4%D0%B6%D0%B0%D0%B1%D0%B1%D0%B5%D1%80%D0%B2%D0%BE%D0%BA%D0%B8&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHi1U_XNzQsNs81MKoyStJSyE620k_LzMnVT8ksSk0uyS-yAvGKFSDc1JRHjL7cAi9_3BOWcpm05uQ1RjsuglqExLjYXPNKMksqhXikuLjgdlcxcTDwLGJVKUktKqpUSM_MyclMzFW4sOXCtgsbLmwEwq0XGy5surDvwq4LOyawMQIAHutIrrcAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BAgbEHw&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "Джаббервоки" + ] + }, + { + "name": "La Cage", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=La+Cage+Film&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHi1U_XNzTMyTDOSzMzTdJSyE620k_LzMnVT8ksSk0uyS-yAvGKFSDc1JRHjL7cAi9_3BOWcpm05uQ1RjsuglqExLjYXPNKMksqhXikuLjgdlcxcTDwLGLl8UlUcE5MT1VwA-qawMYIANBxMGWfAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BQgbEIEB&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "La Cage" + ] + }, + { + "name": "Secret Tournament", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Secret+Tournament+Film&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHi1U_XNzQstCjLS49Pq9JSyE620k_LzMnVT8ksSk0uyS-yAvGKFSDc1JRHjL7cAi9_3BOWcpm05uQ1RjsuglqExLjYXPNKMksqhXikuLjgdlcxcTDwLGIVC05NLkotUQjJLy3KS8xNzStRcAPqn8DGCABUgVDBqQAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BQgbEIYB&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "Tournament" + ] + }, + { + "name": "Mr. Vertigo", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Mr.+Vertigo+Film&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHi1U_XNzRMKzc1TDfJNdFSyE620k_LzMnVT8ksSk0uyS-yAvGKFSDc1JRHjL7cAi9_3BOWcpm05uQ1RjsuglqExLjYXPNKMksqhXikuLjgdlcxcTDwLGIV8C3SUwhLLSrJTM9XcAPqnMDGCAD_WCUlowAAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BQgbEIsB&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "Mr. Vertigo" + ] + }, + { + "name": "Monty Python Live at the Hollywood Bowl", + "link": "https://www.google.com/search?sca_esv=978abaad62f62cb1&rlz=1C5CHFA_enGE1115GE1118&q=Monty+Python+Live+at+the+Hollywood+Bowl+Film&stick=H4sIAAAAAAAAAONgFuLQz9U3MM8wTVHi1U_XNzTMSSmoiq8sLtNSyE620k_LzMnVT8ksSk0uyS-yAvGKFSDc1JRHjL7cAi9_3BOWcpm05uQ1RjsuglqExLjYXPNKMksqhXikuLjgdlcxcTDwLGLV8c3PK6lUCKgsycjPU_DJLEtVSCxRKMlIVfDIz8mpLM_PT1Fwyi_PUXADmjqBjREAiuf7U78AAAA&sa=X&ved=2ahUKEwiqsp6YuteUAxXNUUEAHSfrN6gQ-BZ6BQgbEJAB&tbs=kac:1,kac_so:0", + "image": null, + "extensions": [ + "Hollywood Bowl" + ] + } + ] +} \ No newline at end of file diff --git a/spec/fixtures/source-html/movies-directed-by-Terry-Gilliam-Google-Search.html b/spec/fixtures/source-html/movies-directed-by-Terry-Gilliam-Google-Search.html new file mode 100644 index 00000000..6b8e94c7 --- /dev/null +++ b/spec/fixtures/source-html/movies-directed-by-Terry-Gilliam-Google-Search.html @@ -0,0 +1,95 @@ + + +movies directed by Terry Gilliam - Google Search
Quick Settings

Search Results

Terry Gilliam/Films directed
Feedback
AI Overview
Terry Gilliam is an acclaimed American-British filmmaker and former member of the Monty Python comedy troupe. Known for his highly surreal, satirical, and visually imaginative cinematic style, his directorial portfolio ranges from low-budget absurdist comedy to sweeping dystopian and magical-realist epics.
His directed feature films, shorts, and concert films are organized below:
Something went wrong with this response.
  • Terry Gilliam - IMDb
    Director. Upcoming. 1. Carnival at the End of Days. director. Pre-production. 19. The Man Who Killed Don Quixote. 6.3. Director. 2...
    IMDb
  • Films directed by Terry Gilliam - Letterboxd
    Monty Python and the Holy Grail (1975) Fear and Loathing in Las Vegas (1998) Twelve Monkeys (1995) Brazil (1985) The Fisher King (
    Letterboxd
  • Terry Gilliam - Simple English Wikipedia, the free encyclopedia
    Terrence Vance Gilliam (born November 22, 1940) is an American-British cartoonist and filmmaker. He was born in Minnesota and grew...
    Wikipedia
Show all
Oops, something went wrong.
AI can make mistakes, so double-check responses
Google apps
\ No newline at end of file diff --git a/spec/layouts/i_elo6_spec.rb b/spec/layouts/i_elo6_spec.rb index d356b298..10e08eb4 100644 --- a/spec/layouts/i_elo6_spec.rb +++ b/spec/layouts/i_elo6_spec.rb @@ -24,4 +24,12 @@ it { expect(layout.extension(node)).to be_nil } end + + describe "#link" do + let(:node) { Nokolexbor::HTML('
').css(".iELo6").first } + + it "converts relative href to absolute" do + expect(layout.link(node)).to eq("https://www.google.com/search?q=Starry+Night") + end + end end diff --git a/spec/layouts/j_cuz_jd_spec.rb b/spec/layouts/j_cuz_jd_spec.rb index 3b892608..cff2d901 100644 --- a/spec/layouts/j_cuz_jd_spec.rb +++ b/spec/layouts/j_cuz_jd_spec.rb @@ -6,4 +6,12 @@ it { expect(layout.item_selector).to eq(".jCuzJd") } it { expect(layout).to be_a(Layouts::GridTile) } + + describe "#link" do + let(:node) { Nokolexbor::HTML('
').css(".jCuzJd").first } + + it "preserves absolute href unchanged" do + expect(layout.link(node)).to eq("https://www.google.com/search?q=Joaquin+Phoenix") + end + end end diff --git a/spec/layouts/klitem_tr_spec.rb b/spec/layouts/klitem_tr_spec.rb new file mode 100644 index 00000000..2121e678 --- /dev/null +++ b/spec/layouts/klitem_tr_spec.rb @@ -0,0 +1,70 @@ +require "spec_helper" +require "layouts/klitem_tr" + +RSpec.describe Layouts::KlitemTr do + subject(:layout) { described_class.new } + + it { expect(layout.item_selector).to eq("a.klitem-tr") } + it { expect(layout.image_selector).to eq("img.VeBrne") } + + let(:html) do + <<~HTML + +
+ +
Brazil
+
1985
+
+
+ HTML + end + + let(:node) { Nokolexbor::HTML(html).css("a.klitem-tr").first } + + describe "#name" do + it { expect(layout.name(node)).to eq("Brazil") } + end + + describe "#extension" do + it { expect(layout.extension(node)).to eq("1985") } + end + + describe "#extension with multi-part title" do + let(:html) do + <<~HTML + +
+ +
Monty Python
+
and the Holy Grail
+
1975
+
+
+ HTML + end + + it "returns the last FozYP as extension" do + expect(layout.extension(node)).to eq("1975") + end + + it "reads name from aria-label not FozYP" do + expect(layout.name(node)).to eq("Monty Python and the Holy Grail") + end + end + + describe "#extension when absent" do + let(:html) do + <<~HTML + +
+
+ HTML + end + + it { expect(layout.extension(node)).to be_nil } + end + + describe "#link" do + it { expect(layout.link(node)).to eq("https://www.google.com/search?q=Brazil") } + end +end From 8d5cf75ac418af59a40127cb9f7a0467fad3157f Mon Sep 17 00:00:00 2001 From: Brent Date: Tue, 26 May 2026 19:53:00 +0200 Subject: [PATCH 07/16] Use `at_css` instead of `css(...).first` --- lib/carousel_item.rb | 2 +- lib/layouts/grid_tile.rb | 6 +++--- lib/layouts/i_elo6.rb | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/lib/carousel_item.rb b/lib/carousel_item.rb index 3f5c527d..cef60405 100644 --- a/lib/carousel_item.rb +++ b/lib/carousel_item.rb @@ -31,7 +31,7 @@ def link end def image - img = @node.css(@layout.image_selector).first + img = @node.at_css(@layout.image_selector) return unless img @images[img.attr("id")] || img.attr("data-src") diff --git a/lib/layouts/grid_tile.rb b/lib/layouts/grid_tile.rb index 18b06aef..9ced19cf 100644 --- a/lib/layouts/grid_tile.rb +++ b/lib/layouts/grid_tile.rb @@ -3,8 +3,8 @@ module Layouts # Subclasses override item_selector only — Google rotates the wrapper class independently. class GridTile def image_selector = "img.d7ENZc" - def name(node) = node.css(".JjtOHd").first&.text - def extension(node) = node.css(".cHaqb").first&.text - def link(node) = node.css("a").first&.attr("href") + def name(node) = node.at_css(".JjtOHd")&.text + def extension(node) = node.at_css(".cHaqb")&.text + def link(node) = node.at_css("a")&.attr("href") end end diff --git a/lib/layouts/i_elo6.rb b/lib/layouts/i_elo6.rb index 5be91be6..144347c7 100644 --- a/lib/layouts/i_elo6.rb +++ b/lib/layouts/i_elo6.rb @@ -3,11 +3,11 @@ module Layouts class IELo6 def item_selector = ".iELo6" def image_selector = "img.taFZJe" - def name(node) = node.css(".pgNMRc").first&.text - def extension(node) = node.css(".cxzHyb").first&.text + def name(node) = node.at_css(".pgNMRc")&.text + def extension(node) = node.at_css(".cxzHyb")&.text def link(node) - href = node.css("a").first&.attr("href") + href = node.at_css("a")&.attr("href") href&.start_with?("/") ? "https://www.google.com#{href}" : href end end From b2ea353ba02b570ce4c082fd09fb68ce9be73060 Mon Sep 17 00:00:00 2001 From: Brent Date: Tue, 26 May 2026 20:09:35 +0200 Subject: [PATCH 08/16] Make selectors resilient to class-name rotation. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Only item_selectors (.iELo6, .jCuzJd etc.) now need updating when Google rotates CSS — name, extension, and image resolve via structural invariants: XPath text-node order and img[id]/img[data-src] attributes. --- lib/layouts/grid_tile.rb | 12 +++++++++--- lib/layouts/i_elo6.rb | 12 +++++++++--- lib/layouts/klitem_tr.rb | 19 +++++++++++++------ spec/layouts/i_elo6_spec.rb | 6 +++--- spec/layouts/klitem_tr_spec.rb | 4 ++-- 5 files changed, 36 insertions(+), 17 deletions(-) diff --git a/lib/layouts/grid_tile.rb b/lib/layouts/grid_tile.rb index 9ced19cf..95a96345 100644 --- a/lib/layouts/grid_tile.rb +++ b/lib/layouts/grid_tile.rb @@ -2,9 +2,15 @@ module Layouts # Shared selectors for Google's grid-tile carousel component (actors, albums, etc.). # Subclasses override item_selector only — Google rotates the wrapper class independently. class GridTile - def image_selector = "img.d7ENZc" - def name(node) = node.at_css(".JjtOHd")&.text - def extension(node) = node.at_css(".cHaqb")&.text + def image_selector = "img[id], img[data-src]" + def name(node) = text_nodes(node).first + def extension(node) = text_nodes(node)[1] def link(node) = node.at_css("a")&.attr("href") + + private + + def text_nodes(node) + node.xpath(".//text()[normalize-space()]").map { |t| t.text.strip }.reject(&:empty?) + end end end diff --git a/lib/layouts/i_elo6.rb b/lib/layouts/i_elo6.rb index 144347c7..12a1507f 100644 --- a/lib/layouts/i_elo6.rb +++ b/lib/layouts/i_elo6.rb @@ -2,13 +2,19 @@ module Layouts # Google carousel layout used for paintings, artworks, and similar knowledge-panel carousels. class IELo6 def item_selector = ".iELo6" - def image_selector = "img.taFZJe" - def name(node) = node.at_css(".pgNMRc")&.text - def extension(node) = node.at_css(".cxzHyb")&.text + def image_selector = "img[id], img[data-src]" + def name(node) = text_nodes(node).first + def extension(node) = text_nodes(node)[1] def link(node) href = node.at_css("a")&.attr("href") href&.start_with?("/") ? "https://www.google.com#{href}" : href end + + private + + def text_nodes(node) + node.xpath(".//text()[normalize-space()]").map { |t| t.text.strip }.reject(&:empty?) + end end end diff --git a/lib/layouts/klitem_tr.rb b/lib/layouts/klitem_tr.rb index 5008c87a..f1873681 100644 --- a/lib/layouts/klitem_tr.rb +++ b/lib/layouts/klitem_tr.rb @@ -1,11 +1,18 @@ module Layouts # Google carousel layout used for movies and filmography carousels. - # The item is the anchor itself — name comes from aria-label, year from last .FozYP. + # The item is the anchor itself — name from aria-label, extension by excluding title text nodes. class KlitemTr - def item_selector = "a.klitem-tr" - def image_selector = "img.VeBrne" - def name(node) = node.attr("aria-label") - def extension(node) = node.css(".FozYP").last&.text - def link(node) = node.attr("href") + def item_selector = "a.klitem-tr" + def image_selector = "img[id], img[data-src]" + def name(node) = node.attr("aria-label") + def link(node) = node.attr("href") + + def extension(node) = text_nodes(node).last + + private + + def text_nodes(node) + node.xpath(".//text()[normalize-space()]").map { |t| t.text.strip }.reject(&:empty?) + end end end diff --git a/spec/layouts/i_elo6_spec.rb b/spec/layouts/i_elo6_spec.rb index 10e08eb4..f8701c57 100644 --- a/spec/layouts/i_elo6_spec.rb +++ b/spec/layouts/i_elo6_spec.rb @@ -5,16 +5,16 @@ subject(:layout) { described_class.new } it { expect(layout.item_selector).to eq(".iELo6") } - it { expect(layout.image_selector).to eq("img.taFZJe") } + it { expect(layout.image_selector).to eq("img[id], img[data-src]") } describe "#name" do - let(:node) { Nokolexbor::HTML('
The Starry Night
').css(".iELo6").first } + let(:node) { Nokolexbor::HTML('
The Starry Night
').css(".iELo6").first } it { expect(layout.name(node)).to eq("The Starry Night") } end describe "#extension" do - let(:node) { Nokolexbor::HTML('
1889
').css(".iELo6").first } + let(:node) { Nokolexbor::HTML('
The Starry Night
1889
').css(".iELo6").first } it { expect(layout.extension(node)).to eq("1889") } end diff --git a/spec/layouts/klitem_tr_spec.rb b/spec/layouts/klitem_tr_spec.rb index 2121e678..5cc2111e 100644 --- a/spec/layouts/klitem_tr_spec.rb +++ b/spec/layouts/klitem_tr_spec.rb @@ -5,7 +5,7 @@ subject(:layout) { described_class.new } it { expect(layout.item_selector).to eq("a.klitem-tr") } - it { expect(layout.image_selector).to eq("img.VeBrne") } + it { expect(layout.image_selector).to eq("img[id], img[data-src]") } let(:html) do <<~HTML @@ -43,7 +43,7 @@ HTML end - it "returns the last FozYP as extension" do + it "returns the year, not a title fragment" do expect(layout.extension(node)).to eq("1975") end From 696783e6ef7ed1e924d113ab2e6c8179f60762bc Mon Sep 17 00:00:00 2001 From: Brent Date: Tue, 26 May 2026 20:16:42 +0200 Subject: [PATCH 09/16] Remove `bin/clean-html` and its README docs --- README.md | 37 ++++++------------------------------- bin/clean-html | 26 -------------------------- 2 files changed, 6 insertions(+), 57 deletions(-) delete mode 100755 bin/clean-html diff --git a/README.md b/README.md index 34ad8fcb..505884a0 100644 --- a/README.md +++ b/README.md @@ -27,23 +27,12 @@ markup, inline scripts, base64 images, and lazy-loading machinery. Feeding it di an LLM as context is impractical: it exceeds context limits and makes it nearly impossible to reason about structure. -**First attempt — strip the noise.** `bin/clean-html` uses Nokolexbor to parse the page -and remove all ` + + HTML + end + + it "extracts the image" do + expect(images["_dq123"]).to eq("data:image/jpeg;base64,DQBASE64==") + end + end + context "when the base64 string contains JavaScript hex escapes" do let(:html) do <<~HTML From 9f55fe84a6656f105b4a345f86268d3b3061229e Mon Sep 17 00:00:00 2001 From: Brent Date: Tue, 26 May 2026 21:06:44 +0200 Subject: [PATCH 12/16] Use named captures in ImageExtractor regex. - Split PATTERN into S_PART/II_PART named-capture sub-patterns for readability - Reference captures by name (:src, :ids) instead of positional index - Named backreference `\k` enforces matching quote chars, rejecting mismatched-quote scripts --- lib/image_extractor.rb | 8 ++++--- spec/image_extractor_spec.rb | 44 ++++++++++++++++++++++++++++++++++++ 2 files changed, 49 insertions(+), 3 deletions(-) diff --git a/lib/image_extractor.rb b/lib/image_extractor.rb index 1fa54f8c..6d9c18d0 100644 --- a/lib/image_extractor.rb +++ b/lib/image_extractor.rb @@ -2,7 +2,9 @@ # Parses inline script tags to build an id-to-base64-image lookup map. class ImageExtractor - PATTERN = /var s=(['"])(data:image[^'"]+)\1;var ii=(\[[^\]]+\])/ + S_PART = /var s=(?['"])(?data:image[^'"]+)\k/ + II_PART = /var ii=(?\[[^\]]+\])/ + PATTERN = /#{S_PART};#{II_PART}/ def initialize(doc) @map = build(doc) @@ -19,8 +21,8 @@ def build(doc) match = script.text.match(PATTERN) next unless match - src = match[2].gsub('\x3d', "=") - ids = match[3].scan(/['"]([^'"]+)['"]/).flatten + src = match[:src].gsub('\x3d', "=") + ids = match[:ids].scan(/['"]([^'"]+)['"]/).flatten ids.each { |id| map[id] = src } end diff --git a/spec/image_extractor_spec.rb b/spec/image_extractor_spec.rb index ec2fd787..0b690759 100644 --- a/spec/image_extractor_spec.rb +++ b/spec/image_extractor_spec.rb @@ -53,4 +53,48 @@ expect(images["_esc123"]).to eq("data:image/jpeg;base64,FAKEBASE64==") end end + + context "when the script has mismatched quotes" do + let(:html) do + <<~HTML + + + + HTML + end + + it "does not extract the image" do + expect(images["_bad"]).to be_nil + end + end + + context "when a script tag contains multiple ids" do + let(:html) do + <<~HTML + + + + HTML + end + + it "maps all ids to the same image" do + expect(images["_id1"]).to eq("data:image/jpeg;base64,SHARED==") + expect(images["_id2"]).to eq("data:image/jpeg;base64,SHARED==") + expect(images["_id3"]).to eq("data:image/jpeg;base64,SHARED==") + end + end + + context "when no script tags contain image data" do + let(:html) do + <<~HTML + + + + HTML + end + + it "returns an empty map" do + expect(images["_anything"]).to be_nil + end + end end From f73e79d11d22c151dd46e3dffd1e56295aa366e9 Mon Sep 17 00:00:00 2001 From: Brent Date: Wed, 27 May 2026 10:20:44 +0200 Subject: [PATCH 13/16] Clean up readme. --- README.md | 72 +++++++++++++++++++++++++++++++------------------------ 1 file changed, 41 insertions(+), 31 deletions(-) diff --git a/README.md b/README.md index 505884a0..181afda9 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,8 @@ bundle install lefthook install ``` +### Run tests + ```bash bundle exec rspec ``` @@ -18,45 +20,30 @@ bundle exec rspec The challenge HTML file has been moved from `files/van-gogh-paintings.html` to `spec/fixtures/source-html/van-gogh-paintings.html`, and the expected output from `files/expected-array.json` to `spec/fixtures/json-result/van-gogh-paintings.json`, -to co-locate them with the integration tests. +to co-locate them for the integration tests. Adding new files to this directory automatically adds them to the integration test. ## Approach -The HTML file (`van-gogh-paintings.html`) is a full Google search result page — 12MB of -markup, inline scripts, base64 images, and lazy-loading machinery. Feeding it directly to -an LLM as context is impractical: it exceeds context limits and makes it nearly impossible -to reason about structure. +Feeding (`van-gogh-paintings.html`) — 12MB of markup directly to an LLM as context is impractical: it exceeds context limits and makes it nearly impossible to reason about structure. -**Serve and inspect live.** Rather than reading raw HTML, we run a local HTTP server -(`bin/serve-html`) and connect Playwright CLI to it. This lets Claude drive a real browser -against the page, query the live DOM, and understand exactly how elements are structured — -class names, image injection patterns, lazy-loading ids — without ever having to read the -raw file. Playwright's `eval` can extract structured data from any selector in a single -round-trip. +Run local HTTP server (`bin/serve-html`) - Serves the `spec/fixtures/source-html/` directory over HTTP so HTML fixtures can be opened. -### Image extraction — three cases +Ask claude to call the Playwright CLI. -Google uses two different thumbnail strategies in the same carousel, confirmed by inspecting -the live DOM with Playwright: +This allows Claude to drive a real browser against the page, - queries are more manageable. -1. **Visible items (first ~8)** — the `` has an `id` attribute (e.g. `_L_FkZ4q...`). - The actual jpeg is stored in an inline ` + + HTML + end + + it "still extracts the image" do + expect(images["_abc123"]).to eq("data:image/jpeg;base64,FAKEBASE64==") + end + end + context "when no script tags contain image data" do let(:html) do <<~HTML