rufio 0.41.0 → 0.50.0

data/lib/rufio/dsl_command.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Rufio
+  # DSLで定義されたコマンドを表すクラス
+  class DslCommand
+    attr_reader :name, :script, :description, :interpreter, :errors
+    attr_reader :ruby_block, :shell_command
+
+    # コマンドを初期化する
+    # @param name [String] コマンド名
+    # @param script [String, nil] スクリプトパス
+    # @param description [String] コマンドの説明
+    # @param interpreter [String, nil] インタープリタ（nilの場合は自動検出）
+    # @param ruby_block [Proc, nil] inline Rubyブロック
+    # @param shell_command [String, nil] inline シェルコマンド
+    def initialize(name:, script: nil, description: "", interpreter: nil,
+                   ruby_block: nil, shell_command: nil)
+      @name = name.to_s
+      @script = script ? normalize_path(script.to_s) : nil
+      @description = description.to_s
+      @interpreter = interpreter || auto_resolve_interpreter
+      @ruby_block = ruby_block
+      @shell_command = shell_command
+      @errors = []
+    end
+
+    # コマンドタイプを返す
+    # @return [Symbol] :ruby, :shell, :script のいずれか
+    def command_type
+      if @ruby_block
+        :ruby
+      elsif @shell_command
+        :shell
+      else
+        :script
+      end
+    end
+
+    # コマンドが有効かどうかを検証する
+    # @return [Boolean]
+    def valid?
+      @errors = []
+      validate_name
+      validate_execution_source
+      @errors.empty?
+    end
+
+    # 実行用の引数配列を返す
+    # @return [Array<String>] [インタープリタ, スクリプトパス]
+    def to_execution_args
+      [@interpreter, @script]
+    end
+
+    # ハッシュ表現を返す
+    # @return [Hash]
+    def to_h
+      hash = {
+        name: @name,
+        script: @script,
+        description: @description,
+        interpreter: @interpreter
+      }
+      hash[:has_ruby_block] = true if @ruby_block
+      hash[:shell_command] = @shell_command if @shell_command
+      hash
+    end
+
+    private
+
+    # パスを正規化する（チルダ展開、パストラバーサル解決）
+    # @param path [String] 入力パス
+    # @return [String] 正規化されたパス
+    def normalize_path(path)
+      return "" if path.empty?
+
+      # チルダを展開
+      expanded = File.expand_path(path)
+
+      # ファイルが存在する場合は実際のパスを取得（パストラバーサル解決）
+      if File.exist?(expanded)
+        File.realpath(expanded)
+      else
+        # ファイルが存在しない場合は展開されたパスをそのまま返す
+        expanded
+      end
+    end
+
+    # 拡張子からインタープリタを自動検出する
+    # @return [String, nil]
+    def auto_resolve_interpreter
+      return nil if @script.nil? || @script.empty?
+
+      InterpreterResolver.resolve_from_path(@script)
+    end
+
+    # コマンド名のバリデーション
+    def validate_name
+      if @name.empty?
+        @errors << "Command name is required"
+      end
+    end
+
+    # 実行ソースのバリデーション
+    # ruby_block, shell_command, script のいずれかが必要
+    def validate_execution_source
+      # ruby_block または shell_command がある場合はスクリプト不要
+      return if @ruby_block || @shell_command
+
+      # スクリプトパスのバリデーション
+      if @script.nil? || @script.empty?
+        @errors << "Script path is required"
+        return
+      end
+
+      unless File.exist?(@script)
+        @errors << "Script not found: #{@script}"
+      end
+    end
+  end
+end

