beniya 0.1.0

data/lib/beniya/file_opener.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Beniya
+  class FileOpener
+    def initialize
+      @config_loader = ConfigLoader
+    end
+
+    def open_file(file_path)
+      return false unless File.exist?(file_path)
+      return false if File.directory?(file_path)
+
+      application = find_application_for_file(file_path)
+      execute_command(application, file_path)
+    end
+
+    def open_file_with_line(file_path, line_number)
+      return false unless File.exist?(file_path)
+      return false if File.directory?(file_path)
+
+      application = find_application_for_file(file_path)
+      execute_command_with_line(application, file_path, line_number)
+    end
+
+    private
+
+    def find_application_for_file(file_path)
+      extension = File.extname(file_path).downcase.sub('.', '')
+      applications = @config_loader.applications
+
+      applications.each do |extensions, app|
+        return app if extensions.is_a?(Array) && extensions.include?(extension)
+      end
+
+      applications[:default] || 'open'
+    end
+
+    def execute_command(application, file_path)
+      quoted_path = quote_shell_argument(file_path)
+
+      case RbConfig::CONFIG['host_os']
+      when /mswin|mingw|cygwin/
+        # Windows
+        system("start \"\" \"#{file_path}\"")
+      when /darwin/
+        # macOS
+        if application == 'open'
+          system("open #{quoted_path}")
+        else
+          # VSCodeなど特定のアプリケーション
+          system("#{application} #{quoted_path}")
+        end
+      else
+        # Linux/Unix
+        if application == 'open'
+          system("xdg-open #{quoted_path}")
+        else
+          system("#{application} #{quoted_path}")
+        end
+      end
+    rescue StandardError => e
+      warn "ファイルを開けませんでした: #{e.message}"
+      false
+    end
+
+    def execute_command_with_line(application, file_path, line_number)
+      quoted_path = quote_shell_argument(file_path)
+
+      case RbConfig::CONFIG['host_os']
+      when /mswin|mingw|cygwin/
+        # Windows
+        if application.include?('code')
+          system("#{application} --goto #{quoted_path}:#{line_number}")
+        else
+          system("start \"\" \"#{file_path}\"")
+        end
+      when /darwin/
+        # macOS
+        if application == 'open'
+          system("open #{quoted_path}")
+        elsif application.include?('code')
+          system("#{application} --goto #{quoted_path}:#{line_number}")
+        elsif application.include?('vim') || application.include?('nvim')
+          system("#{application} +#{line_number} #{quoted_path}")
+        else
+          system("#{application} #{quoted_path}")
+        end
+      else
+        # Linux/Unix
+        if application == 'open'
+          system("xdg-open #{quoted_path}")
+        elsif application.include?('code')
+          system("#{application} --goto #{quoted_path}:#{line_number}")
+        elsif application.include?('vim') || application.include?('nvim')
+          system("#{application} +#{line_number} #{quoted_path}")
+        else
+          system("#{application} #{quoted_path}")
+        end
+      end
+    rescue StandardError => e
+      warn "ファイルを開けませんでした: #{e.message}"
+      false
+    end
+
+    def quote_shell_argument(argument)
+      if argument.include?(' ') || argument.include?("'") || argument.include?('"')
+        '"' + argument.gsub('"', '\"') + '"'
+      else
+        argument
+      end
+    end
+  end
+end
+

