strong_csv 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a6324b338c8922470db715a4db9aac4d29a7e658313326df6b860a51eda09a5
-  data.tar.gz: '095654b19ea937ca862c91b98e4c59d29f8ddd148d0cb2feac594edf1ea54a1f'
+  metadata.gz: 8078bf75d84307eb32f647a418d2cd2214d6891a78a25a73f7589b82fec0716c
+  data.tar.gz: 318af2a0c3a42ac7141819b06e729a5e98967c5106988bc4349b308f9c9d87f8
 SHA512:
-  metadata.gz: 9d729e901fcbe7b6cecbe7b0470d5dffaa4c51f7a11269b1f0b2db188c633ee46fb569fab333343268d9f2235ce790508bc0070e6d716888bdfb8ae08c75011c
-  data.tar.gz: 3cfc376f86564afea311afae002488172c9b01ec4676791e7c78b3192495361ddc9f9531a57987c7235c7420acf04819c265c29213a9282c23a93c45af5aae4f
+  metadata.gz: 63aa30f83182e0cab08f816124945d9da91149faaa82017ba0a80ca8b39ef57fed5eab521db1efd8404045aadba189550bd779f195434cef2294975dc30216f3
+  data.tar.gz: e4e74ea2446efcf32f6e67fe8be5df207ae8dbd66b392df4c2fb8895cd71aebf70894d062e64eee2814295aa00f29876afcb95b4c3a88ffffd7be0c8e9a9ba21

data/README.md

@@ -1,10 +1,12 @@
 # strong_csv
 
+<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.
@@ -21,7 +23,7 @@ strong_json helps you to mitigate such a drudgery by letting you declare desired
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'strong_csv'
+gem "strong_csv"
 ```
 
 And then execute:
@@ -38,22 +40,34 @@ 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"
+
 strong_csv = StrongCSV.new do
   let :stock, integer
   let :tax_rate, float
-  let :name, string(255)
-  let :description, string?(1000)
+  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
-  let :priority, 10 | 20 | 30 | 40 | 50
-  let :size, "S" | "M" | "L" do |value|
+  let :priority, 10, 20, 30, 40, 50
+  let :size, "S", "M", "L" do |value|
     case value
     when "S"
       1
@@ -67,7 +81,9 @@ strong_csv = StrongCSV.new do
   # Regular expressions
   let :url, %r{\Ahttps://}
 
-  # Custom validation.
+  # TODO: The followings are not implemented so far.
+
+  # 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.
@@ -75,7 +91,7 @@ strong_csv = StrongCSV.new do
   pick :user_id, as: :user_ids do |ids|
     User.where(id: ids).ids
   end
-  let :user_id, integer { |i| user_ids.include?(i) }
+  let :user_id, integer(constraint: ->(i) { user_ids.include?(i) })
 end
 
 data = <<~CSV
@@ -89,7 +105,7 @@ strong_csv.parse(data, field_size_limit: 2048) do |row|
     row[:active] # => true
     # do something with row
   else
-    row.errors # => [{ row: 2, column: :user_id, messages: ["must be present", "must be an Integer", "must satisfy the custom validation"] }]
+    row.errors # => { user_id: ["must be present", "must be an integer"] }
     # do something with row.errors
   end
 end
@@ -97,9 +113,312 @@ end
 
 ## Available types
 
-| Type    | Description                         |
-| ------- | ----------------------------------- |
-| integer | The value must be casted to Integer |
+<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.
+
+_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
+  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に変換できません"
+    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
 

data/lib/strong_csv/i18n.rb

@@ -0,0 +1,45 @@
+# 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}`",
+      },
+    },
+  },
+)

data/lib/strong_csv/let.rb

@@ -3,7 +3,11 @@
 class StrongCSV
   # Let is a class that is used to define types for columns.
   class Let
-    attr_reader :types, :headers
+    # @return [Hash{Symbol => [Types::Base, Proc]}]
+    attr_reader :types
+
+    # @return [Boolean]
+    attr_reader :headers
 
     def initialize
       @types = {}
@@ -11,12 +15,15 @@ class StrongCSV
     end
 
     # @param name [String, Symbol, Integer]
-    def let(name, type)
+    # @param type [StrongCSV::Type::Base]
+    # @param types [Array<StrongCSV::Type::Base>]
+    def let(name, type, *types, &block)
+      type = types.empty? ? type : Types::Union.new(type, *types)
       case name
-      when Integer
-        @types[name] = type
-      when String, Symbol
-        @types[name.to_sym] = type
+      when ::Integer
+        @types[name] = [type, block]
+      when ::String, ::Symbol
+        @types[name.to_sym] = [type, block]
       else
         raise TypeError, "Invalid type specified for `name`. `name` must be String, Symbol, or Integer: #{name.inspect}"
       end
