strong_csv 0.4.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8078bf75d84307eb32f647a418d2cd2214d6891a78a25a73f7589b82fec0716c
-  data.tar.gz: 318af2a0c3a42ac7141819b06e729a5e98967c5106988bc4349b308f9c9d87f8
+  metadata.gz: 1c242c3b580ec02d431ae78bb7b8f370ef21248dae5fb89ea7ee158b0c9c04c6
+  data.tar.gz: 2d880a823b44c1da78eeb6b79196c56ff46e937efe86ac17e8a522ea8b97f4a0
 SHA512:
-  metadata.gz: 63aa30f83182e0cab08f816124945d9da91149faaa82017ba0a80ca8b39ef57fed5eab521db1efd8404045aadba189550bd779f195434cef2294975dc30216f3
-  data.tar.gz: e4e74ea2446efcf32f6e67fe8be5df207ae8dbd66b392df4c2fb8895cd71aebf70894d062e64eee2814295aa00f29876afcb95b4c3a88ffffd7be0c8e9a9ba21
+  metadata.gz: 81bcf7718f3b792f6ecc394cccc5eb610b32ecb89b9dd492d3f39ab5dadebb633b1c9f4bd804de355902632fd1790fb3bb7b5789a7bb79a6eff6ee1860078491
+  data.tar.gz: 39d417143c5262d1ac781bdd5414d5021e5018b5791a0d6ed6df7c0954b008154c8bc6542ce5cdc184b00b3c4c40a5bcfc4366872610a123feb3af93c991901d

data/README.md

@@ -2,8 +2,6 @@
 
 <a href="https://rubygems.org/gems/strong_csv"><img alt="strong_csv" src="https://img.shields.io/gem/v/strong_csv"></a>
 
-NOTE: This repository is still under development 🚧🚜🚧
-
 Type checker for a CSV file inspired by [strong_json](https://github.com/soutaro/strong_json).
 
 ## Motivation
@@ -81,8 +79,6 @@ strong_csv = StrongCSV.new do
   # Regular expressions
   let :url, %r{\Ahttps://}
 
-  # TODO: The followings are not implemented so far.
-
   # Custom validation
   #
   # This example sees the database to fetch exactly stored `User` IDs,
@@ -105,12 +101,30 @@ strong_csv.parse(data, field_size_limit: 2048) do |row|
     row[:active] # => true
     # do something with row
   else
-    row.errors # => { user_id: ["must be present", "must be an integer"] }
+    row.errors # => { user_id: ["`nil` can't be casted to Integer"] }
     # do something with row.errors
   end
 end
 ```
 
+You can also define types without CSV headers by specifying column numbers.
+Note the numbers must start from `0` (zero-based index).
+
+```ruby
+StrongCSV.new do
+  let 0, integer
+  let 1, string
+  let 2, 1..10
+end
+```
+
+This declaration expects a CSV has the contents like this:
+
+```csv
+123,abc,3
+830,mno,10
+```
+
 ## Available types
 
 <table>
@@ -171,7 +185,7 @@ end
 ### `integer` and `integer?`
 
 The value must be casted to Integer. `integer?` allows the value to be `nil`, so you can declare optional integer type
-for columns.
+for columns. It also lets you allow values that satisfy the specified limitation through `:constraint`.
 
 _Example_
 
@@ -179,25 +193,30 @@ _Example_
 strong_csv = StrongCSV.new do
   let :stock, integer
   let :state, integer?
+  let :user_id, integer(constraint: ->(v) { user_ids.include?(v)})
+  pick :user_id, as: :user_ids do |values|
+    User.where(id: values).ids
+  end
 end
 
 result = strong_csv.parse(<<~CSV)
-  stock,state
-  12,0
-  20,
-  non-integer,1
+  stock,state,user_id
+  12,0,1
+  20,,2
+  non-integer,1,4
 CSV
 
 result.map(&:valid?) # => [true, true, false]
-result[0].slice(:stock, :state) # => {:stock=>12, :state=>0}
-result[1].slice(:stock, :state) # => {:stock=>20, :state=>nil}
-result[2].slice(:stock, :state) # => {:stock=>"non-integer", :state=>1} ("non-integer" cannot be casted to Integer)
+result[0].slice(:stock, :state, :user_id) # => {:stock=>12, :state=>0, :user_id=>1}
+result[1].slice(:stock, :state, :user_id) # => {:stock=>20, :state=>nil, :user_id=>2}
+result[2].slice(:stock, :state, :user_id) # => {:stock=>"non-integer", :state=>1, :user_id=>"4"}
+result[2].errors.slice(:stock, :user_id) # => {:stock=>["`\"non-integer\"` can't be casted to Integer"], :user_id=>["`\"4\"` does not satisfy the specified constraint"]}
 ```
 
 ### `float` and `float?`
 
 The value must be casted to Float. `float?` allows the value to be `nil`, so you can declare optional float type for
-columns.
+columns. It also lets you allow values that satisfy the specified limitation through `:constraint`.
 
 _Example_
 
@@ -383,43 +402,6 @@ result[1].slice(:priority, :size) # => {:priority=>30, :size=>"A"} ("A" is not o
 result[2].slice(:priority, :size) # => {:priority=>"11", :size=>"S"} (11 is not one of 10, 20, and 30)
 ```
 
