blood_contracts-core 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d50ef9d60bc174f486385734c98d18ade0fa6a21cdc809d0a3bead98c044aac
-  data.tar.gz: c55c10f1248097678f6feaab0bfd055494c2de7da69b663ec2458b9449b8b560
+  metadata.gz: bc10cd9d71e3f255a6e3e520acb9fa39e307308a97b227107a0deca3d97b5cb6
+  data.tar.gz: 96d8127169a6f4bef13b1f14128c599b78038c151547521ca5faf668f6d18975
 SHA512:
-  metadata.gz: 469b03faa75fa6a46448aee7592cbbabe2a4ad53c5dca11c7395e67a9fdfcfc6c4bc4364afde47440778befaf78344f856b65f3b6c1ad0c267d1943629152c53
-  data.tar.gz: 4354966854dc2cacaf189fec6531555e5f5784b915e34757db40d896fd095f9666a58b62dacd00874b41b467557abf0fd83dc6fdd7395a0d2353b154e4e5ba46
+  metadata.gz: 41554f77f48de3d91bc3fbb63662db1a3064f6e2c1fe44a7913c3e14658501b7de908a230e0f67410779ce4403d116157f64e687b16090d7be0e0acb04e5c9b0
+  data.tar.gz: 9d0c18ec90d9f283a13754f1dc78c43c117afe0c688bd321a4aa26101c0396eda9bb0a46061ceae2ee99288b8d4733e5981e000faeea176a7d487cf609aaf897

data/bin/console

@@ -7,8 +7,8 @@ require "blood_contracts/core"
 # with your gem easier. You can also use a different console, if you like.
 
 # (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
+require "pry"
+Pry.start
 
-require "irb"
-IRB.start(__FILE__)
+# require "irb"
+# IRB.start(__FILE__)

data/blood_contracts-core.gemspec

@@ -23,9 +23,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "dry-initializer", "~> 2.0"
-
   spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "pry"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/examples/json_response.rb

@@ -2,55 +2,74 @@ require 'json'
 require 'blood_contracts/core'
 
 module Types
-  class JSON < BloodType
-    param :json_string
-
+  class JSON < BC::Refined
     def match
-      @parsed = ::JSON.parse(unpack_refined(json_string))
-      self
-    rescue StandardError => error
-      @errors << error
-      self
+      super do
+        begin
+          context[:parsed] = ::JSON.parse(unpack_refined(@value))
+          self
+        rescue StandardError => error
+          failure(error)
+        end
+      end
     end
 
     def unpack
-      @parsed
+      super { |match| match.context[:parsed] }
     end
   end
 
-  class Tariff < BloodType
-    param :json
-
+  class Tariff < BC::Refined
     def match
       super do
-        @parsed = unpack_refined(self.json).slice("cost", "cur").compact
-        @errors << :not_a_tariff if @parsed.size != 2
-        self
+        context[:data] = unpack_refined(@value).slice("cost", "cur").compact
+        context[:tariff_context] = 1
+        return self if context[:data].size == 2
+        failure(:not_a_tariff)
       end
     end
-  end
 
-  class Error < BloodType
-    param :json
+    def unpack
+      super { |match| match.context[:data] }
+    end
+  end
 
+  class Error < BC::Refined
     def match
       super do
-        @parsed = unpack_refined(self.json).slice("code", "message").compact
-        @errors << :not_an_error if @parsed.size != 2
-        self
+        context[:data] = unpack_refined(value).slice("code", "message").compact
+        context[:known_error_context] = 1
+        return self if context[:data].size == 2
+        failure(:not_a_known_error)
       end
     end
-  end
 
-  class Response < BloodType
-    option :raw, BC::Anything.method(:new)
-    option :parsed, JSON.method(:new), default: -> { raw }
-    option :mapped, (Tariff | Error).method(:new), default: -> { parsed }
+    def unpack
+      super { |match| match.context[:data] }
+    end
   end
+
+  Response = BC::Pipe.new(
+    BC::Anything, JSON, (Tariff | Error | Tariff),
+    names: [:raw, :parsed, :mapped]
+  )
+
+  # The same is
+  # Response = BC::Anything.and_then(JSON).and_then(Tariff | Error) do
+  # class Response
+  #   self.names = [:raw, :parsed, :mapped]
+  # end
+  #
+  # or
+  #
+  # Response = BC::Pipe.new(BC::Anything, JSON, Tariff | Error) do
+  #   self.names = [:raw, :parsed, :mapped]
+  # end
 end
 
 def match_response(response)
