mayak 0.0.15 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8217e22d103f9b3a253973f90f330d3b69d98320919c85b28a9d05df42c9b901
-  data.tar.gz: 89e2f9a86616f036129b0c31b09d864b811067febc4b31191a6d98ef1b332774
+  metadata.gz: 7c803fe79f01fbe1d57d090db09b47e5e8500656819f61951e120fd10860680e
+  data.tar.gz: 8dcaeaa4cbf92d629113c7faedaa1048dad5a69aaca38e82fbadd8609631be3b
 SHA512:
-  metadata.gz: e44eddcb1be94600d1501ecfbac8690557c233410ebb5a470e669201a40d564aafe00ea358027fe78887b893dc3b7cc0fb1aaa6be8f02d9d75ea19ac64abed2c
-  data.tar.gz: 2238e28cfd575b50f0a2fc6fb360485fd10c2fd754c441493f394bd289f3f38a5b54f13d952fbfa8ef09b85bbed9968f8245500ade2ae405bd5b12b93862e6cf
+  metadata.gz: 144fb12c3b37c4cd8f8abdcca91042178647273ee26f8abc23bf3f83373ad5e04affda9aa1a58331fc619f0c362156b57f5b6d5b66bde15bfd5b1c5b966ef042
+  data.tar.gz: e50fe76a28b4591a0ee5b3de40da4b88bff7a05303d7673e00d9873b6abd41a6d6b94d0367660d61bd2777e2d3871f399a83b9f3fbcb1ad9bbaa97b868021184

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Даниил Бобер
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,4 +1,7 @@
-# Mayak
+[gem]: https://rubygems.org/gems/mayak
+[actions]: https://github.com/dnvkv/mayak/actions
+
+# Mayak [![Gem Version](https://badge.fury.io/rb/mayak.svg)][gem] [![CI Status](https://github.com/dnvkv/mayak/actions/workflows/ci.yml/badge.svg)][actions]
 
 ### Overview
 
@@ -9,11 +12,17 @@ Mayak is a library which aims to provide abstractions for well typed programming
 In order to use the library, add the following line to your `Gemfile`:
 
 ```ruby
-gem 'mayak'
+gem "mayak"
 ```
 or install it via the following command:
 ```ruby
-gem install 'mayak'
+gem install "mayak"
+```
+
+If you are using tapioca, add following line into tapioca's `require.rb` before generating rbi's for the gem:
+
+```ruby
+require "mayak"
 ```
 
 ### Documentation
@@ -32,6 +41,10 @@ Mayak consists from separate classes and interfaces as well as separate modules
 
 [Documentation](./lib/mayak/http/README.md)
 
+#### Lazy
+
+[Documentation](./lib/mayak/lazy/README.md)
+
 #### Miscellaneous
 
 ##### Function

data/lib/mayak/codec.rb

@@ -0,0 +1,70 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Mayak
+  module Codec
+    extend T::Sig
+    extend T::Generic
+    extend T::Helpers
+
+    abstract!
+
+    Entity  = type_member
+    Protocol = type_member
+
+    sig { abstract.params(entity: Entity).returns(Protocol) }
+    def encode(entity)
+    end
+
+    sig {
+      abstract
+        .params(response: Protocol)
+        .returns(Mayak::Monads::Try[Entity])
+    }
+    def decode(response)
+    end
+
+    sig { returns(::Mayak::Encoder[Entity, Protocol]) }
+    def to_encoder
+      ::Mayak::Encoder::Implementation[Entity, Protocol].new do |entity|
+        encode(entity)
+      end
+    end
+
+    sig { returns(::Mayak::Decoder[Protocol, Entity]) }
+    def to_decoder
+      ::Mayak::Decoder::Implementation[Protocol, Entity].new do |protocol|
+        decode(protocol)
+      end
+    end
+
+    class FromPair < T::Struct
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      Entity  = type_member
+      Protocol = type_member
+
+      include ::Mayak::Codec
+
+      const :encoder, ::Mayak::Encoder[Entity, Protocol]
+      const :decoder, ::Mayak::Decoder[Protocol, Entity]
+
+
+      sig { override.params(entity: Entity).returns(Protocol) }
+      def encode(entity)
+        encoder.encode(entity)
+      end
+
+      sig {
+        override
+          .params(response: Protocol)
+          .returns(Mayak::Monads::Try[Entity])
+      }
+      def decode(response)
+        decoder.decode(response)
+      end
+    end
+  end
+end

data/lib/mayak/csv/body.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Body < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :rows, T::Array[Row[Value]]
+    end
+  end
+end

