yake 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca67b728ac7669680177b57f9ec3425073859d9e3fccc8e336e8c1d86ee903d9
-  data.tar.gz: 8f02b1e165461fca8af9a36cd2ae1543ba31f49396c868a20af50ee459d394e6
+  metadata.gz: d461854504d327c8e6b363d968b1aebe460d65918a470db73fcab94f9ec43205
+  data.tar.gz: ddd0ae3a98dc95174c0f0bdde89c968d3d45af995c65e42bc0e13f5b430466e2
 SHA512:
-  metadata.gz: 98cf4e930f7868468509a0e1b0fdca92ddf834c404ef087c11ed70361f358ea1dee9bf7b582f72b39a1b1583c6017a40caf5022b50452fc22608a0615c3513aa
-  data.tar.gz: cec7cabf789420d27b88ae5cdfcfba5244422aaccf9a2fdac7e4911de180554543176c05d125123610c672e13cd922d2863e6a8ecc318487f6b5f54558a77c48
+  metadata.gz: 43fbd717b48b43c49f555b6a6176bb64595a75df6c250b30b851a2a29a6cd0d8fe8808a156f9c7411de8777a6564b49b57197244761d080ae8a90632971a4097
+  data.tar.gz: 37a8a171dc9ce1bed8c31a97c990cb5576b8302bcec08445b48f6e20850059998bc6c7f6d02723addb9b90fc3ae708682dec440557c6494e3581fedd50857e93

data/README.md

