[URI] Allows regular expressions as ID constraint. (#75)

* Fixes rubocop config.

* Allows regex in id attributes.

* Cleanup

* Adds example to readme

* Adds missing specs

Author: mitnal

.rubocop.yml

@@ -2,28 +2,27 @@
 # require: rubocop-performance
 
 AllCops:
-  TargetRubyVersion: 2.5
-  Exclude:
-    - db/schema.rb
+  TargetRubyVersion: 2.6
+  NewCops: enable
 
-CaseIndentation:
+Layout/CaseIndentation:
   EnforcedStyle: end
 
-CollectionMethods:
+Style/CollectionMethods:
   PreferredMethods:
     reduce: inject
     inject: inject
 
-Lambda:
+Style/Lambda:
   Enabled: false
 
-Layout/AlignArguments:
+Layout/ArgumentAlignment:
   EnforcedStyle: with_fixed_indentation
 
-Layout/AlignHash:
+Layout/HashAlignment:
   EnforcedLastArgumentHashStyle: ignore_implicit
 
-Layout/AlignParameters:
+Layout/ParameterAlignment:
   EnforcedStyle: with_fixed_indentation
 
 Layout/EmptyLinesAroundBlockBody:
@@ -35,7 +34,7 @@ Layout/EmptyLinesAroundClassBody:
 Layout/EmptyLinesAroundModuleBody:
   Enabled: false
 
-Layout/IndentFirstHashElement:
+Layout/FirstHashElementIndentation:
   EnforcedStyle: consistent
 
 Layout/MultilineOperationIndentation:
@@ -50,13 +49,13 @@ Layout/SpaceInLambdaLiteral:
 Layout/EndAlignment:
   EnforcedStyleAlignWith: variable
 
-MethodLength:
+Metrics/MethodLength:
   Max: 24
 
 Metrics/BlockLength:
-  ExcludedMethods: [it, describe, context, feature, freeze, specify, define, renum]
+  IgnoredMethods: [it, describe, context, feature, freeze, specify, define, renum]
 
-Metrics/LineLength:
+Layout/LineLength:
   Max: 120
 
 Style/AndOr:
@@ -71,5 +70,5 @@ Style/Documentation:
 Style/EachWithObject:
   Enabled: false
 
-TrailingBlankLines:
+Layout/TrailingEmptyLines:
   Enabled: false

README.md

@@ -77,6 +77,13 @@ InvoicesType = InvoiceURI::Types::URI | InvoiceDuplicateURI::Types::URI
 InvoicesType[InvoiceURI.new(id: 'final')] # => <#InvoiceURI 'com.example:billing:invoice:final'>
 InvoicesType[InvoiceDuplicateURI.new(id: 'final')] # => <#InvoiceDuplicateURI 'com.example:billing:invoice:final'>
 InvoicesType[InvoiceURI.new(id: 'pro_forma')] # => Dry::Types::ConstraintError
+
+# regular expressions for `id` are also supported
+InvoiceRegexURI = Studitemps::Utils::URI.build(from: InvoiceURI, id: /I-\d{3}/)
+
+InvoiceRegexURI.build('com.example:billing:invoice:pro_forma') # => Studitemps::Utils::URI::Base::InvalidURI
+InvoiceRegexURI.new(id: 'I-123') # => #<InvoiceRegexURI 'com.example:billing:invoice:I-123'>
+InvoiceRegexURI.new(id: 'pro_forma') # => Dry::Types::ConstraintError
 ```
 
 ### Extensions

lib/studitemps/utils/uri/builder.rb

@@ -79,10 +79,11 @@ def value_regex(value, klass, default: '[\w\-_]+')
         end
 
         def enum_regex(value, klass, default: '[\w\-_]+')
-          return default unless klass.send(value)
+          return default unless (values = klass.send(value))
+          return values if values.is_a? Regexp
 
-          values = Array(klass.send(value)).map { |v| Regexp.escape(v) }
-          "(#{values.join('|')})"
+          escaped_values = Array(values).map { |v| Regexp.escape(v) }
+          "(#{escaped_values.join('|')})"
         end
 
         def default_type

lib/studitemps/utils/uri/extensions/types.rb

@@ -39,7 +39,7 @@ module Types
       ##
       # Adds type checks to initializer arguments.
       # `schema` and `context` values are checked and `resource` and `id` are checked against a possible list of
-      # values (enum if URI builder is provided with an array as the argument).
+      # values (enum if URI builder is provided with an array as the argument). `id` also supports regular expressions.
       #
       # @example
       #   require 'studitemps/utils/uri/extensions/types'
@@ -55,31 +55,47 @@ class Builder
         private
 
         def schema_type(klass)
-          value_type(:schema, klass)
+          value_type(klass.schema)
         end
 
         def context_type(klass)
-          value_type(:context, klass)
+          value_type(klass.context)
         end
 
         def resource_type(klass)
-          enum_type(:resource, klass)
+          enum_type(klass.resource)
         end
 
         def id_type(klass)
-          enum_type(:id, klass)
+          dynamic_type(klass.id)
         end
 
-        def value_type(value, klass, default: default_type)
-          return default unless klass.send(value)
+        def dynamic_type(value)
+          case value
+          when Array then enum_type(value)
+          when String, Symbol then value_type(value)
+          when Regexp then regexp_type(value)
+          else
+            default_type
+          end
+        end
+
+        def value_type(value)
+          return default_type unless value
+
+          Dry.Types::Value(value)
+        end
+
+        def enum_type(value)
+          return default_type unless value
 
-          Dry.Types::Value(klass.send(value))
+          Dry.Types::Strict::String.enum(*Array(value))
         end
 
-        def enum_type(value, klass, default: default_type)
-          return default unless klass.send(value)
+        def regexp_type(value)
+          return default_type unless value
 
-          Dry.Types::Strict::String.enum(*Array(klass.send(value)))
+          Dry.Types::Strict::String.constrained(format: value)
         end
       end
     end

spec/studitemps/uri_spec.rb

@@ -34,10 +34,20 @@ module Utils # rubocop:disable Metrics/ModuleLength
           expect(klass.resource).to eq 'order'
         end
 
+        it 'for single ID' do
+          klass = URI.build(schema: 'com.example', context: 'billing', resource: 'invoice', id: 'final')
+          expect(klass.id).to eq 'final'
+        end
+
         it 'for a list of IDs' do
           klass = URI.build(schema: 'com.example', context: 'billing', resource: 'invoice', id: %w[final past_due])
           expect(klass.id).to eq %w[final past_due]
         end
+
+        it 'for regex' do
+          klass = URI.build(schema: 'com.example', context: 'billing', resource: 'invoice', id: /I-\d{3}/)
+          expect(klass.id).to eq(/I-\d{3}/)
+        end
       end
 
       describe 'URI regex' do
@@ -73,6 +83,18 @@ module Utils # rubocop:disable Metrics/ModuleLength
           it { is_expected.to match 'com.example:billing:invoice:final' }
           it { is_expected.to_not match 'com.example:billing:invoice:pro_forma' }
         end
+
+        context 'custom regex' do
+          subject(:regex) {
+            URI.build(schema: 'com.example', context: 'billing', resource: 'invoice', id: /I-\d{3}/)::REGEX
+          }
+
+          it { is_expected.to match 'com.example:billing:invoice:I-123' }
+          it { is_expected.to_not match 'com.example:billing:invoice:i-123' }
+          it { is_expected.to_not match 'com.example:billing:invoice:123' }
+          it { is_expected.to_not match 'com.example:billing:invoice:I-abc' }
+          it { is_expected.to_not match 'com.example:billing:invoice:I-1234' }
+        end
       end
 
       describe 'URI instance' do
@@ -308,6 +330,44 @@ module Utils # rubocop:disable Metrics/ModuleLength
 
             end
 
+            describe 'Fixed URI' do
+              subject(:klass) {
+                URI.build(
+                  schema: 'com.example',
+                  context: 'billing',
+                  resource: 'invoice',
+                  id: 'final'
+                )
+              }
+
+              it 'only accepts fixed URI' do
+                uri = klass.new(
+                  schema: 'com.example',
+                  context: 'billing',
+                  resource: 'invoice',
+                  id: 'final'
+                )
+
+                expect(klass.new(id: 'final')).to eq uri
+
+                expect {
+                  klass.new(id: 'not_final')
+                }.to raise_error Dry::Types::ConstraintError
+
+                expect {
+                  klass.new(resource: 'not_invoice', id: 'final')
+                }.to raise_error Dry::Types::ConstraintError
+
+                expect {
+                  klass.new(context: 'not_billing', id: 'final')
+                }.to raise_error Dry::Types::ConstraintError
+
+                expect {
+                  klass.new(schema: 'not_example.com', id: 'final')
+                }.to raise_error Dry::Types::ConstraintError
+              end
+            end
+
             describe 'Attribute Types' do
               subject(:klass) {
                 URI.build(
@@ -349,6 +409,42 @@ module Utils # rubocop:disable Metrics/ModuleLength
                 }.to raise_error Dry::Types::ConstraintError
               end
             end
+
+            describe 'Regexp' do
+              let(:invoice_klass) { URI.build(from: klass, resource: 'invoice', id: /I-\d{3}/) }
+
+              it 'validates input' do
+                expect {
+                  invoice_klass.new(id: 'I-123')
+                }.to_not raise_error
+
+                expect {
+                  invoice_klass.new(id: 'X-123')
+                }.to raise_error Dry::Types::ConstraintError
+              end
+
+              it 'has uri type' do
+                type = invoice_klass::Types::URI
+                uri = invoice_klass.new(id: 'I-123')
+
+                expect(type[uri]).to eq uri
+                expect(type['com.example:billing:invoice:I-123']).to eq uri
+                expect {
+                  type['com.example:billing:invoice:<other>']
+                }.to raise_error Dry::Types::CoercionError
+              end
+
+              it 'has string type' do
+                type = invoice_klass::Types::String
+                uri = invoice_klass.new(id: 'I-123')
+
+                expect(type[uri]).to eq uri.to_s
+                expect(type['com.example:billing:invoice:I-123']).to eq uri.to_s
+                expect {
+                  type['com.example:billing:invoice:<other>']
+                }.to raise_error Dry::Types::CoercionError
+              end
+            end
           end
         end
       end