simple-cli-options 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a20b6b59fed0e7c00325c3df20d25fdd3e860bfb8e4635e824abf29ad413348a
-  data.tar.gz: 4e1dde6d25abb317503dd35eee37199886163c37d3b79f2a250b3b6c09749e49
+  metadata.gz: ce3397d023615c8ad267915d0d1517da8bf0cdaee39396d120c03ca5294f8605
+  data.tar.gz: d083348e721fbc03f5818a506a680cecbfb244f715d3d7797ce1d8576d6aba9e
 SHA512:
-  metadata.gz: eea0745fe1eb1a4616f70e90f9d8f5397fc4ebea94018c1e99d97310a949c28656f46a32ecdba211189dba58689edb54bc5b022aea7a9502442cabc006923e62
-  data.tar.gz: 299417202d0fe3f9bdb7cc0ce4db4c92a6ab02843dc23fb9485f59ac10c41a4463efc689ffe421c8c1df38611455ff2b161829870b871b13a69c6ba9a7d64a7f
+  metadata.gz: 8a41c2323a41059d2d3e71db6f981ca02007c0660cd5a6014ff34181508c403eae7a57b4a6b1283f05dea299d3c77b1aa1ec0ab6a21a1636028304ebb09a1ecc
+  data.tar.gz: 927616b95925f141dd3c569cecbda0d802f03deab01d967b51a9279a03b868c50f0cb6bdf660e875a7dc2e1fd066d30fa69b24910b1dba920e4befa479b31a59

data/lib/option.rb

@@ -1,92 +1,145 @@
-# typed: strict
 # frozen_string_literal: true
+# typed: strict
 
 require 'sorbet-runtime'
-require 'stringio'
-
-# ==========================================
-# 1. Option クラス（各フラグの定義と検証・変換）
-# ==========================================
-class Option
-  extend T::Sig
-
-  sig { returns(Symbol) }
-  attr_reader :name
-
-  sig { returns(String) }
-  attr_reader :short, :long, :desc
-
-  sig { returns(T::Boolean) }
-  attr_reader :required_flag
-
-  sig do
-    params(
-      name: Symbol,
-      short: String,
-      long: String,
-      desc: String,
-      required: T::Boolean,
-      options: T.untyped
-    ).void
-  end
-  def initialize(name, short:, long:, desc:, required: false, **options)
-    @name = name
-    @short = short
-    @long = long
-    @desc = desc
-    @required_flag = required
-
-    validate_structure!
-
-    # バリデーションは追加(Array)可能、変換は上書き
-    # 各バリデータは、成功時に nil、失敗時にエラーメッセージ(String)を返す想定
-    @validators = T.let(
-      [options[:validate]].compact,
-      T::Array[T.proc.params(arg0: String).returns(T.nilable(String))]
-    )
-    @converter  = T.let(options[:convert] || ->(v) { v }, T.proc.params(arg0: String).returns(T.untyped))
-  end
 
-  sig { params(block: T.proc.params(arg0: String).returns(T.nilable(String))).returns(T.self_type) }
-  def validate(&block)
-    @validators << block
-    self
-  end
+module SimpleOptions
+  class Option
+    extend T::Sig
+
+    sig { returns(Symbol) }
+    attr_reader :name
+
+    sig { returns(String) }
+    attr_reader :short, :long, :desc
+
+    sig { returns(T::Boolean) }
+    attr_reader :required_flag
+
+    sig { returns(T.untyped) }
+    attr_reader :default
+
+    sig { returns(Symbol) }
+    attr_reader :type
+
+    BOOLEAN_MAP = T.let({
+      'true' => true, 't' => true, '1' => true, 'yes' => true, 'y' => true,
+      'false' => false, 'f' => false, '0' => false, 'no' => false, 'n' => false
+    }.freeze, T::Hash[String, T::Boolean])
+
+    sig do
+      params(
+        name: Symbol,
+        desc: String,
+        short: String,
+        long: String,
+        required: T::Boolean,
+        default: T.untyped,
+        type: Symbol,
+        options: T.untyped
+      ).void
+    end
+    def initialize(name, desc:, short: '', long: '', required: false, default: nil, type: :string, **options)
+      @name = name
+      @desc = desc
+      @required_flag = required
+      @default = default
+      @type = type
+
+      # short/longが両方空の場合、-nameを使用
+      if short.empty? && long.empty?
+        @short = "-#{name}"
+        @long = ''
+      else
+        @short = short
+        @long = long
+      end
+
+      validate_structure!
+
+      # バリデーション用Procの配列
+      @validators = T.let([], T::Array[T.proc.params(arg0: String).returns(T.nilable(String))])
+
+      # 型に基づいたデフォルトのバリデーションを追加
+      setup_default_validators
+
+      # カスタムバリデーターの取り込み
+      raw_validators = options[:validate]
+      if raw_validators.is_a?(Proc)
+        @validators << raw_validators
+      elsif raw_validators.is_a?(Array)
+        raw_validators.each { |v| @validators << v if v.is_a?(Proc) }
+      end
+
+      # 変換用Proc
+      @converter = T.let(
+        options[:convert] || ->(v) { convert_by_type(v) },
+        T.proc.params(arg0: String).returns(T.untyped)
+      )
+    end
 
