mayak 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee52ea75946f8fba910a066d2c8ed1fc064c8ebbf5d37af0bb11d0e5f960a175
-  data.tar.gz: 1900c9018e9d76e5264d1a886282f83299b0bc70d4a2a8b42ecba772cf139cfe
+  metadata.gz: b4924104fc85c9c38df43b25f1902b6c58e3310014229f7a2c8ad728c3af497f
+  data.tar.gz: 249044e065aaa1617531d158bf3a7e2a2d100189550c94f5423501297e60b8e5
 SHA512:
-  metadata.gz: 8763907067e8f4327db3e83314d95acb521e7ca66a8482349a1ed463a350138eaf35d9a2279883d989d88a4340f5bf2101f010e41c8f55d4a61cb7293e4e6e1a
-  data.tar.gz: 54dcd72e0d349e386d1d16312570c368ae183253381ee6c17ee904280201356700e6532cdcfee336d0132464e525d4651f9318e80f6d20b0638b5145e02b8f6b
+  metadata.gz: eb3bbe732669a8a56af42fda964d789baacdabfd225ca5f681cff02e6df26ed23f1c70a2cf001dfe4f2b66e66667e06331b5be7659a57fc6d2b0e52a994f1841
+  data.tar.gz: b03e54bfc4cf520db93e38ea02cadd8f6bd7e3cf81eb5da39c71545013e4d9005fbcc70c7778da35be2ef4bbba94ed9f883298998ce33b8240c9eacad2353d7e

data/README.md

@@ -29,61 +29,14 @@ require "mayak"
 
 Mayak consists from separate classes and interfaces as well as separate modules for specific domains.
 
-#### Caching
-
-[Documentation](./lib/mayak/caching/README.md)
-
-#### Monads
-
-[Documentation](./lib/mayak/monads/README.md)
-
-#### HTTP
-
-[Documentation](./lib/mayak/http/README.md)
-
-#### Lazy
-
-[Documentation](./lib/mayak/lazy/README.md)
+* [Caching](./docs/caching.md)
+* [Monads](./docs/monads.md)
+* [HTTP](./docs/http.md)
+* [Lazy](./docs/lazy.md)
+* [Functions](./docs/function.md)
 
 #### Miscellaneous
 
-##### Function
-In some situations Sorbet can not infer a type of proc passed:
-
-```ruby
-sig {
-  type_parameters(:A)
-    .params(blk: T.proc.params(arg0: T.type_parameter(:A)).returns(T.type_parameter(:A)))
-    .returns(T.proc.params(arg0: T.type_parameter(:A)).returns(T.type_parameter(:A)))
-}
-def proc_identity(&blk)
-  blk
-end
-
-T.reveal_type(proc_identity { |a| 10 })
-# This code is unreachable https://srb.help/7006
-# proc_identity { |a| 10 }
-```
-
-`Mayak::Fuction` allows explicitly define input and output types to help sorbet infer types:
-
-```ruby
-sig {
-  type_parameters(:A)
-    .params(
-      fn: Mayak::Function[T.type_parameter(:A), T.type_parameter(:A)])
-    .returns(Mayak::Function[T.type_parameter(:A), T.type_parameter(:A)])
-}
-def fn_identity(fn)
-  fn
-end
-
-T.reveal_type(
-  fn_identity(Mayak::Function[Integer, Integer].new { |a| a })
-)
-# Revealed type: Mayak::Function[Integer, Integer]
-```
-
 ##### JSON
 
 `JSON` module provides a type alias to encode JSON type:

data/lib/bundled_rbi/mayak.rbi

@@ -0,0 +1,20 @@
+# typed: true
+
+
+module Mayak
+  class JsonCodec::FromHashSerializable
+    extend T::Sig
+    extend T::Generic
+
+    include ::Mayak::Codec
+
+    Entity = type_member {{ upper: ::Mayak::HashSerializable }}
+    Protocol = type_member {{ fixed: String }}
+
+    sig { override.params(entity: Entity).returns(Protocol) }
+    def encode(entity); end
+
+    sig { override.params(response: Protocol).returns(::Mayak::Monads::Try[Entity]) }
+    def decode(response); end
+  end
+end

data/lib/mayak/encoder.rb

@@ -26,7 +26,6 @@ module Mayak
         blk.call(encode(entity))
       end
     end
-
     class Implementation
       extend T::Sig
       extend T::Generic
@@ -34,8 +33,8 @@ module Mayak
 
       include ::Mayak::Encoder
 
-      In = type_member
-      Out   = type_member
+      In  = type_member
+      Out = type_member
 
       sig { params(function: T.proc.params(in: In).returns(Out)).void }
       def initialize(&function)

data/lib/mayak/json_codec/from_hash_serializable.rb

