canopus 0.4.0 → 0.5.0

data/lib/canopus/test_runner/execution.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "digest/sha2"
+
+module Canopus
+  module TestRunner
+    class Execution
+      MAX_OUTPUT_BYTES = 256 << 10
+      MAX_PARSE_LINES = 10_000
+      MAX_FILTER_BYTES = 8_192
+      ANSI = /\e(?:\[[0-?]*[ -\/]*[@-~]|\][^\a]*(?:\a|\e\\))/n
+
+      attr_reader :test, :tests, :output, :generation
+
+      def self.task(test, root:, tests: [test])
+        raise ArgumentError, "discovered test required" unless test.is_a?(Test)
+        unless tests.is_a?(Array) && !tests.empty? && tests.length <= Discovery::MAX_TESTS &&
+            tests.all? { |candidate| candidate.is_a?(Test) && candidate.framework == test.framework &&
+              candidate.path == test.path && candidate.line == test.line }
+          raise ArgumentError, "related discovered tests required"
+        end
+
+        root = File.realpath(root)
+        relative = TestRunner.normalize_path(test.path)
+        raise Error, "Test target is invalid" unless relative == test.path
+
+        candidate = File.join(root, relative)
+        raise Error, "Test target is not a file" if File.lstat(candidate).symlink?
+        path = File.realpath(candidate)
+        prefix = root.end_with?(File::SEPARATOR) ? root : root + File::SEPARATOR
+        raise Error, "Test target is outside the workspace" unless path.start_with?(prefix) && File.file?(path)
+
+        command = case test.framework
+        when :minitest then minitest_command(tests)
+        when :rspec then rspec_command(tests)
+        else raise Error, "Unknown test framework"
+        end
+        gemfile = File.join(root, "Gemfile")
+        bundled = regular_file?(gemfile)
+        command = [RbConfig.ruby, "-S", "bundle", "exec", *command] if bundled
+        environment = unbundled_environment
+        environment["BUNDLE_GEMFILE"] = gemfile if bundled
+        {"label" => label(test), "command" => command.freeze, "cwd" => root,
+         "env" => environment.freeze,
+         "presentation" => {"panel" => "output", "reveal" => "silent"}.freeze}.freeze
+      rescue SystemCallError, TypeError => error
+        raise Error, "Cannot run test: #{error.message}"
+      end
+
+      def initialize(test, output, generation: nil, tests: [test])
+        @test, @tests, @output, @generation = test, tests.dup.freeze, output, generation
+        @bytes, @cancelled = +"".b, false
+      end
+
+      def append(bytes)
+        return if bytes.nil? || bytes.empty?
+
+        @bytes << bytes.b
+        @bytes = @bytes.byteslice(-MAX_OUTPUT_BYTES, MAX_OUTPUT_BYTES) if @bytes.bytesize > MAX_OUTPUT_BYTES
+        nil
+      end
+
+      def cancel = (@cancelled = true)
+
+      def finish(status)
+        return result(:skipped) if @cancelled
+        return failure_result unless status&.success?
+
+        count, skipped = summary
+        return failure_result unless count == tests.length
+
+        skipped == count ? result(:skipped) : result(:success)
+      end
+
+      private
+
+      def self.minitest_command(tests)
+        selectors = tests.map do |test|
+          suite = test.groups.join("::")
+          raise Error, "Minitest suite is unknown" if suite.empty?
+          raise Error, "Minitest selector is unknown" unless test.selector
+
+          "#{Regexp.escape(suite)}##{Regexp.escape(test.selector)}"
+        end
+        body = selectors.length == 1 ? selectors.first : "(?:#{selectors.join("|")})"
+        filter = "\\A#{body}\\z"
+        raise Error, "Minitest selector is too large" if filter.bytesize > MAX_FILTER_BYTES
+
+        [RbConfig.ruby, "-Itest", tests.first.path, "--name", "/#{filter}/"]
+      end
+
+      def self.rspec_command(tests)
+        patterns = tests.map do |test|
+          raise Error, "RSpec selector is unknown" unless test.selector
+
+          pattern = "\\A#{Regexp.escape(test.selector)}\\z"
+          raise Error, "RSpec selector is too large" if pattern.bytesize > MAX_FILTER_BYTES
+          pattern
+        end
+        size = patterns.sum { |pattern| "--example-matches".bytesize + pattern.bytesize + 2 }
+        raise Error, "RSpec selectors are too large" if size > MAX_FILTER_BYTES
+
+        filters = patterns.flat_map { |pattern| ["--example-matches", pattern] }
+        test = tests.first
+        [RbConfig.ruby, "-S", "rspec", "#{test.path}:#{test.line}", *filters,
+         "--format", "progress", "--no-color"]
+      end
+
+      def self.label(test)
+        name = test.path.encode(Encoding::UTF_8, invalid: :replace, undef: :replace).scrub
+          .each_char.map { |character| character.match?(/\s/) ? " " : character }.last(120).join
+        digest = Digest::SHA256.hexdigest(test.path).slice(0, 16)
+        "Test: #{name} [#{digest}]:#{test.line}:#{test.offset}"
+      end
+
+      def self.regular_file?(path)
+        File.lstat(path).file? && !File.lstat(path).symlink?
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        false
+      end
+
+      def self.unbundled_environment
+        clean = if defined?(Bundler) && Bundler.respond_to?(:unbundled_env)
+          Bundler.unbundled_env
+        else
+          ENV.to_h.reject { |key, _| key.start_with?("BUNDLE_") }
+        end
+        (ENV.keys | clean.keys).each_with_object({}) do |key, result|
+          result[key] = clean[key] if ENV[key] != clean[key]
+        end
+      end
+      private_class_method :minitest_command, :rspec_command, :label, :regular_file?, :unbundled_environment
+
+      def failure_result
+        path, line = failure_location || [test.path, test.line]
+        result(:failure, path, line, "#{test.name} failed")
+      end
+
+      def summary
+        summary = nil
+        recent_output.each_line do |line|
+          line = line.strip
+          if test.framework == :minitest &&
+              (match = line.match(/\A(\d+)\s+runs?,.*,[ \t]*(\d+)\s+skips?\z/i))
+            summary = [match[1].to_i, match[2].to_i]
+          elsif test.framework == :rspec &&
+              (match = line.match(/\A(\d+)\s+examples?,[ \t]*0\s+failures?(?:,[ \t]*(\d+)\s+pending(?:\s+.*)?)?\z/i))
+            summary = [match[1].to_i, match[2].to_s.to_i]
+          end
+        end
+        summary || [nil, nil]
+      end
+
+      def failure_location
+        relative = test.path.tr("\\", "/")
+        candidates = ["./#{relative}", relative]
+        recent_output.each_line do |line|
+          normalized = line.tr("\\", "/")
+          candidates.each do |path|
+            cursor = normalized.index("#{path}:")
+            next unless cursor
+            number = normalized[cursor + path.length + 1, 12].to_s[/\A\d{1,10}/]
+            value = number.to_i
+            return [relative, value] if value.between?(1, Discovery::MAX_FILE_BYTES + 1)
+          end
+        end
+        nil
+      end
+
+      def output_text
+        @output_text ||= @bytes.gsub(ANSI, "").encode(Encoding::UTF_8, invalid: :replace, undef: :replace).scrub
+      end
+
+      def recent_output
+        text = output_text
+        bytes, cursor = text.b, text.bytesize
+        MAX_PARSE_LINES.times do
+          index = cursor > 1 ? bytes.rindex("\n".b, cursor - 2) : nil
+          unless index
+            cursor = 0
+            break
+          end
+          cursor = index + 1
+        end
+        text.byteslice(cursor..).force_encoding(Encoding::UTF_8)
+      end
+
+      def result(status, path = nil, line = nil, message = nil)
+        Result.new(status, path, line, message&.byteslice(0, 4_096)&.scrub("")).freeze
+      end
+    end
+  end
+end