@@ -27,6 +34,49 @@ class StrongCSV
       Types::Integer.new
     end
 
+    def integer?
+      optional(integer)
+    end
+
+    def boolean
+      Types::Boolean.new
+    end
+
+    def boolean?
+      optional(boolean)
+    end
+
+    def float
+      Types::Float.new
+    end
+
+    def float?
+      optional(float)
+    end
+
+    # @param options [Hash] See `Types::String#initialize` for more details.
+    def string(**options)
+      Types::String.new(**options)
+    end
+
+    def string?(**options)
+      optional(string(**options))
+    end
+
+    # @param options [Hash] See `Types::Time#initialize` for more details.
+    def time(**options)
+      Types::Time.new(**options)
+    end
+
+    def time?(**options)
+      optional(time(**options))
+    end
+
+    # @param args [Array] See `Types::Optional#initialize` for more details.
+    def optional(*args)
+      Types::Optional.new(*args)
+    end
+
     private
 
     def validate_columns

data/lib/strong_csv/row.rb

@@ -4,8 +4,9 @@ class StrongCSV
   # Row is a representation of a row in a CSV file, which has casted values with specified types.
   class Row
     extend Forwardable
+    using Types::Literal
 
-    def_delegators :@values, :[], :fetch
+    def_delegators :@values, :[], :fetch, :slice
 
     # @return [Hash]
     attr_reader :errors
@@ -20,10 +21,10 @@ class StrongCSV
       @values = {}
       @errors = {}
       @lineno = lineno
-      types.each do |key, type|
+      types.each do |key, (type, block)|
         value_result = type.cast(row[key])
-        @values[key] = value_result.value
-        @errors[key] = value_result.error_message unless value_result.success?
+        @values[key] = block && value_result.success? ? block.call(value_result.value) : value_result.value
+        @errors[key] = value_result.error_messages unless value_result.success?
       end
     end
 

data/lib/strong_csv/types/boolean.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class StrongCSV
+  module Types
+    # Boolean type
+    class Boolean < Base
+      TRUE_VALUES = %w[true True TRUE].to_set.freeze
+      FALSE_VALUES = %w[false False FALSE].to_set.freeze
+      private_constant :TRUE_VALUES, :FALSE_VALUES
+
+      # @param value [Object] Value to be casted to Boolean
+      # @return [ValueResult]
+      def cast(value)
+        boolean = TRUE_VALUES.include?(value) ? true : nil
+        return ValueResult.new(value: boolean, original_value: value) unless boolean.nil?
+
+        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")])
+      end
+    end
+  end
+end

data/lib/strong_csv/types/float.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class StrongCSV
+  module Types
+    # Float type
+    class Float < Base
+      # @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)
+      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")])
+      end
+    end
+  end
+end

data/lib/strong_csv/types/integer.rb

@@ -5,10 +5,12 @@ class StrongCSV
     # Integer type
     class Integer < Base
       # @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)
       rescue ArgumentError, TypeError
