blood_contracts-core 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f3ff63364178ca281b22b2ca291904ce9a70ec47056a41f9a622dd9a00c9a55
-  data.tar.gz: b5b000306c85eb7871fb3f4ad1c7a96d4fd8dbc8ceeab98bab49f50a78f611b0
+  metadata.gz: 5a95e70463f9422ef654272494ae21d3b2440f6df9f2ec93fce292d1760bf8a5
+  data.tar.gz: 38cae2fd0e55b1e4a32fbbafa455659add37c78ed6c03c1f250166d426bff362
 SHA512:
-  metadata.gz: d84a0a438d5d264240e40ef8ba79f2732bcfa3f81d11533e9131b175887197c87e0ed84931126cf7aaa897c6fc7b68b7c0b17fc5ea49c03a383fec86ada6c658
-  data.tar.gz: 614ed9eb7021fc53fc0e55384868599afcfefb84437cf52a6739cb84e615bc929a3e5ad15ead259629820b32627d2641ae0f6738e33dda05ba8aa6d6cc94a864
+  metadata.gz: ee8f1b8795c6906757a188e9714869420c31bdab2b77a43ef8ca299a31c9e95269c4d254e63f1cd6f425ad50fccd6d6568c7f0ace662e1c29eb1e28a8e7671b3
+  data.tar.gz: c7e613e87f3c9038094c15f0f0eda3bee294b69d55998ceed794d9c918065d7faff6a77bdb23760ae36e8ebc3b581de74fa26cc5b2dae34fc7deb9125c661355

data/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## master
+
+Features:
+
+- `BC::Tuple#argument` accepts an optional block to define the attribute class dynamically
+- `BC::Tuple#match` can accept arguments as a Hash
+
 ## [0.4.1] - [2019-07-04]
 
 Fixes:
@@ -16,6 +23,6 @@ key elements. It violates principlke of least surprise.
 
 This is a first public release marked in change log with features extracted from production app.
 Includes:
-- Base class BloodContracs::Core::Refined to write your own validations
-- Meta classes BloodContracs::Core::Pipe, BloodContracs::Core::Sum and BloodContracs::Core::Tuple for validations composition in ADT style
-- BloodContracs::Core::Contract meta class as a syntactic sugar to define your own contracts with Refined validations under the hood
+- Base class BloodContracts::Core::Refined to write your own validations
+- Meta classes BloodContracts::Core::Pipe, BloodContracts::Core::Sum and BloodContracts::Core::Tuple for validations composition in ADT style
+- BloodContracts::Core::Contract meta class as a syntactic sugar to define your own contracts with Refined validations under the hood

data/README.md

@@ -344,10 +344,26 @@ module Registration
     # defines a reader and applies validation on `.match` call
     attribute :login, Email.or_a(Phone)
     attribute :password, Ascii
+    # defines an attribute using the anonymous type class
+    attribute :remember_me do
+      def match
+        value.to_s.in? ["checked", ""]
+      end
+
+      def mapped
+        value.to_s == "checked"
+      end
+    end
   end
 end
 ```
 
+Tuple can accept either a list of arguments or a hash:
+```ruby
+Registration::Form.match(login, password)
+Registration::Form.match(login: login, password: password)
+```
+
 And the code that you'll put in your controller is something like that:
 
 ```ruby

data/blood_contracts-core.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name          = "blood_contracts-core"
-  gem.version       = "0.4.1"
+  gem.version       = "0.4.2"
   gem.authors       = ["Sergey Dolganov (sclinede)"]
   gem.email         = ["sclinede@evilmartians.com"]
 

data/lib/blood_contracts/core/tuple.rb

@@ -1,3 +1,7 @@
+require_relative "../ext/symbolize_keys.rb"
+
+using BloodContracts::SymbolizeKeys
+
 module BloodContracts::Core
   # Meta refinement type, represents product of several refinement types
   class Tuple < Refined
@@ -20,6 +24,8 @@ module BloodContracts::Core
       #
       # rubocop:disable Style/SingleLineMethods
       def new(*args, **kwargs, &block)
+        args = lookup_hash_args(*args, kwargs)
+
         return super(*args, **kwargs) if @finalized
         names = args.pop.delete(:names) if args.last.is_a?(Hash)
 
@@ -34,10 +40,16 @@ module BloodContracts::Core
       # rubocop:enable Style/SingleLineMethods
 
       # Helper which registers attribute in the Tuple, also defines a reader
-      def attribute(name, type)
-        raise ArgumentError unless type < Refined
+      def attribute(name, type = nil, &block)
+        if type.nil?
+          type = type_from_block(name, &block)
+        else
+          raise ArgumentError unless type < Refined
+        end
+
         @attributes << type
         @names << name
+
         define_method(name) do
           match.context.dig(:attributes, name)
         end
@@ -56,6 +68,47 @@ module BloodContracts::Core
         new_klass.failure_klass ||= TupleContractFailure
         super
       end