-  case (match = Types::Response.match(raw: response))
+  match = Types::Response.match(response)
+  case match
   when BC::ContractFailure
     puts "Honeybadger.notify 'Unexpected behavior in Russian Post', context: #{match.context}"
     puts "render json: { errors: 'Ooops! Not working, we've been notified. Please, try again later' }"
@@ -61,12 +80,14 @@ def match_response(response)
     end
   when Types::Tariff
     # работаем с тарифом
-    puts "render json: { tariff: #{match.unpack.mapped} }"
+    puts "match.context # => #{match.context} \n\n"
+    puts "render json: { tariff: #{match.unpack} }"
   when Types::Error
     # работаем с ошибкой, e.g. адрес слишком длинный
-    puts "render json: { errors: [#{match.unpack.mapped.unpack['message']}] } }"
+    puts "match.context # => #{match.context} \n\n"
+    puts "render json: { errors: [#{match.unpack['message']}] } }"
   else
-    binding.irb
+    require'pry';binding.pry
   end
 end
 
@@ -85,7 +106,7 @@ match_response(error_response)
 puts "#{'=' * 20}================================#{'=' * 20}"
 
 
-puts "\n\n\n"
+puts "ss => errors }\n\n\n"
 puts "#{'=' * 20} WHEN UNEXPECTED RESPONSE:      #{'=' * 20}"
 invalid_response = '<xml>'
 match_response(invalid_response)

data/lib/blood_contracts/core/pipe.rb

@@ -0,0 +1,72 @@
+module BloodContracts
+  module Core
+    class Pipe < Refined
+      class << self
+        attr_reader :steps, :names, :finalized
+
+        def new(*args)
+          return super(*args) if finalized
+          if args.last.is_a?(Hash)
+            names = args.pop.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)
+          raise ArgumentError unless Class === other_type
+          pipe = Class.new(Pipe) { def inspect; super; end }
+          pipe.instance_variable_set(:@steps, args)
+          pipe.instance_variable_set(:@names, kwargs[:names].to_a)
+          pipe.instance_variable_set(:@finalized, true)
+          pipe
+        end
+        alias :> :and_then
+      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)
+
+            share_context_with(match) do |context|
+              context[:steps][step_name(index)] = unpacked_value
+              index += 1
+            end
+
+            break match if match.invalid?
+            next refine_value(yield(match)) if block_given?
+            match
+          end
+        end
+      end
+
+      private
+
+      def step_name(index)
+        self.class.names[index] || index
+      end
+
+      def steps_with_names
+        steps = if self.class.names.empty?
+                  self.class.steps.map(&:to_s)
+                else
+                  self.class.steps.zip(self.class.names).map { |k, n| "#{k}(#{n})" }
+                end
+      end
+
+      def inspect
+        require'pry';binding.pry
+        "#<pipe #{self.class.name} = #{steps_with_names.join(' > ')} (value=#{@value})>"
+      end
+    end
+  end
+end

data/lib/blood_contracts/core/refined.rb

@@ -0,0 +1,126 @@
+module BloodContracts
+  module Core
+    class Refined
+      class << self
+        def or_a(other_type)
+          BC::Sum.new(self, other_type)
+        end
+        alias :or_an :or_a
+        alias :| :or_a
+
+        def and_then(other_type)
+          BC::Pipe.new(self, other_type)
+        end
+        alias :> :and_then
+
+        def match(*args)
+          new(*args).match
+        end
+        alias :call :match
+
+        def ===(object)
+          return object.to_ary.any?(self) if object.is_a?(Tuple)
+          super
+        end
+      end
+
+      attr_accessor :context
+      attr_reader :errors, :value
+
+      def initialize(value, context: Hash.new { |h,k| h[k] = Hash.new }, **)
+        @errors = []
+        @context = context
+        @value = value
+      end
+
+      def match
+        return @match if defined? @match
+        return @match = yield if block_given?
+        self
+      end
+      alias :call :match
+
+      def valid?
+        match.errors.empty?
+      end
+      def invalid?; !valid?; end
+
+      def unpack
+        raise "This is not what you're looking for" if match.invalid?
+        return yield(match) if block_given?
+
+        unpack_refined @value
+      end
+
+      def failure(error = nil, errors: @errors, context: @context)
+        errors << error if error
+        ContractFailure.new(
+          { self.class => errors }, context: context
+        )
+      end
+
+      def inspect
+        require'pry';binding.pry
+        super
+      end
+
+      protected
+
+      def refined?(object)
+        object.class < BloodContracts::Core::Refined
+      end
+
+      def share_context_with(match)
+        match.context = @context.merge!(match.context)
+        yield(match.context)
+      end
+
+      def refine_value(value)
+        refined?(value) ? value.match : Anything.new(value)
+      end
+
+      def unpack_refined(value)
+        refined?(value) ? value.unpack : value
+      end
+
+      def errors_by_type(matches)
+        Hash[
+          matches.map(&:class).zip(matches.map(&:errors))
+        ].delete_if { |_, errors| errors.empty? }
+      end
+    end
+
+    class ContractFailure < Refined
+      def initialize(*)
+        super
+        @context.merge!(errors: @value.to_h)
+      end
+
+      def errors
+        context[:errors]
+      end
+
+      def match
+        self
+      end
+
+      def unpack
+        context
+      end
+    end
+
+    class Anything < Refined
+      def match
+        self
+      end
+
+      def valid?
+        true
+      end
+
+      def unpack
+        @value
+      end
+    end
+  end
+end

