lookbook_visual_tester 0.1.6 → 0.5.0

data/lib/lookbook_visual_tester/preview_checker.rb

@@ -0,0 +1,260 @@
+require 'concurrent'
+require 'benchmark'
+
+module LookbookVisualTester
+  class PreviewChecker
+    CheckResult = Struct.new(:preview_name, :example_name, :status, :error, :backtrace, :duration,
+                             keyword_init: true)
+    MissingResult = Struct.new(:component_path, keyword_init: true)
+
+    def initialize(config = LookbookVisualTester.config)
+      @config = config
+    end
+
+    def check
+      run_checks(:basic_check)
+    end
+
+    def deep_check
+      # Ensure custom setup is run before deep checks
+      run_setup
+      run_checks(:deep_render_check)
+    end
+
+    def missing
+      components_dir = Rails.root.join(@config.components_folder)
+      # Assuming standard structure: test/components/previews for previews
+      # But Lookbook can be configured differently. We should use Lookbook's config if possible to know where previews are.
+      # For now, let's stick to the user's script logic which assumes standard paths or iterate through loaded components.
+
+      # Better approach: Iterate through all known components and check if they have a preview.
+      # However, "all known components" might be hard to get if they aren't loaded.
+      # Let's use the file system approach as in the user script.
+
+      components = Dir.glob(File.join(components_dir, '**', '*_component.rb'))
+      previews_dir = Rails.root.join('test/components/previews') # Default, maybe make configurable?
+
+      # Trying to find where previews are located from Rails config if possible
+      if defined?(Rails) && Rails.application.config.view_component.preview_paths.any?
+        # Use simple heuristic: first path
+        previews_dir = Pathname.new(Rails.application.config.view_component.preview_paths.first)
+      end
+
+      missing = []
+      components.each do |component_path|
+        next if component_path.end_with?('application_component.rb')
+        next if component_path.include?('/concerns/')
+
+        relative_path = Pathname.new(component_path).relative_path_from(components_dir).to_s
+        preview_relative_path = relative_path.sub('_component.rb', '_component_preview.rb')
+        preview_path = File.join(previews_dir, preview_relative_path)
+
+        missing << MissingResult.new(component_path: relative_path) unless File.exist?(preview_path)
+      end
+      missing
+    end
+
+    private
+
+    def run_checks(check_method)
+      previews = Lookbook.previews
+      results = []
+
+      # We want to flatten the work items: (PreviewClass, example_name)
+      work_items = []
+      previews.each do |preview|
+        # preview is a Lookbook::Preview object which wraps the class
+        # But for checking we might want the class directly or iterate examples
+        examples = preview.examples
+        examples.each do |example|
+          work_items << { preview: preview, example: example }
+        end
+      end
+
+      if @config.threads > 1
+        pool = Concurrent::FixedThreadPool.new(@config.threads)
+        promises = work_items.map do |item|
+          Concurrent::Promises.future_on(pool) do
+            measure_and_send(item[:preview], item[:example], check_method)
+          end
+        end
+        results = Concurrent::Promises.zip(*promises).value
+        pool.shutdown
+        pool.wait_for_termination
+      else
+        results = work_items.map do |item|
+          measure_and_send(item[:preview], item[:example], check_method)
+        end
+      end
+
+      results
+    end
+
+    def measure_and_send(preview, example, method_name)
+      result = nil
+      time = Benchmark.realtime do
+        result = send(method_name, preview, example)
+      end
+      result.duration = time
+      result
+    end
+
+    def basic_check(preview, example)
+      # user script logic:
+      # preview_instance = preview_class.new
+      # component = preview_instance.public_send(preview_example)
+      # if component.respond_to?(:render_in) ...
+
+      # Lookbook::Preview wrapper might help, but let's go to the class
+      preview_class = preview.preview_class
+      example_name = example.name
+
+      begin
+        preview_instance = preview_class.new
+        preview_instance.public_send(example_name)
+
+        # We don't render, just verify we can call it.
+        CheckResult.new(preview_name: preview.name, example_name: example_name, status: :passed)
+      rescue StandardError => e
+        CheckResult.new(preview_name: preview.name, example_name: example_name, status: :failed,
+                        error: e.message, backtrace: e.backtrace)
+      end
+    end
+
+    def deep_render_check(preview, example)
+      preview_class = preview.preview_class
+      example_name = example.name
+
+      begin
+        preview_instance = preview_class.new
+        result = preview_instance.public_send(example_name)
+
+        if result.respond_to?(:render_in)
+          # Mock current_user/pundit if needed on the component itself if possible
+          # But mainly we render it with a view context
+          view_context = setup_view_context
+
+          # Inject mocks into result if it supports it or reliance on global view_context
+          # The user script defines singleton methods on the result.
+          if @mocks
+            @mocks.each do |key, value|
+              if result.respond_to?(key) || !result.respond_to?(key) # Force define
+                result.define_singleton_method(key) { value }
+              end
+            end
+          end
+
+          result.render_in(view_context)
+        elsif result.is_a?(String)
+          # Rendered string, good.
+        end
+
+        CheckResult.new(preview_name: preview.name, example_name: example_name, status: :passed)
+      rescue StandardError => e
+        CheckResult.new(preview_name: preview.name, example_name: example_name, status: :failed,
+                        error: e.message, backtrace: e.backtrace)
+      end
+    end
+
+    def run_setup
+      if @config.preview_checker_setup
+        @config.preview_checker_setup.call
+      else
+        default_setup
+      end
+    end
+
+    def default_setup
+      # Logic from the user's script
+      # We need to set up a controller and view context globally or for use in checks
+
+      # This part is tricky because we need to make these available to the `deep_render_check` method.
+      # We can store the view_context in an instance variable or re-create it.
+
+      # Let's perform the class-level mocks here (User, etc.)
+
+      # Mock User
+      unless defined?(User)
+        # Defining a dummy user if not exists is risky if the app doesn't have User.
+        # But the script assumes User exists or creates a mock.
+        # Let's create a OpenStruct-like mock for typical Devise/Pundit usage.
+      end
+
+      # The script logic:
+      # controller = ApplicationController.new ...
+      # We will do this in `setup_view_context` called per check or once?
+      # `ApplicationController` might not be thread safe if we modify it?
+      # Actually we create a new controller instance.
+
+      # Define @mocks to be injected
+      @mocks = {}
+      @mocks[:current_user] = build_mock_user
+      @mocks[:pundit_user] = @mocks[:current_user]
+    end
+
+    def build_mock_user
+      # Try to load a real user or build a struct
+      if defined?(User) && User.respond_to?(:first) && User.first
+        User.first
+      else
+        # Fallback mock
+        u = Object.new
+        u.define_singleton_method(:email) { 'test@example.com' }
+        u.define_singleton_method(:id) { 1 }
+        # Add other common methods as needed or let them fail/mock dynamic
+        u
+      end
+    end
+
+    def setup_view_context
+      # We need a controller to get a view context
+      controller = if defined?(ApplicationController)
+                     ApplicationController.new
+                   else
+                     ActionController::Base.new
+                   end
+
+      controller.request = ActionDispatch::TestRequest.create
+      if controller.request.env
+        controller.request.env['rack.session'] = {}
+        controller.request.env['rack.session.options'] = { id: SecureRandom.uuid }
+      end
+
+      # Devise mapping
+      if defined?(Devise)
+        controller.request.env['devise.mapping'] = Devise.mappings[:user] if Devise.mappings[:user]
+
+        # Mock warden
+        warden = Object.new
+        warden.define_singleton_method(:authenticate!) { |*| true }
+        warden.define_singleton_method(:authenticate) { |*| true }
+        warden.define_singleton_method(:user) { |*| @mocks[:current_user] }
+        controller.request.env['warden'] = warden
+      end
+
+      view_context = controller.view_context
+
+      # Add helper methods to view_context
+      # We can use `class_eval` on the singleton class of the view context
+      vc_singleton = view_context.singleton_class
+
+      if @mocks
+        @mocks.each do |key, value|
+          vc_singleton.send(:define_method, key) { value }
+        end
+      end
+
+      # Common auth helpers
+      vc_singleton.send(:define_method, :signed_in?) { true }
+
+      # Pundit policy mock
+      vc_singleton.send(:define_method, :policy) do |_record|
+        Struct.new(:show?, :index?, :create?, :update?, :destroy?, :edit?, :new?, :manage?).new(
+          true, true, true, true, true, true, true, true
+        )
+      end
+
+      view_context
+    end
+  end
+end

