shoko 0.1.3 → 0.1.5

data/lib/shoko/adapters/output/kitty/image_transcoder.rb

@@ -3,68 +3,72 @@
 require 'open3'
 
 module Shoko
-  module Adapters::Output::Kitty
-    # Converts common raster image formats to PNG bytes so they can be rendered
-    # by the Kitty graphics protocol.
-    #
-    # This is invoked only when Kitty images are enabled and an image is about
-    # to be rendered; it is not part of the default import pipeline.
-    class ImageTranscoder
-      PNG_HEADER = "\x89PNG\r\n\x1a\n".b
+  module Adapters
+    module Output
+      module Kitty
+        # Converts common raster image formats to PNG bytes so they can be rendered
+        # by the Kitty graphics protocol.
+        #
+        # This is invoked only when Kitty images are enabled and an image is about
+        # to be rendered; it is not part of the default import pipeline.
+        class ImageTranscoder
+          PNG_HEADER = "\x89PNG\r\n\x1a\n".b
 
-      def initialize(command: nil)
-        @command = command || default_command
-      end
+          def initialize(command: nil)
+            @command = command || default_command
+          end
 
-      def available?
-        !@command.nil?
-      end
+          def available?
+            !@command.nil?
+          end
 
-      # @param bytes [String] original image bytes
-      # @return [String,nil] PNG bytes
-      def to_png(bytes)
-        data = String(bytes).dup
-        data.force_encoding(Encoding::BINARY)
-        return nil if data.empty?
-        return data if png?(data)
-        return nil unless available?
+          # @param bytes [String] original image bytes
+          # @return [String,nil] PNG bytes
+          def to_png(bytes)
+            data = String(bytes).dup
+            data.force_encoding(Encoding::BINARY)
+            return nil if data.empty?
+            return data if png?(data)
+            return nil unless available?
 
-        stdout, _stderr, status = Open3.capture3(*@command, stdin_data: data)
-        return nil unless status.success?
+            stdout, _stderr, status = Open3.capture3(*@command, stdin_data: data)
+            return nil unless status.success?
 
-        out = String(stdout).dup
-        out.force_encoding(Encoding::BINARY)
-        return nil unless png?(out)
+            out = String(stdout).dup
+            out.force_encoding(Encoding::BINARY)
+            return nil unless png?(out)
 
-        out
-      rescue StandardError
-        nil
-      end
+            out
+          rescue Shoko::Error
+            raise
+          end
 
-      private
+          private
 
-      def png?(bytes)
-        bytes.to_s.b.start_with?(PNG_HEADER)
-      rescue StandardError
-        false
-      end
+          def png?(bytes)
+            bytes.to_s.b.start_with?(PNG_HEADER)
+          rescue Shoko::Error
+            raise
+          end
 
-      def default_command
-        return ['magick', '-', 'png:-'] if executable_in_path?('magick')
-        return ['convert', '-', 'png:-'] if executable_in_path?('convert')
+          def default_command
+            return ['magick', '-', 'png:-'] if executable_in_path?('magick')
+            return ['convert', '-', 'png:-'] if executable_in_path?('convert')
 
-        nil
-      end
+            nil
+          end
 
-      def executable_in_path?(name)
-        ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |dir|
-          next false if dir.to_s.empty?
+          def executable_in_path?(name)
+            ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |dir|
+              next false if dir.to_s.empty?
 
-          path = File.join(dir, name)
-          File.file?(path) && File.executable?(path)
+              path = File.join(dir, name)
+              File.file?(path) && File.executable?(path)
+            end
+          rescue Shoko::Error
+            raise
+          end
         end
-      rescue StandardError
-        false
       end
     end
   end

data/lib/shoko/adapters/output/kitty/kitty_graphics.rb

@@ -3,112 +3,116 @@
 require 'base64'
 
 module Shoko
-  module Adapters::Output::Kitty
-    # Minimal support for the Kitty graphics protocol.
-    #
-    # This module intentionally keeps all logic in-process (no external commands)
-    # and suppresses terminal responses (q=2) to avoid corrupting raw input reads.
-    module KittyGraphics
-      module_function
+  module Adapters
+    module Output
+      module Kitty
+        # Minimal support for the Kitty graphics protocol.
+        #
+        # This module intentionally keeps all logic in-process (no external commands)
+        # and suppresses terminal responses (q=2) to avoid corrupting raw input reads.
+        module KittyGraphics
+          module_function
 
-      ESC = "\e"
-      APC_START = "#{ESC}_G".freeze
-      APC_END = "#{ESC}\\".freeze
-      MAX_CHUNK_BYTES = 4096
+          ESC = "\e"
+          APC_START = "#{ESC}_G".freeze
+          APC_END = "#{ESC}\\".freeze
+          MAX_CHUNK_BYTES = 4096
 
-      def supported?
-        return true if env_present?('KITTY_WINDOW_ID')
-        return true if ENV.fetch('TERM', '').include?('kitty')
-        return true if ENV.fetch('TERM_PROGRAM', '') == 'kitty'
+          def supported?
+            return true if env_present?('KITTY_WINDOW_ID')
+            return true if ENV.fetch('TERM', '').include?('kitty')
+            return true if ENV.fetch('TERM_PROGRAM', '') == 'kitty'
 
-        false
-      rescue StandardError
-        false
-      end
+            false
+          rescue Shoko::Error
+            raise
+          end
 