data/lib/beniya/file_preview.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Beniya
+  class FilePreview
+    BINARY_THRESHOLD = 0.3  # treat as binary if 30% or more binary characters
+    DEFAULT_MAX_LINES = 50
+    MAX_LINE_LENGTH = 500
+
+    def initialize
+      # future: hold syntax highlight settings etc.
+    end
+
+    def preview_file(file_path, max_lines: DEFAULT_MAX_LINES)
+      return error_response(ConfigLoader.message('file.not_found')) unless File.exist?(file_path)
+      return error_response(ConfigLoader.message('file.not_readable')) unless File.readable?(file_path)
+
+      file_size = File.size(file_path)
+      return empty_response if file_size == 0
+
+      begin
+        # binary file detection
+        sample = File.read(file_path, [file_size, 512].min)
+        return binary_response if binary_file?(sample)
+
+        # process as text file
+        lines = read_text_file(file_path, max_lines)
+        file_type = determine_file_type(file_path)
+        
+        {
+          type: file_type[:type],
+          language: file_type[:language],
+          lines: lines[:content],
+          truncated: lines[:truncated],
+          size: file_size,
+          modified: File.mtime(file_path),
+          encoding: lines[:encoding]
+        }
+      rescue => e
+        error_response("#{ConfigLoader.message('file.read_error')}: #{e.message}")
+      end
+    end
+
+    private
+
+    def binary_file?(sample)
+      return false if sample.empty?
+      
+      binary_chars = sample.bytes.count { |byte| byte < 32 && ![9, 10, 13].include?(byte) }
+      (binary_chars.to_f / sample.bytes.length) > BINARY_THRESHOLD
+    end
+
+    def read_text_file(file_path, max_lines)
+      lines = []
+      truncated = false
+      encoding = "UTF-8"
+
+      File.open(file_path, "r:UTF-8") do |file|
+        file.each_line.with_index do |line, index|
+          break if index >= max_lines
+          
+          # truncate too long lines
+          if line.length > MAX_LINE_LENGTH
+            line = line[0...MAX_LINE_LENGTH] + "..."
+          end
+          
+          lines << line.chomp
+        end
+        
+        # check if there are more lines to read
+        truncated = !file.eof?
+      end
+
+      {
+        content: lines,
+        truncated: truncated,
+        encoding: encoding
+      }
+    rescue Encoding::InvalidByteSequenceError
+      # try Shift_JIS if UTF-8 fails
+      begin
+        lines = []
+        File.open(file_path, "r:Shift_JIS:UTF-8") do |file|
+          file.each_line.with_index do |line, index|
+            break if index >= max_lines
+            lines << line.chomp
+          end
+          truncated = !file.eof?
+        end
+        {
+          content: lines,
+          truncated: truncated,
+          encoding: "Shift_JIS"
+        }
+      rescue
+        {
+          content: ["(#{ConfigLoader.message('file.encoding_error')})"],
+          truncated: false,
+          encoding: "unknown"
+        }
+      end
+    end
+
+    def determine_file_type(file_path)
+      extension = File.extname(file_path).downcase
+      
+      case extension
+      when ".rb"
+        { type: "code", language: "ruby" }
+      when ".py"
+        { type: "code", language: "python" }
+      when ".js", ".mjs"
+        { type: "code", language: "javascript" }
+      when ".ts"
+        { type: "code", language: "typescript" }
+      when ".html", ".htm"
+        { type: "code", language: "html" }
+      when ".css"
+        { type: "code", language: "css" }
+      when ".json"
+        { type: "code", language: "json" }
+      when ".yml", ".yaml"
+        { type: "code", language: "yaml" }
+      when ".md", ".markdown"
+        { type: "code", language: "markdown" }
+      when ".txt", ".log"
+        { type: "text", language: nil }
+      else
+        { type: "text", language: nil }
+      end
+    end
+
+    def empty_response
+      {
+        type: "empty",
+        lines: [],
+        size: 0,
+        modified: File.mtime(""),
+        encoding: "UTF-8"
+      }
+    rescue
+      {
+        type: "empty",
+        lines: [],
+        size: 0,
+        modified: Time.now,
+        encoding: "UTF-8"
+      }
+    end
+
+    def binary_response
+      {
+        type: "binary",
+        message: "#{ConfigLoader.message('file.binary_file')} - #{ConfigLoader.message('file.cannot_preview')}",
+        lines: ["(#{ConfigLoader.message('file.binary_file')})"],
+        size: 0,
+        modified: Time.now,
+        encoding: "binary"
+      }
+    end
+
+    def error_response(message)
+      {
+        type: "error",
+        message: message,
+        lines: ["#{ConfigLoader.message('file.error_prefix')}: #{message}"],
+        size: 0,
+        modified: Time.now,
+        encoding: "UTF-8"
+      }
+    end
+  end
+end

