blood_contracts-core 0.3.5 → 0.4.0

data/lib/blood_contracts/core/tuple_contract_failure.rb

@@ -0,0 +1,31 @@
+module BloodContracts::Core
+  # Represents failure in during of Tuple data matching
+  class TupleContractFailure < ContractFailure
+    # Hash of attributes (name & type pairs)
+    #
+    # @return [Hash<String, Refined>]
+    #
+    def attributes
+      @context[:attributes]
+    end
+
+    # Subset of attributes which are invalid
+    #
+    # @return [Hash<String, ContractFailure>]
+    #
+    def attribute_errors
+      attributes.select { |_name, type| type.invalid? }
+    end
+
+    # Unpacked matching errors in form of a hash per attribute
+    #
+    # @return [Hash<String, ContractFailure>]
+    #
+    def unpack_h
+      @unpack_h ||= attribute_errors.transform_values(&:unpack)
+    end
+    alias to_hash unpack_h
+    alias to_h unpack_h
+    alias unpack_attributes unpack_h
+  end
+end

data/lib/blood_contracts/core.rb

@@ -1,14 +1,20 @@
-require_relative "./core/refined.rb"
-require_relative "./core/pipe.rb"
-require_relative "./core/contract.rb"
-require_relative "./core/sum.rb"
-require_relative "./core/tuple.rb"
-require_relative "./core/version.rb"
-
-
+# Top-level scope for BloodContracts collection of gems
 module BloodContracts
-  module Core; end
+  # Scope for BloodContracts::Core classes
+  module Core
+    require_relative "./core/refined.rb"
+    require_relative "./core/contract_failure.rb"
+    require_relative "./core/anything.rb"
+    require_relative "./core/pipe.rb"
+    require_relative "./core/contract.rb"
+    require_relative "./core/sum.rb"
+    require_relative "./core/tuple.rb"
+    require_relative "./core/tuple_contract_failure.rb"
+
+    # constant aliases
+    Or = Sum
+    AndThen = Pipe
+  end
 end
 
 BC = BloodContracts::Core
-

data/spec/blood_contracts/core_spec.rb