@@ -0,0 +1,38 @@
+# typed: ignore
+# frozen_string_literal: true
+
+require_relative "../monads/try"
+require "sorbet-coerce"
+
+module Mayak
+  module JsonCodec
+    class FromHashSerializable
+      include ::Mayak::Monads::Try::Mixin
+
+      include ::Mayak::Codec
+
+      def initialize(type)
+        @type = type
+      end
+
+      def self.[](type)
+        ::Mayak::JsonCodec::FromHashSerializable.new(type)
+      end
+
+      def new
+        self
+      end
+
+      def encode(entity)
+        JSON.dump(entity.serialize)
+      end
+
+      def decode(response)
+        Try do
+          parsed = JSON.parse(response)
+          ::TypeCoerce::Converter.new(@type).from(parsed)
+        end
+      end
+    end
+  end
+end

data/lib/mayak/json_codec.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module JsonCodec
+    extend T::Sig
+    extend T::Generic
+    extend T::Helpers
+
+    include ::Mayak::Codec
+
+    abstract!
+
+    Entity   = type_member
+    Protocol = type_member {{ fixed: String }}
+
+    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
+  end
+end

data/lib/mayak.rb

@@ -19,6 +19,8 @@ require_relative 'mayak/codec'
 require_relative 'mayak/hash_serializable'
 require_relative 'mayak/lazy'
 
+require_relative 'mayak/json_codec/from_hash_serializable'
+
 require_relative 'mayak/caching/unbounded_cache'
 require_relative 'mayak/caching/lru_cache'
 

data/mayak.gemspec

@@ -4,7 +4,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "mayak"
-  spec.version       = "0.2.1"
+  spec.version       = "0.2.2"
   spec.summary       = "Set of fully typed utility classes and interfaces integrated with Sorbet."
   spec.description   = spec.summary
   spec.authors       = ["Daniil Bober"]
@@ -15,6 +15,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'sorbet-runtime'
   spec.add_dependency 'sorbet'
+  spec.add_dependency 'sorbet-coerce'
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rspec"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mayak
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Daniil Bober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-07 00:00:00.000000000 Z
+date: 2025-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorbet-coerce
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -88,9 +102,9 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/bundled_rbi/mayak.rbi
 - 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
@@ -111,7 +125,6 @@ files:
 - lib/mayak/failable_function.rb
 - lib/mayak/function.rb
 - lib/mayak/hash_serializable.rb
-- lib/mayak/http/README.md
 - lib/mayak/http/client.rb
 - lib/mayak/http/decoder.rb
 - lib/mayak/http/encoder.rb
@@ -119,10 +132,9 @@ files:
 - lib/mayak/http/response.rb
 - lib/mayak/http/verb.rb
 - lib/mayak/json.rb
-- lib/mayak/json/encoder.rb
+- lib/mayak/json_codec.rb
+- lib/mayak/json_codec/from_hash_serializable.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
 - lib/mayak/monads/try.rb

data/lib/mayak/caching/README.md

@@ -1,100 +0,0 @@
-# Caching
-
-Caching modules constist from `Mayak::Cache` and several implementations in `Mayak::Caching` module. `Mayak::Caching` provides in-memory caches using regular ruby hashes: an unbounded cache and a cache using LRU eviction policy.
-
-Usage of unbounded cache:
-```ruby
-unbounded_cache = Mayak::Caching::UnboundedCache[String, Integer].new
-unbounded_cache.write("foo", 10)
-unbounded_cache.write("bar", 20)
-
-unbounded_cache.read("foo") # 10
-unbounded_cache.read("bar") # 20
-unbounded_cache.read("baz") # nil
-
-unbounded_cache.delete("bar")
-unbounded_cache.read("bar") # nil
-
-unbounded_cache.fetch("foo") { 100 } # 10
-unbounded_cache.fetch("bar") { 100 } # 100
-unbounded_cache.fetch("bar") { 200 } # 100
-
-unbounded_cache.clear # 100
-unbounded_cache.read("foo") # nil
-unbounded_cache.read("bar") # nil
-```
-
-LRU cache has limited size: when the cache is full and a new element is added, some element is evicted using least recently used policy:
-
-```ruby
-lru_cache = Mayak::Caching::LRUCache[String, Integer].new(max_size: 3)
-
-lru_cache.write("key1", 1)
-lru_cache.write("key2", 2)
-lru_cache.write("key3", 3)
-
-lru_cache.read("key1") # 1
-lru_cache.read("key2") # 2
-lru_cache.read("key3") # 3
-
-lru_cache.write("key4", 4)
-lru_cache.read("key4") # 4
-lru_cache.read("key1") # nil
-```
-
-You can implement `Mayak::Cache` interface using a different store (for example default Rails cache) and use different implementations interchangeably:
-
-```ruby
-class RailsCache < T::Struct
-  extend T::Sig
-  extend T::Generic
-  extend T::Helpers
-
-  include Mayak::Cache
-
-  Key   = type_member
-  Value = type_member
-
-  const :converter, T.proc.params(value: T.untyped).returns(Value)
-
-  sig { override.params(key: Key).returns(T.nilable(Value)) }
-  def read(key)
-    converter.call(Rails.cache.read(key))
-  end
-
-  sig { override.params(key: Key, value: Value).void }
-  def write(key, value)
-    Rails.cache.write(key, value)
-  end
-
-  sig { override.params(key: Key, blk: T.proc.returns(Value)).returns(Value) }
-  def fetch(key, &blk)
-    converter.call(Rails.cache.fetch(key, &blk))
-  end
-
-  sig { override.void }
-  def clear
-    Rails.cache.clear
-  end
-
-  sig { override.params(key: Key).void }
-  def delete(key)
-    Rails.cache.delete(key)
-  end
-end
-
-class Service < T::Struct
-  extend T::Sig
-
-  const :cache, Mayak::Cache[String, String]
-end
-
-in_memory = Service.new(
-  cache: Mayak::Caching::UnboundedCache[String, String].new
-)
-rails_cache = Service.new(
-  cache: RailsCache[String, String].new(
-    converter: -> (value) { value.to_s }
-  )
-)
-```