data/lib/beniya/health_checker.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'pastel'
+
+module Beniya
+  class HealthChecker
+    def initialize
+      @pastel = Pastel.new
+      # Load configuration including language settings
+      ConfigLoader.load_config
+    end
+
+    def run_check
+      puts @pastel.bold(ConfigLoader.message('health.title'))
+      puts "=" * 40
+      puts
+
+      checks = [
+        { name: ConfigLoader.message('health.ruby_version'), method: :check_ruby_version },
+        { name: ConfigLoader.message('health.required_gems'), method: :check_required_gems },
+        { name: ConfigLoader.message('health.fzf'), method: :check_fzf },
+        { name: ConfigLoader.message('health.rga'), method: :check_rga },
+        { name: ConfigLoader.message('health.file_opener'), method: :check_file_opener }
+      ]
+
+      results = []
+      checks.each do |check|
+        result = send(check[:method])
+        results << result
+        print_check_result(check[:name], result)
+      end
+
+      puts
+      print_summary(results)
+      
+      results.all? { |r| r[:status] == :ok }
+    end
+
+    private
+
+    def check_ruby_version
+      version = RUBY_VERSION
+      major, minor = version.split('.').map(&:to_i)
+      
+      if major > 2 || (major == 2 && minor >= 7)
+        {
+          status: :ok,
+          message: "Ruby #{version}",
+          details: nil
+        }
+      else
+        {
+          status: :error,
+          message: "Ruby #{version} (requires >= 2.7.0)",
+          details: ConfigLoader.message('health.ruby_upgrade_needed')
+        }
+      end
+    end
+
+    def check_required_gems
+      required_gems = %w[io-console pastel tty-cursor tty-screen]
+      missing_gems = []
+
+      required_gems.each do |gem_name|
+        begin
+          require gem_name.gsub('-', '/')
+        rescue LoadError
+          missing_gems << gem_name
+        end
+      end
+
+      if missing_gems.empty?
+        {
+          status: :ok,
+          message: ConfigLoader.message('health.all_gems_installed'),
+          details: nil
+        }
+      else
+        {
+          status: :error,
+          message: "#{ConfigLoader.message('health.missing_gems')}: #{missing_gems.join(', ')}",
+          details: "#{ConfigLoader.message('health.gem_install_instruction')} #{missing_gems.join(' ')}"
+        }
+      end
+    end
+
+    def check_fzf
+      if system("which fzf > /dev/null 2>&1")
+        version = `fzf --version 2>/dev/null`.strip
+        {
+          status: :ok,
+          message: "fzf #{version}",
+          details: nil
+        }
+      else
+        {
+          status: :warning,
+          message: "fzf #{ConfigLoader.message('health.tool_not_found')}",
+          details: install_instruction_for('fzf')
+        }
+      end
+    end
+
+    def check_rga
+      if system("which rga > /dev/null 2>&1")
+        version = `rga --version 2>/dev/null | head -1`.strip
+        {
+          status: :ok,
+          message: version,
+          details: nil
+        }
+      else
+        {
+          status: :warning,
+          message: "rga #{ConfigLoader.message('health.tool_not_found')}",
+          details: install_instruction_for('rga')
+        }
+      end
+    end
+
+    def check_file_opener
+      case RUBY_PLATFORM
+      when /darwin/
+        opener = "open"
+        description = ConfigLoader.message('health.macos_opener')
+      when /linux/
+        opener = "xdg-open"
+        description = ConfigLoader.message('health.linux_opener')
+      when /mswin|mingw|cygwin/
+        opener = "explorer"
+        description = ConfigLoader.message('health.windows_opener')
+      else
+        return {
+          status: :warning,
+          message: "#{ConfigLoader.message('health.unknown_platform')}: #{RUBY_PLATFORM}",
+          details: ConfigLoader.message('health.file_open_may_not_work')
+        }
+      end
+
+      if system("which #{opener} > /dev/null 2>&1") || RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+        {
+          status: :ok,
+          message: description,
+          details: nil
+        }
+      else
+        {
+          status: :warning,
+          message: "#{opener} #{ConfigLoader.message('health.tool_not_found')}",
+          details: ConfigLoader.message('health.file_open_may_not_work')
+        }
+      end
+    end
+
+    def install_instruction_for(tool)
+      case RUBY_PLATFORM
+      when /darwin/
+        case tool
+        when 'fzf'
+          "#{ConfigLoader.message('health.install_brew')} fzf"
+        when 'rga'
+          "#{ConfigLoader.message('health.install_brew')} rga"
+        end
+      when /linux/
+        case tool
+        when 'fzf'
+          "#{ConfigLoader.message('health.install_apt')} fzf (Ubuntu/Debian) or check your package manager"
+        when 'rga'
+          ConfigLoader.message('health.rga_releases')
+        end
+      else
+        ConfigLoader.message('health.install_guide')
+      end
+    end
+
+    def print_check_result(name, result)
+      status_icon = case result[:status]
+                   when :ok
+                     @pastel.green("✓")
+                   when :warning
+                     @pastel.yellow("⚠")
+                   when :error
+                     @pastel.red("✗")
+                   end
+
+      status_color = case result[:status]
+                    when :ok
+                      :green
+                    when :warning
+                      :yellow
+                    when :error
+                      :red
+                    end
+
+      puts "#{status_icon} #{name.ljust(20)} #{@pastel.decorate(result[:message], status_color)}"
+      
+      if result[:details]
+        puts "  #{@pastel.dim(result[:details])}"
+      end
+    end
+
+    def print_summary(results)
+      ok_count = results.count { |r| r[:status] == :ok }
+      warning_count = results.count { |r| r[:status] == :warning }
+      error_count = results.count { |r| r[:status] == :error }
+
+      puts "#{ConfigLoader.message('health.summary')}"
+      puts "  #{@pastel.green("✓ #{ok_count} #{ConfigLoader.message('health.ok')}")}"
+      puts "  #{@pastel.yellow("⚠ #{warning_count} #{ConfigLoader.message('health.warnings')}")}}" if warning_count > 0
+      puts "  #{@pastel.red("✗ #{error_count} #{ConfigLoader.message('health.errors')}")}}" if error_count > 0
+
+      if error_count > 0
+        puts
+        puts @pastel.red(ConfigLoader.message('health.critical_missing'))
+      elsif warning_count > 0
+        puts
+        puts @pastel.yellow(ConfigLoader.message('health.optional_missing'))
+      else
+        puts
+        puts @pastel.green(ConfigLoader.message('health.all_passed'))
+      end
+    end
+  end
+end