data/lib/lookbook_visual_tester/railtie.rb

@@ -1,17 +1,20 @@
 # lib/lookbook_visual_tester/railtie.rb
 
-require 'lookbook_visual_tester/capybara_setup'
+# require 'lookbook_visual_tester/capybara_setup'
 require 'lookbook_visual_tester/update_previews'
 
 module LookbookVisualTester
   class Railtie < ::Rails::Railtie
     rake_tasks do
-      load 'tasks/lookbook_visual_tester.rake'
+      path = File.expand_path('../tasks/lookbook_visual_tester.rake', __dir__)
+      load path
     end
 
     initializer 'LookbookVisualTester.lookbook_after_change' do |_app|
       Rails.logger.info "LookbookVisualTester initialized with host: #{LookbookVisualTester.config.lookbook_host}"
       Lookbook.after_change do |app, changes|
+        next unless LookbookVisualTester.config.automatic_run
+
         # get hash of content of modified files to see if has changed
         modified = changes[:modified]
         my_hash = modified.sort.map { |f| File.read(f) }.hash

data/lib/lookbook_visual_tester/report_generator.rb

@@ -1,57 +1,34 @@
+require 'erb'
+require 'fileutils'
+
 module LookbookVisualTester
   class ReportGenerator
-    attr_reader :report_path, :baseline_dir, :current_dir, :diff_dir, :base_path
-
-    def initialize
-      @baseline_dir, @current_dir, @diff_dir, @base_path = LookbookVisualTester.config.then do |config|
-        [config.baseline_dir, config.current_dir, config.diff_dir, config.base_path]
-      end
-
-      @report_path = base_path.join('report.html')
+    TEMPLATE_PATH = File.expand_path("../templates/report.html.erb", __FILE__)
+    OUTPUT_PATH = "coverage/visual_report.html"
+
+    def initialize(results)
+      @results = results
+      @stats = {
+        total: results.size,
+        failed: results.count { |r| r.status == :failed },
+        new: results.count { |r| r.status == :new },
+        passed: results.count { |r| r.status == :passed }
+      }
     end
 
