strong_csv 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c718425815c3296bf644f0206eb7f351a25565908eddf5ec9b5811c045a46ec
-  data.tar.gz: fb8912e844d913b06c026e46d0b78084f7f0b3e81738ef3cc48476d8e784d03d
+  metadata.gz: b3e78f36b30b9033ba93a1295d6086f94c1da0aab0da2f9d06050c8d64f85a3c
+  data.tar.gz: c841993791e0cb0918852368c88b5cc19bb0ab021e9234f9f56150eb6d837f77
 SHA512:
-  metadata.gz: cc0564f9036a150e8564ff3bd947d9e4d7197b25179d37ab1c0d9997c7517834c3c76d54b5e28a6c1c5631e5c64f2601989935052b21dd6d588fa7e521ec7c8d
-  data.tar.gz: 205d2e29e1512e1508328f724b63ec40cf1d138c8d3bf83e586f6f0d8d7730f2d8f5fae648a589650efaff1e6104c9cb56ae0b8771fb7098a34d34aa08c525ad
+  metadata.gz: c1ede33a7d67bb74f2d2f56704109d7ed5ba00d31b632a4c0c73a11ff95f5198cb9a63f7fa51dbc583b98adbde12e4cdebb86dcaa5d14775fde6ce3a3ee8aeca
+  data.tar.gz: 1cd0e73ee52d825dbc61acbdb45749b8c9fc66086006cbf81b5e2229e7e5736141c852ebb9e7a3ebbed91b22cfcf1857aef629874511cee5d02a36e544b61b46

data/README.md

@@ -2,11 +2,9 @@
 
 <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**
+## Motivation
 
 Some applications have a feature to receive a CSV file uploaded by a user,
 and in general, it needs to validate each cell of the CSV file.
@@ -40,7 +38,18 @@ gem install strong_csv
 
 ## Usage
 