@@ -0,0 +1,314 @@
+
+require "spec_helper"
+
+RSpec.describe BloodContracts::Core do
+  before do
+    module Test
+      class Json < ::BC::Refined
+        require "json"
+
+        def match
+          context[:raw_value] = unpack_refined(value).to_s
+          context[:parsed] =
+            JSON.parse(context[:raw_value], symbolize_names: true)
+          nil
+        rescue JSON::ParserError => exception
+          failure(exception)
+        end
+
+        def mapped
+          context[:parsed]
+        end
+      end
+
+      class Phone < ::BC::Refined
+        REGEX = /\A(\+7|8)(9|8)\d{9}\z/i
+
+        def match
+          context[:phone] = unpack_refined(value).to_s
+          context[:clean_phone] = context[:phone].gsub(/[\s\(\)-]/, "")
+          return if context[:clean_phone] =~ REGEX
+
+          failure("Not a phone")
+        end
+
+        def mapped
+          context[:clean_phone]
+        end
+      end
+
+      class Email < ::BC::Refined
+        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] =~ REGEX
+
+          failure("Not an email")
+        end
+
+        def mapped
+          context[:email]
+        end
+      end
+
+      class Ascii < ::BC::Refined
+        REGEX = /^[[:ascii:]]+$/i
+
+        def match
+          context[:ascii_string] = value.to_s
+          return if context[:ascii_string] =~ REGEX
+
+          failure("Not ASCII")
+        end
+
+        def mapped
+          context[:ascii_string]
+        end
+      end
+    end
+  end
+
+  context "standalone validation" do
+    subject { Test::Ascii.match(value) }
+
+    context "when value is valid" do
+      let(:value) { "i'm written in pure ASCII" }
+
+      it do
+        is_expected.to be_valid
+        expect { subject.unpack }.not_to raise_error
+        expect(subject.unpack).to eq(value)
+        expect(subject.context).to match({ ascii_string: value })
+      end
+    end
+
+    context "when value is invalid" do
+      let(:value) { "I'm ∑ritten nøt in åßçii" }
+      let(:error) { { Test::Ascii => ["Not ASCII"] } }
+      let(:validation_context) { { ascii_string: value, errors: [error] } }
+
+      it do
+        is_expected.to be_invalid
+        expect(subject.errors).to match([error])
+        expect(subject.messages).to match(["Not ASCII"])
+        expect(subject.unpack).to match(error)
+      end
+    end
+  end
+
+  context "Sum composition" do
+    before do
+      module Test
+        Login = Email.or_a(Phone)
+      end
+    end
+
+    subject { Test::Login.match(login) }
+
+    context "when login is valid" do
+      context "when login is email" do
+        let(:login) { "admin@example.com" }
+        let(:errors) { [{ Test::Phone => ["Not a phone"] }] }
+        let(:validation_context) do
+          hash_including(
+            phone: login,
+            clean_phone: login,
+            errors: errors,
+            email: login
+          )
+        end
+
+        it do
+          is_expected.to be_valid
+          expect { subject.unpack }.not_to raise_error
+          expect(subject.unpack).to eq(login)
+          expect(subject.context).to match(validation_context)
+        end
+      end
+
+      context "when login is phone" do
+        let(:login) { "8(800) 200 - 11 - 00" }
+        let(:cleaned_phone) { "88002001100" }
+        let(:errors) { [{ Test::Email => ["Not an email"] }] }
+        let(:validation_context) do
+          hash_including(
+            phone: login,
+            clean_phone: cleaned_phone,
+            errors: errors,
+            email: login
+          )
+        end
+
+        it do
+          is_expected.to be_valid
+          expect { subject.unpack }.not_to raise_error
+          expect(subject.unpack).to eq(cleaned_phone)
+          expect(subject.context).to match(validation_context)
+        end
+      end
+    end
+
+    context "when login is invalid" do
+      let(:login) { "I'm something else" }
+      let(:errors) do
+        [
+          { Test::Email => ["Not an email"] },
+          { Test::Phone => ["Not a phone"] },
+          { Test::Login => [:no_matches] }
+        ]
+      end
+
+      it do
+        is_expected.to be_invalid
+        expect(subject.errors).to match_array(errors)
+        expect(subject.unpack).to match({ Test::Login => [:no_matches] })
+      end
+    end
+  end
+
+  context "Tuple composition" do
+    before do
+      module Test
+        class RegistrationInput < ::BC::Tuple
+          attribute :email,    Email
+          attribute :password, Ascii
+        end
+      end
+    end
+
+    subject { Test::RegistrationInput.match(email, password) }
+
+    context "when valid input" do
+      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
+      end
+    end
+
+    context "when input is invalid" do
+      let(:email) { "admin" }
+      let(:email_error) { { Test::Email => ["Not an email"] } }
+      let(:password) { "newP@ssw0rd" }
+      let(:attributes) do
+        attribute_errors.merge(password: kind_of(Test::Ascii))
+      end
+      let(:attribute_errors) { { email: kind_of(BC::ContractFailure) } }
+      let(:tuple_invalid) { { Test::RegistrationInput => [:invalid_tuple] } }
+
+      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 "Pipe composition" do
+    before do
+      module Test
+        class RegistrationInput < ::BC::Tuple
+          attribute :login,    Email.or_a(Phone)
+          attribute :password, Ascii
+        end
+
+        ResponseParser = BC::Pipe.new do
+          step :parse, Json
+          step :validate, RegistrationInput
+        end
+      end
+    end
+
+    subject { Test::ResponseParser.match(response) }
+
+    context "when value is invalid JSON" do
+      let(:response) { "<xml>" }
+      let(:error) { { Test::Json => [kind_of(JSON::ParserError)] } }
+      let(:validation_context) do
+        {
+          raw_value: response,
+          errors: [error],
+          steps: ["BloodContracts::Core::ContractFailure"],
+          steps_values: { parse: response }
+        }
+      end
+
+      it do
+        is_expected.to be_invalid
+        is_expected.to be_kind_of(BC::ContractFailure)
+        expect(subject.unpack).to match(error)
+        expect(subject.context).to match(validation_context)
+      end
+    end
+
+    context "when value is valid JSON" do
+      context "when value is invalid registration data" do
+        let(:response) { '{"phone":"+78889992211"}' }
+        let(:error) { { Test::RegistrationInput => [:invalid_tuple] } }
+        let(:errors) do
+          [
+            { Test::Email => ["Not an email"] },
+            { Test::Phone => ["Not a phone"] },
+            { Test::Ascii => ["Not ASCII"] },
+            { Test::RegistrationInput => [:invalid_tuple] }
+          ]
+        end
+        let(:validation_context) do
+          hash_including(
+            raw_value: response,
+            errors: array_including(errors),
+            steps: ["Test::Json", "BloodContracts::Core::TupleContractFailure"],
+            steps_values: {
+              parse: response,
+              validate: { phone: "+78889992211" }
+            }
+          )
+        end
+
+        it do
+          is_expected.to be_invalid
+          is_expected.to be_kind_of(BC::TupleContractFailure)
+          expect(subject.unpack).to match(error)
+          expect(subject.context).to match(validation_context)
+        end
+      end
+
+      context "when value is valid registration data" do
+        context "when login is an email" do
+          let(:response) { '{"login":"admin@example.com", "password":"111"}' }
+          let(:payload) { { login: "admin@example.com", password: "111" } }
+
+          it do
+            is_expected.to be_valid
+            is_expected.to be_kind_of(Test::RegistrationInput)
+            expect(subject.unpack).to match(["admin@example.com", "111"])
+            expect(subject.to_h).to match(payload)
+          end
+        end
+
+        context "when login is a phone" do
+          let(:response) { '{"login":"8 (999) 123-33-12", "password":"111"}' }
+          let(:payload) { { login: "89991233312", password: "111" } }
+
+          it do
+            is_expected.to be_valid
+            is_expected.to be_kind_of(Test::RegistrationInput)
+            expect(subject.unpack).to match(%w[89991233312 111])
+            expect(subject.to_h).to match(payload)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+begin
+  require "pry"
+rescue LoadError
+  nil
+end
+
+require "bundler/setup"
+require "blood_contracts/core"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.around do |example|
+    module Test; end
+    example.run
+    Object.send(:remove_const, :Test)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blood_contracts-core
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.0
 platform: ruby
 authors:
