blood_contracts-core 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15305efec69e9366ea2169a4abf832a1619cc87e5aeef2be0e0d324e4fe49db7
-  data.tar.gz: 50cc4a0a8ba539dcb28ff31f29dfc0e487633753542b30ca5af8222ada5d57c0
+  metadata.gz: 85f39b273547e389e3938ab33f8182857ef7c0d8f573e5664cb877c40c4d991a
+  data.tar.gz: a8e6d07a8311096fdb4a83d7c30a510807b6713a29ad620b4e0e174c09448346
 SHA512:
-  metadata.gz: 94b4bc3793c8a4259f0111daca712e3949361df4b72ce2e95cac9b5e5d64754bf1694e717eb134cb83249b7b028211995c000344afa64fc2b198d11f33817a1d
-  data.tar.gz: 2b43b3fa1b14b0166bfab0aee21406075179de2d58bf68fbce54eece179cc8334b07b5246c2864383f0fdbbf356b5cc018ec0f3b987b5937ef3c34558c5b3f0b
+  metadata.gz: 726747a300fa76dab9a86ac8efe2f79aae54bfadee6c12989a377833754cf5f912d585b214c23370e4b6bf75eecba05684b5f816ac6eb66a3b208505935ccf9d
+  data.tar.gz: dd2d045b398fc3d8a82da25226a2b9f8cddc92e9b451111aa20b8c5ca4e44706d197d0b2eef665e776ef8d4d004ac57409d2c3c260bd650b624bb4da2ce9884d

data/.gitignore

@@ -9,3 +9,4 @@
 
 # rspec failure tracking
 .rspec_status
+Gemfile.lock

data/examples/tariff_contract.rb