data/lib/canopus/test_runner/minitest.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Canopus
+  module TestRunner
+    class Minitest
+      MAX_NODES = 100_000
+      MAX_GROUP_DEPTH = 32
+      MAX_NAME_BYTES = 4_096
+      SPEC_GROUPS = %i[describe context].freeze
+      SPEC_TESTS = %i[it specify].freeze
+
+      def candidate?(path)
+        TestRunner.framework_for(path) == :minitest
+      end
+
+      def discover(root, path:, limit:, cancelled:)
+        require "prism"
+        path = path.dup.freeze
+        tests, visited = [], 0
+        stack = [[root, [].freeze, :none, nil]]
+        until stack.empty? || tests.length >= limit
+          break if cancelled.call
+          node, groups, scope, spec_count = stack.pop
+          break if (visited += 1) > MAX_NODES
+
+          case node
+          when Prism::ClassNode
+            group = name(node.constant_path, rootless: true)
+            children = group && groups.length < MAX_GROUP_DEPTH ? [*groups, group].freeze : groups
+            class_scope = spec_class?(node) ? :spec_class : :class
+            stack << [node.body, children, class_scope, class_scope == :spec_class ? [0] : nil] if node.body
+          when Prism::ModuleNode
+            group = name(node.constant_path, rootless: true)
+            children = group && groups.length < MAX_GROUP_DEPTH ? [*groups, group].freeze : groups
+            stack << [node.body, children, :none, nil] if node.body
+          when Prism::SingletonClassNode
+            next
+          when Prism::DefNode
+            method_name = name(node.name.to_s)
+            if [:class, :spec_class].include?(scope) && !node.receiver && method_name&.start_with?("test_")
+              add(tests, path, method_name, groups, node, method_name)
+            end
+          when Prism::CallNode
+            if group_call?(node) && groups.length < MAX_GROUP_DEPTH && (group = group_name(node))
+              parent = [:spec, :spec_class].include?(scope) ? groups : []
+              stack << [node.block.body, [*parent, group].freeze, :spec, [0]] if node.block.body
+            elsif spec_test_call?(node, scope)
+              selector = format("test_%04d_%s", spec_count[0] += 1, (test_name = literal_argument_name(node)))
+              add(tests, path, test_name, groups, node, selector) if test_name
+            elsif class_test_call?(node, scope) && (test_name = literal_argument_name(node))
+              add(tests, path, test_name, groups, node, "test_#{test_name.gsub(/\s+/, "_")}")
+            else
+              push_children(stack, node, groups, scope, spec_count) unless node.block
+            end
+          else
+            push_children(stack, node, groups, scope, spec_count)
+          end
+        end
+        tests.freeze
+      end
+
+      private
+
+      def group_call?(node) = SPEC_GROUPS.include?(node.name) && node.block && !node.receiver
+      def spec_test_call?(node, scope)
+        [:spec, :spec_class].include?(scope) && SPEC_TESTS.include?(node.name) && !node.receiver
+      end
+      def class_test_call?(node, scope)
+        [:class, :spec_class].include?(scope) && node.name == :test && node.block && !node.receiver
+      end
+
+      def spec_class?(node)
+        superclass = name(node.superclass)
+        superclass&.delete_prefix("::") == "Minitest::Spec"
+      end
+
+      def push_children(stack, node, groups, scope, spec_count)
+        node.compact_child_nodes.reverse_each { |child| stack << [child, groups, scope, spec_count] }
+      end
+
+      def literal_argument_name(node)
+        argument = node.arguments&.arguments&.first
+        name(argument) if argument.is_a?(Prism::StringNode) || argument.is_a?(Prism::SymbolNode)
+      end
+
+      def group_name(node)
+        arguments = node.arguments&.arguments
+        return if !arguments || arguments.empty?
+
+        parts = arguments.map { |argument| name(argument, rootless: true) }
+        parts.join("::").freeze if parts.all?
+      end
+
+      def name(node, rootless: false)
+        value = case node
+        when String then node
+        when Prism::StringNode, Prism::SymbolNode then node.unescaped
+        when Prism::ConstantReadNode, Prism::ConstantPathNode then node.full_name
+        end
+        return unless value
+
+        value = value.to_s.encode(Encoding::UTF_8)
+        value = value.delete_prefix("::") if rootless
+        return unless value.valid_encoding? && !value.include?("\0") && value.bytesize <= MAX_NAME_BYTES
+        value.freeze
+      rescue EncodingError
+        nil
+      end
+
+      def add(tests, path, name, groups, node, selector)
+        tests << Test.new(:minitest, path, name, groups,
+          node.location.start_line, node.location.start_column, node.location.start_offset, selector.freeze)
+      end
+    end
+  end
+end