-  sig { params(block: T.proc.params(arg0: String).returns(T.untyped)).returns(T.self_type) }
-  def convert(&block)
-    @converter = block
-    self
-  end
+    # 実行時にバリデーションと変換をまとめて行う
+    sig { params(value: T.nilable(String)).returns(T.untyped) }
+    def process(value)
+      return @default if value.nil?
+
+      # 1. バリデーションの実行
+      @validators.each do |v|
+        msg = v.call(value)
+        next if msg.nil?
 
-  sig { params(value: String).returns(T.untyped) }
-  def process(value)
-    @validators.each do |v|
-      msg = v.call(value)
-      next if msg.nil?
-
-      flags = [@short, @long].reject(&:empty?)
-      flags_part =
-        if flags.empty?
-          "option '#{@name}'"
-        else
-          "#{flags.join(' or ')} option"
-        end
-
-      raise ArgumentError, "#{msg} for #{flags_part}"
+        flags = [@short, @long].reject(&:empty?)
+        flags_part = flags.empty? ? "option '#{@name}'" : "#{flags.join(' or ')} option"
+        raise ArgumentError, "Validation failed: #{msg} for #{flags_part}"
+      end
+
+      # 2. 変換の実行
+      @converter.call(value)
     end
 
-    @converter.call(value)
-  end
+    # ビルダーパターン用メソッド
+    sig { params(block: T.proc.params(arg0: String).returns(T.nilable(String))).returns(T.self_type) }
+    def validate(&block)
+      @validators << block
+      self
+    end
 
-  private
+    private
 
-  sig { void }
-  def validate_structure!
-    raise ArgumentError, "Property 'name' and 'desc' cannot be empty." if @name.to_s.empty? || @desc.empty?
+    sig { void }
+    def setup_default_validators
+      case @type
+      when :integer
+        @validators << ->(v) { v.match?(/\A-?\d+\z/) ? nil : 'must be an integer' }
+      when :number
+        @validators << ->(v) { v.match?(/\A-?\d+(\.\d+)?\z/) ? nil : 'must be a number' }
+      end
+    end
 
-    return unless @short.empty? && @long.empty?
+    sig { params(value: String).returns(T.untyped) }
+    def convert_by_type(value)
+      case @type
+      when :integer then value.to_i
+      when :number  then smart_number(value)
+      when :boolean then BOOLEAN_MAP.fetch(value.downcase, true)
+      else value.to_s
+      end
+    end
 
-    raise ArgumentError, "At least one of 'short' or 'long' flags must be provided for option '#{@name}'."
+    sig { params(value: String).returns(T.any(Integer, Float, String)) }
+    def smart_number(value)
+      num = Float(value)
+      (num % 1).zero? ? num.to_i : num
+    rescue ArgumentError, TypeError
+      @default || value
+    end
+
+    sig { void }
+    def validate_structure!
+      raise ArgumentError, "Property 'name' and 'desc' cannot be empty." if @name.to_s.empty? || @desc.empty?
+      return unless @short.empty? && @long.empty?
+
+      raise ArgumentError, "At least one of 'short' or 'long' flags must be provided for option '#{@name}'."
+    end
   end
 end

data/lib/options.rb

@@ -1,71 +1,184 @@
-# typed: strict
 # frozen_string_literal: true