-    def generate
-      File.open(report_path, 'w') do |file|
-        file.puts '<!DOCTYPE html>'
-        file.puts "<html lang='en'>"
-        file.puts "<head><meta charset='UTF-8'><title>Visual Regression Report</title></head>"
-        file.puts '<body>'
-        file.puts '<h1>Visual Regression Report</h1>'
-        file.puts '<ul>'
-
-        diff_files = Dir.glob(diff_dir.join('*_diff.png'))
-        diff_files.each do |diff_file|
-          filename = File.basename(diff_file)
-          # Extract preview and scenario names
-          preview_scenario = filename.sub('_diff.png', '')
-          preview, scenario = preview_scenario.split('_', 2)
-
-          baseline_image = baseline_dir.join("#{preview}_#{scenario}.png")
-          current_image = current_dir.join("#{preview}_#{scenario}.png")
+    def call
+      template = File.read(TEMPLATE_PATH)
+      renderer = ERB.new(template)
+      html = renderer.result(binding)
 
-          file.puts '<li>'
-          file.puts "<h2>#{preview.titleize} - #{scenario.titleize}</h2>"
-          file.puts "<div style='display: flex; gap: 10px;'>"
-
-          baseline_image_path = Pathname.new(baseline_image)
-          current_image_path = Pathname.new(current_image)
-          diff_file_path = Pathname.new(diff_file)
-
-          file.puts "<div><h3>Baseline</h3><img src='#{baseline_image_path.relative_path_from(base_path)}' alt='Baseline'></div>"
-          file.puts "<div><h3>Current</h3><img src='#{current_image_path.relative_path_from(base_path)}' alt='Current'></div>"
-          file.puts "<div><h3>Diff</h3><img src='#{diff_file_path.relative_path_from(base_path)}' alt='Diff'></div>"
-          file.puts '</div>'
-          file.puts '</li>'
-        end
-
-        file.puts '<li>No differences found!</li>' if diff_files.empty?
-
-        file.puts '</ul>'
-        file.puts '</body>'
-        file.puts '</html>'
-      end
+      FileUtils.mkdir_p("coverage")
+      File.write(OUTPUT_PATH, html)
+      puts "📊 Report generated at: #{OUTPUT_PATH}"
+    end
 