data/lib/mayak/csv/codec.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    module Codec
+      extend T::Sig
+    end
+  end
+end

data/lib/mayak/csv/column.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Column < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :name,       String
+      const :serializer, T.proc.params(value: Value).returns(String)
+    end
+  end
+end

data/lib/mayak/csv/decoder.rb

@@ -0,0 +1,154 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    module Decoder
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      abstract!
+    
+      sig {
+        abstract
+          .params(csv: T.any(String, T::Enumerable[String]))
+          .returns(Mayak::Monads::Try[T::Array[Value]])
+      }
+      def decode(csv)
+      end
+
+      sig {
+        type_parameters(:NewValue)
+          .params(blk: T.proc.params(arg: Value).returns(T.type_parameter(:NewValue)))
+          .returns(::Mayak::Csv::Decoder[T.type_parameter(:NewValue)])
+      }
+      def map(&blk)
+        ::Mayak::Csv::Decoder::FromFunction[T.type_parameter(:NewValue)].new(fn: -> (csv) do
+          decode(csv).map do |values|
+            values.map { |value| blk.call(value) }
+          end
+        end)
+      end
+
+      sig {
+        type_parameters(:NewValue)
+          .params(blk: T.proc.params(arg: Value).returns(Mayak::Monads::Try[T.type_parameter(:NewValue)]))
+          .returns(::Mayak::Csv::Decoder[T.type_parameter(:NewValue)])
+      }
+      def map_try(&blk)
+        ::Mayak::Csv::Decoder::FromFunction[T.type_parameter(:NewValue)].new(fn: -> (csv) do
+          decode(csv).flat_map do |values|
+            Mayak::Monads::Try.sequence(
+              values.map { |value| blk.call(value) }
+            )
+          end
+        end)
+      end
+
+      sig { params(separator: String).returns(Mayak::Csv::Decoder[T::Hash[String, String]]) }
+      def self.hash_decoder_strict(separator: ",")
+        HashDecoderStrict.new(separator: separator)
+      end
+
+      sig { params(separator: String).returns(Mayak::Csv::Decoder[T::Hash[String, T.nilable(String)]]) }
+      def self.hash_decoder(separator: ",")
+        HashDecoder.new(separator: separator)
+      end
+
+      class HashDecoder < T::Struct
+        extend T::Sig
+        extend T::Generic
+      
+        Value = type_member {{ fixed: T::Hash[String, T.nilable(String)] }}
+
+        const :separator, String, default: ","
+
+        include ::Mayak::Csv::Decoder
+      
+        sig {
+          override
+            .params(csv: T.any(String, T::Enumerable[String]))
+            .returns(Mayak::Monads::Try[T::Array[Value]])
+        }
+        def decode(csv)
+          csv_string = begin
+            case csv
+            when String then csv
+            else csv.to_a.join("\n")
+            end
+          end
+          Mayak::Monads::Try::Success.new(CSV.parse(csv_string, headers: :first_row, col_sep: separator).map(&:to_h))
+        end
+      end
+
+      class HashDecoderStrict < T::Struct
+        extend T::Sig
+        extend T::Generic
+      
+        Value = type_member {{ fixed: T::Hash[String, String] }}
+
+        const :separator, String, default: ","
+
+        include ::Mayak::Csv::Decoder
+      
+        sig {
+          override
+            .params(csv: T.any(String, T::Enumerable[String]))
+            .returns(Mayak::Monads::Try[T::Array[Value]])
+        }
+        def decode(csv)
+          lines = begin
+            case csv
+            when String then csv.split("\n")
+            else csv.to_a
+            end
+          end
+          header, *rows = lines
+          return Mayak::Monads::Try::Success.new([]) if rows.nil? || rows.empty?
+          return Mayak::Monads::Try::Success.new([]) if header.nil? || header.empty?
+          keys = header.split(separator)
+          parse_results = rows.map.with_index do |row, index|
+            values = row.split(separator)
+            if values.length != keys.length
+              Mayak::Monads::Try::Failure.new(
+                ::Mayak::Csv::ParseError.new(build_error_message(keys.length, row.length, index))
+              )
+            else
+              keys.zip(values).to_h
+            end
+          end
+          Mayak::Monads::Try.sequence(parse_results).map(&:to_h)
+        end
+
+        private
+
+        sig { params(keys_length: Integer, rows_length: Integer, index: Integer).returns(String) }
+        def build_error_message(keys_length, rows_length, index)
+          "Invalid number of columns on line #{index + 2}: expected #{keys_length}, found #{rows_length}"
+        end
+      end
+    
+      class FromFunction < T::Struct
+        extend T::Sig
+        extend T::Generic
+    
+        Value = type_member
+    
+        include ::Mayak::Csv::Decoder
+    
+        const :fn, T.proc.params(csv: T.any(String, T::Enumerable[String])).returns(Mayak::Monads::Try[T::Array[Value]])
+    
+        sig {
+          override
+            .params(csv: T.any(String, T::Enumerable[String]))
+            .returns(Mayak::Monads::Try[T::Array[Value]])
+        }
+        def decode(csv)
+          fn.call(csv)
+        end
+      end
+    end
+  end
+end