data/lib/blood_contracts/core/sum.rb

@@ -0,0 +1,48 @@
+require 'set'
+
+module BloodContracts
+  module Core
+    class Sum < Refined
+      class << self
+        attr_reader :sum_of, :finalized
+
+        def new(*args)
+          return super if finalized
+
+          sum = Class.new(Sum) { def inspect; super; end }
+          sum.instance_variable_set(:@sum_of, ::Set.new(args))
+          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))
+          sum.instance_variable_set(:@finalized, true)
+          sum
+        end
+        alias :or_an :or_a
+        alias :| :or_a
+      end
+
+      def match
+        super do
+          or_matches = self.class.sum_of.map do |type|
+            match = type.match(@value, context: @context)
+          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))
+          end
+        end
+      end
+
+      def inspect
+        "#<sum #{self.class.name} is #{self.class.sum_of.to_a.join(' or ')} (value=#{@value})>"
+      end
+    end
+  end
+end

data/lib/blood_contracts/core/tuple.rb

@@ -0,0 +1,53 @@
+module BloodContracts
+  module Core
+    class Tuple < Refined
+      class << self
+        attr_reader :attributes, :names, :finalized
+
+        def new(*args, **kwargs)
+          return super(*args, **kwargs) if finalized
+
+          raise ArgumentError unless args.all?(Class)
+          pipe = Class.new(Tuple) { def inspect; super; end }
+          pipe.instance_variable_set(:@attributes, args)
+          pipe.instance_variable_set(:@names, kwargs[:names].to_a)
+          pipe.instance_variable_set(:@finalized, true)
+          pipe
+        end
+      end
+
+      attr_reader :values
+      def initialize(*args)
+        super
+        @values = args
+      end
+
+      def match
+        super do
+          matches = self.class.attributes.zip(values).map do |(type, value)|
+            type.match(value, context: @context)
+          end
+          next self unless (failure = matches.find?(&:invalid?)).nil?
+          failure
+        end
+      end
+
+      def unpack
+        super { |match| match.values.map(&method(:unpack_refined)) }
+      end
+      alias :to_ary :unpack
+
+      private def values_by_names
+        if self.class.names.empty?
+          self.values
+        else
+          self.class.names.zip(attributes).map { |k, v| [k, v].join('=') }
+        end
+      end
+
+      private def inspect
+        "#<tuple #{self.class.name} (#{values_by_names.join(',')}>"
+      end
+    end
+  end
+end

data/lib/blood_contracts/core/version.rb

@@ -1,5 +1,5 @@
 module BloodContracts
   module Core
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/blood_contracts/core.rb

@@ -1,30 +1,13 @@
-require "dry-initializer"
-require_relative "./core/contract.rb"
-require_relative "./core/type.rb"
+require_relative "./core/refined.rb"
+require_relative "./core/pipe.rb"
+require_relative "./core/sum.rb"
+require_relative "./core/tuple.rb"
 require_relative "./core/version.rb"
 
-BloodContract = BloodContracts::Core::Contract
-BloodType = BloodContracts::Core::Type
 
 module BloodContracts
   module Core; end
-
-  class ContractFailure < Core::Type
-    def errors
-      context[:errors].to_h
-    end
-
-    def unpack
-      context
-    end
-  end
-
-  class Anything < Core::Type
-    param :data
-  end
 end
 
-module BC
-  Anything = BloodContracts::Anything
-  ContractFailure = BloodContracts::ContractFailure
-end
+BC = BloodContracts::Core
+

metadata

@@ -1,23 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: blood_contracts-core
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Sergey Dolganov
 autorequire: 
 bindir: bin/
 cert_chain: []
-date: 2019-03-23 00:00:00.000000000 Z
+date: 2019-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: dry-initializer
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -88,7 +88,10 @@ files:
 - lib/blood_contracts-core.rb
 - lib/blood_contracts/core.rb
 - lib/blood_contracts/core/contract.rb