-      @report_path
+    # Helper to generate the terminal command for the user
+    def approve_command(result)
+      "cp \"#{result.current_path}\" \"#{result.baseline_path}\""
     end
   end
 end

data/lib/lookbook_visual_tester/runner.rb

@@ -0,0 +1,224 @@
+require 'lookbook'
+require 'json'
+require_relative 'configuration'
+require_relative 'scenario_run'
+require_relative 'services/image_comparator'
+require_relative 'drivers/ferrum_driver'
+require_relative 'variant_resolver'
+
+module LookbookVisualTester
+  class Runner
+    Result = Struct.new(:scenario_name, :status, :mismatch, :diff_path, :error, :baseline_path,
+                        :current_path, keyword_init: true)
+
+    def initialize(config = LookbookVisualTester.config, pattern: nil)
+      @config = config
+      @pattern = pattern
+      @driver_pool = Queue.new
+      init_driver_pool
+      @results = []
+      @variants = load_variants
+    end
+
+    def run
+      previews = Lookbook.previews
+
+      if @pattern.present?
+        previews = previews.select do |preview|
+          preview.label.downcase.include?(@pattern.downcase) ||
+            preview.name.downcase.include?(@pattern.downcase)
+        end
+      end
+
+      puts "Found #{previews.count} previews matching '#{@pattern}'."
+      puts "Running against #{@variants.size} variant(s)."
+
+      @variants.each do |variant_input|
+        resolver = VariantResolver.new(variant_input)
+        variant_options = resolver.resolve
+        variant_slug = resolver.slug
+        width = resolver.width_in_pixels
+
+        puts "  Variant: #{variant_slug.presence || 'Default'}"
+
+        if @config.threads > 1
+          run_concurrently(previews, variant_slug, variant_options, width)
+        else
+          run_sequentially(previews, variant_slug, variant_options, width)
+        end
+      end
+
+      @results
+    ensure
+      cleanup_drivers
+    end
+
+    private
+
+    def load_variants
+      variants_json = ENV['VARIANTS'] || ENV.fetch('LOOKBOOK_VARIANTS', nil)
+      return [{}] if variants_json.blank?
+
+      begin
+        JSON.parse(variants_json)
+      rescue JSON::ParserError
+        puts 'Invalid JSON in VARIANTS env var. Defaulting to standard run.'
+        [{}]
+      end
+    end
+
+    def run_sequentially(previews, variant_slug, variant_options, width)
+      previews.each do |preview|
+        group = preview.respond_to?(:scenarios) ? preview.scenarios : preview.examples
+        group.each do |scenario|
+          driver = checkout_driver
+          begin
+            @results << run_scenario(scenario, driver, variant_slug, variant_options, width)
+          ensure
+            return_driver(driver)
+          end
+        end
+      end
+    end
+
+    def run_concurrently(previews, variant_slug, variant_options, width)
+      require 'concurrent-ruby'
+      pool = Concurrent::FixedThreadPool.new(@config.threads)
+      promises = []
+
+      previews.each do |preview|
+        group = preview.respond_to?(:scenarios) ? preview.scenarios : preview.examples
+        group.each do |scenario|
+          promises << Concurrent::Promises.future_on(pool) do
+            driver = checkout_driver
+            begin
+              run_scenario(scenario, driver, variant_slug, variant_options, width)
+            ensure
+              return_driver(driver)
+            end
+          end
+        end
+      end
+
+      # Zip results from this concurrent batch into results
+      # Note: This aggregates results per variant loop.
+      @results.concat(Concurrent::Promises.zip(*promises).value)
+      pool.shutdown
+      pool.wait_for_termination
+    end
+
+    def init_driver_pool
+      count = @config.threads > 1 ? @config.threads : 1
+      count.times do
+        @driver_pool << LookbookVisualTester::Drivers::FerrumDriver.new(@config)
+      end
+    end
+
+    def checkout_driver
+      @driver_pool.pop
+    end
+
+    def return_driver(driver)
+      @driver_pool << driver
+    end
+
+    def cleanup_drivers
+      until @driver_pool.empty?
+        driver = @driver_pool.pop
+        driver.cleanup
+      end
+    end
+
+    def run_scenario(scenario, driver, variant_slug, variant_options, width)
+      run_data = ScenarioRun.new(scenario, variant_slug: variant_slug,
+                                           display_params: variant_options)
+      puts "Running visual test for: #{run_data.name} #{variant_slug.present? ? "[#{variant_slug}]" : ''}"
+
+      begin
+        driver_width = width || 1280
+        driver.resize_window(driver_width, 800)
+        driver.visit(run_data.preview_url)
+
+        # Determine paths
+        current_path = run_data.current_path
+        baseline_path = run_data.baseline_path
+        diff_path = @config.diff_dir.join(run_data.diff_filename)
+        # Update diff path to respect variant structure if needed?
+        # Actually ScenarioRun#diff_filename is just flat for now but let's fix that?
+        # ScenarioRun doesn't expose diff_path with slug. Let's fix that manually here if needed or update ScenarioRun.
+        # Wait, ScenarioRun stores baseline/current in folders but diff_filename is just name.
+        # We should probably put diffs in folders too.
+        # Let's adjust diff_path here:
+        if variant_slug.present?
+          diff_path = @config.diff_dir.join(variant_slug, run_data.diff_filename)
+        end
+
+        FileUtils.mkdir_p(File.dirname(current_path))
+        FileUtils.mkdir_p(File.dirname(diff_path))
+
+        driver.save_screenshot(current_path.to_s)
+
+        # Trimming (Feature parity with legacy ScreenshotTaker)
+        if File.exist?(current_path)
+          system("convert #{current_path} -trim -bordercolor white -border 10x10 #{current_path}")
+        end
+
+        comparator = LookbookVisualTester::ImageComparator.new(
+          baseline_path.to_s,
+          current_path.to_s,
+          diff_path.to_s
+        )
+
+        result = comparator.call
+
+        status = :passed
+        mismatch = 0.0
+        error = nil
+
+        if result[:error]
+          if result[:error] == 'Baseline not found'
+            # First run, maybe auto-approve or just report
+            puts '  [NEW] Baseline not found. Saved current as potential baseline.'
+            status = :new
+          else
+            puts "  [ERROR] #{result[:error]}"
+            status = :error
+            error = result[:error]
+          end
+        elsif result[:mismatch] > 0
+          mismatch = result[:mismatch]
+          puts "  [FAIL] Mismatch: #{mismatch.round(2)}%. Diff saved to #{diff_path}"
+          status = :failed
+
+          # Clipboard (Feature parity with legacy ScreenshotTaker)
+          if @config.copy_to_clipboard
+            system("xclip -selection clipboard -t image/png -i #{current_path}")
+          end
+        else
+          puts '  [PASS] Identical.'
+          status = :passed
+        end
+
+        Result.new(
+          scenario_name: run_data.name,
+          status: status,
+          mismatch: mismatch,
+          diff_path: diff_path.to_s,
+          error: error,
+          baseline_path: baseline_path.to_s,
+          current_path: current_path.to_s
+        )
+      rescue StandardError => e
+        puts "  [ERROR] Exception: #{e.message}"
+        puts e.backtrace.take(5)
+        Result.new(
+          scenario_name: run_data.name,
+          status: :error,
+          error: e.message,
+          baseline_path: run_data.baseline_path.to_s,
+          current_path: run_data.current_path.to_s
+        )
+      end
+    end
+  end
+end

data/lib/lookbook_visual_tester/scenario_finder.rb

@@ -12,19 +12,24 @@ module LookbookVisualTester
     end
 
     def regex
-      @regex = Regexp.new(search.chars.join('.*'), Regexp::IGNORECASE)
+      @regex = Regexp.new(clean_search.chars.join('.*'), Regexp::IGNORECASE)
     end
 
     def matched_previews
       @matched_previews ||= previews.select { |preview| regex.match?(preview.name.downcase) }
     end
 
+    def clean_search
+      @clean_search ||= search.downcase.gsub(/[^a-z0-9\s]/, '').strip
+    end
+
     def call
       return nil if search.nil? || search == '' || previews.empty?
 
       previews.each do |preview|
         preview.scenarios.each do |scenario|
-          return ScenarioRun.new(scenario) if scenario.name.downcase.include?(search.downcase)
+          name = "#{preview.name} #{scenario.name}".downcase
+          return ScenarioRun.new(scenario) if regex.match?(name.downcase) #name.downcase.include?(clean_search)
         end
       end
 

data/lib/lookbook_visual_tester/scenario_run.rb

@@ -2,17 +2,19 @@ require 'lookbook_visual_tester/configuration'
 
 module LookbookVisualTester
   class ScenarioRun
-    attr_reader :scenario, :preview
+    attr_reader :scenario, :preview, :variant_slug, :display_params
 
-    def initialize(scenario)
+    def initialize(scenario, variant_slug: nil, display_params: {})
       @scenario = scenario
       @preview = scenario.preview
+      @variant_slug = variant_slug
+      @display_params = display_params
 
-      puts "  Scenario: #{scenario_name}"
+      LookbookVisualTester.config.logger.info "  Scenario: #{scenario_name} #{variant_suffix}"
     end
 
     def preview_name
-      preview.name.underscore
+      preview.name.underscore.gsub('/', '_')
     end
 
     def scenario_name
@@ -39,18 +41,34 @@ module LookbookVisualTester
     end
 
     def current_path
-      LookbookVisualTester.config.current_dir.join(filename)
+      base = LookbookVisualTester.config.current_dir
+      base = base.join(variant_slug) if variant_slug.present?
+      base.join(filename)
     end
 
     def baseline_path
-      LookbookVisualTester.config.baseline_dir.join(filename)
+      base = LookbookVisualTester.config.baseline_dir
+      base = base.join(variant_slug) if variant_slug.present?
+      base.join(filename)
     end
 
     def preview_url
+      params = { path: preview.lookup_path + '/' + scenario.name }
+
+      if display_params.any?
+        # Transform display_params { theme: 'dark' } -> { _display: { theme: 'dark' } }
+        params[:_display] = display_params
+      end
+
       Lookbook::Engine.routes.url_helpers.lookbook_preview_url(
-        path: preview.lookup_path + '/' + scenario.name,
-        host: LookbookVisualTester.config.lookbook_host
+        params.merge(host: LookbookVisualTester.config.lookbook_host)
       )
     end
+
+    private
+
+    def variant_suffix
+      variant_slug.present? ? "[#{variant_slug}]" : ''
+    end
   end
 end