mayak 0.0.15 → 0.2.0

data/lib/mayak/validations/rule.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module Validations
+    class Rule
+      extend T::Sig
+      extend T::Helpers
+      extend T::Generic
+    
+      Value = type_member
+      Error = type_member
+    
+      sig {
+        params(
+          blk: T.proc.params(arg0: Value).returns(::Mayak::ValidationResult[Error])
+        ).void
+      }
+      def initialize(&blk)
+        @blk = T.let(@blk, T.proc.params(arg0: Value).returns(::Mayak::ValidationResult[Error]))
+      end
+    
+      sig { params(value: Value).returns(::Mayak::ValidationResult[Error]) }
+      def check(value)
+        @blk.call(value)
+      end
+    
+      sig {
+        type_parameters(:NewError)
+          .params(blk: T.proc.params(arg0: Value).returns(T.type_parameter(:NewError)))
+          .returns(Rule[Value, T.type_parameter(:NewError)])
+      }
+      def error_from_value(&blk)
+        Rule[Value, T.type_parameter(:NewError)].new do |checked|
+          result = check(checked)
+    
+          case result
+          when ::Mayak::ValidationResult::Valid
+            ::Mayak::ValidationResult::Valid[T.type_parameter(:NewError)].new
+          when ::Mayak::ValidationResult::Invalid
+            ::Mayak::ValidationResult::Invalid[T.type_parameter(:NewError)].new(errors: [blk.call(checked)])
+          else
+            T.absurd(result)
+          end
+        end
+      end
+    
+      sig {
+        type_parameters(:NewError)
+          .params(new_error: T.type_parameter(:NewError))
+          .returns(Rule[Value, T.type_parameter(:NewError)])
+      }
+      def error(new_error)
+        error_from_value { |_| new_error }
+      end
+    
+      sig {
+        params(another: Rule[Value, Error]).returns(Rule[Value, Error])
+      }
+      def any(another)
+        Rule[Value, Error].new do |checked|
+          first_result = check(checked)
+          case first_result
+          when ::Mayak::ValidationResult::Valid
+            another.check(checked)
+          when ::Mayak::ValidationResult::Invalid
+            first_result
+          else
+            T.absurd(first_result)
+          end
+        end
+      end
+    
+      alias | any
+    
+      sig {
+        params(another: Rule[Value, Error]).returns(Rule[Value, Error])
+      }
+      def both(another)
+        Rule[Value, Error].new do |checked|
+          first_result = check(checked)
+          case first_result
+          when ::Mayak::ValidationResult::Valid
+            another.check(checked)
+          when ::Mayak::ValidationResult::Invalid
+            second_result = another.check(checked)
+            case second_result
+            when ::Mayak::ValidationResult::Valid
+              first_result
+            when ::Mayak::ValidationResult::Invalid
+              ::Mayak::ValidationResult::Invalid.new(errors: first_result.errors + second_result.errors)
+            else
+              T.absurd(first_result)
+            end
+          else
+            T.absurd(first_result)
+          end
+        end
+      end
+    
+      alias & both
+    
+      sig { params(key: Symbol).returns(Rule[Value, [Symbol, Error]]) }
+      def with_key(key)
+        Rule[Value, [Symbol, Error]].new do |checked|
+          result = check(checked)
+          case result
+          when ::Mayak::ValidationResult::Valid
+            ::Mayak::ValidationResult::Valid[[Symbol, Error]].new
+          when ::Mayak::ValidationResult::Invalid
+            ::Mayak::ValidationResult::Invalid[[Symbol, Error]].new(
+              errors: result.errors.map { |error| [key, error] }
+            )
+          else
+            T.absurd(result)
+          end
+        end
+      end
+    
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.greater_than(value)
+        Rule[T.any(Float, Integer), String].new do |checked|
+          if checked > value
+            ::Mayak::ValidationResult::Valid.new
+          else
+            ::Mayak::ValidationResult::Invalid.new(
+              errors: ["Value #{checked} should be greater than the #{value}"]
+            )
+          end
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.less_than(value)
+        Rule[T.any(Float, Integer), String].new do |checked|
+          if checked < value
+            ::Mayak::ValidationResult::Valid.new
+          else
+            ::Mayak::ValidationResult::Invalid.new(
+              errors: ["Value #{checked} should be less than the #{value}"]
+            )
+          end
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.equal_to(value)
+        Rule[T.any(Float, Integer), String].new do |checked|
+          if checked == value
+            ::Mayak::ValidationResult::Valid.new
+          else
+            ::Mayak::ValidationResult::Invalid.new(
+              errors: ["Value #{checked} should equal to #{value}"]
+            )
+          end
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.greater_than_or_equal_to(value)
+        (greater_than(value) | equal_to(value)).error_from_value do |checked|
+          "Value #{checked} should greater than or equal to #{value}"
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.less_than_or_equal_to(value)
+        (less_than(value) | equal_to(value)).error_from_value do |checked|
+          "Value #{checked} should less than or equal to #{value}"
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.positive(value)
+        greater_than(0)
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.negative(value)
+        less_than(0)
+      end
+    
+      sig {
+        returns(Rule[T.any(String, T::Array[T.anything], T::Hash[T.anything, T.anything], String), String])
+      }
+      def self.not_empty
+        Rule[T.any(String, Array, Hash, String), String].new do |checked|
+          if checked.empty?
+            ::Mayak::ValidationResult::Invalid.new(
+              errors: ["Value #{checked} should not be empty equal"]
+            )
+          else
+            ::Mayak::ValidationResult::Valid.new
+          end
+        end
+      end
+    
+      sig {
+        type_parameters(:Value, :Error)
+          .params(rule: Rule[T.type_parameter(:Value), T.type_parameter(:Error)])
+          .returns(Rule[T.nilable(T.type_parameter(:Value)), T.type_parameter(:Error)])
+      }
+      def self.not_nil(rule)
+        Rule[T.nilable(T.type_parameter(:Value)), T.type_parameter(:Error)].new do |checked|
+          case checked
+          when NilClass
+            ::Mayak::ValidationResult::Invalid.new(errors: ["Should not be nil"])
+          else
+            rule.check(checked)
+          end
+        end
+      end
+    
+      sig {
+        type_parameters(:Value, :Error)
+          .params(rule: Rule[T.type_parameter(:Value), [Symbol, T.type_parameter(:Error)]])
+          .returns(Rule[T.type_parameter(:Value), T::Hash[Symbol, T.type_parameter(:Error)]])
+      }
+      def self.with_keys_aggregated(rule)
+        Rule[T.type_parameter(:Value), T::Hash[Symbol, T.type_parameter(:Error)]].new do |checked|
+          result = rule.check(checked)
+          case result
+          when ::Mayak::ValidationResult::Valid
+            ::Mayak::ValidationResult::Valid[T::Hash[Symbol, T.type_parameter(:Error)]].new
+          when ::Mayak::ValidationResult::Invalid
+            accumulated = result.errors.reduce({}) do |acc, tuple|
+              key, error = tuple
+              if acc.key?(key)
+                acc[key] << error
+              else
+                acc[key] = [error]
+              end
+            end
+            ::Mayak::ValidationResult::Invalid[T::Hash[Symbol, T.type_parameter(:Error)]].new(
+              accumulated
+            )
+          else
+            T.absurd(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mayak/validations/validation.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module Validations
+    class Contract
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+      Error = type_member
+    
+      sig { returns(T::Set[Rule[Value, [Symbol, Error]]]) }
+      attr_reader :rule_set
+    
+      sig { params(rule_set: T::Set[Rule[Value, [Symbol, Error]]]).void }
+      def initialize(rule_set = Set.new)
+        @rule_set = T.let(rule_set, T::Set[Rule[Value, [Symbol, Error]]])
+      end
+    
+      sig {
+        type_parameters(:MappedValue)
+          .params(
+            rule: Rule[T.type_parameter(:MappedValue), Error],
+            key:  Symbol,
+            blk:  T.proc.params(arg0: Value).returns(T.type_parameter(:MappedValue))
+          ).returns(Contract[Value, Error])
+      }
+      def validate(rule, key:, &blk)
+        rule = Rule[Value, Error].new do |checked|
+          rule.check(blk.call(checked))
+        end
+        Contract.new(rule_set.add(rule.with_key(key)))
+      end
+    
+      sig { params(value: Value).returns(::Mayak::ValidationResult[T::Hash[Symbol, Error]]) }
+      def check(value)
+        initial = T.let(
+          ::Mayak::ValidationResult::Valid[T::Hash[Symbol, Error]].new,
+          ::Mayak::ValidationResult[T::Hash[Symbol, Error]]
+        )
+        rule_set.reduce(initial) do |aggreated_result, rule|
+          current_result = Rule.with_keys_aggregated(rule).check(value)
+          case aggreated_result
+          when ::Mayak::ValidationResult::Valid
+            current_result
+          when ::Mayak::ValidationResult::Invalid
+            case current_result
+            when ::Mayak::ValidationResult::Valid
+              aggreated_result
+            when ::Mayak::ValidationResult::Invalid
+              ::Mayak::ValidationResult::Invalid[T::Hash[Symbol, Error]].new(errors: [ ])
+            else
+              T.absurd(current_result)
+            end
+          else
+            T.absurd(aggreated_result)
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/mayak/version.rb

@@ -2,5 +2,5 @@
 # typed: strict
 
 module Mayak
-  VERSION = T.let("0.0.1", String)
+  VERSION = T.let("0.1.0", String)
 end

data/lib/mayak.rb

@@ -16,6 +16,7 @@ require_relative 'mayak/weak_ref'
 require_relative 'mayak/decoder'
 require_relative 'mayak/encoder'
 require_relative 'mayak/hash_serializable'
+require_relative 'mayak/lazy'
 
 require_relative 'mayak/caching/unbounded_cache'
 require_relative 'mayak/caching/lru_cache'
@@ -29,7 +30,6 @@ require_relative 'mayak/http/request'
 require_relative 'mayak/http/response'
 require_relative 'mayak/http/verb'
 require_relative 'mayak/http/client'
-require_relative 'mayak/http/codec'
 
 require_relative 'mayak/monads/maybe'
 require_relative 'mayak/monads/result'

data/mayak.gemspec

@@ -4,7 +4,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "mayak"
-  spec.version       = "0.0.15"
+  spec.version       = "0.2.0"
   spec.summary       = "Set of fully typed utility classes and interfaces integrated with Sorbet."
   spec.description   = spec.summary
   spec.authors       = ["Daniil Bober"]
@@ -18,6 +18,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "parlour"
   spec.add_development_dependency "tapioca"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mayak
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniil Bober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-21 00:00:00.000000000 Z
+date: 2025-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -66,20 +66,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: parlour
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: tapioca
   requirement: !ruby/object:Gem::Requirement
@@ -100,15 +86,26 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - lib/mayak.rb
 - lib/mayak/cache.rb
 - lib/mayak/caching/README.md
 - lib/mayak/caching/lru_cache.rb
 - lib/mayak/caching/unbounded_cache.rb
+- lib/mayak/codec.rb
 - lib/mayak/collections/README.md
 - lib/mayak/collections/priority_queue.rb
 - lib/mayak/collections/queue.rb
+- lib/mayak/csv/body.rb
+- lib/mayak/csv/codec.rb
+- lib/mayak/csv/column.rb
+- lib/mayak/csv/decoder.rb
+- lib/mayak/csv/document.rb
+- lib/mayak/csv/encoder.rb
+- lib/mayak/csv/header.rb
+- lib/mayak/csv/parse_error.rb
+- lib/mayak/csv/row.rb
 - lib/mayak/decoder.rb
 - lib/mayak/encoder.rb
 - lib/mayak/failable_function.rb
@@ -116,7 +113,6 @@ files:
 - lib/mayak/hash_serializable.rb
 - lib/mayak/http/README.md
 - lib/mayak/http/client.rb
-- lib/mayak/http/codec.rb
 - lib/mayak/http/decoder.rb
 - lib/mayak/http/encoder.rb
 - lib/mayak/http/request.rb
@@ -124,6 +120,8 @@ files:
 - lib/mayak/http/verb.rb
 - lib/mayak/json.rb
 - lib/mayak/json/encoder.rb
+- lib/mayak/lazy.rb
+- lib/mayak/lazy/README.md
 - lib/mayak/monads/README.md
 - lib/mayak/monads/maybe.rb
 - lib/mayak/monads/result.rb
@@ -133,6 +131,8 @@ files:
 - lib/mayak/predicates/rule.rb
 - lib/mayak/random.rb
 - lib/mayak/validation_result.rb
+- lib/mayak/validations/rule.rb
+- lib/mayak/validations/validation.rb
 - lib/mayak/version.rb
 - lib/mayak/weak_ref.rb
 - mayak.gemspec

data/lib/mayak/http/codec.rb

@@ -1,25 +0,0 @@
-# typed: strong
-# frozen_string_literal: true
-
-require_relative 'encoder'
-require_relative 'decoder'
-
-module Mayak
-  module Http
-    module Codec
-      extend T::Sig
-      extend T::Generic
-      extend T::Helpers
-
-      abstract!
-
-      include ::Mayak::Http::Encoder
-      include ::Mayak::Http::Decoder
-
-      ResponseEntity = type_member
-      ResponseType   = type_member {{ fixed: ::Mayak::Http::Response }}
-      RequestType    = type_member {{ fixed: ::Mayak::Http::Request }}
-      RequestEntity  = type_member
-    end
-  end
-end