data/lib/mayak/http/README.md

@@ -1,105 +0,0 @@
-# Http
-
-This module contains abstraction for HTTP interactions. It provides data classes that models HTTP requests and response as well interfaces for http client and codecs.
-
-#### Verb
-
-Enumaration that encodes an HTTP verb.
-
-```ruby
-get_verb     = Mayak::Http::Verb::Get
-post_verb    = Mayak::Http::Verb::Post
-head_verb    = Mayak::Http::Verb::Head
-put_verb     = Mayak::Http::Verb::Put
-patch_verb   = Mayak::Http::Verb::Patch
-delete_verb  = Mayak::Http::Verb::Delete
-connect_verb = Mayak::Http::Verb::Connect
-options_verb = Mayak::Http::Verb::Options
-trace_verb   = Mayak::Http::Verb::Trace
-```
-
-#### Request
-
-`Mayak::Http::Request` is a datastructure that encodes an HTTP request.
-```ruby
-# to build an HTTP request verb and URI should be provided, as well as optional headers hash and body
-request = Mayak::Http::Request.new(
-  verb:     Mayak::Http::Verb::Put,
-  url:      URI.parse("https://www.foobar.com/users/update"),
-  headers:  { "content-type" => "application/json" },
-  body:     """{ id: 100, name: "Daniil" })"""
-)
-
-# to build request helper constructor methods can be used
-get_request = Mayak::Http::Request.get(url: URI.parse("https://www.foobar.com"))
-```
-
-#### Response
-
-`Mayak::Http::Response` is a datastructure that encodes an HTTP request. It contains status, and optional headers and body:
-
-```ruby
-response = Mayak::Http::Response.new(
-  status:  200
-  headers: { "content-type" => "application/json" },
-  body:     """{ id: 100, name: "Daniil" }"""
-)
-```
-
-#### Client
-
-Interface that encodes an HTTP client. The interface is very simple and consists from one method that receives a request and returns a `Try` monad containg response:
-```ruby
-module Mayak
-  module Http
-    module Client
-      extend T::Sig
-      extend T::Generic
-
-      interface!
-
-      sig { abstract.params(request: Http::Request).returns(Mayak::Monads::Try[Mayak::Http::Response]) }
-      def send_request(request)
-      end
-    end
-  end
-end
-```
-
-You can implement this interface using a specific library:
-
-```ruby
-class FaradayClient
-  extend T::Sig
-
-  include Mayak::Http::Client
-
-  include Mayak::Monads::Try::Mixin
-
-  sig { params(config_blk: T.nilable(T.proc.params(connection: Faraday::Connection).void)).void }
-  def initialize(&config_blk)
-    @faraday_instance = T.let(
-      config_blk.nil? ? Faraday.new : Faraday.new(&@config_blk),
-      Faraday
-    )
-  end
-
-  sig { override.params(request: Mayak::Http::Request).returns(Mayak::Monads::Try[Mayak::Http::Response]) }
-  def send_request(request)
-    Try do
-      faraday_response = @faraday_instance.run_request(
-        verb.serialize.downcase.to_sym,
-        request.url,
-        request.body,
-        request.headers
-      )
-
-      Mayak::Http::Response.new(
-        status:  T.must(faraday_response.status.to_i),
-        headers: faraday_response.headers || {},
-        body:    faraday_response.body || ""
-      )
-    end
-  end
-end
-```

data/lib/mayak/json/encoder.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-# typed: strict
-
-require "json"
-
-module Mayak
-  module Json
-    module Encoder
-      extend T::Sig
-      extend T::Generic
-      extend T::Helpers
-
-      abstract!
-
-      include ::Mayak::Encoder
-
-      In = type_member
-      Out = type_member {{ fixed: ::Mayak::Json::JsonType }}
-    end
-  end
-end