-TBD: This hasn't yet been implemented.
+The most important APIs of strong_csv are `StrongCSV.new` and `StrongCSV#parse`.
+`StrongCSV.new` lets you declare types for each CSV column with Ruby's block syntax.
+Inside the block, you will mainly use `let` and declare types for a column.
+
+After defining types, you can parse CSV content with `StrongCSV#parse`.
+`StrongCSV#parse` won't raise errors as possible and just store error messages in its rows.
+The reason why it won't raise errors is CSV content may contain _invalid_ rows,
+but sometimes, it makes sense to ignore them and process something for _valid_ rows.
+If you want to stop all processes with invalid rows,
+check whether all rows are valid before proceeding with computation.
+
+Here is an example usage of this gem:
 
 ```ruby
 require "strong_csv"
@@ -51,8 +60,7 @@ strong_csv = StrongCSV.new do
   let :name, string(within: 1..255)
   let :description, string?(within: 1..1000)
   let :active, boolean
-  let :started_at, time?
-  let :data, any?
+  let :started_at, time?(format: "%Y-%m-%dT%H:%M:%S")
 
   # Literal declaration
   let :status, 0..6
@@ -71,7 +79,7 @@ strong_csv = StrongCSV.new do
   # Regular expressions
   let :url, %r{\Ahttps://}
 
-  # Custom validation.
+  # Custom validation
   #
   # This example sees the database to fetch exactly stored `User` IDs,
   # and it checks the `:user_id` cell really exists in the `users` table.
@@ -93,32 +101,345 @@ 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
 
-| Type                     | Arguments | Description                                                                             | Example                                                    |
-| ------------------------ | --------- | --------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
-| `integer`                |           | The value must be casted to Integer                                                     | `let :stock, integer`                                      |
-| `integer?`               |           | The value can be `nil`. If the value exists, it must satisfy `integer` constraint.      | `let :stock, integer?`                                     |
-| `float`                  |           | The value must be casted to Float                                                       | `let :rate, float`                                         |
-| `float?`                 |           | The value can be `nil`. If the value exists, it must satisfy `float` constraint.        | `let :rate, float?`                                        |
-| `boolean`                |           | The value must be casted to Boolean                                                     | `let :active, boolean`                                     |
-| `boolean?`               |           | The value can be `nil`. If the value exists, it must satisfy `boolean` constraint.      | `let :active, boolean?`                                    |
-| `string`                 | `:within` | The value must be casted to String                                                      | `let :name, string(within: 1..255)`                        |
-| `string?`                | `:within` | The value can be `nil`. If the value exists, it must satisfy `string` constraint.       | `let :name, string?(within: 1..255)`                       |
-| `time`                   | `:format` | The value must be casted to Time                                                        | `let :started_at, time(format: "%Y-%m-%dT%%H:%M:%S")`      |
-| `time?`                  | `:format` | The value can be `nil`. If the value exists, it must satisfy `time` constraint.         | `let :started_at, time?(format: "%Y-%m-%dT%%H:%M:%S")`     |
-| `optional`               | `type`    | The value can be `nil`. If the value exists, it must satisfy the given type constraint. | `let :foo, optional(123)`                                  |
-| `23` (Integer literal)   |           | The value must be casted to the specific Integer literal                                | `let :id, 3`                                               |
-| `15.12` (Float literal)  |           | The value must be casted to the specific Float literal                                  | `let :id, 3.8`                                             |
-| `1..10` (Range literal)  |           | The value must be casted to the beginning of Range and be covered with it               | `let :id, 10..30`, `let :id, 1.0..30`, `let :id, "a".."z"` |
-| `"abc"` (String literal) |           | The value must be casted to the specific String literal                                 | `let :drink, "coffee"`                                     |
-| , (Union type)           |           | The value must satisfy one of the subtypes                                              | `let :id, 1, 2, 3`                                         |
+<table>
+    <tr>
+        <th>Type</th>
+        <th>Description</th>
+    </tr>
+    <tr>
+        <td><a href="#integer-and-integer"><code>integer</code> and <code>integer?</code></a></td>
+        <td>The value must be casted to <code>Integer</code>.</td>
+    </tr>
+    <tr>
+        <td><a href="#float-and-float"><code>float</code> and <code>float?</code></a></td>
+        <td>The value must be casted to <code>Float</code>.</td>
+    </tr>
+    <tr>
+        <td><a href="#boolean-and-boolean"><code>boolean</code> and <code>boolean?</code></a></td>
+        <td>The value must be casted to Boolean (<code>true</code> or <code>false</code>).</td>
+    </tr>
+    <tr>
+        <td><a href="#string-and-string"><code>string</code> and <code>string?</code></a></td>
+        <td>The value must be casted to <code>String</code>.</td>
+    </tr>
+    <tr>
+        <td><a href="#time-and-time"><code>time</code> and <code>time?</code></a></td>
+        <td>The value must be casted to <code>Time</code>.</td>
+    </tr>
+    <tr>
+        <td><a href="#optional"><code>optional</code></a></td>
+        <td>The value can be <code>nil</code>. If the value exists, it must satisfy the given type constraint.</td>
+    </tr>
+    <tr>
+        <td><a href="#literal"><code>23</code> (Integer literal)</a></td>
+        <td>The value must be casted to the specific <code>Integer</code> literal.</td>
+    </tr>
+    <tr>
+        <td><a href="#literal"><code>15.12</code> (Float literal)</a></td>
+        <td>The value must be casted to the specific <code>Float</code> literal.</td>
+    </tr>
+    <tr>
+        <td><a href="#literal"><code>1..10</code> (Range literal)</a></td>
+        <td>The value must be casted to the beginning of <code>Range</code> and be covered with it.</td>
+    </tr>
+    <tr>
+        <td><a href="#literal"><code>"abc"</code> (String literal)</a></td>
+        <td>The value must be casted to the specific <code>String</code> literal.</td>
+    </tr>
+    <tr>
+        <td><a href="#literal"><code>%r{\Ahttps://}</code> (Regexp literal)</a></td>
+        <td>The value must be casted to a <code>String</code> that matches the specified Regexp.</td>
+    </tr>
+    <tr>
+        <td><a href="#union"><code>,</code> (Union type)</a></td>
+        <td>The value must satisfy one of the subtypes.</td>
+    </tr>
+</table>
+
+### `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. It also lets you allow values that satisfy the specified limitation through `:constraint`.
+
+_Example_
+
+```ruby
+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,user_id
+  12,0,1
+  20,,2
+  non-integer,1,4
+CSV
+
+result.map(&:valid?) # => [true, true, false]
+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. It also lets you allow values that satisfy the specified limitation through `:constraint`.
+
+_Example_
+
+```ruby
+strong_csv = StrongCSV.new do
+  let :tax_rate, float
+  let :fail_rate, float?
+end
+
+result = strong_csv.parse(<<~CSV)
+  tax_rate,fail_rate
+  0.02,0.1
+  0.05,
+  ,0.8
+CSV
+
+result.map(&:valid?) # => [true, true, false]
+result[0].slice(:tax_rate, :fail_rate) # => {:tax_rate=>0.02, :fail_rate=>0.1}
+result[1].slice(:tax_rate, :fail_rate) # => {:tax_rate=>0.05, :fail_rate=>nil}
+result[2].slice(:tax_rate, :fail_rate) # => {:tax_rate=>nil, :fail_rate=>0.8} (`nil` is not allowed for `tax_rate`)
+```
+
+### `boolean` and `boolean?`
+
+The value must be casted to Boolean (`true` of `false`).
+`"true"`, `"True"`, and `"TRUE"` are casted to `true`,
+while `"false"`, `"False"`, and `"FALSE"` are casted to `false`.
+`boolean?` allows the value to be `nil` as an optional boolean
+value.
+
+_Example_
+
+```ruby
+strong_csv = StrongCSV.new do
+  let :enabled, boolean
+  let :active, boolean?
+end
+
+result = strong_csv.parse(<<~CSV)
+  enabled,active
+  True,True
+  False,
+  ,
+CSV
+
+result.map(&:valid?) # => [true, true, false]
+result[0].slice(:enabled, :active) # => {:enabled=>true, :active=>true}
+result[1].slice(:enabled, :active) # => {:enabled=>false, :active=>nil}
+result[2].slice(:enabled, :active) # => {:enabled=>nil, :active=>nil} (`nil` is not allowed for `enabled`)
+```
+
+### `string` and `string?`
+
+The value must be casted to String. `string?` allows the value to be `nil` as an optional string value.
+They also support `:within` in its arguments, and it limits the length of the string value within the specified `Range`.
+
+_Example_
+
+```ruby
+strong_csv = StrongCSV.new do
+  let :name, string(within: 1..4)
+  let :description, string?
+end
+
+result = strong_csv.parse(<<~CSV)
+  name,description
+  JB,Hello
+  yykamei,
+  ,🤷
+CSV
+
+result.map(&:valid?) # => [true, false, false]
+result[0].slice(:name, :description) # => {:name=>"JB", :description=>"Hello"}
+result[1].slice(:name, :description) # => {:name=>"yykamei", :description=>nil} ("yykamei" exceeds the `Range` specified with `:within`)
+result[2].slice(:name, :description) # => {:name=>nil, :description=>"🤷"} (`nil` is not allowed for `name`)
+```
+
+### `time` and `time?`
+
+The value must be casted to Time. `time?` allows the value to be `nil` as an optional time value.
+They have the `:format` argument, which is used as the format
+of [`Time.strptime`](https://rubydoc.info/stdlib/time/Time.strptime);
+it means you can ensure the value must satisfy the time format. The default value of `:format` is `"%Y-%m-%d"`.
+
+_Example_
+
+```ruby
+strong_csv = StrongCSV.new do
+  let :start_on, time
+  let :updated_at, time?(format: "%FT%T")
+end
+
+result = strong_csv.parse(<<~CSV)
+  start_on,updated_at
+  2022-04-01,2022-04-30T15:30:59
+  2022-05-03
+  05-03,2021-09-03T09:48:23
+CSV
+
+result.map(&:valid?) # => [true, true, false]
+result[0].slice(:start_on, :updated_at) # => {:start_on=>2022-04-01 00:00:00 +0900, :updated_at=>2022-04-30 15:30:59 +0900}
+result[1].slice(:start_on, :updated_at) # => {:start_on=>2022-05-03 00:00:00 +0900, :updated_at=>nil}
+result[2].slice(:start_on, :updated_at) # => {:start_on=>"05-03", :updated_at=>2021-09-03 09:48:23 +0900} ("05-03" does not satisfy the default format `"%Y-%m-%d"`)
+```
+
+### `optional`
+
+While each type above has its optional type with `?`, literals cannot be suffixed with `?`.
+However, there would be a case to have an optional literal type.
+In this case, `optional` might be useful and lets you declare such types.
+
+_Example_
+
+```ruby
+strong_csv = StrongCSV.new do
+  let :foo, optional(123)
+  let :bar, optional("test")
+end
+
+result = strong_csv.parse(<<~CSV)
+  foo,bar
+  123,test
+  ,
+  124
+CSV
+
+result.map(&:valid?) # => [true, true, false]
+result[0].slice(:foo, :bar) # => {:foo=>123, :bar=>"test"}
+result[1].slice(:foo, :bar) # => {:foo=>nil, :bar=>nil}
+result[2].slice(:foo, :bar) # => {:foo=>"124", :bar=>nil} (124 is not equal to 123)
+```
+
+### Literal
+
+You can declare literal value as types. The supported literals are `Integer`, `Float`, `String`, and `Range`.
+
+_Example_
+
+```ruby
+strong_csv = StrongCSV.new do
+  let 0, 123
+  let 1, "test"
+  let 2, 2.5
+  let 3, 1..10
+  let 4, /[a-z]+/
+end
+
+result = strong_csv.parse(<<~CSV)
+  123,test,2.5,9,abc
+  123,test,2.5,0,xyz
+  123,Hey,2.5,10,!
+CSV
+
+result.map(&:valid?) # => [true, false, false]
+result[0].slice(0, 1, 2, 3, 4) # => {0=>123, 1=>"test", 2=>2.5, 3=>9, 4=>"abc"}
+result[1].slice(0, 1, 2, 3, 4) # => {0=>123, 1=>"test", 2=>2.5, 3=>"0", 4=>"xyz"} (0 is out of 1..10)
+result[2].slice(0, 1, 2, 3, 4) # => {0=>123, 1=>"Hey", 2=>2.5, 3=>10, 4=>"!"} ("Hey" is not equal to "test", and "!" does not match /[a-z]+/)
+```
+
+### Union
+
+There would be a case that it's alright if a value satisfies one of the types.
+Union types are useful for such a case.
+
+_Example_
+
+```ruby
+strong_csv = StrongCSV.new do
+  let :priority, 10, 20, 30
+  let :size, "S", "M", "L"
+end
+
+result = strong_csv.parse(<<~CSV)
+  priority,size
+  10,M
+  30,A
+  11,S
+CSV
+
+result.map(&:valid?) # => [true, false, false]
+result[0].slice(:priority, :size) # => {:priority=>10, :size=>"M"}
+result[1].slice(:priority, :size) # => {:priority=>30, :size=>"A"} ("A" is not one of "S", "M", and "L")
+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に変換できません"
+      constraint_error: "`%{value}`は指定された成約を満たしていません",
+    integer:
+      cant_be_casted: "`%{value}`はIntegerに変換できません"
+      constraint_error: "`%{value}`は指定された成約を満たしていません",
+    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
 