data/lib/rufio/dsl_command_loader.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Rufio
+  # DSL設定ファイルを読み込んでDslCommandを生成するクラス
+  class DslCommandLoader
+    attr_reader :errors, :warnings
+
+    def initialize
+      @errors = []
+      @warnings = []
+    end
+
+    # 文字列からDSLを解析してコマンドをロードする
+    # @param dsl_string [String] DSL文字列
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def load_from_string(dsl_string)
+      @errors = []
+      @warnings = []
+
+      context = DslContext.new
+      begin
+        context.instance_eval(dsl_string)
+      rescue SyntaxError, StandardError => e
+        @errors << "DSL parse error: #{e.message}"
+        return []
+      end
+
+      validate_commands(context.commands)
+    end
+
+    # ファイルからDSLをロードする
+    # @param file_path [String] 設定ファイルのパス
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def load_from_file(file_path)
+      @errors = []
+      @warnings = []
+
+      expanded_path = File.expand_path(file_path)
+      unless File.exist?(expanded_path)
+        return []
+      end
+
+      content = File.read(expanded_path)
+      load_from_string(content)
+    end
+
+    # 複数のパスからDSLをロードする
+    # @param paths [Array<String>] 設定ファイルのパス配列
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def load_from_paths(paths)
+      commands = []
+
+      paths.each do |path|
+        commands.concat(load_from_file(path))
+      end
+
+      commands
+    end
+
+    # デフォルトのパスからDSLをロードする
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def load
+      load_from_paths(default_config_paths)
+    end
+
+    # デフォルトの設定ファイルパスを返す
+    # @return [Array<String>] 設定ファイルパスの配列
+    def default_config_paths
+      home = Dir.home
+      [
+        File.join(home, ".rufio", "commands.rb"),
+        File.join(home, ".config", "rufio", "commands.rb")
+      ]
+    end
+
+    private
+
+    # コマンドをバリデーションし、有効なもののみを返す
+    # @param commands [Array<DslCommand>] コマンドの配列
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def validate_commands(commands)
+      valid_commands = []
+
+      commands.each do |cmd|
+        if cmd.valid?
+          valid_commands << cmd
+        else
+          @warnings << "Command '#{cmd.name}' is invalid: #{cmd.errors.join(', ')}"
+        end
+      end
+
+      valid_commands
+    end
+
+    # DSL評価用の独立したコンテキスト
+    class DslContext < BasicObject
+      attr_reader :commands
+
+      def initialize
+        @commands = []
+      end
+
+      # コマンドを定義する
+      # @param name [String] コマンド名
+      # @yield コマンドの設定ブロック
+      def command(name, &block)
+        builder = CommandBuilder.new(name)
+        builder.instance_eval(&block) if block
+        @commands << builder.build
+      end
+
+      # 安全でないメソッドをブロック
+      def method_missing(method_name, *_args)
+        ::Kernel.raise ::NoMethodError, "Method '#{method_name}' is not allowed in DSL"
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        false
+      end
+    end
+
+    # コマンドビルダー
+    class CommandBuilder
+      def initialize(name)
+        @name = name
+        @script = nil
+        @description = ""
+        @interpreter = nil
+        @ruby_block = nil
+        @shell_command = nil
+      end
+
+      def script(path)
+        @script = path
+      end
+
+      def description(desc)
+        @description = desc
+      end
+
+      def interpreter(interp)
+        @interpreter = interp
+      end
+
+      # inline Rubyブロックを定義
+      def ruby(&block)
+        @ruby_block = block
+      end
+
+      # inline シェルコマンドを定義
+      def shell(command)
+        @shell_command = command
+      end
+
+      def build
+        DslCommand.new(
+          name: @name,
+          script: @script,
+          description: @description,
+          interpreter: @interpreter,
+          ruby_block: @ruby_block,
+          shell_command: @shell_command
+        )
+      end
+
+      # 未知のメソッドは無視
+      def method_missing(_method_name, *_args)
+        # DSL内で未知のメソッドが呼ばれた場合は無視
+        nil
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/rufio/interpreter_resolver.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Rufio
+  # 拡張子からインタープリタを解決するクラス
+  class InterpreterResolver
+    # デフォルトの拡張子とインタープリタのマッピング
+    DEFAULT_EXTENSIONS = {
+      ".rb" => "ruby",
+      ".py" => "python3",
+      ".sh" => "bash",
+      ".js" => "node",
+      ".pl" => "perl",
+      ".lua" => "lua",
+      ".ts" => "ts-node",
+      ".php" => "php",
+      ".ps1" => nil # プラットフォーム依存
+    }.freeze
+
+    class << self
+      # 拡張子からインタープリタを解決する
+      # @param extension [String] 拡張子（ドット付きまたはなし）
+      # @return [String, nil] インタープリタ名、解決できない場合はnil
+      def resolve(extension)
+        # ドットで始まらない場合は追加
+        ext = extension.start_with?(".") ? extension : ".#{extension}"
+        ext = ext.downcase
+
+        # PowerShellはプラットフォーム依存
+        return resolve_powershell if ext == ".ps1"
+
+        DEFAULT_EXTENSIONS[ext]
+      end
+
+      # ファイルパスから拡張子を取得してインタープリタを解決する
+      # @param path [String] ファイルパス
+      # @return [String, nil] インタープリタ名、解決できない場合はnil
+      def resolve_from_path(path)
+        ext = File.extname(path)
+        return nil if ext.empty?
+
+        resolve(ext)
+      end
+
+      # 全ての拡張子マッピングを取得する
+      # @return [Hash] 拡張子とインタープリタのマッピング
+      def all_extensions
+        # PowerShellのプラットフォーム依存を解決した状態で返す
+        DEFAULT_EXTENSIONS.merge(".ps1" => resolve_powershell)
+      end
+
+      # Windowsプラットフォームかどうか
+      # @return [Boolean]
+      def windows?
+        RUBY_PLATFORM =~ /mingw|mswin|cygwin/ ? true : false
+      end
+
+      # macOSプラットフォームかどうか
+      # @return [Boolean]
+      def macos?
+        RUBY_PLATFORM =~ /darwin/ ? true : false
+      end
+
+      # Linuxプラットフォームかどうか
+      # @return [Boolean]
+      def linux?
+        RUBY_PLATFORM =~ /linux/ ? true : false
+      end
+
+      private
+
+      # PowerShellのインタープリタを解決する
+      # WindowsではpowershellとWindowsではpwsh
+      # @return [String]
+      def resolve_powershell
+        windows? ? "powershell" : "pwsh"
+      end
+    end
+  end
+end

