yake 0.6.1 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab366348807492835eeb4720413691046d71155071facf97fcb11cf8de960f71
-  data.tar.gz: b4377e2e6e7a6259c7c98d8b37fff0d1f39d6c591fdb8390ce4b9cc70b96312c
+  metadata.gz: e96eec76402a33ac4b0b57846ebfb90fcf22dd0adf3416cbd5acdf4b065f4675
+  data.tar.gz: 057c08011065fd17236d85d5327be67204af2c17e94c5c4af65de4fd4ed61941
 SHA512:
-  metadata.gz: 53ee3404d6fb1500242faf9718ac4c25c976534affee66d9b939f1d950b1e1c9bcdc3293de6d694e62b6aec545d5ae5701759ce267f5ca751ebb45d630b6813b
-  data.tar.gz: f3088a7ad9f0ab9dc4e0f8b05d60b918a1b3568cfc8471dc9e08b5eea56d00223607fcde7e6ec8240a5013bd2d639be9a49b12e02674202583fccb22e221d320
+  metadata.gz: 41435fce4006498e59c12939eb0b02a4b2c43ac2de2c892930ab38b0b5736c83a96922b28fb04b1a14530ed8deb35b849cfcb46ea38a90de71eb555e848897d7
+  data.tar.gz: 8ff001c1440a29f90440e120187c2df33f0f9fd72c693587b07654a6543a1d1bef585e0b03483100df5002b302d7bcf03874ce16a0380bd85b00e397d5992e18

data/README.md

@@ -205,6 +205,16 @@ MyObject.new.try(:some_method)
 `Hash` helpers:
 
 ```ruby
+{ a: { b: 'c', d: 'e' }, f: 'g' }.deep_keys
+# => [:a, :b, :d, :f]
+
+{ a: { b: 'c', d: 'e' }, f: 'g' }.deep_transform_keys(&:to_s)
+# => { "a" => { "b" => "c", "d" => "e" }, "f" => "g" }
+
+hash = { a: { b: 'c', d: 'e' }, f: 'g' }
+hash.deep_transform_keys!(&:to_s)
+# => { "a" => { "b" => "c", "d" => "e" }, "f" => "g" }
+
 { f: 'g', a: { d: 'e', b: 'c' } }.deep_sort
 # => { a: { b: 'c', d: 'e' }, f: 'g' }
 

data/lib/yake/errors.rb

@@ -29,7 +29,7 @@ module Yake
     class RequestTimeout < Error; end                # HTTP 408
     class Conflict < Error; end                      # HTTP 409
     class Gone < Error; end                          # HTTP 410
-    class LengthRequired < Error; end                # HTTP 410
+    class LengthRequired < Error; end                # HTTP 411
     class PreconditionFailed < Error; end            # HTTP 412
     class PayloadTooLarge < Error; end               # HTTP 413
     class UriTooLong < Error; end                    # HTTP 414
@@ -58,6 +58,54 @@ module Yake
     class InsufficientStorage < Error; end           # HTTP 507
     class LoopDetected < Error; end                  # HTTP 508
     class NotExtended < Error; end                   # HTTP 510
-    class NetworkAuthenticationRequired < Error; end # HTTP 507
+    class NetworkAuthenticationRequired < Error; end # HTTP 511
+
+    ERRORS = {
+      '400' => BadRequest,
+      '401' => Unauthorized,
+      '402' => PaymentRequired,
+      '403' => Forbidden,
+      '404' => NotFound,
+      '405' => MethodNotAllowed,
+      '406' => NotAcceptable,
+      '407' => ProxyAuthenticationRequired,
+      '408' => RequestTimeout,
+      '409' => Conflict,
+      '410' => Gone,
+      '411' => LengthRequired,
+      '412' => PreconditionFailed,
+      '413' => PayloadTooLarge,
+      '414' => UriTooLong,
+      '415' => UnsupportedMediaType,
+      '416' => RangeNotSatisfiable,
+      '417' => ExpectationFailed,
+      '418' => ImATeapot,
+      '420' => EnhanceYourCalm,
+      '421' => MisdirectedRequest,
+      '422' => UnprocessableEntity,
+      '423' => Locked,
+      '424' => FailedDependency,
+      '425' => TooEarly,
+      '426' => UpgradeRequired,
+      '428' => PreconditionRequired,
+      '429' => TooManyRequests,
+      '431' => RequestHeaderFieldsTooLarge,
+      '451' => UnavailableForLegalReasons,
+      '500' => InternalServerError,
+      '501' => NotImplemented,
+      '502' => BadGateway,
+      '503' => ServiceUnavailable,
+      '504' => GatewayTimeout,
+      '505' => HttpVersionNotSupported,
+      '506' => VariantAlsoNegotiates,
+      '507' => InsufficientStorage,
+      '508' => LoopDetected,
+      '510' => NotExtended,
+      '511' => NetworkAuthenticationRequired,
+    }
+
+    def self.[](code)
+      ERRORS.fetch(code.to_s)
+    end
   end
 end

data/lib/yake/support.rb

@@ -4,14 +4,32 @@ require 'json'
 require 'time'
 
 class Hash
-  def deep_sort() self.sort.map { |k,v| [ k, v.try(:deep_sort) { |x| x } ] }.to_h end
+  def deep_keys() map { |k,v| v.respond_to?(:deep_keys) ? [k] + v.deep_keys : k }.flatten end
+  def deep_sort() sort.map { |k,v| [ k, v.try(:deep_sort) { |x| x } ] }.to_h end
   def encode64() to_json.encode64 end
-  def except(*keys) self.reject { |key,_| keys.include? key } end
+  def except(*keys) reject { |key,_| keys.include? key } end
   def strict_encode64() to_json.strict_encode64 end
-  def stringify_names() JSON.parse(to_json) end
-  def symbolize_names() JSON.parse(to_json, symbolize_names: true) end
+  def stringify_names() deep_transform_keys(&:to_s) end
+  def stringify_names!() deep_transform_keys!(&:to_s) end
+  def symbolize_names() deep_transform_keys(&:to_sym) end
+  def symbolize_names!() deep_transform_keys!(&:to_sym) end
   def to_form() URI.encode_www_form(self) end
   def to_json_sorted() deep_sort.to_json end
+
+  def deep_transform_keys(&block)
+    deep_transform(:transform_keys, &block)
+  end
+
+  def deep_transform_keys!(&block)
+    deep_transform(:transform_keys!, &block)
+  end
+
+  private def deep_transform(method, &block)
+    f = -> (x) { x.respond_to?(:"deep_#{method}") ? x.send(:"deep_#{method}", &block) : x }
+    block_given? ? send(method, &block).map do |key, val|
+      [key, val.is_a?(Array) ? val.map(&f) : val.then(&f)]
+    end.to_h : self
+  end
 end
 
 class Integer

data/lib/yake/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yake
-  VERSION = '0.6.1'
+  VERSION = '0.6.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yake
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.4
 platform: ruby
 authors:
 - Alexander Mancevice
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-01 00:00:00.000000000 Z
+date: 2022-08-12 00:00:00.000000000 Z
 dependencies: []
 description:
 email: