dev_ruby 0.1.0 → 1.0.0

data/lib/dev_ruby/resources/articles_resource.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength
+module DevRuby
+  module Resources
+    class ArticlesResource < BaseResource
+      def published(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('articles', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Article,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def create(**body)
+        response = post_request('articles', body: { article: body })
+
+        if Helpers.expected_response?(response, 201)
+          article = DevRuby::Objects::Article.new(response.body)
+
+          Success(article)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def latest_published(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('articles/latest', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Article,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def find(id)
+        response = get_request("articles/#{id}")
+
+        if Helpers.expected_response?(response, 200)
+          article = DevRuby::Objects::Article.new(response.body)
+
+          Success(article)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def update(id:, **body)
+        response = put_request("articles/#{id}", body: { article: body })
+
+        if Helpers.expected_response?(response, 200)
+          article = DevRuby::Objects::Article.new(response.body)
+
+          Success(article)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def find_by_path(username:, slug:)
+        response = get_request("articles/#{username}/#{slug}")
+
+        if Helpers.expected_response?(response, 200)
+          article = DevRuby::Objects::Article.new(response.body)
+
+          Success(article)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def me(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('articles/me')
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Article,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def me_published(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('articles/me/published', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Article,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def me_unpublished(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('articles/me/unpublished', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Article,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def me_all(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('articles/me/all', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Article,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def videos(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('videos', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::VideoArticle,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength

data/lib/dev_ruby/resources/base_resource.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'dry/monads'
+
+module DevRuby
+  module Resources
+    class BaseResource
+      include Dry::Monads[:result]
+
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      def get_request(url, params: {}, headers: {})
+        client.connection.get(url, params, headers)
+      end
+
+      def post_request(url, body:, headers: {})
+        client.connection.post(url, body, headers)
+      end
+
+      def patch_request(url, body:, headers: {})
+        client.connection.patch(url, body, headers)
+      end
+
+      def put_request(url, body:, headers: {})
+        client.connection.put(url, body, headers)
+      end
+
+      def delete_request(url, params: {}, headers: {})
+        client.connection.delete(url, params, headers)
+      end
+
+      def error_parser(response)
+        DevRuby::Objects::Error.new(response.body)
+      end
+
+      def to_default_pagination_params(params)
+        params[:page] ||= 1
+        params[:per_page] ||= DevRuby.per_page
+        params
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/comments_resource.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class CommentsResource < BaseResource
+      def all(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('comments', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Comment,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def find(id)
+        response = get_request("comments/#{id}")
+
+        if Helpers.expected_response?(response, 200)
+          comment = DevRuby::Objects::Comment.new(response.body)
+
+          Success(comment)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/followers_resource.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class FollowersResource < BaseResource
+      def all(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('followers/users')
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Follower,
+                                                params: params)
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/follows_resource.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class FollowsResource < BaseResource
+      def followed_tags(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('follows/tags', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Tag,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/listings_resource.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class ListingsResource < BaseResource
+      def published(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('listings', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Listing,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def create(**body)
+        response = post_request('listings', body: { listing: body })
+
+        if Helpers.expected_response?(response, 201)
+          listing = DevRuby::Objects::Listing.new(response.body)
+
+          Success(listing)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def published_by_category(category:, **params)
+        params = to_default_pagination_params(params)
+
+        response = get_request("listings/category/#{category}", params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Listing,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def find(id)
+        response = get_request("listings/#{id}")
+
+        if Helpers.expected_response?(response, 200)
+          listing = DevRuby::Objects::Listing.new(response.body)
+
+          Success(listing)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def update(id:, **body)
+        response = put_request("listings/#{id}", body: { listing: body })
+
+        if Helpers.expected_response?(response, 200)
+          listing = DevRuby::Objects::Listing.new(response.body)
+
+          Success(listing)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/organizations_resource.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class OrganizationsResource < BaseResource
+      def find_by_username(username)
+        response = get_request("organizations/#{username}")
+
+        if Helpers.expected_response?(response, 200)
+          organization = DevRuby::Objects::Organization.new(response.body)
+
+          Success(organization)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def all_users_by_username(username:, **params)
+        params = to_default_pagination_params(params)
+
+        response = get_request("organizations/#{username}/users", params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::User,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def all_listings_by_username(username:, **params)
+        params = to_default_pagination_params(params)
+
+        response = get_request("organizations/#{username}/listings", params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Listing,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def all_articles_by_username(username:, **params)
+        params = to_default_pagination_params(params)
+
+        response = get_request("organizations/#{username}/articles", params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Article,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/podcast_episodes_resource.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class PodcastEpisodesResource < BaseResource
+      def published(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('podcast_episodes', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::PodcastEpisode,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/profile_images_resource.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class ProfileImagesResource < BaseResource
+      def find_by_username(username)
+        response = get_request("profile_images/#{username}")
+
+        if Helpers.expected_response?(response, 200)
+          profile_image = DevRuby::Objects::ProfileImage.new(response.body)
+
+          Success(profile_image)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/readinglists_resource.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class ReadinglistsResource < BaseResource
+      def all(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('readinglist', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Article,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/tags_resource.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class TagsResource < BaseResource
+      def all(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('tags', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Tag,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def followed_tags(**params)
+        params = to_default_pagination_params(params)
+
+        response = get_request('tags', params: params)
+
+        if Helpers.expected_response?(response, 200)
+          collection = Collection.from_response(response: response,
+                                                type: DevRuby::Objects::Tag,
+                                                params: params)
+
+          Success(collection)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/resources/users_resource.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DevRuby
+  module Resources
+    class UsersResource < BaseResource
+      def me
+        response = get_request('users/me')
+
+        if Helpers.expected_response?(response, 200)
+          user = DevRuby::Objects::User.new(response.body)
+
+          Success(user)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def find(id)
+        response = get_request("users/#{id}")
+
+        if Helpers.expected_response?(response, 200)
+          user = DevRuby::Objects::User.new(response.body)
+
+          Success(user)
+        else
+          Failure(error_parser(response))
+        end
+      end
+
+      def invite_user(**body)
+        response = post_request('admin/users', body: body)
+
+        if Helpers.expected_response?(response, 200)
+          Success(response.body)
+        else
+          Failure(error_parser(response))
+        end
+      end
+    end
+  end
+end

data/lib/dev_ruby/version.rb

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

data/lib/dev_ruby.rb

@@ -1,8 +1,43 @@
 # frozen_string_literal: true
 
+require 'faraday'
+require 'dry-configurable'
+require 'awesome_print'
 require_relative 'dev_ruby/version'
 
 module DevRuby
-  class Error < StandardError; end
-  # Your code goes here...
+  extend Dry::Configurable
+
+  setting :logger, default: ::Logger.new($stdout), reader: true
+  setting :log_api_bodies, default: false, reader: true
+  setting :per_page, default: 20, reader: true
+
+  require_relative 'dev_ruby/helpers'
+  require_relative 'dev_ruby/error'
+  require_relative 'dev_ruby/client'
+  require_relative 'dev_ruby/collection'
+  require_relative 'dev_ruby/resources/base_resource'
+  require_relative 'dev_ruby/resources/articles_resource'
+  require_relative 'dev_ruby/resources/comments_resource'
+  require_relative 'dev_ruby/resources/follows_resource'
+  require_relative 'dev_ruby/resources/followers_resource'
+  require_relative 'dev_ruby/resources/listings_resource'
+  require_relative 'dev_ruby/resources/organizations_resource'
+  require_relative 'dev_ruby/resources/podcast_episodes_resource'
+  require_relative 'dev_ruby/resources/readinglists_resource'
+  require_relative 'dev_ruby/resources/users_resource'
+  require_relative 'dev_ruby/resources/tags_resource'
+  require_relative 'dev_ruby/resources/profile_images_resource'
+  require_relative 'dev_ruby/objects/base_object'
+  require_relative 'dev_ruby/objects/article'
+  require_relative 'dev_ruby/objects/video_article'
+  require_relative 'dev_ruby/objects/comment'
+  require_relative 'dev_ruby/objects/error'
+  require_relative 'dev_ruby/objects/tag'
+  require_relative 'dev_ruby/objects/follower'
+  require_relative 'dev_ruby/objects/listing'
+  require_relative 'dev_ruby/objects/organization'
+  require_relative 'dev_ruby/objects/user'
+  require_relative 'dev_ruby/objects/podcast_episode'
+  require_relative 'dev_ruby/objects/profile_image'
 end