feat(picker): picker support

spec/config_spec.lua

@@ -231,6 +231,39 @@ describe('cp.config', function()
         end)
       end)
     end)
+
+    describe('picker validation', function()
+      it('validates picker is valid value', function()
+        local invalid_config = {
+          picker = 'invalid_picker',
+        }
+
+        assert.has_error(function()
+          config.setup(invalid_config)
+        end, "Invalid picker 'invalid_picker'. Must be 'telescope' or 'fzf-lua'")
+      end)
+
+      it('allows nil picker', function()
+        assert.has_no.errors(function()
+          local result = config.setup({ picker = nil })
+          assert.is_nil(result.picker)
+        end)
+      end)
+
+      it('allows telescope picker without checking availability', function()
+        assert.has_no.errors(function()
+          local result = config.setup({ picker = 'telescope' })
+          assert.equals('telescope', result.picker)
+        end)
+      end)
+
+      it('allows fzf-lua picker without checking availability', function()
+        assert.has_no.errors(function()
+          local result = config.setup({ picker = 'fzf-lua' })
+          assert.equals('fzf-lua', result.picker)
+        end)
+      end)
+    end)
   end)
 
   describe('default_filename', function()

spec/fzf_lua_spec.lua

@@ -0,0 +1,31 @@
+describe('cp.fzf_lua', function()
+  local spec_helper = require('spec.spec_helper')
+
+  before_each(function()
+    spec_helper.setup()
+
+    package.preload['fzf-lua'] = function()
+      return {
+        fzf_exec = function(entries, opts) end,
+      }
+    end
+  end)
+
+  after_each(function()
+    spec_helper.teardown()
+  end)
+
+  describe('module loading', function()
+    it('loads fzf-lua integration without error', function()
+      assert.has_no.errors(function()
+        require('cp.pickers.fzf_lua')
+      end)
+    end)
+
+    it('returns module with platform_picker function', function()
+      local fzf_lua_cp = require('cp.pickers.fzf_lua')
+      assert.is_table(fzf_lua_cp)
+      assert.is_function(fzf_lua_cp.platform_picker)
+    end)
+  end)
+end)

spec/picker_spec.lua

@@ -0,0 +1,188 @@
+describe('cp.picker', function()
+  local picker
+  local spec_helper = require('spec.spec_helper')
+
+  before_each(function()
+    spec_helper.setup()
+    picker = require('cp.pickers')
+  end)
+
+  after_each(function()
+    spec_helper.teardown()
+  end)
+
+  describe('get_platforms', function()
+    it('returns platform list with display names', function()
+      local platforms = picker.get_platforms()
+
+      assert.is_table(platforms)
+      assert.is_true(#platforms > 0)
+
+      for _, platform in ipairs(platforms) do
+        assert.is_string(platform.id)
+        assert.is_string(platform.display_name)
+        assert.is_true(platform.display_name:match('^%u'))
+      end
+    end)
+
+    it('includes expected platforms with correct display names', function()
+      local platforms = picker.get_platforms()
+      local platform_map = {}
+      for _, p in ipairs(platforms) do
+        platform_map[p.id] = p.display_name
+      end
+
+      assert.equals('CodeForces', platform_map['codeforces'])
+      assert.equals('AtCoder', platform_map['atcoder'])
+      assert.equals('CSES', platform_map['cses'])
+    end)
+  end)
+
+  describe('get_contests_for_platform', function()
+    it('returns empty list when scraper fails', function()
+      vim.system = function(cmd, opts)
+        return {
+          wait = function()
+            return { code = 1, stderr = 'test error' }
+          end,
+        }
+      end
+
+      local contests = picker.get_contests_for_platform('test_platform')
+      assert.is_table(contests)
+      assert.equals(0, #contests)
+    end)
+
+    it('returns empty list when JSON is invalid', function()
+      vim.system = function(cmd, opts)
+        return {
+          wait = function()
+            return { code = 0, stdout = 'invalid json' }
+          end,
+        }
+      end
+
+      local contests = picker.get_contests_for_platform('test_platform')
+      assert.is_table(contests)
+      assert.equals(0, #contests)
+    end)
+
+    it('returns contest list when scraper succeeds', function()
+      vim.system = function(cmd, opts)
+        return {
+          wait = function()
+            return {
+              code = 0,
+              stdout = vim.json.encode({
+                success = true,
+                contests = {
+                  {
+                    id = 'abc123',
+                    name = 'AtCoder Beginner Contest 123',
+                    display_name = 'Beginner Contest 123 (ABC)',
+                  },
+                  {
+                    id = '1951',
+                    name = 'Educational Round 168',
+                    display_name = 'Educational Round 168',
+                  },
+                },
+              }),
+            }
+          end,
+        }
+      end
+
+      local contests = picker.get_contests_for_platform('test_platform')
+      assert.is_table(contests)
+      assert.equals(2, #contests)
+      assert.equals('abc123', contests[1].id)
+      assert.equals('AtCoder Beginner Contest 123', contests[1].name)
+      assert.equals('Beginner Contest 123 (ABC)', contests[1].display_name)
+    end)
+  end)
+
+  describe('get_problems_for_contest', function()
+    it('returns problems from cache when available', function()
+      local cache = require('cp.cache')
+      cache.load = function() end
+      cache.get_contest_data = function(platform, contest_id)
+        return {
+          problems = {
+            { id = 'a', name = 'Problem A' },
+            { id = 'b', name = 'Problem B' },
+          },
+        }
+      end
+
+      local problems = picker.get_problems_for_contest('test_platform', 'test_contest')
+      assert.is_table(problems)
+      assert.equals(2, #problems)
+      assert.equals('a', problems[1].id)
+      assert.equals('Problem A', problems[1].name)
+      assert.equals('a - Problem A', problems[1].display_name)
+    end)
+
+    it('falls back to scraping when cache miss', function()
+      local cache = require('cp.cache')
+      local scrape = require('cp.scrape')
+
+      cache.load = function() end
+      cache.get_contest_data = function()
+        return nil
+      end
+      scrape.scrape_contest_metadata = function(platform, contest_id)
+        return {
+          success = true,
+          problems = {
+            { id = 'x', name = 'Problem X' },
+          },
+        }
+      end
+
+      local problems = picker.get_problems_for_contest('test_platform', 'test_contest')
+      assert.is_table(problems)
+      assert.equals(1, #problems)
+      assert.equals('x', problems[1].id)
+    end)
+
+    it('returns empty list when scraping fails', function()
+      local cache = require('cp.cache')
+      local scrape = require('cp.scrape')
+
+      cache.load = function() end
+      cache.get_contest_data = function()
+        return nil
+      end
+      scrape.scrape_contest_metadata = function(platform, contest_id)
+        return {
+          success = false,
+          error = 'test error',
+        }
+      end
+
+      local problems = picker.get_problems_for_contest('test_platform', 'test_contest')
+      assert.is_table(problems)
+      assert.equals(0, #problems)
+    end)
+  end)
+
+  describe('setup_problem', function()
+    it('calls cp.handle_command with correct arguments', function()
+      local cp = require('cp')
+      local called_with = nil
+
+      cp.handle_command = function(opts)
+        called_with = opts
+      end
+
+      picker.setup_problem('codeforces', '1951', 'a')
+
+      assert.is_table(called_with)
+      assert.is_table(called_with.fargs)
+      assert.equals('codeforces', called_with.fargs[1])
+      assert.equals('1951', called_with.fargs[2])
+      assert.equals('a', called_with.fargs[3])
+    end)
+  end)
+end)

spec/telescope_spec.lua

@@ -0,0 +1,78 @@
+describe('cp.telescope', function()
+  local spec_helper = require('spec.spec_helper')
+
+  before_each(function()
+    spec_helper.setup()
+
+    package.preload['telescope'] = function()
+      return {
+        register_extension = function(ext_config)
+          return ext_config
+        end,
+      }
+    end
+
+    package.preload['telescope.pickers'] = function()
+      return {
+        new = function(opts, picker_opts)
+          return {
+            find = function() end,
+          }
+        end,
+      }
+    end
+
+    package.preload['telescope.finders'] = function()
+      return {
+        new_table = function(opts)
+          return opts
+        end,
+      }
+    end
+
+    package.preload['telescope.config'] = function()
+      return {
+        values = {
+          generic_sorter = function()
+            return {}
+          end,
+        },
+      }
+    end
+
+    package.preload['telescope.actions'] = function()
+      return {
+        select_default = {
+          replace = function() end,
+        },
+        close = function() end,
+      }
+    end
+
+    package.preload['telescope.actions.state'] = function()
+      return {
+        get_selected_entry = function()
+          return nil
+        end,
+      }
+    end
+  end)
+
+  after_each(function()
+    spec_helper.teardown()
+  end)
+
+  describe('module loading', function()
+    it('registers telescope extension without error', function()
+      assert.has_no.errors(function()
+        require('cp.pickers.telescope')
+      end)
+    end)
+
+    it('returns module with platform_picker function', function()
+      local telescope_cp = require('cp.pickers.telescope')
+      assert.is_table(telescope_cp)
+      assert.is_function(telescope_cp.platform_picker)
+    end)
+  end)
+end)