data/lib/strong_csv/i18n.rb

@@ -0,0 +1,47 @@
+# 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",
+        constraint_error: "`%{value}` does not satisfy the specified constraint",
+      },
+      integer: {
+        cant_be_casted: "`%{value}` can't be casted to Integer",
+        constraint_error: "`%{value}` does not satisfy the specified constraint",
+      },
+      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}`",
+      },
+    },
+  },
+)

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
+
+    # @param options [Hash] See `Types::Integer#initialize` for more details.
+    def integer(**options)
+      Types::Integer.new(**options)
     end
 
-    def integer?
-      optional(integer)
+    # @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.

data/lib/strong_csv/row.rb

@@ -6,7 +6,7 @@ class StrongCSV
     extend Forwardable
     using Types::Literal
 
-    def_delegators :@values, :[], :fetch
+    def_delegators :@values, :[], :fetch, :slice
 
     # @return [Hash]
     attr_reader :errors

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: ["`#{value.inspect}` can't be casted to Boolean"])
+        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")])
       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: [I18n.t("strong_csv.float.constraint_error", value: value.inspect, default: :"_strong_csv.float.constraint_error")])
+        end
       rescue ArgumentError, TypeError
-        ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Float"])
+        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")])
       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: [I18n.t("strong_csv.integer.constraint_error", value: value.inspect, default: :"_strong_csv.integer.constraint_error")])