@@ -2,8 +2,6 @@
 
 [![gem](https://img.shields.io/gem/v/yake?color=crimson&logo=rubygems&logoColor=eee&style=flat-square)](https://rubygems.org/gems/yake)
 [![rspec](https://img.shields.io/github/actions/workflow/status/amancevice/yake/rspec.yml?logo=github&style=flat-square)](https://github.com/amancevice/yake/actions/workflows/rspec.yml)
-[![coverage](https://img.shields.io/codeclimate/coverage/amancevice/yake?logo=code-climate&style=flat-square)](https://codeclimate.com/github/amancevice/yake/test_coverage)
-[![maintainability](https://img.shields.io/codeclimate/maintainability/amancevice/yake?logo=code-climate&style=flat-square)](https://codeclimate.com/github/amancevice/yake/maintainability)
 
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/smallweirdnumber)
 
@@ -179,7 +177,7 @@ end
 
 ### (Near) Zero Dependencies
 
-Finally, `yake` does not depend on any 3rd party gems. The only exceptions are the `ostruct` and `logger` gems, which are being removed from the Ruby stdlib in Ruby v3.5. This helps keep your Lambda packages slim & speedy.
+Finally, `yake` does not depend on any 3rd party gems. This helps keep your Lambda packages slim & speedy.
 
 ## Support Helpers
 
@@ -191,6 +189,18 @@ Enable the helpers by requiring the `support` submodule:
 require 'yake/support'
 ```
 
+`Array` helpers:
+
+```ruby
+array = [{ a: 'b'}, { a: 'c' }, { a: 'd' }]
+
+array.pluck(:a)
+# => ["b", "c", "d"]
+
+array.to_dynamodb
+# => {:L=>[{:a=>{:S=>"b"}}, {:a=>{:S=>"c"}}, {:a=>{:S=>"d"}}]}
+```
+
 `Object` helpers:
 
 ```ruby
@@ -228,9 +238,6 @@ hash.deep_transform_keys!(&:to_s)
 { fizz: 'buzz' }.encode64
 # => "eyJmaXp6IjoiYnV6eiJ9\n"
 
-{ fizz: 'buzz', jazz: 'fuzz' }.except(:buzz)
-# => { :fizz => 'buzz' }
-
 { fizz: 'buzz' }.strict_encode64
 # => "eyJmaXp6IjoiYnV6eiJ9"
 

data/lib/yake/api.rb

@@ -7,10 +7,12 @@ require_relative 'errors'
 
 module Yake
   module API
+    ##
+    # Yake API DSL
     module DSL
       ##
-      # Proxy handler for HTTP requests from Slack
-      def route(event, context = nil, &block)
+      # Proxy handler for HTTP requests from API Gateway
+      def route(event, context = nil)
         # Extract route method
         method = event['routeKey']
         raise Yake::Errors::UndeclaredRoute, method unless respond_to?(method)
@@ -33,20 +35,20 @@ module Yake
       # Transform to API Gateway response
       def respond(status_code, body = nil, **headers)
         # Log response
-        log = "RESPONSE [#{ status_code }] #{ body }"
+        log = "RESPONSE [#{status_code}] #{body}"
         Yake.logger&.send(status_code.to_i >= 400 ? :error : :info, log)
 
         # Set headers
         content_length = (body&.bytesize || 0).to_s
-        to_s_downcase  = -> (key) { key.to_s.downcase }
+        to_s_downcase  = ->(key) { key.to_s.downcase }
         headers = {
           'content-length' => content_length,
           **(@headers || {}),
-          **headers,
+          **headers
         }.transform_keys(&to_s_downcase).compact
 
         # Send response
-        { statusCode: status_code, headers: headers, body: body }.compact
+        { statusCode: status_code, headers:, body: }.compact
       end
 
       ##
@@ -55,55 +57,13 @@ module Yake
         (@headers ||= {}).update(headers)
       end
 
-      ##
-      # Define ANY route
-      def any(path, &block)
-        define_singleton_method("ANY #{ path }") { |*args| instance_exec(*args, &block) }
-      end
-
-      ##
-      # Define DELETE route
-      def delete(path, &block)
-        define_singleton_method("DELETE #{ path }") { |*args| instance_exec(*args, &block) }
-      end
-
-      ##
-      # Define GET route
-      def get(path, &block)
-        define_singleton_method("GET #{ path }") { |*args| instance_exec(*args, &block) }
-      end
-
-      ##
-      # Define HEAD route
-      def head(path, &block)
-        define_singleton_method("HEAD #{ path }") { |*args| instance_exec(*args, &block) }
-      end
-
-      ##
-      # Define OPTIONS route
-      def options(path, &block)
-        define_singleton_method("OPTIONS #{ path }") { |*args| instance_exec(*args, &block) }
-      end
-
-      ##
-      # Define PATCH route
-      def patch(path, &block)
-        define_singleton_method("PATCH #{ path }") { |*args| instance_exec(*args, &block) }
-      end
-
-      ##
-      # Define POST route
-      def post(path, &block)
-        define_singleton_method("POST #{ path }") { |*args| instance_exec(*args, &block) }
-      end
-
-      ##
-      # Define PUT route
-      def put(path, &block)
-        define_singleton_method("PUT #{ path }") { |*args| instance_exec(*args, &block) }
+      %w[ANY DELETE GET HEAD OPTIONS PATCH POST PUT].each do |verb|
+        define_method(verb.downcase) do |path, &block|
+          define_singleton_method("#{verb} #{path}") { |*args| instance_exec(*args, &block) }
+        end
       end
     end
   end
 end
 
-extend Yake::API::DSL
+extend Yake::API::DSL # rubocop: disable Style/MixinUsage

data/lib/yake/datadog.rb

@@ -5,23 +5,24 @@ require 'logger'
 require 'datadog/lambda'
 require 'yake'
 
+##
+# Yake
 module Yake
   module Datadog
+    ##
+    # Datadog Logger Formatter
     class Formatter < ::Logger::Formatter
-      Format = "[%s] %s %s %s %s\n"
+      Format = "[%s] %s %s %s %s\n" # rubocop: disable Naming/ConstantName
 
       def call(severity, time, progname, msg)
-        Format % [
-          severity,
-          time.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ'),
-          progname.nil? ? '-' : progname.split.last,
-          ::Datadog::Tracing.log_correlation,
-          msg2str(msg).strip,
-        ]
+        format(Format, severity, time.utc.strftime('%Y-%m-%dT%H:%M:%S.%LZ'), progname.nil? ? '-' : progname.split.last,
+               ::Datadog::Tracing.log_correlation, msg2str(msg).strip)
       end
     end
 
-    class MockContext < Struct.new(
+    ##
+    # Mock Lambda Context
+    MockContext = Struct.new(
       :clock_diff,
       :deadline_ms,
       :aws_request_id,
@@ -30,8 +31,8 @@ module Yake
       :log_stream_name,
       :function_name,
       :memory_limit_in_mb,
-      :function_version)
-
+      :function_version
+    ) do
       def invoked_function_arn
         @invoked_function_arn ||= begin
           region = ENV['AWS_REGION'] || ENV['AWS_DEFAULT_REGION'] || 'us-east-1'
@@ -40,13 +41,15 @@ module Yake
       end
     end
 
+    ##
+    # Datadog DSL
     module DSL
       include Yake::DSL
 
       ##
       # Datadog handler wrapper
       def datadog(name, &block)
-        define_method(name) do |event:nil, context:nil|
+        define_method(name) do |event: nil, context: nil|
           context ||= MockContext.new
           ::Datadog::Lambda.wrap(event, context) do
             Yake.wrap(event, context, &block)
@@ -59,4 +62,4 @@ module Yake
   logger.formatter = Datadog::Formatter.new
 end
 
-extend Yake::Datadog::DSL
+extend Yake::Datadog::DSL # rubocop: disable Style/MixinUsage

data/lib/yake/dsl.rb

@@ -2,14 +2,19 @@
 
 require 'json'
 
+require_relative 'errors'
 require_relative 'logger'
 
+##
+# Yake
 module Yake
+  ##
+  # Yake DSL
   module DSL
     ##
     # Lambda handler task wrapper
     def handler(name, &block)
-      define_method(name) do |event:nil, context:nil|
+      define_method(name) do |event: nil, context: nil|
         Yake.wrap(event, context, &block)
       end
     end
@@ -35,12 +40,12 @@ module Yake
   end
 
   class << self
-    def wrap(event = nil, context = nil, &block)
+    def wrap(event = nil, context = nil, &) # rubocop: disable Metrics/AbcSize
       original_progname = logger.progname
       logger.progname   = context&.aws_request_id
-      jsonify           = -> (obj) { pretty? ? JSON.pretty_generate(obj) : obj.to_json }
-      log_return        = -> (res) { logger.info("RETURN #{ jsonify === res }") }
-      logger.info("EVENT #{ jsonify === event }")
+      jsonify           = ->(obj) { pretty? ? JSON.pretty_generate(obj) : obj.to_json }
+      log_return        = ->(res) { logger.info("RETURN #{jsonify.call(res)}") }
+      logger.info("EVENT #{jsonify.call(event)}")
       (yield(event, context) if block_given?).tap(&log_return)
     ensure
       logger.progname = original_progname
@@ -48,4 +53,4 @@ module Yake
   end
 end
 
-extend Yake::DSL
+extend Yake::DSL # rubocop: disable Style/MixinUsage

data/lib/yake/errors.rb

@@ -1,23 +1,38 @@
 # frozen_string_literal: true
 
 module Yake
+  ##
+  # Custom Errors
   module Errors
     class Error < StandardError; end
 
+    ##
+    # Error not found by code
+    class CodeNotFound < Error
+      def initialize(code = nil)
+        super("No Error class for code '#{code}'")
+      end
+    end
+
+    ##
+    # Event uses undeclared route
     class UndeclaredRoute < Error
       def initialize(method = nil)
-        super("No route declared for '#{ method }'")
+        super("No route declared for '#{method}'")
       end
     end
 
+    ##
+    # Bad logging setting
     class UnknownLoggingSetting < Error
       def initialize(method = nil)
-        super("Unknown logging setting '#{ method }'. Use :on or :off")
+        super("Unknown logging setting '#{method}'. Use :on or :off")
       end
     end
 
     # HTTP Errors
 
+    # rubocop: disable Style/CommentedKeyword
     class BadRequest < Error; end                    # HTTP 400
     class Unauthorized < Error; end                  # HTTP 401
     class PaymentRequired < Error; end               # HTTP 402
@@ -59,6 +74,7 @@ module Yake
     class LoopDetected < Error; end                  # HTTP 508
     class NotExtended < Error; end                   # HTTP 510
     class NetworkAuthenticationRequired < Error; end # HTTP 511
+    # rubocop: enable Style/CommentedKeyword
 
     ERRORS = {
       '400' => BadRequest,
@@ -101,11 +117,13 @@ module Yake
       '507' => InsufficientStorage,
       '508' => LoopDetected,
       '510' => NotExtended,
-      '511' => NetworkAuthenticationRequired,
-    }
+      '511' => NetworkAuthenticationRequired
+    }.freeze
 
     def self.[](code)
       ERRORS.fetch(code.to_s)
+    rescue KeyError
+      raise CodeNotFound.new(code)
     end
   end
 end

data/lib/yake/logger.rb

@@ -3,7 +3,11 @@
 require 'json'
 require 'logger'
 
+##
+# Yake
 module Yake
+  ##
+  # Yake Logger
   module Logger
     attr_writer :logger
 
@@ -17,15 +21,13 @@ module Yake
       end
     end
 
+    ##
+    # Yake Logger Formatter
     class Formatter < ::Logger::Formatter
-      Format = "%s %s %s\n"
-
-      def call(severity, time, progname, msg)
-        Format % [
-          severity,
-          progname.nil? ? '-' : "RequestId: #{ progname }",
-          msg2str(msg).strip
-        ]
+      Format = "%s %s %s\n" # rubocop: disable Naming/ConstantName
+
+      def call(severity, _time, progname, msg)
+        format(Format, severity, progname.nil? ? '-' : "RequestId: #{progname}", msg2str(msg).strip)
       end
     end
   end

data/lib/yake/support/array.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+##
+# Array helpers
+class Array
+  def pluck(key)  = map { |x| x[key] }
+  def to_dynamodb = { L: map(&:to_dynamodb) }
+end

data/lib/yake/support/hash.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+##
+# Hash helpers
+class Hash
+  def deep_keys               = map { |k, v| v.respond_to?(:deep_keys) ? [k] + v.deep_keys : k }.flatten
+  def deep_sort               = sort.to_h { |k, v| [k, v.try(:deep_sort) { |x| x }] }
+  def deep_transform_keys(&)  = deep_transform(:transform_keys, &)
+  def deep_transform_keys!(&) = deep_transform(:transform_keys!, &)
+  def encode64                = to_json.encode64
+  def strict_encode64         = to_json.strict_encode64
+  def stringify_names         = deep_transform_keys(&:to_s)
+  def stringify_names!        = deep_transform_keys!(&:to_s)
+  def symbolize_names         = deep_transform_keys(&:to_sym)
+  def symbolize_names!        = deep_transform_keys!(&:to_sym)
+  def to_form                 = URI.encode_www_form(self)
+  def to_json_sorted          = deep_sort.to_json
+  def to_struct               = Struct.new(*keys.map(&:to_sym)).new(*values)
+
+  ##
+  # Adapted from ActiveSupport Hash#deep_merge
+  # https://github.com/rails/rails/blob/f95c0b7e96eb36bc3efc0c5beffbb9e84ea664e4/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+  def deep_merge(other, &block) # rubocop: disable Metrics/MethodLength
+    merge(other) do |key, a, b|
+      if a.is_a?(Hash) && b.is_a?(Hash)
+        a.deep_merge(b, &block)
+      elsif a.is_a?(Array) && b.is_a?(Array)
+        a + b
+      elsif block_given?
+        yield key, a, b
+      else
+        b
+      end
+    end
+  end
+
+  def to_deep_struct # rubocop: disable Metrics/MethodLength
+    to_struct.tap do |struct|
+      struct.to_h.each do |key, val|
+        struct[key] =
+          if val.is_a?(Array)
+            val.map { |i| i.respond_to?(:to_deep_struct) ? i.to_deep_struct : i }
+          elsif val.is_a?(Hash)
+            val.to_deep_struct
+          else
+            val
+          end
+      end
+    end
+  end
+
+  def to_dynamodb
+    map do |key, val|
+      { key => val.is_a?(Hash) ? { M: val.to_dynamodb } : val.to_dynamodb }
+    end.reduce(&:merge)
+  end
+
+  def to_h_from_dynamodb # rubocop: disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    decode = lambda do |i|
+      type, val = i.first
+      case type.to_sym
+      when :BOOL, :S then val
+      when :NULL then nil
+      when :NS then Set.new(val.map { |x| x =~ /^[0-9]+$/ ? x.to_i : x.to_f })
+      when :SS then Set.new(val)
+      when :N then val =~ /^[0-9]+$/ ? val.to_i : val.to_f
+      when :L then val.map(&decode)
+      when :M then val.transform_values(&decode)
+      end
+    end
+    map do |key, val|
+      { key => decode.call(val) }
+    end.reduce(&:merge)
+  end
+
+  private
+
+  def deep_transform(method, &block)
+    f = ->(x) { x.respond_to?(:"deep_#{method}") ? x.send(:"deep_#{method}", &block) : x }
+    if block_given?
+      send(method, &block).to_h do |key, val|
+        [key, val.is_a?(Array) ? val.map(&f) : val.then(&f)]
+      end
+    else
+      self
+    end
+  end
+end

data/lib/yake/support/integer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+##
+# Integer helpers
+class Integer
+  def weeks   = days * 7
+  def days    = hours * 24
+  def hours   = minutes * 60
+  def minutes = seconds * 60
+  def seconds = self
+  def utc     = UTC.at(self)
+
+  alias second seconds
+  alias minute minutes
+  alias hour hours
+  alias day days
+  alias week weeks
+end

data/lib/yake/support/numeric.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+##
+# Numeric helpers
+class Numeric
+  def to_dynamodb = { N: to_s }
+end

data/lib/yake/support/object.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+##
+# Object helpers
+class Object
+  def try(method, *, **, &)
+    public_send(method, *, **)
+  rescue NoMethodError
+    block_given? ? yield(self) : nil
+  end
+end

data/lib/yake/support/string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+##
+# String helpers
+class String
+  def /(other) = File.join(self, other.to_s)
+  def camel_case          = split(/[_ ]/).map(&:capitalize).join
+  def decode64            = unpack1('m')
+  def encode64            = [self].pack('m')
+  def md5sum              = Digest::MD5.hexdigest(self)
+  def sha1sum             = Digest::SHA1.hexdigest(self)
+  def snake_case          = gsub(/([a-z])([A-Z])/, '\1_\2').gsub(/ /, '_').downcase
+  def strict_decode64     = unpack1('m0')
+  def strict_encode64     = [self].pack('m0')
+  def to_dynamodb         = { S: self }
+  def to_h_from_json(...) = JSON.parse(self, ...)
+  def to_h_from_form      = URI.decode_www_form(self).to_h
+  def utc                 = UTC.parse(self)
+end

data/lib/yake/support/symbol.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+##
+# Symbol helpers
+class Symbol
+  def camel_case  = to_s.camel_case.to_sym
+  def snake_case  = to_s.snake_case.to_sym
+  def to_dynamodb = { S: to_s }
+end

data/lib/yake/support/utc.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+##
+# UTC time
+class UTC < Time
+  def initialize(...) = super.utc
+  def self.at(...)    = super.utc
+  def self.now        = super.utc
+end

data/lib/yake/support.rb

@@ -5,141 +5,11 @@ require 'json'
 require 'time'
 require 'uri'
 
-class Array
-  def to_dynamodb = { L: map(&:to_dynamodb) }
-end
-
-class Hash
-  def deep_keys                     = map { |k,v| v.respond_to?(:deep_keys) ? [k] + v.deep_keys : k }.flatten
-  def deep_sort                     = sort.map { |k,v| [ k, v.try(:deep_sort) { |x| x } ] }.to_h
-  def deep_transform_keys(&block)   = deep_transform(:transform_keys, &block)
-  def deep_transform_keys!(&block)  = deep_transform(:transform_keys!, &block)
-  def encode64                      = to_json.encode64
-  def except(*keys)                 = reject { |key,_| keys.include? key }
-  def strict_encode64               = to_json.strict_encode64
-  def stringify_names               = deep_transform_keys(&:to_s)
-  def stringify_names!              = deep_transform_keys!(&:to_s)
-  def symbolize_names               = deep_transform_keys(&:to_sym)
-  def symbolize_names!              = deep_transform_keys!(&:to_sym)
-  def to_form                       = URI.encode_www_form(self)
-  def to_json_sorted                = deep_sort.to_json
-  def to_struct                     = Struct.new(*keys.map(&:to_sym)).new(*values)
-
-  ##
-  # Adapted from ActiveSupport Hash#deep_merge
-  # https://github.com/rails/rails/blob/f95c0b7e96eb36bc3efc0c5beffbb9e84ea664e4/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
-  def deep_merge(other, &block)
-    merge(other) do |key, a, b|
-      if a.is_a?(Hash) && b.is_a?(Hash)
-        a.deep_merge(b, &block)
-      elsif a.is_a?(Array) && b.is_a?(Array)
-        a + b
-      elsif block_given?
-        yield key, a, b
-      else
-        b
-      end
-    end
-  end
-
-  def to_deep_struct
-    to_struct.tap do |struct|
-      struct.to_h.each do |key, val|
-        struct[key] = if val.is_a?(Array)
-          val.map do |item|
-            item.respond_to?(:to_deep_struct) ? item.to_deep_struct : item
-          end
-        elsif val.is_a?(Hash)
-          val.to_deep_struct
-        else
-          val
-        end
-      end
-    end
-  end
-
-  def to_dynamodb
-    map do |key, val|
-      { key => val.is_a?(Hash) ? { M: val.to_dynamodb } : val.to_dynamodb }
-    end.reduce(&:merge)
-  end
-
-  def to_h_from_dynamodb
-    decode = -> (i) do
-      type, val = i.first
-      case type.to_sym
-      when :S then val
-      when :N then val =~ /^[0-9]+$/ ? val.to_i : val.to_f
-      when :L then val.map(&decode)
-      when :M then val.transform_values(&decode)
-      end
-    end
-    map do |key, val|
-      { key => decode === val }
-    end.reduce(&:merge)
-  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 Numeric
-  def to_dynamodb = { N: to_s }
-end
-
-class Integer
-  def weeks   = days * 7
-  def days    = hours * 24
-  def hours   = minutes * 60
-  def minutes = seconds * 60
-  def seconds = self
-  def utc     = UTC.at(self)
-
-  alias :second :seconds
-  alias :minute :minutes
-  alias :hour :hours
-  alias :day :days
-  alias :week :weeks
-end
-
-class Object
-  def try(method, *args, **kwargs, &block)
-    send(method, *args, **kwargs)
-  rescue
-    block_given? ? yield(self) : nil
-  end
-end
-
-class String
-  def /(path)             = File.join(self, path.to_s)
-  def camel_case          = split(/[_ ]/).map(&:capitalize).join
-  def decode64            = self.unpack1('m')
-  def encode64            = [self].pack('m')
-  def md5sum              = Digest::MD5.hexdigest(self)
-  def sha1sum             = Digest::SHA1.hexdigest(self)
-  def snake_case          = gsub(/([a-z])([A-Z])/, '\1_\2').gsub(/ /, '_').downcase
-  def strict_decode64     = self.unpack1('m0')
-  def strict_encode64     = [self].pack('m0')
-  def to_dynamodb         = { S: self }
-  def to_h_from_json(...) = JSON.parse(self, ...)
-  def to_h_from_form      = URI.decode_www_form(self).to_h
-  def utc                 = UTC.parse(self)
-end
-
-class Symbol
-  def camel_case  = to_s.camel_case.to_sym
-  def snake_case  = to_s.snake_case.to_sym
-  def to_dynamodb = { S: to_s }
-end
-
-class UTC < Time
-  def initialize(...) = super.utc
-  def self.at(...)    = super.utc
-  def self.now        = super.utc
-end
+require_relative 'support/array'
+require_relative 'support/hash'
+require_relative 'support/integer'
+require_relative 'support/numeric'
+require_relative 'support/object'
+require_relative 'support/string'
+require_relative 'support/symbol'
+require_relative 'support/utc'

data/lib/yake/version.rb

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

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: yake
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Alexander Mancevice
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-03 00:00:00.000000000 Z
+date: 2026-06-21 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: ostruct
-  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: logger
   requirement: !ruby/object:Gem::Requirement
@@ -54,11 +40,20 @@ files:
 - lib/yake/errors.rb
 - lib/yake/logger.rb
 - lib/yake/support.rb
+- lib/yake/support/array.rb
+- lib/yake/support/hash.rb
+- lib/yake/support/integer.rb
+- lib/yake/support/numeric.rb
+- lib/yake/support/object.rb
+- lib/yake/support/string.rb
+- lib/yake/support/symbol.rb
+- lib/yake/support/utc.rb
 - lib/yake/version.rb
 homepage: https://github.com/amancevice/yake
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -74,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Rake-like DSL for declaring AWS Lambda function handlers