@@ -0,0 +1,357 @@
+require "bundler/setup"
+require "json"
+require 'blood_contracts/core'
+require "pry"
+
+module Types
+  class JSON < BC::Refined
+    def match
+      super do
+        begin
+          context[:parsed] = ::JSON.parse(unpack_refined(@value))
+          self
+        rescue StandardError => error
+          failure(error)
+        end
+      end
+    end
+
+    def unpack
+      super { |match| match.context[:parsed] }
+    end
+  end
+end
+
+module RussianPost
+  class DomesticTariffMapper
+    def self.call(parcel)
+      {
+        "mass": parcel.weight,
+        "mail-from": parcel.origin_postal_code,
+        "mail-to":   parcel.destination_postal_code,
+      }
+    end
+  end
+
+  class InputValidationFailure < BC::ContractFailure; end
+  class ExceptionCaught < BC::ContractFailure; end
+
+  class BaseType < BC::Refined
+    def exception(ex, context: @context)
+      ExceptionCaught.new({ exception: ex }, context: context)
+    end
+  end
+
+  class DomesticParcel < BaseType
+    self.failure_klass = InputValidationFailure
+
+    alias :parcel :value
+    def _match
+      return failure(key: :undef_weight, field: :weight) unless parcel.weight
+      return self if domestic?
+      failure(non_domestic_error)
+    rescue StandardError => error
+      exception(error)
+    end
+
+    def _unpack(match)
+      DomesticTariffMapper.call(match.parcel)
+    end
+
+    private
+
+    def domestic?
+      [parcel.origin_country, parcel.destination_country].all?("RU")
+    end
+
+    def non_domestic_error
+      {
+        key: :non_domestic_parcel,
+        context: {
+          origin: parcel.origin_country,
+          destination: parcel.destination_country,
+        }
+      }
+    end
+  end
+
+  class InternationalTariffMapper
+    def self.call(parcel)
+      {
+        "mass": parcel.weight,
+        "mail-direct":   parcel.destination_country,
+      }
+    end
+  end
+
+  class InternationalParcel < BaseType
+    self.failure_klass = InputValidationFailure
+
+    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
+    rescue StandardError => error
+      exception(error)
+    end
+
+    def _unpack(match)
+      InternationalTariffMapper.call(match.parcel)
+    end
+
+    private
+
+    def parcel_outside_ru?
+      parcel.origin_country != "RU"
+    end
+
+    def non_international_parcel?
+      parcel.destination_country == "RU"
+    end
+
+    def not_from_ru_error
+      {
+        key: :parcel_is_not_from_ru,
+        context: {
+          origin: parcel.origin_country,
+        }
+      }
+    end
+
+    def non_international_error
+      { key: :parcel_is_not_international }
+    end
+  end
+
+  class RecoverableInputError < BC::Refined
+    alias :parsed_response :value
+    def match
+      super do
+        begin
+          next self if [error_code, error_message].all?
+          failure(not_a_recoverable_error)
+        rescue StandardError => error
+          failure(error)
+        end
+      end
+    end
+
+    def error_message
+      @error_message ||= parsed_response["desc"]
+      @error_message ||= parsed_response["error-details"]&.join("; ")
+    end
+
+    private
+
+    def not_a_recoverable_error
+      { key: :not_a_recoverable_error }
+    end
+
+    def error_code
+      parsed_response.values_at("code", "error-code").compact.first
+    end
+  end
+
+  class OtherError < BC::Refined
+    alias :parsed_response :value
+    def match
+      super do
+        begin
+          next failure({key: :not_a_known_error}) if error_code.nil?
+          self
+        rescue StandardError => error
+          failure(error)
+        end
+      end
+    end
+
+    private
+
+    def error_code
+      parsed_response.values_at("code", "error-code", "status").compact.first
+    end
+  end
+
+  class DomesticTariff < BC::Refined
+    alias :parsed_response :value
+    def match
+      super do
+        begin
+          next self if is_a_domestic_tariff?
+          context[:raw_response] = parsed_response
+          failure({key: :not_a_domestic_tariff})
+        rescue StandardError => error
+          failure(error)
+        end
+      end
+    end
+
+    def cost
+      @cost ||= delivery_cost / 100.0
+    end
+
+    private
+
+    def is_a_domestic_tariff?
+      [delivery_cost, delivery_date, cost].all?
+    end
+
+    def delivery_cost
+      parsed_response["total-cost"]
+    end
+
+    def delivery_date
+      @delivery_date ||= parsed_response["delivery-till"]
+    end
+  end
+
+  class InternationalTariff < BC::Refined
+    alias :parsed_response :value
+    def match
+      super do
+        begin
+          next self if is_an_international_tariff?
+          context[:raw_response] = parsed_response
+          failure({key: :not_an_international_tariff})
+        rescue StandardError => error
+          failure(error)
+        end
+      end
+    end
+
+    def cost
+      @cost ||= (delivery_rate + delivery_vat) / 100.0
+    end
+
+    private
+
+    def is_an_international_tariff?
+      [delivery_rate, delivery_vat, cost].all?
+    end
+
+    def delivery_rate
+      parsed_response["total-rate"]
+    end
+
+    def delivery_vat
+      parsed_response["total-vat"]
+    end
+  end
+end
+
+module RussianPost
+  KnownError = RecoverableInputError | OtherError
+
+  DomesticResponse =
+    (Types::JSON > (DomesticTariff | KnownError)).set(names: %i(parsed mapped))
+  InternationalResponse =
+    (Types::JSON > (InternationalTariff | KnownError)).set(names: %i(parsed mapped))
+
+  TariffRequestContract = ::BC::Contract.new(
+    DomesticParcel      => DomesticResponse,
+    InternationalParcel => InternationalResponse,
+  )
+end
+
+def contractable_request_tariff(input)
+  RussianPost::TariffRequestContract.match(input) do |refined_parcel|
+    request_tariff(refined_parcel.unpack)
+  end
+end
+
+def match_response(response)
+  case response
+  when RussianPost::ExceptionCaught
+    puts "Honeybadger.notify #{response.errors_h[:exception]}"
+  when RussianPost::InputValidationFailure
+    # работаем с тарифом
+    puts "render json: { errors: 'Parcel is invalid for request (#{response.to_h})' }"
+  when RussianPost::DomesticTariff
+    # работаем с тарифом
+    puts "render json: { context: 'inside Russia only!', cost: #{response.cost} }"
+  when RussianPost::InternationalTariff
+    # работаем с тарифом
+    puts "render json: { context: 'outside Russia only!', cost_inc_vat: #{response.cost} }"
+  when RussianPost::RecoverableInputError
+    # работаем с ошибкой, e.g. адрес слишком длинный
+    puts "render json: { errors: [#{response.error_message}] } }"
+  when RussianPost::OtherError
+    # работаем с ошибкой, 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 BC::ContractFailure
+    puts "Honeybadger.notify 'Unexpected behavior in Russian Post API Client', context:"
+    puts "  'Unexpected behavior in Russian Post API Client'"
+    puts "  context:"
+    pp(response.context)
+    puts "render json: { errors: 'Ooops! Not working, we've been notified. Please, try again later' }"
+  else
+    require'pry';binding.pry
+  end
+end
+
+# DEMO STUFF
+
+Stuff = Struct.new(:daaamn, keyword_init: true)
+Parcel = Struct.new(
+  :weight, :origin_country, :origin_postal_code, :destination_country,
+  :destination_postal_code,
+  keyword_init: true
+)
+
+PARCELS = [
+  # domestic without weight
+  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" ),
+
+  # domestic
+  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" ),
+
+  # not a parcel
+  Stuff.new(daaamn: "WTF?!")
+]
+
+RESPONSES = [
+  '{"total-cost": 10000, "delivery-till": "2019-12-12"}',
+  '{"total-rate": 100000, "total-vat": 1800}',
+  '{"code": 1010, "desc": "Too long address"}',
+  '{"error-code": 2020, "error-details": ["Too heavy parcel"]}',
+]
+
+def run_tests(runs: ENV["RUNS"] || 10)
+  runs.to_i.times do
+    input = PARCELS.sample
+    puts "#{'=' * 20}================================#{'=' * 20}"
+    puts "\n\n\n"
+    puts "#{'=' * 20}================================#{'=' * 20}"
+    puts "#{'=' * 20} WHEN INPUT:                    #{'=' * 20}"
+    pp(input)
+    match = contractable_request_tariff(input)
+    puts "#{'=' * 20}================================#{'=' * 20}"
+    puts "#{'=' * 20} ACTION:                        #{'=' * 20}"
+    match_response(match)
+    puts "#{'=' * 20}================================#{'=' * 20}"
+  end
+end
+
+def request_tariff(request)
+  puts "#{'=' * 20}================================#{'=' * 20}"
+  puts "#{'=' * 20} AND THEN REQUEST:              #{'=' * 20}"
+  pp(request)
+
+  puts "#{'=' * 20}================================#{'=' * 20}"
+  puts "#{'=' * 20} AND THEN RESPONSE:             #{'=' * 20}"
+  response = RESPONSES.sample
+  puts response
+
+  response
+end
+
+run_tests