+        end
       rescue ArgumentError, TypeError
-        ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Integer"])
+        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")])
       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: ["`#{inspect}` is expected, but `#{int}` was given"])
+            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")])
           end
         rescue ArgumentError, TypeError
-          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to #{self.class.name}"])
+          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")])
         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: ["`#{inspect}` is expected, but `#{float}` was given"])
+            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")])
           end
         rescue ArgumentError, TypeError
-          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to #{self.class.name}"])
+          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")])
         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: ["`nil` can't be casted to the beginning of `#{inspect}`"]) if value.nil?
+          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?
 
           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: ["`#{casted.inspect}` is not within `#{inspect}`"])
+            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")])
           end
         rescue ArgumentError
-          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to the beginning of `#{inspect}`"])
+          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")])
         end
       end
 
@@ -68,7 +68,21 @@ class StrongCSV
           if self == value
             ValueResult.new(value: self, original_value: value)
           else
-            ValueResult.new(original_value: value, error_messages: ["`#{inspect}` is expected, but `#{value.inspect}` was given"])
+            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")])
+          end
+        end
+      end
+
+      refine ::Regexp do
+        # @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?
+
+          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")])
           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: ["`#{value.inspect}` can't be casted to String"]) if value.nil?
+        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?
 
         casted = String(value)
         if @within && !@within.cover?(casted.size)
-          ValueResult.new(original_value: value, error_messages: ["`#{casted.inspect}` is out of range `#{@within.inspect}`"])
+          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")])
         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: ["`#{value.inspect}` can't be casted to Time"]) if value.nil?
+        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?
 
         ValueResult.new(value: ::Time.strptime(value.to_s, @format), original_value: value)
       rescue ArgumentError
-        ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to Time with the format `#{@format}`"])
+        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")])
       end
     end
   end

data/lib/strong_csv/version.rb

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

data/lib/strong_csv.rb

@@ -4,8 +4,10 @@ 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"
@@ -35,6 +37,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)

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: strong_csv
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Yutaka Kamei
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-29 00:00:00.000000000 Z
-dependencies: []
+date: 2022-05-12 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'
 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:
@@ -21,6 +41,7 @@ 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