-## I18n (Internationalization)
-
-strong_csv depends on [i18n](https://rubygems.org/gems/i18n) for internationalization.
-If you want to have a locale-specific error message, put the message catalog in your locale files.
-Here is an example of a locale file.
-
-```yaml
-ja:
-  strong_csv:
-    boolean:
-      cant_be_casted: "`%{value}`はBooleanに変換できません"
-    float:
-      cant_be_casted: "`%{value}`はFloatに変換できません"
-    integer:
-      cant_be_casted: "`%{value}`はIntegerに変換できません"
-    literal:
-      integer:
-        unexpected: "`%{expected}`ではなく`%{value}`が入力されています"
-        cant_be_casted: "`%{expected}`ではなく`%{value}`が入力されています"
-      float:
-        unexpected: "`%{expected}`ではなく`%{value}`が入力されています"
-        cant_be_casted: "`%{value}`はFloatに変換できません"
-      string:
-        unexpected: "`%{expected}`ではなく`%{value}`が入力されています"
-      range:
-        cant_be_casted: "`%{value}`は`%{expected}`の始端に変換できません"
-        out_of_range: "`%{value}`は`%{range}`の範囲外です"
-      regexp:
-        cant_be_casted: "`%{value}`はStringに変換できません"
-        unexpected: "`%{value}`は`%{expected}`とマッチしませんでした"
-    string:
-      cant_be_casted: "`%{value}`はStringに変換できません"
-      out_of_range: "`%{value}`の文字数は`%{range}`の範囲外です"
-    time:
-      cant_be_casted: "`%{value}`は`%{time_format}`でTimeに変換できません"
-```
-
 ## Contributing
 
 Bug reports and pull requests are welcome on the [GitHub repository](https://github.com/yykamei/strong_csv).

data/lib/strong_csv/let.rb

@@ -9,9 +9,14 @@ class StrongCSV
     # @return [Boolean]
     attr_reader :headers
 
+    # @return [Hash]
+    attr_reader :pickers
+
     def initialize
       @types = {}
       @headers = false
+      @pickers = {}
+      @picked = {}
     end
 
     # @param name [String, Symbol, Integer]
@@ -30,12 +35,35 @@ class StrongCSV
       validate_columns
     end
 
-    def integer
-      Types::Integer.new
+    # #pick is intended for defining a singleton method with `:as`.
+    # This might be useful for the case where you want to receive IDs that are stored in a database,
+    # and you want to make sure the IDs actually exist.
+    #
+    # @example
+    #  pick :user_id, as: :user_ids do |user_ids|
+    #    User.where(id: user_ids).ids
+    #  end
+    #
+    # @param column [Symbol, Integer]
+    # @param as [Symbol]
+    # @yieldparam values [Array<String>] The values for the column. NOTE: This is an array of String, not casted values.
+    def pick(column, as:, &block)
+      define_singleton_method(as) do
+        @picked[as]
+      end
+      @pickers[as] = lambda do |csv|
+        @picked[as] = block.call(csv.map { |row| row[column] })
+      end
     end
 
-    def integer?
-      optional(integer)
+    # @param options [Hash] See `Types::Integer#initialize` for more details.
+    def integer(**options)
+      Types::Integer.new(**options)
+    end
+
+    # @param options [Hash] See `Types::Integer#initialize` for more details.
+    def integer?(**options)
+      optional(integer(**options))
     end
 
     def boolean
@@ -46,12 +74,14 @@ class StrongCSV
       optional(boolean)
     end
 
-    def float
-      Types::Float.new
+    # @param options [Hash] See `Types::Float#initialize` for more details.
+    def float(**options)
+      Types::Float.new(**options)
     end
 
-    def float?
-      optional(float)
+    # @param options [Hash] See `Types::Float#initialize` for more details.
+    def float?(**options)
+      optional(float(**options))
     end
 
     # @param options [Hash] See `Types::String#initialize` for more details.
@@ -59,6 +89,7 @@ class StrongCSV
       Types::String.new(**options)
     end
 
+    # @param options [Hash] See `Types::String#initialize` for more details.
     def string?(**options)
       optional(string(**options))
     end
@@ -68,6 +99,7 @@ class StrongCSV
       Types::Time.new(**options)
     end
 
+    # @param options [Hash] See `Types::Time#initialize` for more details.
     def time?(**options)
       optional(time(**options))
     end

data/lib/strong_csv/row.rb

@@ -28,6 +28,9 @@ class StrongCSV
       end
     end
 
+    # It returns true if the row has no errors.
+    #
+    # @return [Boolean]
     def valid?
       @errors.empty?
     end

data/lib/strong_csv/types/boolean.rb

@@ -17,7 +17,7 @@ class StrongCSV
         boolean = FALSE_VALUES.include?(value) ? false : nil
         return ValueResult.new(value: boolean, original_value: value) unless boolean.nil?
 
-        ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.boolean.cant_be_casted", value: value.inspect, default: :"_strong_csv.boolean.cant_be_casted")])
+        ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Boolean"])
       end
     end
   end

data/lib/strong_csv/types/float.rb

@@ -4,13 +4,27 @@ class StrongCSV
   module Types
     # Float type
     class Float < Base
+      DEFAULT_CONSTRAINT = ->(_) { true }
+      private_constant :DEFAULT_CONSTRAINT
+
+      # @param constraint [Proc]
+      def initialize(constraint: DEFAULT_CONSTRAINT)
+        super()
+        @constraint = constraint
+      end
+
       # @todo Use :exception for Float after we drop the support of Ruby 2.5
       # @param value [Object] Value to be casted to Float
       # @return [ValueResult]
       def cast(value)
-        ValueResult.new(value: Float(value), original_value: value)
+        float = Float(value)
+        if @constraint.call(float)
+          ValueResult.new(value: float, original_value: value)
+        else
+          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` does not satisfy the specified constraint"])
+        end
       rescue ArgumentError, TypeError
-        ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.float.cant_be_casted", value: value.inspect, default: :"_strong_csv.float.cant_be_casted")])
+        ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Float"])
       end
     end
   end

data/lib/strong_csv/types/integer.rb

@@ -4,13 +4,27 @@ class StrongCSV
   module Types
     # Integer type
     class Integer < Base
+      DEFAULT_CONSTRAINT = ->(_) { true }
+      private_constant :DEFAULT_CONSTRAINT
+
+      # @param constraint [Proc]
+      def initialize(constraint: DEFAULT_CONSTRAINT)
+        super()
+        @constraint = constraint
+      end
+
       # @todo Use :exception for Integer after we drop the support of Ruby 2.5
       # @param value [Object] Value to be casted to Integer
       # @return [ValueResult]
       def cast(value)
-        ValueResult.new(value: Integer(value), original_value: value)
+        int = Integer(value)
+        if @constraint.call(int)
+          ValueResult.new(value: int, original_value: value)
+        else
+          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` does not satisfy the specified constraint"])
+        end
       rescue ArgumentError, TypeError
-        ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.integer.cant_be_casted", value: value.inspect, default: :"_strong_csv.integer.cant_be_casted")])
+        ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Integer"])
       end
     end
   end

data/lib/strong_csv/types/literal.rb

@@ -13,10 +13,10 @@ class StrongCSV
           if int == self
             ValueResult.new(value: int, original_value: value)
           else
-            ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.integer.unexpected", value: int.inspect, expected: inspect, default: :"_strong_csv.literal.integer.unexpected")])
+            ValueResult.new(original_value: value, error_messages: ["`#{inspect}` is expected, but `#{int.inspect}` was given"])
           end
         rescue ArgumentError, TypeError
-          ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.integer.cant_be_casted", value: value.inspect, default: :"_strong_csv.literal.integer.cant_be_casted")])
+          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Integer"])
         end
       end
 
@@ -28,10 +28,10 @@ class StrongCSV
           if float == self
             ValueResult.new(value: float, original_value: value)
           else
-            ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.float.unexpected", value: float.inspect, expected: inspect, default: :"_strong_csv.literal.float.unexpected")])
+            ValueResult.new(original_value: value, error_messages: ["`#{inspect}` is expected, but `#{float.inspect}` was given"])
           end
         rescue ArgumentError, TypeError
-          ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.float.cant_be_casted", value: value.inspect, default: :"_strong_csv.literal.float.cant_be_casted")])
+          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Float"])
         end
       end
 
@@ -39,7 +39,7 @@ class StrongCSV
         # @param value [Object] Value to be casted to Range
         # @return [ValueResult]
         def cast(value)
-          return ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.range.cant_be_casted", value: value.inspect, expected: inspect, default: :"_strong_csv.literal.range.cant_be_casted")]) if value.nil?
+          return ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to the beginning of `#{inspect}`"]) if value.nil?
 
           casted = case self.begin
                    when ::Float
@@ -54,10 +54,10 @@ class StrongCSV
           if cover?(casted)
             ValueResult.new(value: casted, original_value: value)
           else
-            ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.range.out_of_range", value: casted.inspect, range: inspect, default: :"_strong_csv.literal.range.out_of_range")])
+            ValueResult.new(original_value: value, error_messages: ["`#{casted.inspect}` is not within `#{inspect}`"])
           end
         rescue ArgumentError
-          ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.range.cant_be_casted", value: value.inspect, expected: inspect, default: :"_strong_csv.literal.range.cant_be_casted")])
+          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to the beginning of `#{inspect}`"])
         end
       end
 
@@ -68,7 +68,7 @@ class StrongCSV
           if self == value
             ValueResult.new(value: self, original_value: value)
           else
-            ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.string.unexpected", value: value.inspect, expected: inspect, default: :"_strong_csv.literal.string.unexpected")])
+            ValueResult.new(original_value: value, error_messages: ["`#{inspect}` is expected, but `#{value.inspect}` was given"])
           end
         end
       end
@@ -77,12 +77,12 @@ class StrongCSV
         # @param value [Object] Value to be casted to String
         # @return [ValueResult]
         def cast(value)
-          return ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.regexp.cant_be_casted", value: value.inspect, default: :"_strong_csv.literal.regexp.cant_be_casted")]) if value.nil?
+          return ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to String"]) if value.nil?
 
           if self =~ value
             ValueResult.new(value: value, original_value: value)
           else
-            ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.literal.regexp.unexpected", value: value.inspect, expected: inspect, default: :"_strong_csv.literal.regexp.unexpected")])
+            ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` did not match `#{inspect}`"])
           end
         end
       end

data/lib/strong_csv/types/string.rb

@@ -15,11 +15,11 @@ class StrongCSV
       # @param value [Object] Value to be casted to Boolean
       # @return [ValueResult]
       def cast(value)
-        return ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.string.cant_be_casted", value: value.inspect, default: :"_strong_csv.string.cant_be_casted")]) if value.nil?
+        return ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to String"]) if value.nil?
 
         casted = String(value)
         if @within && !@within.cover?(casted.size)
-          ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.string.out_of_range", value: value.inspect, range: @within.inspect, default: :"_strong_csv.string.out_of_range")])
+          ValueResult.new(original_value: value, error_messages: ["The length of `#{value.inspect}` is out of range `#{@within.inspect}`"])
         else
           ValueResult.new(value: casted, original_value: value)
         end

data/lib/strong_csv/types/time.rb

@@ -15,11 +15,11 @@ class StrongCSV
       # @param value [Object] Value to be casted to Time
       # @return [ValueResult]
       def cast(value)
-        return ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.time.cant_be_casted", value: value.inspect, time_format: @format.inspect, default: :"_strong_csv.time.cant_be_casted")]) if value.nil?
+        return ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Time with the format `#{@format.inspect}`"]) if value.nil?
 
         ValueResult.new(value: ::Time.strptime(value.to_s, @format), original_value: value)
       rescue ArgumentError
-        ValueResult.new(original_value: value, error_messages: [I18n.t("strong_csv.time.cant_be_casted", value: value.inspect, time_format: @format.inspect, default: :"_strong_csv.time.cant_be_casted")])
+        ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Time with the format `#{@format.inspect}`"])
       end
     end
   end

data/lib/strong_csv/value_result.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class StrongCSV
-  # ValueResult represents a CSV field is valid or not and contains its casted value if it's valid.
+  # ValueResult represents whether a CSV field is valid or not, and contains its casted value if it's valid.
   class ValueResult
     DEFAULT_VALUE = Object.new
     private_constant :DEFAULT_VALUE
@@ -15,11 +15,13 @@ class StrongCSV
       @error_messages = error_messages
     end
 
-    # @return [Object] The casted value if it's valid. Otherwise, returns the original value.
+    # @return [::Float, ::Integer, ::Object, ::String, ::Range, Boolean, ::Time, nil] The casted value if it's valid. Otherwise, returns the original value.
     def value
       success? ? @value : @original_value
     end
 
+    # It returns true if the value is successfully casted.
+    #
     # @return [Boolean]
     def success?
       @error_messages.nil?

data/lib/strong_csv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class StrongCSV
-  VERSION = "0.4.0"
+  VERSION = "0.7.0"
 end

data/lib/strong_csv.rb

@@ -4,10 +4,8 @@ require "csv"
 require "forwardable"
 require "set"
 require "time"
-require "i18n"
 
 require_relative "strong_csv/version"
-require_relative "strong_csv/i18n"
 require_relative "strong_csv/value_result"
 require_relative "strong_csv/types/base"
 require_relative "strong_csv/types/boolean"
@@ -21,7 +19,7 @@ require_relative "strong_csv/types/union"
 require_relative "strong_csv/let"
 require_relative "strong_csv/row"
 
-# The top-level namespace for the strong_csv gem.
+# StrongCSV is a library for parsing CSV contents with type checking.
 class StrongCSV
   class Error < StandardError; end
 
@@ -37,6 +35,12 @@ class StrongCSV
     options.delete(:nil_value)
     options = options.merge(headers: @let.headers, header_converters: :symbol)
     csv = CSV.new(csv, **options)
+
+    @let.pickers.each_value do |picker|
+      picker.call(csv)
+      csv.rewind
+    end
+
     if block_given?
       csv.each do |row|
         yield Row.new(row: row, types: @let.types, lineno: csv.lineno)

data/sig/strong_csv.rbs

@@ -0,0 +1,163 @@
+# TypeProf 0.21.2
+
+type literals = ::Integer | ::Float | ::Range[untyped] | ::String | ::Regexp
+type declarable = StrongCSV::Types::Base | literals
+type casted = bool | ::Float | ::Integer | ::Range[untyped] | ::String | ::Regexp | ::Time
+type column = ::Integer | ::Symbol
+
+# Classes
+class StrongCSV
+  VERSION: String
+
+  @let: Let
+
+  def initialize: -> void
+
+  def parse: (String | IO, **untyped) -> Array[Row]
+    | (String | IO, **untyped) { (Row) -> void } -> untyped
+
+  class ValueResult
+    DEFAULT_VALUE: Object
+
+    @value: (casted)?
+    @original_value: untyped
+
+    attr_reader error_messages: [::String]?
+
+    def initialize: (original_value: ::String | nil, ?value: (casted | ::Object)?, ?error_messages: [::String]?) -> void
+
+    def value: -> ((casted | ::Object | nil)?)
+
+    def success?: -> bool
+  end
+
+  module Types
+    class Base
+      def cast: (untyped _value) -> bot
+    end
+
+    class Boolean < Base
+      TRUE_VALUES: Set[::String]
+      FALSE_VALUES: Set[::String]
+
+      def cast: (::String | nil) -> ValueResult
+    end
+
+    class Float < Base
+      DEFAULT_CONSTRAINT: ^(::Float) -> true
+
+      @constraint: ^(::Float) -> boolish
+
+      def initialize: (?constraint: ^(::Float) -> boolish) -> void
+
+      def cast: (::String | nil) -> ValueResult
+    end
+
+    class Integer < Base
+      DEFAULT_CONSTRAINT: ^(::Integer) -> true
+
+      @constraint: ^(::Integer) -> boolish
+
+      def initialize: (?constraint: ^(::Integer) -> boolish) -> void
+
+      def cast: (::String | nil) -> ValueResult
+    end
+
+    module Literal
+      def cast: (untyped value) -> ValueResult
+        | (untyped value) -> ValueResult
+        | (untyped value) -> ValueResult
+        | (untyped value) -> ValueResult
+        | (untyped value) -> ValueResult
+    end
+
+    class Optional < Base
+      @type: Boolean | Float | Integer | String | Time | Literal
+
+      def initialize: (declarable) -> void
+
+      def cast: (::String | nil) -> ValueResult
+    end
+
+    class String < Base
+      @within: Range[untyped] | nil
+
+      def initialize: (?within: Range[untyped] | nil) -> void
+
+      def cast: (::String | nil) -> ValueResult
+    end
+
+    class Time < Base
+      @format: ::String
+
+      def initialize: (?format: ::String) -> void
+
+      def cast: (::String | nil) -> ValueResult
+    end
+
+    class Union < Base
+      @types: Array[untyped]
+
+      def initialize: (untyped `type`, *untyped types) -> void
+
+      def cast: (::String | nil) -> untyped
+    end
+  end
+
+  class Let
+    @picked: Hash[untyped, untyped]
+
+    attr_reader types: Hash[column, [declarable, ^(casted) -> untyped | nil]]
+    attr_reader headers: bool
+    attr_reader pickers: Hash[untyped, Proc]
+
+    def initialize: -> void
+
+    def let: (::String | column, declarable, *declarable) -> void
+      | (::String | column, declarable, *declarable) { (casted) -> untyped } -> void
+
+    def pick: (column, as: ::Symbol) { (Array[::String]) -> untyped } -> void
+
+    def integer: (**untyped) -> Types::Integer
+
+    def integer?: (**untyped) -> Types::Optional
+
+    def boolean: -> Types::Boolean
+
+    def boolean?: -> Types::Optional
+
+    def float: (**untyped) -> Types::Float
+
+    def float?: (**untyped) -> Types::Optional
+
+    def string: (**untyped) -> Types::String
+
+    def string?: (**untyped) -> Types::Optional
+
+    def time: (**untyped) -> Types::Time
+
+    def time?: (**untyped) -> Types::Optional
+
+    def optional: (*declarable) -> Types::Optional
+
+    private
+
+    def validate_columns: -> bool
+  end
+
+  class Row
+    extend Forwardable
+
+    @values: Hash[column, casted | ::Object | nil]
+
+    attr_reader errors: Hash[column, Array[::String]]
+    attr_reader lineno: ::Integer
+
+    def initialize: (row: Array[::String] | CSV::Row, types: Hash[column, [declarable, (^(casted | ::Object | nil) -> untyped | nil)]], lineno: ::Integer) -> void
+
+    def valid?: -> bool
+  end
+
+  class Error < StandardError
+  end
+end

metadata

@@ -1,35 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: strong_csv
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Yutaka Kamei
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-10 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: i18n
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.8.11
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.8.11
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
+date: 2022-07-20 00:00:00.000000000 Z
+dependencies: []
 description: strong_csv is a type checker for a CSV file. It lets developers declare
   types for each column to ensure all cells are satisfied with desired types.
 email:
@@ -41,7 +21,6 @@ files:
 - LICENSE
 - README.md
 - lib/strong_csv.rb
-- lib/strong_csv/i18n.rb
 - lib/strong_csv/let.rb
 - lib/strong_csv/row.rb
 - lib/strong_csv/types/base.rb
@@ -55,6 +34,7 @@ files:
 - lib/strong_csv/types/union.rb
 - lib/strong_csv/value_result.rb
 - lib/strong_csv/version.rb
+- sig/strong_csv.rbs
 homepage: https://github.com/yykamei/strong_csv
 licenses:
 - MIT

data/lib/strong_csv/i18n.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-I18n.backend.store_translations(
-  :en, {
-    _strong_csv: {
-      boolean: {
-        cant_be_casted: "`%{value}` can't be casted to Boolean",
-      },
-      float: {
-        cant_be_casted: "`%{value}` can't be casted to Float",
-      },
-      integer: {
-        cant_be_casted: "`%{value}` can't be casted to Integer",
-      },
-      literal: {
-        integer: {
-          unexpected: "`%{expected}` is expected, but `%{value}` was given",
-          cant_be_casted: "`%{value}` can't be casted to Integer",
-        },
-        float: {
-          unexpected: "`%{expected}` is expected, but `%{value}` was given",
-          cant_be_casted: "`%{value}` can't be casted to Float",
-        },
-        string: {
-          unexpected: "`%{expected}` is expected, but `%{value}` was given",
-        },
-        range: {
-          cant_be_casted: "`%{value}` can't be casted to the beginning of `%{expected}`",
-          out_of_range: "`%{value}` is not within `%{range}`",
-        },
-        regexp: {
-          cant_be_casted: "`%{value}` can't be casted to String",
-          unexpected: "`%{value}` did not match `%{expected}`",
-        },
-      },
-      string: {
-        cant_be_casted: "`%{value}` can't be casted to String",
-        out_of_range: "The length of `%{value}` is out of range `%{range}`",
-      },
-      time: {
-        cant_be_casted: "`%{value}` can't be casted to Time with the format `%{time_format}`",
-      },
-    },
-  },
-)