-- Sergey Dolganov
+- Sergey Dolganov (sclinede)
 autorequire: 
-bindir: bin/
+bindir: bin
 cert_chain: []
-date: 2019-06-21 00:00:00.000000000 Z
+date: 2019-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,16 +66,36 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: Core classes for Contracts API validation
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+description: Core classes for data validation with contracts approach (using Either
+  + Writer monad combination & ADT for composition)
 email:
 - sclinede@evilmartians.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- CODE_OF_CONDUCT.md
+- README.md
+- CHANGELOG.md
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -89,12 +109,16 @@ files:
 - examples/tuple.rb
 - lib/blood_contracts-core.rb
 - lib/blood_contracts/core.rb
+- lib/blood_contracts/core/anything.rb
 - lib/blood_contracts/core/contract.rb
+- lib/blood_contracts/core/contract_failure.rb
 - lib/blood_contracts/core/pipe.rb
 - lib/blood_contracts/core/refined.rb
 - lib/blood_contracts/core/sum.rb
 - lib/blood_contracts/core/tuple.rb
-- lib/blood_contracts/core/version.rb
+- lib/blood_contracts/core/tuple_contract_failure.rb
+- spec/blood_contracts/core_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/sclinede/blood_contracts-core
 licenses:
 - MIT
@@ -107,7 +131,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -117,5 +141,7 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Core classes for Contracts API validation
-test_files: []
+summary: Core classes for data validation with contracts approach
+test_files:
+- spec/blood_contracts/core_spec.rb
+- spec/spec_helper.rb

data/lib/blood_contracts/core/version.rb

@@ -1,5 +0,0 @@
-module BloodContracts
-  module Core
-    VERSION = "0.3.5"
-  end
-end