data/lib/mayak/csv/document.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Document < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :header, Header[Value]
+      const :body,   Body[Value]
+
+      sig { params(separator: String).returns(String) }
+      def serialize_to_csv(separator: ",")
+        buffer = String.new
+        buffer << header.serialize_to_csv(separator: separator)
+        buffer << "\n"
+        body.rows.each do |row|
+          buffer << row.serialize_to_csv(separator: separator)
+          buffer << "\n"
+        end
+        buffer
+      end
+    end
+  end
+end

data/lib/mayak/csv/encoder.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    module Encoder
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      abstract!
+    
+      sig { abstract.params(values: T::Enumerable[Value]).returns(String) }
+      def encode(values)
+      end
+    
+      class FromFunction < T::Struct
+        extend T::Sig
+        extend T::Generic
+    
+        Value = type_member
+    
+        include ::Mayak::Csv::Encoder
+    
+        const :fn, T.proc.params(value: T::Enumerable[Value]).returns(String)
+    
+        sig { override.params(values: T::Enumerable[Value]).returns(String) }
+        def encode(values)
+          fn.call(values)
+        end
+      end
+    end
+  end
+end

data/lib/mayak/csv/header.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Header < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :columns, T::Array[Column[Value]]
+    
+      sig {
+        params(
+          name:       String,
+          serializer: T.proc.params(value: Value).returns(String)
+        ).returns(::Mayak::Csv::Header[Value])
+      }
+      def with_column(name, &serializer)
+        new_column = ::Mayak::Csv::Column[Value].new(
+          name:       name,
+          serializer: -> (value) { serializer.call(value) }
+        )
+        Header[Value].new(columns: columns.concat([new_column]))
+      end
+    
+      sig { params(values: T::Enumerable[Value]).returns(Body[Value]) }
+      def build_body(values)
+        rows = values.map do |value|
+          Row.new(cells: columns.map { |column| [column, column.serializer.call(value)] })
+        end
+        Body.new(rows: rows)
+      end
+    
+      sig { params(values: T::Enumerable[Value]).returns(Document[Value]) }
+      def build_document(values)
+        Document[Value].new(header: self, body: build_body(values))
+      end
+
+      sig { params(separator: String).returns(String) }
+      def serialize_to_csv(separator: ",")
+        columns.map(&:name).join(separator)
+      end
+    
+      sig { params(separator: String).returns(::Mayak::Csv::Encoder[Value]) }
+      def to_encoder(separator: ",")
+        ::Mayak::Csv::Encoder::FromFunction[Value].new(
+          fn: -> (values) { build_document(values).serialize_to_csv(separator: separator) }
+        )
+      end
+    end
+  end
+end

data/lib/mayak/csv/parse_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module Csv
+    class ParseError < StandardError
+    end
+  end
+end

data/lib/mayak/csv/row.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Row < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :cells, T::Array[[Column[Value], String]]
+
+      sig { params(separator: String).returns(String) }
+      def serialize_to_csv(separator: ",")
+        cells.map { |cell| cell[1] }.join(separator)
+      end
+    end
+  end
+end

data/lib/mayak/decoder.rb

@@ -9,15 +9,51 @@ module Mayak
 
     abstract!
 
-    RequestType   = type_member
-    RequestEntity = type_member
+    In  = type_member(:in)
+    Out = type_member(:out)
 
     sig {
       abstract
-        .params(response: RequestType)
-        .returns(Mayak::Monads::Try[RequestEntity])
+        .params(response: In)
+        .returns(Mayak::Monads::Try[Out])
     }
     def decode(response)
     end
