♻️ Clean up the code a bit

Towards: SYS-320

Author: jeffdill2

CHANGELOG.md

@@ -1,3 +1,15 @@
-## [0.1.0] - 2024-07-02
+## [0.1.0] - 2024-07-10
 
-- Initial release
+The initial release. Provides all basic Ruby wrapper functionality for JustCall's V2 API.
+
+The V2 API currently includes the following endpoints:
+- Calls
+  - [List all calls](https://developer.justcall.io/reference/call_list)
+  - [Get a call](https://developer.justcall.io/reference/call_get)
+  - [Update a call](https://developer.justcall.io/reference/call_update)
+  - [Download a recording](https://developer.justcall.io/reference/call_recording_download)
+- SMS
+  - [List all texts](https://developer.justcall.io/reference/texts_list)
+  - [Get a text](https://developer.justcall.io/reference/texts_get)
+  - [Check reply](https://developer.justcall.io/reference/texts_checkreply)
+  - [Send SMS/MMS](https://developer.justcall.io/reference/texts_new)

lib/justcall_ruby/api.rb

@@ -5,46 +5,39 @@ module API
     ROOT_URL = 'https://api.justcall.io/v2'.freeze
     USER_AGENT = "JustCallRubyGem/#{JustCall::VERSION}".freeze
 
-    def get_request(client, endpoint)
+    private
+
+    def get_request(client:, endpoint:)
       request = Net::HTTP::Get.new(request_url(endpoint))
 
-      set_request_headers(client, request)
-      submit_request(request)
+      submit_request(client: client, request: request)
     end
 
-    def post_request(client, endpoint, data = {})
+    def post_request(client:, endpoint:, data: {})
       request = Net::HTTP::Post.new(request_url(endpoint))
 
-      set_request_headers(client, request, 'application/json')
-      submit_request(request, data)
+      submit_request(client: client, request: request, data: data)
     end
 
-    def put_request(client, endpoint, data = {})
+    def put_request(client:, endpoint:, data: {})
       request = Net::HTTP::Put.new(request_url(endpoint))
 
-      set_request_headers(client, request, 'application/json')
-      submit_request(request, data)
+      submit_request(client: client, request: request, data: data)
     end
 
-    def delete_request(client, endpoint)
+    def delete_request(client:, endpoint:)
       request = Net::HTTP::Delete.new(request_url(endpoint))
 
-      set_request_headers(client, request)
-      submit_request(request)
+      submit_request(client: client, request: request)
     end
 
-    private
-
-    def submit_request(request, data = {})
-      request.body = data.is_a?(Hash) ? data.to_json : data if data.any?
-
-      process_request(request)
-    end
+    def submit_request(client:, request:, data: {})
+      set_request_headers(client: client, request: request)
 
-    def process_request(request)
       uri = URI(request.path)
       http = Net::HTTP.new(uri.host, uri.port)
 
+      request.body = data.is_a?(Hash) ? data.to_json : data if data.any?
       http.use_ssl = true
       http.set_debug_output($stdout) if JustCall.config.full_debug?
 
@@ -53,7 +46,7 @@ def process_request(request)
       JustCall::Response.new(response)
     end
 
-    def set_request_headers(client, request)
+    def set_request_headers(client:, request:)
       request['Accept'] = 'application/json'
       request['Authorization'] = [client.api_key, client.api_secret].join(':')
       request['Content-Type'] = 'application/json'
@@ -64,11 +57,11 @@ def request_url(endpoint)
       [ROOT_URL, endpoint].join('/')
     end
 
-    def standardize_body_data(submitted_data, permitted_data_attrs)
-      submitted_data = submitted_data.deep_transform_keys(&:to_sym)
-      permitted_data = submitted_data.select! { |k, _| permitted_data_attrs.include?(k) } || submitted_data
+    def standardize_body_data(submitted_attrs:, permitted_attrs:)
+      submitted_attrs = submitted_attrs.deep_transform_keys(&:to_sym)
+      permitted_attrs = submitted_attrs.select! { |k, _| permitted_attrs.include?(k) } || submitted_attrs
 
-      permitted_data.deep_transform_keys { |k| k.to_s.camelize(:lower) }
+      permitted_attrs.deep_transform_keys { |k| k.to_s.camelize(:lower) }
     end
 
     def convert_params_to_request_query(params)

lib/justcall_ruby/call.rb

@@ -36,35 +36,35 @@ class Call < Base
       download_recording: "calls/%s/recording/download".freeze,
     }.freeze
 
-    def initialize(client)
+    def initialize(client:)
       @client = client
     end
 
     def list(params = {})
-      params = standardize_body_data(params, LIST_ATTRS[:permitted])
+      params = standardize_body_data(submitted_attrs: params, permitted_attrs: LIST_ATTRS[:permitted])
       endpoint = ENDPOINTS[:list] % convert_params_to_request_query(params)
 
-      get_request(@client, endpoint)
+      get_request(client: @client, endpoint: endpoint)
     end
 
     def fetch(call_id, params = {})
-      params = standardize_body_data(params, FETCH_ATTRS[:permitted])
+      params = standardize_body_data(submitted_attrs: params, permitted_attrs: FETCH_ATTRS[:permitted])
       endpoint = ENDPOINTS[:fetch] % [call_id, convert_params_to_request_query(params)] # rubocop:disable Style/FormatString
 
-      get_request(@client, endpoint)
+      get_request(client: @client, endpoint: endpoint)
     end
 
     def update(call_id, params)
       endpoint = ENDPOINTS[:update] % call_id
-      params = standardize_body_data(params, UPDATE_ATTRS[:permitted])
+      params = standardize_body_data(submitted_attrs: params, permitted_attrs: UPDATE_ATTRS[:permitted])
 
-      put_request(@client, endpoint, params)
+      put_request(client: @client, endpoint: endpoint, data: params)
     end
 
     def download_recording(call_id)
       endpoint = ENDPOINTS[:download_recording] % call_id
 
-      get_request(@client, endpoint)
+      get_request(client: @client, endpoint: endpoint)
     end
   end
 end

lib/justcall_ruby/client.rb

@@ -14,11 +14,11 @@ def initialize(api_key:, api_secret:)
     end
 
     def call
-      @call ||= JustCall::Call.new(self)
+      @call ||= JustCall::Call.new(client: self)
     end
 
     def sms
-      @sms ||= JustCall::SMS.new(self)
+      @sms ||= JustCall::SMS.new(client: self)
     end
   end
 end

lib/justcall_ruby/error.rb

@@ -1,11 +1,9 @@
 module JustCall
   class Error < StandardError
-
     class NoContent < JustCall::Error; end
     class NotAuthorized < JustCall::Error; end
     class NotFound < JustCall::Error; end
     class RequestError < JustCall::Error; end
     class TimeoutError < JustCall::Error; end
-
   end
 end

lib/justcall_ruby/response.rb

@@ -1,6 +1,6 @@
 module JustCall
   class Response
-    attr_accessor :success
+    attr_reader :body, :response, :sucess
 
     def initialize(response)
       @response = response
@@ -11,14 +11,13 @@ def initialize(response)
       when Net::HTTPNotFound
         raise JustCall::Error::NotFound, @response.body
       when Net::HTTPOK, Net::HTTPSuccess, Net::HTTPNoContent, Net::HTTPCreated
-        self.success = true
-        data = (JSON.parse(@response.body) if @response.body.present?)
-
-        @data =
-          if data.is_a?(Hash)
-            data.deep_symbolize_keys
-          elsif data.is_a?(Array)
-            data.map(&:deep_symbolize_keys)
+        @success = true
+        body = (JSON.parse(@response.body) if @response.body.present?)
+        @body =
+          if body.is_a?(Hash)
+            body.deep_symbolize_keys
+          elsif body.is_a?(Array)
+            body.map(&:deep_symbolize_keys)
           end
       else
         puts "-- DEBUG: #{self}: RequestError: #{@response.inspect}" if JustCall.config.full_debug?
@@ -34,15 +33,11 @@ def initialize(response)
     end
 
     def [](key)
-      @data[key]
-    end
-
-    def body
-      @data
+      body[key]
     end
 
     def fetch(key)
-      @data.fetch(key)
+      body.fetch(key)
     end
 
     def success?

lib/justcall_ruby/sms.rb

@@ -28,39 +28,39 @@ class SMS < Base
       send: "texts/new".freeze,
     }.freeze
 
-    def initialize(client)
+    def initialize(client:)
       @client = client
     end
 
     def list(params = {})
-      params = standardize_body_data(params, LIST_ATTRS[:permitted])
+      params = standardize_body_data(submitted_attrs: params, permitted_attrs: LIST_ATTRS[:permitted])
       endpoint = ENDPOINTS[:list] % convert_params_to_request_query(params)
 
-      get_request(@client, endpoint)
+      get_request(client: @client, endpoint: endpoint)
     end
 
     def fetch(sms_id)
       endpoint = ENDPOINTS[:fetch] % sms_id
 
-      get_request(@client, endpoint)
+      get_request(client: @client, endpoint: endpoint)
     end
 
     def check_reply(params)
       requires!(params, *CHECK_REPLY_ATTRS[:required])
 
       endpoint = ENDPOINTS[:check_reply]
-      params = standardize_body_data(params, CHECK_REPLY_ATTRS[:permitted])
+      params = standardize_body_data(submitted_attrs: params, permitted_attrs: CHECK_REPLY_ATTRS[:permitted])
 
-      post_request(@client, endpoint, params)
+      post_request(client: @client, endpoint: endpoint, data: params)
     end
 
     def send(params)
       requires!(params, *SEND_ATTRS[:required])
 
       endpoint = ENDPOINTS[:send]
-      params = standardize_body_data(params, SEND_ATTRS[:permitted])
+      params = standardize_body_data(submitted_attrs: params, permitted_attrs: SEND_ATTRS[:permitted])
 
-      post_request(@client, endpoint, params)
+      post_request(client: @client, endpoint: endpoint, data: params)
     end
   end
 end