sofia 0.1.0

data/lib/sofia/response.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  class Response
+
+    #: Integer
+    attr_reader :status
+
+    #: Hash[String, String]
+    attr_reader :headers
+
+    #: String?
+    attr_reader :raw_body
+
+    #: Sofia::Request
+    attr_reader :request
+
+    #: (status: Integer, headers: Hash[String, String], raw_body: String?, request: Sofia::Request) -> void
+    def initialize(status:, headers:, raw_body:, request:)
+      @status  = status
+      @headers = headers
+      @raw_body = raw_body
+      @request = request
+    end
+
+    #: -> bool
+    def success?
+      (200..299).include?(@status)
+    end
+
+    #: -> bool
+    def failure?
+      !success?
+    end
+
+    #: -> JSONValue?
+    def body
+      body = raw_body
+      return unless body
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      raise Sofia::Error::InvalidJSON
+    end
+
+    #: -> bool
+    def client_error?
+      (400..499).include?(@status)
+    end
+
+    #: -> bool
+    def server_error?
+      (500..599).include?(@status)
+    end
+  end
+end

data/lib/sofia/sorbet_types.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  # JSONValue represents any valid JSON data
+  JSONValue = T.type_alias do
+    T.any(
+      String,
+      Integer,
+      Float,
+      TrueClass,
+      FalseClass,
+      NilClass,
+      T::Array[T.untyped],
+      T::Hash[String, T.untyped],
+    )
+  end
+
+end

data/lib/sofia/types/adapter.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    class Adapter
+
+      #: singleton(Sofia::Adapter::Base)
+      attr_reader :klass
+
+      #: (?untyped adapter) -> void
+      def initialize(adapter = :net_http)
+        name, klass = validate_and_set(adapter || :net_http)
+        @name  = T.let(name, Symbol)
+        @klass = T.let(klass, T.class_of(Sofia::Adapter::Base))
+      end
+
+      #: -> Symbol
+      def to_sym
+        @name
+      end
+
+      private
+
+      #: (untyped) -> [Symbol, singleton(Sofia::Adapter::Base)]
+      def validate_and_set(adapter)
+        case adapter&.to_sym
+        when :net_http
+          [:net_http, Sofia::Adapter::NetHTTP]
+        else
+          Kernel.raise Sofia::Error::ArgumentError, "unknown adapter #{adapter}"
+        end
+
+      rescue NoMethodError
+        Kernel.raise Sofia::Error::ArgumentError, "unknown adapter #{adapter}"
+      end
+    end
+  end
+end

data/lib/sofia/types/base_url.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    class BaseUrl
+
+      #: (untyped base_url) -> void
+      def initialize(base_url)
+        @base_url = validate_and_normalize(base_url).freeze #: String
+      end
+
+      #: -> String
+      def to_s
+        @base_url
+      end
+
+      private
+
+      #: (untyped) -> String
+      def validate_and_normalize(base_url)
+        unless base_url.is_a?(String) && !base_url.strip.empty?
+          raise Sofia::Error::ArgumentError, 'base_url must be a non-empty String'
+        end
+
+        normalized = base_url.chomp('/')
+        return normalized if normalized.start_with?('http://', 'https://')
+
+        "https://#{normalized}"
+      end
+    end
+  end
+end

data/lib/sofia/types/body.rb

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    class Body
+
+      #:  Hash[String, untyped]
+      attr_reader :body
+
+      #: (?untyped? body) -> void
+      def initialize(body = nil)
+        @body = validate_and_normalize(body) #:  Hash[String, untyped]
+      end
+
+      #: -> Hash[String, untyped]
+      def to_h
+        @body.dup
+      end
+
+      private
+
+      #: (untyped? body) -> Hash[String, untyped]
+      def validate_and_normalize(body)
+        return {} unless body
+
+        Kernel.raise Sofia::Error::ArgumentError, 'body must be a Hash' unless body.is_a?(Hash)
+        body.each_with_object({}) do |(key, value), acc|
+          next if value.nil?
+
+          acc[key.to_s] =
+            case value
+            when Hash
+              validate_and_normalize(value)
+            when Array
+              validate_and_normalize_array(value)
+            else
+              value
+            end
+        end
+      end
+
+      #: (Array[untyped]) -> Array[untyped]
+      def validate_and_normalize_array(array)
+        array.each_with_object([]) do |value, acc|
+          next if value.nil?
+
+          acc << case value
+                 when Hash
+                   validate_and_normalize(value)
+                 when Array
+                   validate_and_normalize_array(value)
+                 else
+                   value
+                 end
+        end
+      end
+    end
+  end
+end

data/lib/sofia/types/headers.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    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

data/lib/sofia/types/params.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    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

data/lib/sofia/types/path.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Sofia
+  module Types
+    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

data/lib/sofia/types.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+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'

data/lib/sofia/version.rb

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

data/lib/sofia.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+require 'sorbet-runtime'
+require 'byebug'
+
+require_relative 'sofia/version'
+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)
+    end
+  end
+end

data/sig/sofia.rbs

@@ -0,0 +1,4 @@
+module Sofia
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/sorbet/config

@@ -0,0 +1,6 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/
+--enable-experimental-rbs-comments
+--enable-experimental-requires-ancestor

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true