schemacop 3.0.14 → 3.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45a0558e32f2c4a8e4d9db631ac874629ed7e92a378a177266a216b9e35295bd
-  data.tar.gz: fa2da0867bf598a32ba7728b246343f6bf3849aa1ccdddf9093dcd360df2b53e
+  metadata.gz: 2e43238e69ebe95beaac85536a9dadbf3233bd4fa5751c7e019ca6d07aa05860
+  data.tar.gz: 8bafd412f0572e0c12a7c163cba48b6f6f69900ec903684dc3c9495b4913cf52
 SHA512:
-  metadata.gz: 557da4f2765fc6a9c081b1b894f57b9acb8f3f16ff72c56589064672d060b1879b4d68a498692aeb4764b78ab1091de9b5b0a8dbd4b0ebc0e8bc401875ff5167
-  data.tar.gz: 54748996bd7ea09dda23163c808e32300e898ceb3910d1decfaa0516d49a268d79afeb9c9292f3a3fbc6d5f128ba8de1470111c66470585772b5903580088cbb
+  metadata.gz: 9da291f938673bf76f55f4f4fddbf5a3355fe9c72ae30f8be8c9e224b9bea2f1a89dbcb2da8312ddbaca09dcd25da5511e904963400633d9ef193014da9ee0ec
+  data.tar.gz: 21793a6a7f3fc730a123f7ed8ceacde1e930620b77fef63c7e30c919a9e9ebf3372a8a5208dbdf177880e011322f529d04558bd68d363cbfd85b023a1f2ed265

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change log
 
+## 3.0.15 (2021-10-11)
+
+* Add support for custom string formatters
+
 ## 3.0.14 (2021-10-11)
 
 * Add string format `integer_list`

data/README_V3.md

@@ -252,6 +252,24 @@ transformed into various types.
 * `symbol`
   The string can be anything and will be casted to a ruby `Symbol` object.
 
