strong_csv 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a6324b338c8922470db715a4db9aac4d29a7e658313326df6b860a51eda09a5
-  data.tar.gz: '095654b19ea937ca862c91b98e4c59d29f8ddd148d0cb2feac594edf1ea54a1f'
+  metadata.gz: 5c718425815c3296bf644f0206eb7f351a25565908eddf5ec9b5811c045a46ec
+  data.tar.gz: fb8912e844d913b06c026e46d0b78084f7f0b3e81738ef3cc48476d8e784d03d
 SHA512:
-  metadata.gz: 9d729e901fcbe7b6cecbe7b0470d5dffaa4c51f7a11269b1f0b2db188c633ee46fb569fab333343268d9f2235ce790508bc0070e6d716888bdfb8ae08c75011c
-  data.tar.gz: 3cfc376f86564afea311afae002488172c9b01ec4676791e7c78b3192495361ddc9f9531a57987c7235c7420acf04819c265c29213a9282c23a93c45af5aae4f
+  metadata.gz: cc0564f9036a150e8564ff3bd947d9e4d7197b25179d37ab1c0d9997c7517834c3c76d54b5e28a6c1c5631e5c64f2601989935052b21dd6d588fa7e521ec7c8d
+  data.tar.gz: 205d2e29e1512e1508328f724b63ec40cf1d138c8d3bf83e586f6f0d8d7730f2d8f5fae648a589650efaff1e6104c9cb56ae0b8771fb7098a34d34aa08c525ad

data/README.md

@@ -1,5 +1,7 @@
 # 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).
@@ -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:
@@ -41,19 +43,21 @@ gem install strong_csv
 TBD: This hasn't yet been implemented.
 
 ```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?
 
   # 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
@@ -75,7 +79,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 +93,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 +101,24 @@ end
 
 ## Available types
 
-| Type    | Description                         |
-| ------- | ----------------------------------- |
-| integer | The value must be casted to Integer |
+| 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`                                         |
 
 ## Contributing
 

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,6 +4,7 @@ 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
 
@@ -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: ["`#{value.inspect}` can't be casted to Boolean"])
+      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: ["`#{value.inspect}` can't be casted to Float"])
+      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: ["`#{value.inspect}` can't be casted to Integer"])
       end
     end
   end

data/lib/strong_csv/types/literal.rb

@@ -0,0 +1,77 @@
+# 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: ["`#{inspect}` is expected, but `#{int}` was given"])
+          end
+        rescue ArgumentError, TypeError
+          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to #{self.class.name}"])
+        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: ["`#{inspect}` is expected, but `#{float}` was given"])
+          end
+        rescue ArgumentError, TypeError
+          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to #{self.class.name}"])
+        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: ["`nil` can't be casted to the beginning of `#{inspect}`"]) 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: ["`#{casted.inspect}` is not within `#{inspect}`"])
+          end
+        rescue ArgumentError
+          ValueResult.new(original_value: value, error_messages: ["`#{value.inspect}` can't be casted to the beginning of `#{inspect}`"])
+        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: ["`#{inspect}` is expected, but `#{value.inspect}` was given"])
+          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: ["`#{value.inspect}` can't be casted to String"]) if value.nil?
+
+        casted = String(value)
+        if @within && !@within.cover?(casted.size)
+          ValueResult.new(original_value: value, error_messages: ["`#{casted.inspect}` is out of range `#{@within.inspect}`"])
+        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: ["`#{value.inspect}` can't be casted to Time"]) 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}`"])
+      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.2.0"
 end

data/lib/strong_csv.rb

@@ -2,12 +2,21 @@
 
 require "csv"
 require "forwardable"
+require "set"
+require "time"
 
 require_relative "strong_csv/version"
-require_relative "strong_csv/let"
 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 +31,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strong_csv
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yutaka Kamei
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2022-04-26 00:00:00.000000000 Z
+date: 2022-04-29 00:00:00.000000000 Z
 dependencies: []
 description: strong_csv is a type checker for a CSV file. It lets developers declare
   types for each column to ensure all cells are satisfied with desired types.
@@ -24,7 +24,14 @@ files:
 - 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