+
+      private
+
+      # Generate an anonymous type from a block
+      #
+      # @param String name of the attribute to define the type for
+      #
+      # @param Proc block which will be evaluated in a context
+      # of our anonymous type
+      #
+      # @return Class
+      #
+      def type_from_block(name, &block)
+        raise ArgumentError unless block_given?
+
+        const_set(
+          "InlineType_#{name.to_s.capitalize}",
+          Class.new(Refined) { class_eval(&block) }
+        )
+      end
+
+      # Handle arguments passed as hash with string or
+      # symbol keys
+      #
+      # @param [Array<Object>] *args that can contain an array of arguments
+      # or a single Hash we're looking for
+      #
+      # @param [Hash<Object, Object>] **kwargs hash that can be converted to
+      # args when args array is empty
+      #
+      # @return [Array<Object>]
+      #
+      def lookup_hash_args(*args, **kwargs)
+        if args.empty?
+          [kwargs]
+        elsif args.length == 1 && args.last.is_a?(Hash)
+          [args.first.symbolize_keys]
+        else
+          args
+        end
+      end
     end
 
     # List of values in Tuple

data/lib/blood_contracts/ext/symbolize_keys.rb

@@ -0,0 +1,11 @@
+module BloodContracts
+  module SymbolizeKeys
+    refine Hash do
+      def symbolize_keys
+        each_with_object({}) do |(key, value), acc|
+          acc[key.to_sym] = value
+        end
+      end
+    end
+  end
+end

data/spec/blood_contracts/core_spec.rb

@@ -179,18 +179,111 @@ RSpec.describe BloodContracts::Core do
     subject { Test::RegistrationInput.match(email, password) }
 
     context "when valid input" do
+      shared_examples "is valid" do |options = {}|
+        it do
+          expect(subject).to be_valid
+          unless options[:without_attributes]
+            expect(subject.attributes).to match(attributes)
+          end
+          expect(subject.to_h).to match(email: email, password: password)
+          expect(subject.errors).to be_empty
+          expect(subject.attribute_errors).to be_empty
+        end
+      end
+
       let(:email) { "admin@mail.com" }
       let(:password) { "newP@ssw0rd" }
       let(:attributes) do
         { email: kind_of(Test::Email), password: kind_of(Test::Ascii) }
       end
 
-      it do
-        expect(subject).to be_valid
-        expect(subject.attributes).to match(attributes)
-        expect(subject.to_h).to match(email: email, password: password)
-        expect(subject.errors).to be_empty
-        expect(subject.attribute_errors).to be_empty
+      include_examples "is valid"
+
+      context "when attributes are defined inline" do
+        before do
+          module Test
+            class InlineRegistrationInput < ::BC::Tuple
+              attribute :email do
+                EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
+
+                def match
+                  context[:email] = unpack_refined(value).to_s
+                  return if context[:email] =~ EMAIL_REGEX
+
+                  failure("Not an email")
+                end
+
+                def mapped
+                  context[:email]
+                end
+              end
+
+              attribute :password do
+                ASCII_REGEX = /^[[:ascii:]]+$/i
+
+                def match
+                  context[:ascii_string] = value.to_s
+                  return if context[:ascii_string] =~ ASCII_REGEX
+
+                  failure("Not ASCII")
+                end
+
+                def mapped
+                  context[:ascii_string]
+                end
+              end
+            end
+          end
+        end
+
+        subject { Test::InlineRegistrationInput.match(email, password) }
+
+        include_examples "is valid", without_attributes: true
+
+        context "when input is invalid" do
+          let(:email) { "admin" }
+          let(:dynamic_email_type) do
+            Test::InlineRegistrationInput::InlineType_Email
+          end
+          let(:dynamic_password_type) do
+            Test::InlineRegistrationInput::InlineType_Password
+          end
+          let(:email_error) { { dynamic_email_type => ["Not an email"] } }
+          let(:password) { "newP@ssw0rd" }
+          let(:attributes) do
+            attribute_errors.merge(password: kind_of(dynamic_password_type))
+          end
+          let(:attribute_errors) { { email: kind_of(BC::ContractFailure) } }
+          let(:tuple_invalid) do
+            { Test::InlineRegistrationInput => [:invalid_tuple] }
+          end
+
+          it do
+            expect(subject).to be_invalid
+            expect(subject.attributes).to match(attributes)
+            expect(subject.to_h).to match(email: email_error)
+            expect(subject.errors).to match_array([email_error, tuple_invalid])
+            expect(subject.attribute_errors).to match(attribute_errors)
+          end
+        end
+      end
+
+      context "when input is a Hash" do
+        subject do
+          Test::RegistrationInput.match(password: password, email: email)
+        end
+
+        include_examples "is valid"
+
+        context "when keys are strings" do
+          subject do
+            Test::RegistrationInput.match(
+              "password" => password, "email" => email
+            )
+          end
+
+          include_examples "is valid"
+        end
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blood_contracts-core
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Sergey Dolganov (sclinede)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-04 00:00:00.000000000 Z
+date: 2019-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -117,6 +117,7 @@ files:
 - lib/blood_contracts/core/sum.rb
 - lib/blood_contracts/core/tuple.rb
 - lib/blood_contracts/core/tuple_contract_failure.rb
+- lib/blood_contracts/ext/symbolize_keys.rb
 - spec/blood_contracts/core_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/sclinede/blood_contracts-core