data/lib/rufio/script_executor.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Rufio
+  # スクリプトを安全に実行するクラス
+  class ScriptExecutor
+    class << self
+      # スクリプトを実行する
+      # @param interpreter [String] インタープリタ（ruby, python3, bashなど）
+      # @param script_path [String] スクリプトのパス
+      # @param args [Array<String>] スクリプトへの引数
+      # @param timeout [Numeric, nil] タイムアウト秒数（nilの場合は無制限）
+      # @param chdir [String, nil] 作業ディレクトリ
+      # @param env [Hash, nil] 環境変数
+      # @return [Hash] 実行結果
+      def execute(interpreter, script_path, args = [], timeout: nil, chdir: nil, env: nil)
+        # 配列ベースのコマンドを構築（シェルインジェクション防止）
+        command = [interpreter, script_path, *args]
+
+        # オプションを構築
+        options = {}
+        options[:chdir] = chdir if chdir
+        # 環境変数をマージ（既存の環境変数を保持）
+        spawn_env = env || {}
+
+        execute_with_options(command, spawn_env, options, timeout)
+      rescue StandardError => e
+        build_error_result(e)
+      end
+
+      # DslCommandを実行する（タイプ別に分岐）
+      # @param dsl_command [DslCommand] 実行するDSLコマンド
+      # @param args [Array<String>] 追加の引数
+      # @param timeout [Numeric, nil] タイムアウト秒数
+      # @param chdir [String, nil] 作業ディレクトリ
+      # @param env [Hash, nil] 環境変数
+      # @return [Hash] 実行結果
+      def execute_command(dsl_command, args = [], timeout: nil, chdir: nil, env: nil)
+        case dsl_command.command_type
+        when :ruby
+          execute_ruby(dsl_command)
+        when :shell
+          execute_shell(dsl_command, timeout: timeout, chdir: chdir, env: env)
+        else
+          exec_args = dsl_command.to_execution_args
+          execute(exec_args[0], exec_args[1], args, timeout: timeout, chdir: chdir, env: env)
+        end
+      end
+
+      # inline Rubyコマンドを実行する
+      # @param dsl_command [DslCommand] 実行するDSLコマンド
+      # @return [Hash] 実行結果
+      def execute_ruby(dsl_command)
+        result = dsl_command.ruby_block.call
+        {
+          success: true,
+          exit_code: 0,
+          stdout: result.to_s,
+          stderr: "",
+          timeout: false
+        }
+      rescue StandardError => e
+        {
+          success: false,
+          exit_code: 1,
+          stdout: "",
+          stderr: "",
+          error: e.message,
+          timeout: false
+        }
+      end
+
+      # inline シェルコマンドを実行する
+      # @param dsl_command [DslCommand] 実行するDSLコマンド
+      # @param timeout [Numeric, nil] タイムアウト秒数
+      # @param chdir [String, nil] 作業ディレクトリ
+      # @param env [Hash, nil] 環境変数
+      # @return [Hash] 実行結果
+      def execute_shell(dsl_command, timeout: nil, chdir: nil, env: nil)
+        options = {}
+        options[:chdir] = chdir if chdir
+        spawn_env = env || {}
+
+        if timeout
+          execute_shell_with_timeout(dsl_command.shell_command, spawn_env, options, timeout)
+        else
+          execute_shell_without_timeout(dsl_command.shell_command, spawn_env, options)
+        end
+      rescue StandardError => e
+        build_error_result(e)
+      end
+
+      private
+
+      # コマンドを実行し、結果を返す
+      # @param command [Array<String>] 実行するコマンド
+      # @param env [Hash] 環境変数
+      # @param options [Hash] Open3オプション
+      # @param timeout_sec [Numeric, nil] タイムアウト秒数
+      # @return [Hash] 実行結果
+      def execute_with_options(command, env, options, timeout_sec)
+        if timeout_sec
+          execute_with_timeout(command, env, options, timeout_sec)
+        else
+          execute_without_timeout(command, env, options)
+        end
+      end
+
+      # タイムアウト付きで実行
+      def execute_with_timeout(command, env, options, timeout_sec)
+        stdout = ""
+        stderr = ""
+        status = nil
+        timed_out = false
+        pid = nil
+
+        begin
+          Timeout.timeout(timeout_sec) do
+            stdin, stdout_io, stderr_io, wait_thread = Open3.popen3(env, *command, **options)
+            pid = wait_thread.pid
+            stdin.close
+            stdout = stdout_io.read
+            stderr = stderr_io.read
+            stdout_io.close
+            stderr_io.close
+            status = wait_thread.value
+          end
+        rescue Timeout::Error
+          timed_out = true
+          # プロセスを終了
+          if pid
+            begin
+              Process.kill("TERM", pid)
+              sleep 0.1
+              Process.kill("KILL", pid)
+            rescue Errno::ESRCH, Errno::EPERM
+              # プロセスが既に終了している、または権限がない
+            end
+          end
+        end
+
+        if timed_out
+          {
+            success: false,
+            exit_code: nil,
+            stdout: stdout,
+            stderr: stderr,
+            timeout: true
+          }
+        else
+          {
+            success: status&.success? || false,
+            exit_code: status&.exitstatus || 1,
+            stdout: stdout,
+            stderr: stderr,
+            timeout: false
+          }
+        end
+      end
+
+      # タイムアウトなしで実行
+      def execute_without_timeout(command, env, options)
+        stdout, stderr, status = Open3.capture3(env, *command, **options)
+
+        {
+          success: status.success?,
+          exit_code: status.exitstatus,
+          stdout: stdout,
+          stderr: stderr,
+          timeout: false
+        }
+      end
+
+      # シェルコマンドをタイムアウト付きで実行
+      def execute_shell_with_timeout(shell_command, env, options, timeout_sec)
+        stdout = ""
+        stderr = ""
+        status = nil
+        timed_out = false
+        pid = nil
+
+        begin
+          Timeout.timeout(timeout_sec) do
+            stdin, stdout_io, stderr_io, wait_thread = Open3.popen3(env, shell_command, **options)
+            pid = wait_thread.pid
+            stdin.close
+            stdout = stdout_io.read
+            stderr = stderr_io.read
+            stdout_io.close
+            stderr_io.close
+            status = wait_thread.value
+          end
+        rescue Timeout::Error
+          timed_out = true
+          if pid
+            begin
+              Process.kill("TERM", pid)
+              sleep 0.1
+              Process.kill("KILL", pid)
+            rescue Errno::ESRCH, Errno::EPERM
+              # プロセスが既に終了している、または権限がない
+            end
+          end
+        end
+
+        if timed_out
+          {
+            success: false,
+            exit_code: nil,
+            stdout: stdout,
+            stderr: stderr,
+            timeout: true
+          }
+        else
+          {
+            success: status&.success? || false,
+            exit_code: status&.exitstatus || 1,
+            stdout: stdout,
+            stderr: stderr,
+            timeout: false
+          }
+        end
+      end
+
+      # シェルコマンドをタイムアウトなしで実行
+      def execute_shell_without_timeout(shell_command, env, options)
+        stdout, stderr, status = Open3.capture3(env, shell_command, **options)
+
+        {
+          success: status.success?,
+          exit_code: status.exitstatus,
+          stdout: stdout,
+          stderr: stderr,
+          timeout: false
+        }
+      end
+
+      # エラー結果を構築
+      def build_error_result(error)
+        {
+          success: false,
+          exit_code: 1,
+          stdout: "",
+          stderr: "",
+          error: error.message,
+          timeout: false
+        }
+      end
+    end
+  end
+end

data/lib/rufio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rufio
-  VERSION = '0.41.0'
+  VERSION = '0.50.0'
 end

data/lib/rufio.rb

@@ -21,10 +21,13 @@ require_relative "rufio/application"
 require_relative "rufio/file_opener"
 require_relative "rufio/health_checker"
 
-# プラグインシステム
-require_relative "rufio/plugin_config"
-require_relative "rufio/plugin"
-require_relative "rufio/plugin_manager"
+# DSLコマンドシステム
+require_relative "rufio/interpreter_resolver"
+require_relative "rufio/dsl_command"
+require_relative "rufio/script_executor"
+require_relative "rufio/dsl_command_loader"
+require_relative "rufio/builtin_commands"
+
 require_relative "rufio/command_mode"
 require_relative "rufio/command_mode_ui"
 require_relative "rufio/command_history"
@@ -45,9 +48,6 @@ require_relative "rufio/project_mode"
 require_relative "rufio/project_command"
 require_relative "rufio/project_log"
 
-# プラグインをロード
-Rufio::PluginManager.load_all
-
 module Rufio
   class Error < StandardError; end
 end