strong_csv 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c718425815c3296bf644f0206eb7f351a25565908eddf5ec9b5811c045a46ec
-  data.tar.gz: fb8912e844d913b06c026e46d0b78084f7f0b3e81738ef3cc48476d8e784d03d
+  metadata.gz: a367df39ccd195cbb7f62845c919f9718a4ef536de595294991fa7bc26693ca7
+  data.tar.gz: 220e1d69c32123c78d5a31cb63d2c9c21686bbe76feb68e4f0aeb9762601e0e3
 SHA512:
-  metadata.gz: cc0564f9036a150e8564ff3bd947d9e4d7197b25179d37ab1c0d9997c7517834c3c76d54b5e28a6c1c5631e5c64f2601989935052b21dd6d588fa7e521ec7c8d
-  data.tar.gz: 205d2e29e1512e1508328f724b63ec40cf1d138c8d3bf83e586f6f0d8d7730f2d8f5fae648a589650efaff1e6104c9cb56ae0b8771fb7098a34d34aa08c525ad
+  metadata.gz: bfe0ecbb668a07be731f9f50143812fc42d213993b4e3591e04678a4c6323347f69f18a6241d4dbfa524faa37baada63c7ffc0ab394073c1f435c914910f5d95
+  data.tar.gz: d345d0c12929b60d801c16e8d994fa1570f0e5fc2034f6d74de3f96bf188a7a0e85f7b9c2b1bbe61a1a0f4e4cdb4a41deddf7915cbeb540ace4b0c790c5056b0

data/README.md

@@ -6,7 +6,7 @@ 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 +40,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 +62,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
@@ -68,10 +78,12 @@ strong_csv = StrongCSV.new do
     end
   end
 
+  # TODO: The followings are not implemented so far.
+
   # 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.
@@ -101,24 +113,304 @@ end
 
 ## 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="#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.
+
+_Example_
+
+```ruby
+strong_csv = StrongCSV.new do
+  let :stock, integer
+  let :state, integer?
+end
+
+result = strong_csv.parse(<<~CSV)
+  stock,state
+  12,0
+  20,
+  non-integer,1
+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)
+```
+
+### `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.
+
+_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
+end
+
+result = strong_csv.parse(<<~CSV)
+  123,test,2.5,9
+  123,test,2.5,0
+  123,Hey,2.5,10
+CSV
+
+result.map(&:valid?) # => [true, false, false]
+result[0].slice(0, 1, 2, 3) # => {0=>123, 1=>"test", 2=>2.5, 3=>9}
+result[1].slice(0, 1, 2, 3) # => {0=>123, 1=>"test", 2=>2.5, 3=>"0"} (0 is out of 1..10)
+result[2].slice(0, 1, 2, 3) # => {0=>123, 1=>"Hey", 2=>2.5, 3=>10} ("Hey" is not equal to "test")
+```
+
+### 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に変換できません"
+    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}`の範囲外です"
+    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,41 @@
+# 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}`",
+        },
+      },
+      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/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

@@ -10,7 +10,7 @@ class StrongCSV
       def cast(value)
         ValueResult.new(value: Float(value), original_value: value)
       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

@@ -10,7 +10,7 @@ class StrongCSV
       def cast(value)
         ValueResult.new(value: Integer(value), original_value: value)
       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,7 @@ 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

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.3.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"

metadata

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