+# typed: strict
 
 require 'sorbet-runtime'
 require_relative 'option'
 
-# ==========================================
-# 2. Options クラス（オプションの管理と解析）
-# ==========================================
-class Options
-  extend T::Sig
-
-  sig { params(description: String).void }
-  def initialize(description: '')
-    @description = T.let(description, String)
-    @options = T.let([], T::Array[Option])
-    @values = T.let({}, T::Hash[Symbol, T.untyped])
-    @program_name = T.let(File.basename($0), String)
-  end
+module SimpleOptions
+  class Options
+    extend T::Sig
 
-  sig { params(option: Option).void }
-  def add(option)
-    @options << option
-  end
+    # initialize で引数をオプション（nil許容）に変更
+    sig { params(program_name: T.nilable(String), description: T.nilable(String)).void }
+    def initialize(program_name: nil, description: nil)
+      # 指定がなければ実行スクリプト名を取得
+      @program_name = T.let(program_name || File.basename($PROGRAM_NAME), String)
+      @description = T.let(description, T.nilable(String))
+      @options = T.let([], T::Array[Option])
+      @values = T.let({}, T::Hash[Symbol, T.untyped])
+    end
+
+    sig { params(name: String).void }
+    def program_name(name) = @program_name = name
 
-  sig { void }
-  def show_help
-    puts "#{@description}\n\n" unless @description.empty?
-    puts "Usage:\n  #{@program_name} [flags]\n\n"
-    puts 'Flags:'
-    @options.each do |opt|
-      flags = [
-        opt.short.empty? ? nil : opt.short,
-        opt.long.empty? ? nil : opt.long
-      ].compact.join(', ')
-      printf "  %-20s %s\n", flags, opt.desc
+    sig { params(desc: String).void }
+    def description(desc) = @description = desc
+
+    # --- 型明示的な定義メソッド ---
+
+    sig { params(name: Symbol, desc: String, short: String, long: String, required: T::Boolean, default: T.nilable(Integer)).returns(Option) }
+    def integer(name, desc: '', short: '', long: '', required: false, default: nil)
+      add_internal(name, desc, short, long, required, default || 0, type: :integer)
     end
-  end
 
-  sig { params(argv: T.nilable(T::Array[String])).void }
-  def parse!(argv = nil)
-    argv = T.let(argv || ARGV, T::Array[String])
+    sig { params(name: Symbol, desc: String, short: String, long: String, required: T::Boolean, default: T.nilable(T::Boolean)).returns(Option) }
+    def boolean(name, desc: '', short: '', long: '', required: false, default: nil)
+      add_internal(name, desc, short, long, required, default.nil? ? false : default, type: :boolean)
+    end
+
+    sig { params(name: Symbol, desc: String, short: String, long: String, required: T::Boolean, default: T.untyped).returns(Option) }
+    def number(name, desc: '', short: '', long: '', required: false, default: nil)
+      add_internal(name, desc, short, long, required, default || 0, type: :number)
+    end
+
+    sig { params(name: Symbol, desc: String, short: String, long: String, required: T::Boolean, default: T.nilable(String)).returns(Option) }
+    def string(name, desc: '', short: '', long: '', required: false, default: nil)
+      add_internal(name, desc, short, long, required, default || '', type: :string)
+    end
+
+    # 汎用的なoptionメソッド（typeを省略可能、デフォルトは:string）
+    sig { params(name: Symbol, desc: String, short: String, long: String, required: T::Boolean, default: T.untyped, type: Symbol).returns(Option) }
+    def option(name, desc: '', short: '', long: '', required: false, default: nil, type: :string)
+      add_internal(name, desc, short, long, required, default, type: type)
+    end
+
+    # --- ヘルプ表示（レイアウト改良版） ---
+
+    sig { void }
+    def show_help
+      # 1. プログラム名
+      puts @program_name
 