+#### Custom Formats
+
+You can also implement your custom formats or override the behavior of the
+standard formats. This can be done in the initializer configuration (in case of
+a Rails appliation):
+
+```ruby
+# config/initializers/schemacop.rb
+Schemacop.register_string_formatter(
+  :character_array,                        # Formatter name
+  pattern: /^[a-zA-Z](,[a-zA-Z])*/,        # Regex pattern for validation
+  handler: ->(value) { value.split(',') }  # Casting callback
+)
+
+# In your schema
+str! :my_list, format: :character_array
+```
+
 #### Examples
 
 ```ruby

data/VERSION

@@ -1 +1 @@
-3.0.14
+3.0.15

data/lib/schemacop/v3/string_node.rb

@@ -7,21 +7,6 @@ module Schemacop
         format
       ].freeze
 
-      # rubocop:disable Layout/LineLength
-      FORMAT_PATTERNS = {
-        date:           /^([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])$/,
-        'date-time':    /^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$/,
-        time:           /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$/,
-        email:          URI::MailTo::EMAIL_REGEXP,
-        boolean:        /^(true|false|0|1)$/,
-        binary:         nil,
-        symbol:         nil,
-        integer:        /^-?[0-9]+$/,
-        number:         /^-?[0-9]+(\.[0-9]+)?$/,
-        'integer-list': /^(-?[0-9]+)(,-?[0-9]+)*$/
-      }.freeze
-      # rubocop:enable Layout/LineLength
-
       def self.allowed_options
         super + ATTRIBUTES + %i[format_options pattern allow_blank]
       end
@@ -71,8 +56,9 @@ module Schemacop
         end
 
         # Validate format #
-        if options[:format] && FORMAT_PATTERNS.include?(options[:format])
-          pattern = FORMAT_PATTERNS[options[:format]]
+        if options[:format] && Schemacop.string_formatters.include?(options[:format])
+          pattern = Schemacop.string_formatters[options[:format]][:pattern]
+
           if pattern && !super_data.match?(pattern)
             result.error "String does not match format #{options[:format].to_s.inspect}."
           elsif options[:format_options] && Node.resolve_class(options[:format])
@@ -91,23 +77,8 @@ module Schemacop
           return nil
         end
 
-        case options[:format]
-        when :boolean
-          %w[true 1].include?(to_cast)
-        when :date
-          return Date.parse(to_cast)
-        when :'date-time'
-          return DateTime.parse(to_cast)
-        when :time
-          Time.parse(to_cast)
-        when :integer
-          return Integer(to_cast)
-        when :number
-          return Float(to_cast)
-        when :'integer-list'
-          return to_cast.split(',').map(&:to_i)
-        when :symbol
-          return to_cast.to_sym
+        if (handler = Schemacop.string_formatters.dig(options[:format], :handler))
+          return handler.call(to_cast)
         else
           return to_cast
         end
@@ -122,7 +93,7 @@ module Schemacop
       end
 
       def validate_self
-        if options.include?(:format) && !FORMAT_PATTERNS.include?(options[:format])
+        if options.include?(:format) && !Schemacop.string_formatters.include?(options[:format])
           fail "Format #{options[:format].to_s.inspect} is not supported."
         end
 

data/lib/schemacop.rb

@@ -13,6 +13,80 @@ module Schemacop
   mattr_accessor :default_schema_version
   self.default_schema_version = 3
 
+  mattr_accessor :string_formatters
+  self.string_formatters = {}
+
+  def self.register_string_formatter(name, pattern:, handler:)
+    name = name.to_s.dasherize.to_sym
+
+    string_formatters[name] = {
+      pattern: pattern,
+      handler: handler
+    }
+  end
+
+  register_string_formatter(
+    :date,
+    pattern: /^([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])$/,
+    handler: ->(value) { Date.parse(value) }
+  )
+
+  # rubocop: disable Layout/LineLength
+  register_string_formatter(
+    :'date-time',
+    pattern: /^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$/,
+    handler: ->(value) { DateTime.parse(value) }
+  )
+  # rubocop: enable Layout/LineLength
+
+  register_string_formatter(
+    :time,
+    pattern: /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$/,
+    handler: ->(value) { Time.parse(value) }
+  )
+
+  register_string_formatter(
+    :email,
+    pattern: URI::MailTo::EMAIL_REGEXP,
+    handler: ->(value) { value }
+  )
+
+  register_string_formatter(
+    :boolean,
+    pattern: /^(true|false|0|1)$/,
+    handler: ->(value) { %w[true 1].include?(value) }
+  )
+
+  register_string_formatter(
+    :binary,
+    pattern: nil,
+    handler: ->(value) { value }
+  )
+
+  register_string_formatter(
+    :symbol,
+    pattern: nil,
+    handler: ->(value) { value.to_sym }
+  )
+
+  register_string_formatter(
+    :integer,
+    pattern: /^-?[0-9]+$/,
+    handler: ->(value) { Integer(value) }
+  )
+
+  register_string_formatter(
+    :number,
+    pattern: /^-?[0-9]+(\.[0-9]+)?$/,
+    handler: ->(value) { Float(value) }
+  )
+
+  register_string_formatter(
+    :'integer-list',
+    pattern: /^(-?[0-9]+)(,-?[0-9]+)*$/,
+    handler: ->(value) { value.split(',').map(&:to_i) }
+  )
+
   def self.with_context(context)
     prev_context = Thread.current[CONTEXT_THREAD_KEY]
     Thread.current[CONTEXT_THREAD_KEY] = context

data/schemacop.gemspec

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: schemacop 3.0.14 ruby lib
+# stub: schemacop 3.0.15 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "schemacop".freeze
-  s.version = "3.0.14"
+  s.version = "3.0.15"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]

data/test/unit/schemacop/v3/string_node_test.rb

@@ -158,6 +158,14 @@ module Schemacop
         assert_cast('2018-11-13T20:20:39+00:00', DateTime.new(2018, 11, 13, 20, 20, 39))
       end
 
+      def test_format_time
+        schema :string, format: :time
+        assert_json(type: :string, format: :time)
+        assert_cast '20:30:39+00:00', Time.strptime('20:30:39+00:00', '%H:%M:%S%z')
+
+        assert_cast nil, nil
+      end
+
       def test_format_email
         schema :string, format: :email
 
@@ -183,6 +191,17 @@ module Schemacop
         assert_cast('john.doe@example.com', 'john.doe@example.com')
       end
 
+      def test_format_boolean
+        schema :string, format: :boolean
+
+        assert_json(type: :string, format: :boolean)
+
+        assert_cast 'true', true
+        assert_cast 'false', false
+
+        assert_cast nil, nil
+      end
+
       def test_format_symbol
         schema :string, format: :symbol
 
@@ -200,6 +219,28 @@ module Schemacop
         assert_cast('039n23$g- sfk3/', :'039n23$g- sfk3/')
       end
 
+      def test_format_integer
+        schema :string, format: :integer
+
+        assert_json(type: :string, format: :integer)
+
+        assert_validation '23425'
+        assert_validation '-23425'
+
+        assert_validation 12_312 do
+          error '/', StringNodeTest.invalid_type_error(Integer)
+        end
+
+        assert_validation '24.32' do
+          error '/', 'String does not match format "integer".'
+        end
+
+        assert_cast(nil, nil)
+        assert_cast('2234', 2234)
+        assert_cast('-1', -1)
+        assert_cast('-0', 0)
+      end
+
       def test_format_integer_list
         schema :string, format: :integer_list
 
@@ -224,6 +265,34 @@ module Schemacop
         assert_cast '-1',     [-1]
       end
 
+      def test_format_custom
+        Schemacop.register_string_formatter(
+          :integer_tuple_list,
+          pattern: /^(-?[0-9]+):(-?[0-9]+)(,(-?[0-9]+):(-?[0-9]+))*$/,
+          handler: proc do |value|
+            value.split(',').map { |t| t.split(':').map(&:to_i) }
+          end
+        )
+
+        schema :string, format: :integer_tuple_list
+
+        assert_json(type: :string, format: :'integer-tuple-list')
+
+        assert_validation '1:5,4:2,-4:4,4:-1,0:0'
+        assert_validation '-1:5'
+
+        assert_validation 234 do
+          error '/', StringNodeTest.invalid_type_error(Integer)
+        end
+
+        assert_validation 'sd sfdij soidf' do
+          error '/', 'String does not match format "integer-tuple-list".'
+        end
+
+        assert_cast nil, nil
+        assert_cast '1:2,3:4,5:-6', [[1, 2], [3, 4], [5, -6]]
+      end
+
       def test_enum
         schema :string, enum: ['foo', 'some string', 'some other string', 42]
 
@@ -248,33 +317,6 @@ module Schemacop
         end
       end
 
-      def test_boolean_casting
-        schema :string, format: :boolean
-
-        assert_json(type: :string, format: :boolean)
-
-        assert_cast 'true', true
-        assert_cast 'false', false
-
-        assert_cast nil, nil
-      end
-
-      def test_time_casting
-        schema :string, format: :time
-        assert_json(type: :string, format: :time)
-        assert_cast '20:30:39+00:00', Time.strptime('20:30:39+00:00', '%H:%M:%S%z')
-
-        assert_cast nil, nil
-      end
-
-      def test_date_casting
-        schema :string, format: :date
-        assert_json(type: :string, format: :date)
-        assert_cast '2018-11-13', Date.new(2018, 11, 13)
-
-        assert_cast nil, nil
-      end
-
       def test_date_time_casting
         schema :string, format: :date_time
         assert_json(type: :string, format: :'date-time')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schemacop
 version: !ruby/object:Gem::Version
-  version: 3.0.14
+  version: 3.0.15
 platform: ruby
 authors:
 - Sitrox