data/lib/blood_contracts/core/contract.rb

@@ -2,15 +2,26 @@ module BloodContracts
   module Core
     class Contract
       class << self
-        attr_accessor :input_type, :output_type
-      end
+        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
 
-      def self.call(*args)
-        if (input_match = input_type.match(*args)).valid?
-          result = yield(input_match)
-          output_type.match(result, context: input_match.context)
-        else
-          input_match
+        def _validate_args!(args)
+          return if args.size == 2
+          raise ArgumentError, <<~MESSAGE
+            wrong number of arguments (given #{args.size}, expected 2)
+          MESSAGE
         end
       end
     end

data/lib/blood_contracts/core/pipe.rb

@@ -28,6 +28,14 @@ module BloodContracts
           pipe
         end
         alias :> :and_then
+
+        def inspect
+          self.name || "Pipe(#{self.steps.to_a.join(',')})"
+        end
+
+        private
+
+        attr_writer :names
       end
 
       def match
@@ -43,27 +51,27 @@ module BloodContracts
             end
 
             break match if match.invalid?
-            next refine_value(yield(match)) if block_given?
+            if block_given? && index < self.class.steps.size
+              next refine_value(yield(match))
+            end
             match
           end
         end
       end
 
-      private
-
-      def step_name(index)
+      private def step_name(index)
         self.class.names[index] || index
       end
 
-      def steps_with_names
+      private def steps_with_names
         steps = if self.class.names.empty?
-                  self.class.steps.map(&:to_s)
+                  self.class.steps.map(&:inspect)
                 else
-                  self.class.steps.zip(self.class.names).map { |k, n| "#{k}(#{n})" }
+                  self.class.steps.zip(self.class.names).map { |k, n| "#{k.inspect}(#{n})" }
                 end
       end
 
-      def inspect
+      private def inspect
         "#<pipe #{self.class.name} = #{steps_with_names.join(' > ')} (value=#{@value})>"
       end
     end

data/lib/blood_contracts/core/refined.rb

@@ -14,7 +14,11 @@ module BloodContracts
         alias :> :and_then
 
         def match(*args)
-          new(*args).match
+          if block_given?
+            new(*args).match { |*subargs| yield(*subargs) }
+          else
+            new(*args).match
+          end
         end
         alias :call :match
 
@@ -22,6 +26,18 @@ module BloodContracts
           return object.to_ary.any?(self) if object.is_a?(Tuple)
           super
         end
+
+        def set(**kwargs)
+          kwargs.each do |setting, value|
+            send(:"#{setting}=", value)
+          end
+          self
+        end
+
+        attr_accessor :failure_klass
+        def inherited(new_klass)
+          new_klass.failure_klass ||= ContractFailure
+        end
       end
 
       attr_accessor :context
@@ -36,6 +52,7 @@ module BloodContracts
       def match
         return @match if defined? @match
         return @match = yield if block_given?
+        return @match = _match if respond_to?(:_match)
         self
       end
       alias :call :match
@@ -48,13 +65,15 @@ module BloodContracts
       def unpack
         raise "This is not what you're looking for" if match.invalid?
         return yield(match) if block_given?
+        return @match = _unpack(match) if respond_to?(:_unpack)
 
         unpack_refined @value
       end
 
-      def failure(error = nil, errors: @errors, context: @context)
+      def failure(error = nil, errors: @errors, context: @context, **kwargs)
+        error ||= kwargs unless kwargs.empty?
         errors << error if error
-        ContractFailure.new(
+        self.class.failure_klass.new(
           { self.class => errors }, context: context
         )
       end
@@ -79,21 +98,25 @@ module BloodContracts
       end
 
       def errors_by_type(matches)
-        Hash[
-          matches.map(&:class).zip(matches.map(&:errors))
-        ].delete_if { |_, errors| errors.empty? }
+        matches.map(&:errors).reduce(:+).delete_if(&:empty?)
       end
     end
 
     class ContractFailure < Refined
-      def initialize(*)
+      def initialize(value = nil, **)
         super
-        @context.merge!(errors: @value.to_h)
+        return unless @value
+        @context[:errors] = (@context[:errors].to_a << @value.to_h)
       end
 
       def errors
-        context[:errors]
+        @context[:errors].to_a
+      end
+
+      def errors_h
+        errors.reduce(:merge)
       end
+      alias :to_h :errors_h
 
       def match
         self

data/lib/blood_contracts/core/sum.rb

@@ -9,20 +9,29 @@ module BloodContracts
         def new(*args)
           return super if finalized
 
+          new_sum = args.reduce([]) { |acc, type| type.respond_to?(:sum_of) ? acc + type.sum_of.to_a : acc << type  }
+
           sum = Class.new(Sum) { def inspect; super; end }
-          sum.instance_variable_set(:@sum_of, ::Set.new(args))
+          sum.instance_variable_set(:@sum_of, ::Set.new(new_sum.compact))
           sum.instance_variable_set(:@finalized, true)
           sum
         end
 
         def or_a(other_type)
           sum = Class.new(Sum) { def inspect; super; end }
-          sum.instance_variable_set(:@sum_of, ::Set.new(self.sum_of << other_type))
+          new_sum = self.sum_of.to_a
+          new_sum += other_type.sum_of.to_a if other_type.respond_to?(:sum_of)
+          sum.instance_variable_set(:@sum_of, ::Set.new(new_sum.compact))
           sum.instance_variable_set(:@finalized, true)
           sum
         end
         alias :or_an :or_a
         alias :| :or_a
+
+        def inspect
+          return super if self.name
+          "Sum(#{self.sum_of.map(&:inspect).join(',')})"
+        end
       end
 
       def match
@@ -32,10 +41,11 @@ module BloodContracts
           end
 
           if (match = or_matches.find(&:valid?))
-            match.context[:errors].merge(errors_by_type(or_matches))
             match
           else
-            failure(errors: errors_by_type(or_matches))
+            or_matches.first
+            # just use the context
+            # ContractFailure.new(context: context)
           end
         end
       end

data/lib/blood_contracts/core/tuple.rb

@@ -17,6 +17,10 @@ module BloodContracts
           tuple.instance_variable_set(:@finalized, true)
           tuple
         end
+
+        private
+
+        attr_writer :names
       end
 
       attr_reader :values

data/lib/blood_contracts/core/version.rb

@@ -1,5 +1,5 @@
 module BloodContracts
   module Core
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/blood_contracts/core.rb

@@ -1,5 +1,6 @@
 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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blood_contracts-core
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Sergey Dolganov
@@ -85,6 +85,7 @@ files:
 - bin/setup
 - blood_contracts-core.gemspec
 - examples/json_response.rb
+- examples/tariff_contract.rb
 - examples/tuple.rb
 - lib/blood_contracts-core.rb
 - lib/blood_contracts/core.rb