-    if argv.include?('-h') || argv.include?('--help')
-      show_help
-      exit 0
+      # 2. 説明文（存在する場合のみ、改行を入れて表示）
+      if @description && !@description.to_s.empty?
+        puts ''
+        puts @description
+      end
+
+      # 3. Usage
+      puts ''
+      puts 'Usage:'
+      puts "  #{@program_name} [flags]"
+
+      # 4. Flags
+      puts ''
+      puts 'Flags:'
+      @options.each do |opt|
+        short_part = opt.short.empty? ? '    ' : "#{opt.short},"
+        long_part  = opt.long.empty? ? '' : " #{opt.long}"
+
+        flag_str = "  #{short_part}#{long_part}"
+        printf "%-25<flag>s %<desc>s\n", flag: flag_str, desc: opt.desc
+      end
     end
 
-    @options.each do |opt|
-      # short または long に一致する引数を探す
-      idx = argv.find_index { |arg| arg == opt.short || arg == opt.long }
+    # --- パース処理 ---
+
+    sig { params(argv: T.nilable(T::Array[String])).void }
+    def parse(argv = nil)
+      args = T.let(argv || ARGV.dup, T::Array[String])
+
+      # ヘルプフラグが指定されている場合は、他のオプションをパースせず即座にヘルプを表示
+      if args.include?('-h') || args.include?('--help')
+        show_help
+        exit 0
+      end
+
+      @options.each { |opt| @values[opt.name] = opt.default }
+
+      while args.any?
+        arg = T.must(args.shift)
+
+        unless arg.start_with?('-')
+          (@values[:args] ||= []) << arg
+          next
+        end
+
+        opt = @options.find { |o| o.short == arg || o.long == arg }
+
+        if opt.nil?
+          warn "Error: Unknown option '#{arg}'"
+          puts ''
+          show_help
+          exit 1
+        end
+
+        # 既に値が設定されている場合はスキップ（最初の出現を優先）
+        if @values.key?(opt.name) && @values[opt.name] != opt.default
+          # 値を消費する必要がある
+          if opt.type == :boolean
+            next_arg = args.first
+            args.shift if next_arg && Option::BOOLEAN_MAP.key?(next_arg.downcase)
+          else
+            args.shift
+          end
+          next
+        end
 
-      if idx && argv[idx + 1]
         begin
-          @values[opt.name] = opt.process(T.must(argv[idx + 1]))
+          if opt.type == :boolean
+            next_arg = args.first
+            @values[opt.name] = if next_arg && Option::BOOLEAN_MAP.key?(next_arg.downcase)
+                                  opt.process(T.must(args.shift))
+                                else
+                                  true
+                                end
+          else
+            val = args.shift
+            if val.nil? || val.start_with?('-')
+              warn "Error: Missing value for option '#{arg}'"
+              exit 1
+            end
+            @values[opt.name] = opt.process(val)
+          end
         rescue ArgumentError => e
           warn "Error: #{e.message}"
           exit 1
         end
-      elsif opt.required_flag
-        warn "Error: Missing required option: #{opt.long.empty? ? opt.short : opt.long}"
-        exit 1
+      end
+
+      @options.each do |opt|
+        if opt.required_flag && (@values[opt.name] == opt.default || @values[opt.name].nil?)
+          warn "Error: Missing required option: #{opt.long.empty? ? opt.short : opt.long}"
+          exit 1
+        end
       end
     end
-  end
 
-  sig { params(name: Symbol).returns(T.untyped) }
-  def get(name)
-    @values[name]
+    sig { params(name: Symbol).returns(T.untyped) }
+    def get(name)
+      @values[name]
+    end
+
+    # addメソッド（Optionオブジェクトを直接追加）
+    sig { params(option: Option).returns(Option) }
+    def add(option)
+      @options << option
+      option
+    end
+
+    private
+
+    sig do
+      params(
+        name: Symbol, desc: String, short: String, long: String,
+        required: T::Boolean, default: T.untyped, type: Symbol
+      ).returns(Option)
+    end
+    def add_internal(name, desc, short, long, required, default, type: :string)
+      opt = Option.new(name, desc: desc, short: short, long: long, required: required, default: default, type: type)
+      @options << opt
+      opt
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-cli-options
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - HIROAKI SATOU
@@ -42,7 +42,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/hiroakisatou/simple-options
   source_code_uri: https://github.com/hiroakisatou/simple-options
-  changelog_uri: https://github.com/hiroakisatou/simple-options/blob/main/README.md
+  changelog_uri: https://github.com/hiroakisatou/simple-options/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -57,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A small Ruby library for parsing command-line flags (short and long options
   with values).