-        ValueResult.new(original_value: value, error_message: "`#{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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+class StrongCSV
+  module Types
+    # Literal is a module to collect all the literal types for CSV parsing.
+    # This module is intended for refining built-in classes and provide `#cast` like `Base` class.
+    module Literal
+      refine ::Integer do
+        # @param value [Object] Value to be casted to Integer
+        # @return [ValueResult]
+        def cast(value)
+          int = Integer(value)
+          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")])
+          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")])
+        end
+      end
+
+      refine ::Float do
+        # @param value [Object] Value to be casted to Float
+        # @return [ValueResult]
+        def cast(value)
+          float = Float(value)
+          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")])
+          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")])
+        end
+      end
+
+      refine ::Range do
+        # @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?
+
+          casted = case self.begin
+                   when ::Float
+                     Float(value)
+                   when ::Integer
+                     Integer(value)
+                   when ::String
+                     value
+                   else
+                     raise TypeError, "#{self.begin.class} is not supported"
+                   end
+          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")])
+          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")])
+        end
+      end
+
+      refine ::String do
+        # @param value [Object] Value to be casted to String
+        # @return [ValueResult]
+        def cast(value)
+          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")])
+          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
+    end
+  end
+end

data/lib/strong_csv/types/optional.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class StrongCSV
+  module Types
+    # Optional type
+    class Optional < Base
+      using Types::Literal
+
+      # @param type [Base]
+      def initialize(type)
+        super()
+        @type = type
+      end
+
+      # @param value [Object]
+      # @return [ValueResult]
+      def cast(value)
+        value.nil? ? ValueResult.new(value: nil, original_value: value) : @type.cast(value)
+      end
+    end
+  end
+end

data/lib/strong_csv/types/string.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class StrongCSV
+  module Types
+    # String type
+    class String < Base
+      # @param within [Range, nil]
+      def initialize(within: nil)
+        raise ArgumentError, "`within` must be a Range" unless within.nil? || within.is_a?(Range)
+
+        super()
+        @within = within
+      end
+
+      # @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?
+
+        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")])
+        else
+          ValueResult.new(value: casted, original_value: value)
+        end
+      end
+    end
+  end
+end

data/lib/strong_csv/types/time.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class StrongCSV
+  module Types
+    # Time type
+    class Time < Base
+      # @param format [String] The format of #strptime
+      def initialize(format: "%Y-%m-%d")
+        raise ArgumentError, "`format` must be a String" unless format.is_a?(::String)
+
+        super()
+        @format = format
+      end
+
+      # @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?
+
+        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")])
+      end
+    end
+  end
+end

data/lib/strong_csv/types/union.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class StrongCSV
+  module Types
+    # Union type is a type that combine multiple types.
+    class Union < Base
+      using Types::Literal
+
+      # @param type [Base]
+      # @param types [Array<Base>]
+      def initialize(type, *types)
+        super()
+        @types = [type, *types]
+      end
+
+      # @param value [Object] Value to be casted to Integer
+      # @return [ValueResult]
+      def cast(value)
+        results = @types.map { |type| type.cast(value) }
+        results.find(&:success?) || results.reduce do |memo, result|
+          memo.error_messages.concat(result.error_messages).uniq!
+          memo
+        end
+      end
+    end
+  end
+end

data/lib/strong_csv/value_result.rb

@@ -6,13 +6,13 @@ class StrongCSV
     DEFAULT_VALUE = Object.new
     private_constant :DEFAULT_VALUE
 
-    # @return [String, nil] The error message for the field.
-    attr_reader :error_message
+    # @return [Array<String>, nil] The error messages for the field.
+    attr_reader :error_messages
 
-    def initialize(original_value:, value: DEFAULT_VALUE, error_message: nil)
+    def initialize(original_value:, value: DEFAULT_VALUE, error_messages: nil)
       @value = value
       @original_value = original_value
-      @error_message = error_message
+      @error_messages = error_messages
     end
 
     # @return [Object] The casted value if it's valid. Otherwise, returns the original value.
@@ -22,7 +22,7 @@ class StrongCSV
 
     # @return [Boolean]
     def success?
-      @error_message.nil?
+      @error_messages.nil?
     end
   end
 end

data/lib/strong_csv/version.rb

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

data/lib/strong_csv.rb

@@ -2,12 +2,23 @@
 
 require "csv"
 require "forwardable"
+require "set"
+require "time"
+require "i18n"
 
 require_relative "strong_csv/version"
-require_relative "strong_csv/let"
+require_relative "strong_csv/i18n"
 require_relative "strong_csv/value_result"
 require_relative "strong_csv/types/base"
+require_relative "strong_csv/types/boolean"
+require_relative "strong_csv/types/float"
 require_relative "strong_csv/types/integer"
+require_relative "strong_csv/types/literal"
+require_relative "strong_csv/types/optional"
+require_relative "strong_csv/types/string"
+require_relative "strong_csv/types/time"
+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.
@@ -22,6 +33,8 @@ class StrongCSV
   # @param csv [String, IO]
   # @param options [Hash] CSV options for parsing.
   def parse(csv, **options)
+    # NOTE: Some options are overridden here to ensure that StrongCSV can handle parsed values correctly.
+    options.delete(:nil_value)
     options = options.merge(headers: @let.headers, header_converters: :symbol)
     csv = CSV.new(csv, **options)
     if block_given?

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: strong_csv
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Yutaka Kamei
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2022-04-26 00:00:00.000000000 Z
-dependencies: []
+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'
 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,10 +41,18 @@ 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
+- lib/strong_csv/types/boolean.rb
+- lib/strong_csv/types/float.rb
 - lib/strong_csv/types/integer.rb
+- lib/strong_csv/types/literal.rb
+- lib/strong_csv/types/optional.rb
+- lib/strong_csv/types/string.rb
+- lib/strong_csv/types/time.rb
+- lib/strong_csv/types/union.rb
 - lib/strong_csv/value_result.rb
 - lib/strong_csv/version.rb
 homepage: https://github.com/yykamei/strong_csv