sofia 0.1.0 → 0.1.2

data/lib/sofia/types/client/headers.rb

@@ -0,0 +1,58 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Client
+      class Headers
+
+        #: (?untyped headers) -> void
+        def initialize(headers = {})
+          defaults = { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
+          headers = validate_and_normalize(headers)
+          @headers = defaults.merge(headers) #: Hash[String, String]
+        end
+
+        #: (untyped key) -> void
+        def [](key)
+          @headers[key.to_s]
+        end
+
+        #: (untyped key, untyped value) -> void
+        def []=(key, value)
+          @headers[key.to_s] = value.to_s
+        end
+
+        #: -> Hash[String, String]
+        def to_h
+          @headers.dup
+        end
+
+        #: () { ([String, String]) -> untyped } -> Hash[String, String]
+        def each(&block) # rubocop:disable Naming/BlockForwarding
+          @headers.each(&block) # rubocop:disable Naming/BlockForwarding
+        end
+
+        private
+
+        #: (untyped) -> Hash[String, String]
+        def validate_and_normalize(headers)
+          Kernel.raise Sofia::Error::ArgumentError, 'headers must be a Hash' unless headers.is_a?(Hash)
+          normalized = {}
+
+          headers.each do |key, value|
+            next if value.nil?
+
+            if value.is_a?(Hash) || value.is_a?(Array)
+              Kernel.raise Sofia::Error::ArgumentError, "invalid header value for #{key}"
+            end
+
+            normalized[key.to_s] = value.to_s
+          end
+
+          normalized
+        end
+      end
+    end
+  end
+end

data/lib/sofia/types/client/options.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Client
+      class Options
+
+        #: Sofia::Options
+        attr_reader :value
+
+        #: (?untyped options) -> void
+        def initialize(options = nil)
+          @value = build(options) #: Sofia::Options
+        end
+
+        private
+
+        #: (untyped) -> Sofia::Options
+        def build(options)
+          case options
+          when nil
+            Sofia::Options.new
+          when Hash
+            Sofia::Options.new(**options)
+          else
+            Kernel.raise Sofia::Error::ArgumentError, "options must be a Hash, got #{options.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sofia/types/client/params.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Client
+      class Params
+        extend T::Sig
+
+        #: (?untyped params) -> void
+        def initialize(params = {}) # rubocop:disable Style/OptionHash
+          @params = validate_and_normalize(params || {}) #: Hash[String, String]
+        end
+
+        #: (untyped key) -> void
+        def [](key)
+          @params[key.to_s]
+        end
+
+        #: (untyped key, untyped value) -> void
+        def []=(key, value)
+          @params[key.to_s] = value.to_s
+        end
+
+        #: -> Hash[String, String]
+        def to_h
+          @params.dup
+        end
+
+        #: -> String
+        def to_s
+          URI.encode_www_form(@params)
+        end
+
+        private
+
+        #: (untyped) -> Hash[String, String]
+        def validate_and_normalize(headers)
+          Kernel.raise Sofia::Error::ArgumentError, 'params must be a Hash' unless headers.is_a?(Hash)
+          normalized = {}
+
+          headers.each do |key, value|
+            next if value.nil?
+
+            if value.is_a?(Hash) || value.is_a?(Array)
+              Kernel.raise Sofia::Error::ArgumentError, "invalid param value for #{key}"
+            end
+
+            normalized[key.to_s] = value.to_s
+          end
+
+          normalized
+        end
+      end
+    end
+  end
+end

data/lib/sofia/types/client/path.rb

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Client
+      class Path
+
+        #: (?untyped path) -> void
+        def initialize(path = '/')
+          @path = validate_and_normalize(path).freeze #: String
+        end
+
+        #: -> String
+        def to_s
+          @path
+        end
+
+        private
+
+        #: (untyped) -> String
+        def validate_and_normalize(path)
+          Kernel.raise Sofia::Error::ArgumentError, 'path must be a String' unless path.is_a?(String)
+
+          path.start_with?('/') ? path : "/#{path}"
+        end
+      end
+    end
+  end
+end

data/lib/sofia/types/client.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Client; end
+  end
+end
+
+require_relative 'client/adapter'
+require_relative 'client/base_url'
+require_relative 'client/headers'
+require_relative 'client/body'
+require_relative 'client/params'
+require_relative 'client/path'
+require_relative 'client/options'

data/lib/sofia/types/options/timeout/base.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Options
+      module Timeout
+        class Base
+
+          #: (untyped value) -> void
+          def initialize(value)
+            @value = validate_and_normalize(value) #: Float
+          end
+
+          #: -> Float
+          def to_f
+            @value
+          end
+
+          private
+
+          #: (untyped) -> Float
+          def validate_and_normalize(value)
+            unless value.is_a?(Numeric) && value.to_f > 0
+              raise Sofia::Error::ArgumentError, "timeout must be a positive number, got #{value.inspect}"
+            end
+
+            value.to_f
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sofia/types/options/timeout/connection.rb

@@ -0,0 +1,12 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Options
+      module Timeout
+        class Connection < Base; end
+      end
+    end
+  end
+end

data/lib/sofia/types/options/timeout/read.rb

@@ -0,0 +1,12 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Options
+      module Timeout
+        class Read < Base; end
+      end
+    end
+  end
+end

data/lib/sofia/types/options/timeout/write.rb

@@ -0,0 +1,12 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Options
+      module Timeout
+        class Write < Base; end
+      end
+    end
+  end
+end

data/lib/sofia/types/options/timeout.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Options
+      module Timeout; end
+    end
+  end
+end
+
+require_relative 'timeout/base'
+require_relative 'timeout/read'
+require_relative 'timeout/write'
+require_relative 'timeout/connection'

data/lib/sofia/types/options.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    module Options; end
+  end
+end
+
+require_relative 'options/timeout'

data/lib/sofia/types.rb

@@ -5,9 +5,5 @@ module Sofia
   module Types; end
 end
 
-require_relative 'types/adapter'
-require_relative 'types/base_url'
-require_relative 'types/headers'
-require_relative 'types/body'
-require_relative 'types/params'
-require_relative 'types/path'
+require_relative 'types/client'
+require_relative 'types/options'

data/lib/sofia/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sofia
-  VERSION = '0.1.0'
+  VERSION = '0.1.2'
 end

data/lib/sofia.rb

@@ -8,18 +8,20 @@ require 'sorbet-runtime'
 require 'byebug'
 
 require_relative 'sofia/version'
+require_relative 'sofia/error'
+require_relative 'sofia/defaults'
+require_relative 'sofia/types'
+require_relative 'sofia/options'
 require_relative 'sofia/request'
 require_relative 'sofia/response'
 require_relative 'sofia/adapter'
 require_relative 'sofia/client'
-require_relative 'sofia/error'
-require_relative 'sofia/types'
 
 module Sofia
   class << self
-    #: (base_url: untyped, ?adapter: untyped) -> Sofia::Client
-    def new(base_url:, adapter: nil)
-      Client.new(base_url: base_url, adapter: adapter)
+    #: (base_url: untyped, ?adapter: untyped, ?options: untyped) -> Sofia::Client
+    def new(base_url:, adapter: nil, options: nil)
+      Client.new(base_url: base_url, adapter: adapter, options: options)
     end
   end
 end