blood_contracts-core 0.3.5 → 0.4.0

data/examples/tariff_contract.rb

@@ -1,6 +1,6 @@
 require "bundler/setup"
 require "json"
-require 'blood_contracts/core'
+require "blood_contracts/core"
 require "pry"
 
 module Types
@@ -14,7 +14,7 @@ module Types
   class JSON < Base
     def _match
       context[:parsed] = ::JSON.parse(unpack_refined(@value))
-      self
+      nil
     rescue StandardError => error
       exception(error)
     end
@@ -41,17 +41,18 @@ module RussianPost
   class DomesticParcel < Types::Base
     self.failure_klass = InputValidationFailure
 
-    alias :parcel :value
-    def _match
+    alias parcel value
+    def match
       return failure(key: :undef_weight, field: :weight) unless parcel.weight
       return if domestic?
+
       failure(non_domestic_error)
     rescue StandardError => error
       exception(error)
     end
 
-    def _unpack(match)
-      DomesticTariffMapper.call(match.parcel)
+    def mapped
+      DomesticTariffMapper.call(parcel)
     end
 
     private
@@ -83,18 +84,18 @@ module RussianPost
   class InternationalParcel < Types::Base
     self.failure_klass = InputValidationFailure
 
-    alias :parcel :value
-    def _match
+    alias parcel value
+    def match
       return failure(key: :undef_weight, field: :weight) unless parcel.weight
       return failure(not_from_ru_error) if parcel_outside_ru?
       return failure(non_international_error) if non_international_parcel?
-      self
+      nil
     rescue StandardError => error
       exception(error)
     end
 
-    def _unpack(match)
-      InternationalTariffMapper.call(match.parcel)
+    def mapped
+      InternationalTariffMapper.call(parcel)
     end
 
     private
@@ -122,9 +123,10 @@ module RussianPost
   end
 
   class RecoverableInputError < Types::Base
-    alias :parsed_response :value
-    def _match
+    alias parsed_response value
+    def match
       return if [error_code, error_message].all?
+
       failure(key: :not_a_recoverable_error)
     rescue StandardError => error
       exception(error)
@@ -143,10 +145,11 @@ module RussianPost
   end
 
   class OtherError < Types::Base
-    alias :parsed_response :value
-    def _match
-      return failure(key: :not_a_known_error) if error_code.nil?
-      self
+    alias parsed_response value
+    def match
+      return unless error_code.nil?
+
+      failure(key: :not_a_known_error)
     rescue StandardError => error
       exception(error)
     end
@@ -159,8 +162,8 @@ module RussianPost
   end
 
   class DomesticTariff < Types::Base
-    alias :parsed_response :value
-    def _match
+    alias parsed_response value
+    def match
       return if is_a_domestic_tariff?
       context[:raw_response] = parsed_response
       failure(key: :not_a_domestic_tariff)
@@ -188,8 +191,8 @@ module RussianPost
   end
 
   class InternationalTariff < Types::Base
-    alias :parsed_response :value
-    def _match
+    alias parsed_response value
+    def match
       return if is_an_international_tariff?
       context[:raw_response] = parsed_response
       failure(key: :not_an_international_tariff)
@@ -221,13 +224,13 @@ module RussianPost
   KnownError = RecoverableInputError | OtherError
 
   DomesticResponse =
-    (Types::JSON.and_then(DomesticTariff | KnownError)).set(names: %i(parsed mapped))
+    (Types::JSON.and_then(DomesticTariff | KnownError)).set(names: %i[parsed mapped])
   InternationalResponse =
-    (Types::JSON.and_then(InternationalTariff | KnownError)).set(names: %i(parsed mapped))
+    (Types::JSON.and_then(InternationalTariff | KnownError)).set(names: %i[parsed mapped])
 
   TariffRequestContract = ::BC::Contract.new(
     DomesticParcel      => DomesticResponse,
-    InternationalParcel => InternationalResponse,
+    InternationalParcel => InternationalResponse
   )
 end
 
@@ -239,8 +242,6 @@ end
 
 def match_response(response)
   case response
-  when Types::ExceptionCaught
-    puts "Honeybadger.notify #{response.errors_h[:exception]}"
   when RussianPost::InputValidationFailure
     # работаем с тарифом
     puts "render json: { errors: 'Parcel is invalid for request (#{response.to_h})' }"
@@ -257,6 +258,8 @@ def match_response(response)
     # работаем с ошибкой, e.g. адрес слишком длинный
     puts "Honeybadger.notify 'Non-recoverable error from Russian Post API', context: #{pp(response.context)}"
     puts "render json: { errors: ['Sorry, API could not process your request, we've been notified. Try again later'] } }"