-      def enabled_for?(config_store)
-        return false unless supported?
-        return false unless config_store.respond_to?(:get)
+          def enabled_for?(config_reader)
+            return false unless supported?
+            return false unless config_reader
 
-        !!config_store.get(%i[config kitty_images])
-      rescue StandardError
-        false
-      end
+            !!config_reader.kitty_images
+          rescue Shoko::Error
+            raise
+          end
 
-      def transmit_png(image_id, png_bytes, quiet: true)
-        bytes = String(png_bytes).dup
-        bytes.force_encoding(Encoding::BINARY)
-        payload = Base64.strict_encode64(bytes)
-        chunks = chunk_payload(payload)
-        chunks.map.with_index do |chunk, index|
-          more = index < chunks.length - 1 ? 1 : 0
-          keys = if index.zero?
-                   { a: 't', f: 100, t: 'd', i: image_id.to_i, m: more }
-                 else
-                   { m: more }
-                 end
-          keys[:q] = 2 if quiet
-          control = serialize_keys(keys)
-          "#{APC_START}#{control};#{chunk}#{APC_END}"
-        end
-      end
+          def transmit_png(image_id, png_bytes, quiet: true)
+            bytes = String(png_bytes).dup
+            bytes.force_encoding(Encoding::BINARY)
+            payload = Base64.strict_encode64(bytes)
+            chunks = chunk_payload(payload)
+            chunks.map.with_index do |chunk, index|
+              more = index < chunks.length - 1 ? 1 : 0
+              keys = if index.zero?
+                       { a: 't', f: 100, t: 'd', i: image_id.to_i, m: more }
+                     else
+                       { m: more }
+                     end
+              keys[:q] = 2 if quiet
+              control = serialize_keys(keys)
+              "#{APC_START}#{control};#{chunk}#{APC_END}"
+            end
+          end
 
-      def place(image_id, placement_id:, cols:, rows:, quiet: true, **options)
-        z = options.fetch(:z, nil)
-        keys = {
-          a: 'p',
-          i: image_id.to_i,
-          p: placement_id.to_i,
-          c: cols.to_i,
-          r: rows.to_i,
-          C: 1,
-        }
-        keys[:q] = 2 if quiet
-        keys[:z] = z.to_i if z
-        "#{APC_START}#{serialize_keys(keys)}#{APC_END}"
-      end
+          def place(image_id, placement_id:, cols:, rows:, quiet: true, **options)
+            z = options.fetch(:z, nil)
+            keys = {
+              a: 'p',
+              i: image_id.to_i,
+              p: placement_id.to_i,
+              c: cols.to_i,
+              r: rows.to_i,
+              C: 1,
+            }
+            keys[:q] = 2 if quiet
+            keys[:z] = z.to_i if z
+            "#{APC_START}#{serialize_keys(keys)}#{APC_END}"
+          end
 
-      def virtual_place(image_id, cols:, rows:, placement_id: nil, quiet: true, **options)
-        z = options.fetch(:z, nil)
-        keys = {
-          a: 'p',
-          U: 1,
-          i: image_id.to_i,
-          p: placement_id.to_i,
-          c: cols.to_i,
-          r: rows.to_i,
-          C: 1,
-        }
-        keys.delete(:p) if placement_id.to_i <= 0
-        keys[:q] = 2 if quiet
-        keys[:z] = z.to_i if z
-        "#{APC_START}#{serialize_keys(keys)}#{APC_END}"
-      end
+          def virtual_place(image_id, cols:, rows:, placement_id: nil, quiet: true, **options)
+            z = options.fetch(:z, nil)
+            keys = {
+              a: 'p',
+              U: 1,
+              i: image_id.to_i,
+              p: placement_id.to_i,
+              c: cols.to_i,
+              r: rows.to_i,
+              C: 1,
+            }
+            keys.delete(:p) if placement_id.to_i <= 0
+            keys[:q] = 2 if quiet
+            keys[:z] = z.to_i if z
+            "#{APC_START}#{serialize_keys(keys)}#{APC_END}"
+          end
 
-      def delete_visible(quiet: true)
-        keys = { a: 'd' }
-        keys[:q] = 2 if quiet
-        "#{APC_START}#{serialize_keys(keys)}#{APC_END}"
-      end
+          def delete_visible(quiet: true)
+            keys = { a: 'd' }
+            keys[:q] = 2 if quiet
+            "#{APC_START}#{serialize_keys(keys)}#{APC_END}"
+          end
 
-      def chunk_payload(payload)
-        return [] if payload.nil? || payload.empty?
+          def chunk_payload(payload)
+            return [] if payload.nil? || payload.empty?
 
-        max = MAX_CHUNK_BYTES
-        payload.scan(/.{1,#{max}}/m)
-      end
-      private_class_method :chunk_payload
+            max = MAX_CHUNK_BYTES
+            payload.scan(/.{1,#{max}}/m)
+          end
+          private_class_method :chunk_payload
 
-      def serialize_keys(hash)
-        hash.map { |k, v| "#{k}=#{v}" }.join(',')
-      end
-      private_class_method :serialize_keys
+          def serialize_keys(hash)
+            hash.map { |k, v| "#{k}=#{v}" }.join(',')
+          end
+          private_class_method :serialize_keys
 
-      def env_present?(key)
-        value = ENV[key].to_s
-        !value.empty?
+          def env_present?(key)
+            value = ENV[key].to_s
+            !value.empty?
+          end
+          private_class_method :env_present?
+        end
       end
-      private_class_method :env_present?
     end
   end
 end