+
+    sig {
+      type_parameters(:In2)
+        .params(blk: T.proc.params(arg0: Out).returns(T.type_parameter(:In2)))
+        .returns(::Mayak::Decoder[In, T.type_parameter(:In2)])
+    }
+    def map(&blk)
+      ::Mayak::Decoder::Implementation[In, T.type_parameter(:In2)].new do |entity|
+        decode(entity).map { |result| blk.call(result) }
+      end
+    end
+
+    class Implementation
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      include ::Mayak::Decoder
+
+      In = type_member
+      Out   = type_member
+
+      sig { params(function: T.proc.params(response: In).returns(::Mayak::Monads::Try[Out])).void }
+      def initialize(&function)
+        @function = T.let(function, T.proc.params(response: In).returns(::Mayak::Monads::Try[Out]))
+      end
+
+      sig {
+        override
+          .params(response: In)
+          .returns(Mayak::Monads::Try[Out])
+      }
+      def decode(response)
+        @function.call(response)
+      end
+    end
   end
 end

data/lib/mayak/encoder.rb

@@ -9,40 +9,40 @@ module Mayak
 
     abstract!
 
-    ResponseEntity = type_member
-    ResponseType   = type_member
+    In  = type_member(:in)
+    Out = type_member(:out)
 
-    sig { abstract.params(entity: ResponseEntity).returns(ResponseType) }
-    def encode(entity)
+    sig { abstract.params(input: In).returns(Out) }
+    def encode(input)
     end
 
     sig {
-      type_parameters(:NewResponse)
-        .params(blk: T.proc.params(arg0: ResponseType).returns(T.type_parameter(:NewResponse)))
-        .returns(::Mayak::Encoder[ResponseEntity, T.type_parameter(:NewResponse)])
+      type_parameters(:In2)
+        .params(blk: T.proc.params(arg0: Out).returns(T.type_parameter(:In2)))
+        .returns(::Mayak::Encoder[In, T.type_parameter(:In2)])
     }
-    def map_request(&blk)
-      ::Mayak::Encoder::FromFunction[ResponseEntity, T.type_parameter(:NewResponse)].new do |entity|
+    def map(&blk)
+      ::Mayak::Encoder::Implementation[In, T.type_parameter(:In2)].new do |entity|
         blk.call(encode(entity))
       end
     end
 
-    class FromFunction
+    class Implementation
       extend T::Sig
       extend T::Generic
       extend T::Helpers
 
       include ::Mayak::Encoder
 
-      ResponseEntity = type_member
-      ResponseType   = type_member
+      In = type_member
+      Out   = type_member
 
-      sig { params(function: T.proc.params(response: ResponseEntity).returns(ResponseType)).void }
+      sig { params(function: T.proc.params(in: In).returns(Out)).void }
       def initialize(&function)
-        @function = T.let(function, T.proc.params(response: ResponseEntity).returns(ResponseType))
+        @function = T.let(function, T.proc.params(in: In).returns(Out))
       end
 
-      sig { override.params(entity: ResponseEntity).returns(ResponseType) }
+      sig { override.params(entity: In).returns(Out) }
       def encode(entity)
         @function.call(entity)
       end

data/lib/mayak/http/decoder.rb

@@ -14,8 +14,8 @@ module Mayak
 
       include ::Mayak::Decoder
 
-      RequestType   = type_member {{ fixed: ::Mayak::Http::Request }}
-      RequestEntity = type_member
+      In  = type_member(:in) {{ fixed: ::Mayak::Http::Request }}
+      Out = type_member(:out)
 
       sig {
         type_parameters(:A)
@@ -33,13 +33,13 @@ module Mayak
 
         include ::Mayak::Http::Decoder
 
-        RequestType   = type_member {{ fixed: ::Mayak::Http::Request }}
-        RequestEntity = type_member {{ fixed: ::Mayak::Http::Request }}
+        In   = type_member(:in) {{ fixed: ::Mayak::Http::Request }}
+        Out = type_member(:out) {{ fixed: ::Mayak::Http::Request }}
 
         sig {
           override
-            .params(response: RequestType)
-            .returns(Mayak::Monads::Try[RequestEntity])
+            .params(response: In)
+            .returns(Mayak::Monads::Try[Out])
         }
         def decode(response)
           Mayak::Monads::Try::Success.new(response)
@@ -53,15 +53,15 @@ module Mayak
 
         include ::Mayak::Http::Decoder
 
-        RequestType   = type_member {{ fixed: ::Mayak::Http::Request }}
-        RequestEntity = type_member
+        In  = type_member {{ fixed: ::Mayak::Http::Request }}
+        Out = type_member
 
-        const :decoder, T.proc.params(arg: String).returns(Mayak::Monads::Try[RequestEntity])
+        const :decoder, T.proc.params(arg: String).returns(Mayak::Monads::Try[Out])
 
         sig {
           override
-            .params(response: RequestType)
-            .returns(Mayak::Monads::Try[RequestEntity])
+            .params(response: In)
+            .returns(Mayak::Monads::Try[Out])
         }
         def decode(response)
           decoder.call(response.body || "")