+  when Types::ExceptionCaught
+    puts "Honeybadger.notify #{response.errors_h[:exception]}"
   when BC::ContractFailure
     puts "Honeybadger.notify 'Unexpected behavior in Russian Post API Client', context:"
     puts "  'Unexpected behavior in Russian Post API Client'"
@@ -264,7 +267,7 @@ def match_response(response)
     pp(response.context)
     puts "render json: { errors: 'Ooops! Not working, we've been notified. Please, try again later' }"
   else
-    require'pry';binding.pry
+    require"pry"; binding.pry
   end
 end
 
@@ -279,16 +282,16 @@ Parcel = Struct.new(
 
 PARCELS = [
   # domestic without weight
-  Parcel.new(weight: nil, origin_country: "RU", origin_postal_code: "123", destination_country: "RU", destination_postal_code: "123" ),
+  Parcel.new(weight: nil, origin_country: "RU", origin_postal_code: "123", destination_country: "RU", destination_postal_code: "123"),
 
   # not from RU
-  Parcel.new(weight: 123, origin_country: "US", origin_postal_code: "123", destination_country: "RU", destination_postal_code: "123" ),
+  Parcel.new(weight: 123, origin_country: "US", origin_postal_code: "123", destination_country: "RU", destination_postal_code: "123"),
 
   # domestic
-  Parcel.new(weight: 123, origin_country: "RU", origin_postal_code: "123", destination_country: "RU", destination_postal_code: "123" ),
+  Parcel.new(weight: 123, origin_country: "RU", origin_postal_code: "123", destination_country: "RU", destination_postal_code: "123"),
 
   # international
-  Parcel.new(weight: 123, origin_country: "RU", origin_postal_code: "123", destination_country: "RU", destination_postal_code: "123" ),
+  Parcel.new(weight: 123, origin_country: "RU", origin_postal_code: "123", destination_country: "RU", destination_postal_code: "123"),
 
   # not a parcel
   Stuff.new(daaamn: "WTF?!")
@@ -299,7 +302,7 @@ RESPONSES = [
   '{"total-rate": 100000, "total-vat": 1800}',
   '{"total-rate": "some", "total-vat": "text"}',
   '{"code": 1010, "desc": "Too long address"}',
-  '{"error-code": 2020, "error-details": ["Too heavy parcel"]}',
+  '{"error-code": 2020, "error-details": ["Too heavy parcel"]}'
 ]
 
 def run_tests(runs: ENV["RUNS"] || 10)

data/examples/tuple.rb

@@ -1,6 +1,6 @@
 require "bundler/setup"
 require "json"
-require 'blood_contracts/core'
+require "blood_contracts/core"
 require "pry"
 
 module Types
@@ -8,7 +8,7 @@ module Types
     def match
       super do
         begin
-          context[:parsed] = ::JSON.parse(unpack_refined(@value))
+          context[:parsed] = ::JSON.parse(value)
           self
         rescue StandardError => error
           failure(error)
@@ -23,14 +23,10 @@ module Types
 
   class Symbol < BC::Refined
     def match
-      super do
-        begin
-          context[:as_symbol] = unpack_refined(@value).to_sym
-          self
-        rescue StandardError => error
-          failure(error)
-        end
-      end
+      context[:as_symbol] = value.to_sym
+      self
+    rescue StandardError => error
+      failure(error)
     end
 
     def unpack
@@ -39,7 +35,10 @@ module Types
   end
 end
 
-Config = BC::Tuple.new(Types::Symbol, Types::JSON, names: %i(name config))
+Config = BC::Tuple.new do
+  attribute :name,  Types::Symbol
+  attribute :config, Types::JSON
+end
+
 c = Config.new("test", '{"some": "value"}')
 binding.pry
-

data/lib/blood_contracts/core/anything.rb

@@ -0,0 +1,23 @@
+module BloodContracts::Core
+  # Refinement type which represents data which is always correct
+  class Anything < Refined
+
+    # The type which is the result of data matching process
+    # (for Anything is always self)
+    #
+    # @return [BC::Refined]
+    #
+    def match
+      self
+    end
+
+    # Checks whether the data matches the expectations or not
+    # (for Anything is always true)
+    #
+    # @return [Boolean]
+    #
+    def valid?
+      true
+    end
+  end
+end

data/lib/blood_contracts/core/contract.rb

@@ -1,28 +1,42 @@
-module BloodContracts
-  module Core
-    class Contract
-      class << self
-        def new(*args)
-          input, output =
-            if (opts = args.last).is_a?(Hash)
-              accumulate_contract = opts.reduce({}) do |acc, (input, output)|
-                prev_input, prev_output = acc.first
-                { (input | prev_input) => (output | prev_output) }
-              end
-              accumulate_contract.first
-            else
-              _validate_args!(args)
-              args
-            end
-          BC::Pipe.new(input, output, names: %i(input output))
-        end
+module BloodContracts::Core
+  # Meta refinement type, represents contract built upon input and output
+  # types
+  class Contract
+    class << self
+      # Metaprogramming around constructor
+      # Turns input types into a contract
+      #
+      # @param [Hash<BC::Refined, BC::Refined>] expectations about possible
+      #   data input expressed in form of BC::Refined types
+      # @return [BC::Refined] contract for data validation in form of
+      #   BC::Refined class
+      #
+      def new(*args)
+        input, output =
+          if (opts = args.last).is_a?(Hash)
+            accumulate_contract(opts)
+          else
+            _validate_args!(args)
+            args
+          end
+        BC::Pipe.new(input, output, names: %i[input output])
+      end
+
+      # @private
+      private def _validate_args!(args)
+        return if args.size == 2
+        raise ArgumentError, <<~MESSAGE
+          wrong number of arguments (given #{args.size}, expected 2)
+        MESSAGE
+      end
 
-        def _validate_args!(args)
-          return if args.size == 2
-          raise ArgumentError, <<~MESSAGE
-            wrong number of arguments (given #{args.size}, expected 2)
-          MESSAGE
+      # @private
+      private def accumulate_contract(options)
+        accumulate_contract = options.reduce({}) do |acc, (input, output)|
+          prev_input, prev_output = acc.first
+          { (input | prev_input) => (output | prev_output) }
         end
+        accumulate_contract.first
       end
     end
   end

data/lib/blood_contracts/core/contract_failure.rb

@@ -0,0 +1,50 @@
+module BloodContracts::Core
+  # Refinement type which represents invalid data
+  class ContractFailure < Refined
+    # Constructs a ContractsFailure using the given value
+    # (for ContractFailure value is an error)
+    #
+    # @return [ContractFailure]
+    #
+    def initialize(value = nil, **)
+      super
+      @match = self
+      return unless @value
+      @context[:errors] = (@context[:errors].to_a << @value.to_h)
+    end
+
+    # List of errors per type after the data matching process
+    #
+    # @return [Array<Hash<BC::Refined, String>>]
+    #
+    def errors
+      @context[:errors].to_a
+    end
+
+    # Flatten list of error messages
+    #
+    # @return [Array<String>]
+    #
+    def messages
+      errors.reduce(:merge).values.flatten!
+    end
+
+    # Merged map of errors per type after the data matching process
+    #
+    # @return [Hash<BC::Refined, String>]
+    #
+    def errors_h
+      errors.reduce(:merge)
+    end
+    alias to_h errors_h
+
+    # The type which is the result of validation
+    # (for ContractFailure is always self)
+    #
+    # @return [BC::Refined]
+    #
+    def match
+      self
+    end
+  end
+end

data/lib/blood_contracts/core/pipe.rb

@@ -1,95 +1,161 @@
-module BloodContracts
-  module Core
-    class Pipe < Refined
-      class << self
-        attr_reader :steps, :names, :finalized
-
-        def new(*args, **kwargs)
-          return super(*args, **kwargs) if finalized
-          unless kwargs.empty?
-            names = kwargs.delete(:names)
-          end
-          names ||= []
-
-          raise ArgumentError unless args.all?(Class)
-          pipe = Class.new(Pipe) { def inspect; super; end }
-          pipe.instance_variable_set(:@steps, args)
-          pipe.instance_variable_set(:@names, names)
-          pipe.instance_variable_set(:@finalized, true)
-          pipe
-        end
-
-        def and_then(other_type, **kwargs)
-          raise ArgumentError unless Class === other_type
-          pipe = Class.new(Pipe) { def inspect; super; end }
-          pipe.instance_variable_set(:@steps, [self, other_type])
-          pipe.instance_variable_set(:@names, kwargs[:names].to_a)
-          pipe.instance_variable_set(:@finalized, true)
-          pipe
-        end
-        alias :> :and_then
-
-        def inspect
-          self.name || "Pipe(#{self.steps.to_a.join(',')})"
-        end
-
-        private
-
-        attr_writer :names
+module BloodContracts::Core
+  # Meta refinement type, represents pipe of several refinement types
+  class Pipe < Refined
+    class << self
+      # List of data transformation step
+      #
+      # @return [Array<Refined>]
+      #
+      attr_reader :steps
+
+      # List of data transformation step names
+      #
+      # @return [Array<Symbol>]
+      #
+      attr_reader :names
+
+      # rubocop:disable Style/SingleLineMethods
+      def new(*args, **kwargs, &block)
+        return super(*args, **kwargs) if @finalized
+        names = kwargs.delete(:names) unless kwargs.empty?
+        names ||= []
+
+        raise ArgumentError unless args.all? { |type| type < Refined }
+        pipe = Class.new(Pipe) { def inspect; super; end }
+        finalize!(pipe, args, names)
+        pipe.class_eval(&block) if block_given?
+        pipe
       end
 
-      def initialize(*)
-        super
-        @context[:types] = @context[:types].to_a
+      # Compose types in a Pipe check
+      # Pipe passes data from type to type sequentially
+      #
+      # @return [BC::Pipe]
+      #
+      # rubocop:disable Style/CaseEquality
+      def and_then(other_type, **kwargs)
+        raise ArgumentError unless Class === other_type
+        pipe = Class.new(Pipe) { def inspect; super; end }
+        finalize!(pipe, [self, other_type], kwargs[:names].to_a)
+        pipe
       end
-
-      def match
-        super do
-          index = 0
-          self.class.steps.reduce(value) do |next_value, step|
-            unpacked_value = unpack_refined(next_value)
-            match = step.match(unpacked_value, context: @context)
-
-            @context[:steps][step_name(index)] = unpacked_value
-            types << match.class.name unless current_type.eql?(match.class.name)
-            index += 1
-
-            break match if match.invalid?
-            if block_given? && index < self.class.steps.size
-              next refine_value(yield(match))
-            end
-            match
-          end
+      # rubocop:enable Style/CaseEquality Style/SingleLineMethods
+      alias > and_then
+
+      # Helper which registers step in validation pipe, also defines a reader
+      #
+      # @param [Symbol] name of the matching step
+      # @param [Refined] type of the matching step
+      #
+      def step(name, type)
+        raise ArgumentError unless type < Refined
+        @steps << type
+        @names << name
+        define_method(name) do
+          match.context.dig(:steps_values, name)
         end
       end
 
-      def errors
-        match.errors
+      # Returns text representation of Pipe meta-class
+      #
+      # @return [String]
+      #
+      def inspect
+        return super if name
+        "Pipe(#{steps.to_a.join(',')})"
       end
 
-      private def types
-        context[:types]
+      private def finalize!(new_class, steps, names)
+        new_class.instance_variable_set(:@steps, steps)
+        new_class.instance_variable_set(:@names, names)
+        new_class.instance_variable_set(:@finalized, true)
       end
+    end
 
-      private def current_type
-        context[:types].last
-      end
+    # Constructs a Pipe using the given value
+    # (for Pipe steps are also stored in the context)
+    #
+    # @return [Pipe]
+    #
+    def initialize(*)
+      super
+      @context[:steps] = @context[:steps].to_a
+    end
 
-      private def step_name(index)
-        self.class.names[index] || index
+    # The type which is the result of data matching process
+    # For PIpe it verifies that data is valid through all data transformation
+    # steps
+    #
+    # @return [BC::Refined]
+    #
+    def match
+      steps_enumerator.reduce(value) do |next_value, (step, index)|
+        match = next_step_value_match!(step, next_value, index)
+
+        break match if match.invalid?
+        next match unless block_given?
+        next refine_value(yield(match)) if index < self.class.steps.size - 1
+
+        match
       end
+    end
 
-      private def steps_with_names
-        steps = if self.class.names.empty?
-                  self.class.steps.map(&:inspect)
-                else
-                  self.class.steps.zip(self.class.names).map { |k, n| "#{k.inspect}(#{n})" }
-                end
-      end
+    # List of errors per type during the matching
+    #
+    # @return [Array<Hash<Refined, String>>]
+    #
+    def errors
+      @context[:errors]
+    end
 
-      private def inspect
-        "#<pipe #{self.class.name} = #{steps_with_names.join(' > ')} (value=#{@value})>"
+    # @private
+    private def next_step_value_match!(step, value, index)
+      unpacked_value = unpack_refined(value)
+      match = step.match(unpacked_value, context: @context)
+      track_steps!(index, unpacked_value, match.class.name)
+      match
+    end
+
+    # @private
+    private def steps_enumerator
+      self.class.steps.each_with_index
+    end
+
+    # @private
+    private def track_steps!(index, unpacked_value, match_class_name)
+      @context[:steps_values][step_name(index)] = unpacked_value
+      steps << match_class_name unless current_step.eql?(match_class_name)
+    end
+
+    # @private
+    private def steps
+      @context[:steps]
+    end
+
+    # @private
+    private def current_step
+      @context[:steps].last
+    end
+
+    # @private
+    private def step_name(index)
+      self.class.names[index] || index
+    end
+
+    # @private
+    private def steps_with_names
+      steps = self.class.steps
+      if self.class.names.empty?
+        steps.map(&:inspect)
+      else
+        steps.zip(self.class.names).map { |k, n| "#{k.inspect}(#{n})" }
       end
     end
+
+    # @private
+    private def inspect
+      "#<pipe #{self.class.name} = #{steps_with_names.join(' > ')}"\
+      " (value=#{@value})>"
+    end
   end
 end