-- lib/blood_contracts/core/type.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
 homepage: https://github.com/sclinede/blood_contracts-core
 licenses:

data/lib/blood_contracts/core/type.rb

@@ -1,197 +0,0 @@
-module BloodContracts
-  module Core
-    class Type
-      extend Dry::Initializer
-
-      # TODO: share context between Refinement Types match
-      class << self
-        def attributes
-          @attributes ||= []
-        end
-
-        def param(name, *)
-          @attributes = attributes | [name.to_sym]
-          super
-        end
-
-        def option(name, type = nil, as: name, **)
-          @attributes = attributes | [as.to_sym]
-          super
-        end
-
-        def single?
-          attributes.size <= 1
-        end
-
-        attr_reader :sum
-        def or_a(other_type)
-          c = Class.new(Anything)
-          c.instance_variable_set(
-            :@sum, Set.new([self] + self.sum.to_a << other_type)
-          )
-          c
-        end
-        alias :or_an :or_a
-        alias :| :or_a
-
-        def match(*args)
-          new(*args).match
-        end
-        alias :call :match
-
-        def ===(object)
-          return true if (result = super)
-          return result unless object.class < BloodContracts::Core::Type
-          if object.class.send(:single?)
-            return result if object.class.sum.to_a.empty?
-            return object.class.sum.any? { |or_type| self == or_type }
-          end
-
-          object.attributes.values.any? { |sub_type| self === sub_type }
-        end
-      end
-
-      attr_accessor :context
-      attr_reader :errors, :value_handler
-      def initialize(*args, **kwargs)
-        @errors = []
-        @context = kwargs.delete(:context) || {}
-        @value_handler = self.class.single? ? Single.new(self) : Tuple.new(self)
-
-        super(*args, **kwargs)
-      end
-
-      def attributes
-        @attributes ||= self.class.dry_initializer.attributes(self)
-      end
-
-      def match
-        return @match if defined? @match
-        return @match = yield if block_given?
-        @match = value_handler.match
-      end
-      alias :call :match
-
-      def valid?
-        value_handler.valid?
-      end
-      def invalid?; !valid?; end
-
-      def unpack
-        value_handler.unpack
-      end
-
-      def single?
-        Single === value_handler
-      end
-
-      def refined?(object)
-        BloodContracts::Core::Type === object
-      end
-
-      def unpack_refined(value)
-        refined?(value) ? value.unpack : value
-      end
-
-      protected
-
-      class ValueHandler
-        def initialize(subject)
-          @subject = subject
-        end
-
-        def errors_by_type(matches)
-          Hash[
-            matches.map(&:class).zip(matches.map(&:errors))
-          ].delete_if { |_, errors| errors.empty? }
-        end
-
-        def refined?(object)
-          @subject.refined?(object)
-        end
-
-        def unpack_refined(value)
-          @subject.unpack_refined(value)
-        end
-      end
-
-      class Tuple < ValueHandler
-        def initialize(*)
-          super
-          @wrapper = Struct.new(*@subject.class.attributes, keyword_init: true)
-        end
-
-        def wrap_unpacked(match)
-          @wrapper.new(
-            match.attributes.transform_values(&method(:unpack_refined))
-          )
-        end
-
-        def match
-          failed_match =
-            @subject.attributes.values.lazy.map(&:match).find(&:invalid?)
-
-          if failed_match
-            BloodContracts::ContractFailure.new(
-              context: { errors: errors_by_type([failed_match]) }
-            )
-          else
-            @subject
-          end
-        end
-
-        def unpack
-          raise "This is not what you're looking for" if invalid?
-
-          wrap_unpacked(@subject.match)
-        end
-
-        def invalid?
-          BloodContracts::ContractFailure === @subject.match
-        end
-        def valid?; !invalid?; end
-
-        def single?
-          false
-        end
-      end
-
-      class Single < ValueHandler
-        def match
-          sum = @subject.class.sum.to_a
-          return refined?(value) ? value.match : @subject if sum.empty?
-
-          or_matches = sum.map { |type| type.match(value) }
-          if (match = or_matches.find(&:valid?))
-            match.context.merge!(errors: errors_by_type(or_matches))
-            match
-          else
-            BloodContracts::ContractFailure.new(
-              context: { errors: errors_by_type(or_matches) }
-            )
-          end
-        end
-
-        def valid?
-          @subject.errors.empty?
-        end
-
-        def unpack
-          raise "This is not what you're looking for" unless valid?
-
-          unpack_refined value
-        end
-
-        def single?
-          true
-        end
-
-        private
-
-        def value
-          @value ||= @subject.attributes.values.first
-        end
-      end
-    end
-  end
-end