data/lib/canopus/test_runner/rspec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Canopus
+  module TestRunner
+    class RSpec
+      MAX_NODES = 100_000
+      MAX_GROUP_DEPTH = 32
+      MAX_NAME_BYTES = 4_096
+      GROUPS = %i[describe context feature fdescribe xdescribe fcontext xcontext].freeze
+      EXAMPLES = %i[it specify example scenario fit focus fspecify xit xspecify xexample fexample fscenario xscenario skip].freeze
+
+      def candidate?(path)
+        TestRunner.framework_for(path) == :rspec
+      end
+
+      def discover(root, path:, limit:, cancelled:)
+        require "prism"
+        path = path.dup.freeze
+        tests, visited = [], 0
+        stack = [[root, [].freeze, "".freeze, false]]
+        until stack.empty? || tests.length >= limit
+          break if cancelled.call
+          node, groups, full_description, parent_module = stack.pop
+          break if (visited += 1) > MAX_NODES
+
+          if node.is_a?(Prism::DefNode)
+            next
+          elsif node.is_a?(Prism::CallNode)
+            if group_call?(node) && groups.length < MAX_GROUP_DEPTH && (details = group_name(node))
+              group, last_module = details
+              separator = !full_description.empty? && !(parent_module && group.match?(/\A(?:#|::|\.)/)) ? " " : ""
+              nested_description = "#{full_description}#{separator}#{group}".freeze
+              stack << [node.block.body, [*groups, group].freeze, nested_description, last_module] if node.block.body
+              next
+            elsif !groups.empty? && EXAMPLES.include?(node.name) && !node.receiver && (name = literal_name(node.arguments&.arguments&.first))
+              add(tests, path, name, groups, full_description, node)
+              next
+            end
+            next if node.block
+          end
+          node.compact_child_nodes.reverse_each do |child|
+            stack << [child, groups, full_description, parent_module]
+          end
+        end
+        tests.freeze
+      end
+
+      private
+
+      def group_call?(node)
+        return false unless GROUPS.include?(node.name) && node.block
+        return true unless node.receiver
+
+        (node.receiver.is_a?(Prism::ConstantReadNode) || node.receiver.is_a?(Prism::ConstantPathNode)) &&
+          node.receiver.full_name.delete_prefix("::") == "RSpec"
+      end
+
+      def group_name(node)
+        arguments = node.arguments&.arguments&.dup
+        return if !arguments || arguments.empty?
+
+        arguments.pop if arguments.last.is_a?(Prism::KeywordHashNode) || arguments.last.is_a?(Prism::HashNode)
+        arguments.pop while arguments.length > 1 && arguments.last.is_a?(Prism::SymbolNode)
+        return unless arguments.length.between?(1, 2)
+
+        first = name(arguments.first, rootless: true)
+        second = name(arguments[1], rootless: true) if arguments.length == 2
+        return unless first && !first.empty? && (arguments.length == 1 || second && !second.empty?)
+        return [first, constant?(arguments.first)].freeze if arguments.length == 1
+
+        separator = constant?(arguments.first) && second.match?(/\A(?:#|::|\.)/) ? "" : " "
+        ["#{first}#{separator}#{second}".freeze, constant?(arguments.last)].freeze
+      end
+
+      def literal_name(node)
+        name(node) if node.is_a?(Prism::StringNode) || node.is_a?(Prism::SymbolNode)
+      end
+
+      def constant?(node) = node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+
+      def name(node, rootless: false)
+        value = case node
+        when Prism::StringNode, Prism::SymbolNode then node.unescaped
+        when Prism::ConstantReadNode, Prism::ConstantPathNode then node.full_name
+        end
+        return unless value
+
+        value = value.to_s.encode(Encoding::UTF_8)
+        value = value.delete_prefix("::") if rootless
+        return unless value.valid_encoding? && !value.include?("\0") && value.bytesize <= MAX_NAME_BYTES
+        value.freeze
+      rescue EncodingError
+        nil
+      end
+
+      def add(tests, path, name, groups, full_description, node)
+        selector = "#{full_description} #{name}".freeze
+        tests << Test.new(:rspec, path, name, groups,
+          node.location.start_line, node.location.start_column, node.location.start_offset, selector)
+      end
+    end
+  end
+end

data/lib/canopus/test_runner/safe_walker.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Canopus
+  module TestRunner
+    # Rejects byte-invalid names before Alkaid computes depth or consults ignores.
+    class SafeWalker < Alkaid::Walker
+      private
+
+      def walk(directory, visited, &block)
+        return if @cancelled&.call
+
+        absolute_directory = absolute(directory)
+        stat = File.stat(absolute_directory)
+        return unless visited.add?([stat.dev, stat.ino])
+
+        Dir.children(absolute_directory).sort.each do |name|
+          return if @cancelled&.call
+          next if name == ".git" || (!@hidden && name.start_with?("."))
+
+          relative = directory.empty? ? name : File.join(directory, name)
+          normalized = File::ALT_SEPARATOR ? relative.tr(File::ALT_SEPARATOR, "/") : relative
+          normalized = TestRunner.normalize_path(normalized)
+          next unless normalized
+
+          depth = normalized.count("/") + 1
+          next if @max_depth && depth > @max_depth
+
+          visit(relative, normalized, depth, visited, &block)
+        rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP, Errno::ENOTDIR, ArgumentError, EncodingError
+          next
+        end
+      rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP, Errno::ENOTDIR
+        nil
+      end
+    end
+  end
+end

data/lib/canopus/test_runner.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "data_compat"
+require "thuban"
+alkaid_path = ENV["ALKAID_PATH"]
+alkaid_root = File.expand_path("../..", __dir__)
+alkaid_path ? require(File.expand_path("lib/alkaid", File.expand_path(alkaid_path, alkaid_root))) : require("alkaid")
+
+module Canopus
+  module TestRunner
+    Test = Data.define(:framework, :path, :name, :groups, :line, :column, :offset, :selector)
+    Result = Data.define(:status, :path, :line, :message)
+    MAX_PATH_BYTES = 16_384
+
+    class << self
+      def normalize_path(path)
+        return unless path.is_a?(String) && path.bytesize <= MAX_PATH_BYTES && !path.include?("\0")
+
+        value = path.encode(Encoding::UTF_8)
+        value = value.tr(File::ALT_SEPARATOR, "/") if File::ALT_SEPARATOR
+        return unless value.valid_encoding? && !value.start_with?("/")
+        return if value.split("/").any? { |part| part.empty? || part == "." || part == ".." }
+
+        value.freeze
+      rescue EncodingError
+        nil
+      end
+
+      def framework_for(path)
+        path = normalize_path(path)
+        return unless path&.end_with?(".rb")
+
+        name = File.basename(path)
+        return :rspec if name.end_with?("_spec.rb")
+        return :minitest if name.end_with?("_test.rb") || name.start_with?("test_")
+
+        path.split("/")[0...-1].reverse_each do |directory|
+          return :minitest if directory == "test"
+          return :rspec if directory == "spec"
+        end
+        nil
+      end
+    end
+  end
+end
+
+require_relative "test_runner/bounded_ignore"
+require_relative "test_runner/safe_walker"
+require_relative "test_runner/minitest"
+require_relative "test_runner/rspec"
+require_relative "test_runner/discovery"
+require_relative "test_runner/execution"
+
+Canopus::TestRunner.private_constant :SafeWalker

data/lib/canopus/theme/import.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "json"
+require "rexml/document"
+
+module Canopus
+  class Theme
+    module Import
+      COLOR_KEYS = {
+        "editor.background" => :background, "editor.foreground" => :foreground,
+        "sideBar.background" => :panel, "panel.background" => :panel,
+        "panel.border" => :border, "editorGroup.border" => :border,
+        "tab.activeBackground" => :active_tab, "descriptionForeground" => :muted,
+        "focusBorder" => :accent, "editor.selectionBackground" => :selection,
+        "editorCursor.foreground" => :cursor, "editor.lineHighlightBackground" => :current_line,
+        "statusBar.background" => :status, "errorForeground" => :error,
+        "editorError.foreground" => :"diagnostic.error", "problemsErrorIcon.foreground" => :"diagnostic.error",
+        "editorWarning.foreground" => :"diagnostic.warning", "problemsWarningIcon.foreground" => :"diagnostic.warning",
+        "editorInfo.foreground" => :"diagnostic.information", "problemsInfoIcon.foreground" => :"diagnostic.information",
+        "editorHint.foreground" => :"diagnostic.hint", "editorIndentGuide.background" => :"indent.guide",
+        "editorIndentGuide.activeBackground" => :"indent.guide.active",
+        "editorBracketHighlight.foreground1" => :"bracket.1", "editorBracketHighlight.foreground2" => :"bracket.2",
+        "editorBracketHighlight.foreground3" => :"bracket.3", "editorBracketHighlight.foreground4" => :"bracket.4",
+        "editorBracketHighlight.foreground5" => :"bracket.5", "editorBracketHighlight.foreground6" => :"bracket.6",
+        "editorIndentGuide.background1" => :"indent.guide", "editorIndentGuide.activeBackground1" => :"indent.guide.active"
+      }.freeze
+      TOKEN_KEYS = {
+        "comment" => "Comment", "keyword" => "Keyword", "entity.name.type" => "Name.Class", "entity.name.class" => "Name.Class",
+        "entity.name.function" => "Name.Function", "string" => "Literal.String",
+        "constant.numeric" => "Literal.Number", "keyword.operator" => "Operator",
+        "markup.heading" => "Generic.Heading", "invalid" => "Error"
+      }.freeze
+
+      module_function
+
+      def vscode(data, warnings: nil)
+        colors = map_colors(data.fetch("colors", {}), warnings)
+        syntax = {}
+        Array(data["tokenColors"]).each do |entry|
+          next unless entry.is_a?(Hash)
+
+          settings = entry["settings"]
+          color = settings.is_a?(Hash) && settings["foreground"]
+          next unless color
+          scopes = entry["scope"].to_s.split(/[,;]/).map(&:strip)
+          scopes.each do |scope|
+            key = TOKEN_KEYS.keys.find { |prefix| scope == prefix || scope.start_with?(prefix + ".") }
+            if key
+              syntax[TOKEN_KEYS.fetch(key)] = {"color" => color}
+            elsif warnings
+              warnings << "unsupported token scope: #{scope}"
+            end
+          end
+        end
+        new_theme(data["name"], colors, syntax)
+      end
+
+      def tm_theme(xml, warnings: nil)
+        values = plist(REXML::Document.new(xml).root.elements[1])
+        colors = map_colors(values.fetch("colors", {}), warnings)
+        syntax = {}
+        Array(values["settings"]).each do |entry|
+          next unless entry.is_a?(Hash)
+
+          settings = entry["settings"]
+          if entry["scope"].to_s.empty? && settings.is_a?(Hash)
+            colors[:foreground] ||= settings["foreground"] if settings["foreground"].is_a?(String)
+            colors[:background] ||= settings["background"] if settings["background"].is_a?(String)
+            colors[:cursor] ||= settings["caret"] if settings["caret"].is_a?(String)
+            next
+          end
+          color = settings.is_a?(Hash) && settings["foreground"]
+          next unless color
+          scope = entry["scope"].to_s
+          key = TOKEN_KEYS.keys.find { |prefix| scope == prefix || scope.start_with?(prefix + ".") }
+          if key
+            syntax[TOKEN_KEYS.fetch(key)] = {"color" => color}
+          elsif warnings
+            warnings << "unsupported token scope: #{scope}"
+          end
+        end
+        new_theme(values["name"], colors, syntax)
+      rescue REXML::ParseException => error
+        raise Canopus::Error, "invalid tmTheme: #{error.message}"
+      end
+
+      def load(path, warnings: nil)
+        raise Canopus::Error, "theme exceeds 1 MiB" if File.size(path) > 1_048_576
+
+        source = File.read(path)
+        if File.extname(path).downcase == ".tmtheme"
+          tm_theme(source, warnings: warnings)
+        else
+          data = JSON.parse(source)
+          vscode(data, warnings: warnings)
+        end
+      rescue JSON::ParserError => error
+        raise Canopus::Error, "invalid theme JSON: #{error.message}"
+      end
+
+      def map_colors(values, warnings)
+        return {} unless values.is_a?(Hash)
+
+        values.each_with_object({}) do |(key, value), result|
+          mapped = COLOR_KEYS[key]
+          if mapped && value.is_a?(String)
+            result[mapped] = value
+          elsif warnings
+            warnings << "unsupported theme color: #{key}"
+          end
+        end
+      end
+
+      def new_theme(name, colors, syntax)
+        Canopus::Theme.new(name: name.to_s.empty? ? "Imported" : name, colors: colors, syntax: syntax)
+      end
+
+      def plist(element)
+        return {} unless element
+        return element.elements.each_with_object({}) do |child, result|
+          next unless child.name == "key"
+          value = child.next_element
+          result[child.text.to_s] = plist(value)
+        end if element.name == "dict"
+        return element.elements.map { |child| plist(child) } if element.name == "array"
+        return element.text.to_s if %w[string integer real].include?(element.name)
+        element.name == "true"
+      end
+    end
+  end
+end