minisky 0.0.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afde2461017bd9cc0127a64921329a07f884377d5e434dd9b81f15e42493f5b2
-  data.tar.gz: 29c86293b904fa973cdc2c2a74e17a7f8096ac02c97377d39c9daef9a1cdc194
+  metadata.gz: 8f4836f5b8d8de9c5f9af0368144fe60f274e1b61176d1c919b70d3fd645a3f3
+  data.tar.gz: 8c87cdbb362b19651e848804aa6c551c88abc759bbdd3df6e609b62b94a7da4b
 SHA512:
-  metadata.gz: 23f5239dddeed66c6ad1a4195d53adea8d7b35d8dbc2a0680d39351a7ca9b5aeb42ef8ccdb38d4d2cd589406e93cc90ae9b5cea9f3ad4f91d3586e3b3e7fc85f
-  data.tar.gz: fdfce69b885db91ca2efbe19a92cdfc2e11e7fd5ac363be71e47f1e7c4186ba160f9dd2f99ae55950f3404b33a5a72014e3f14e917ceb76cbca7657cce09ddf6
+  metadata.gz: 84052665f10f23db1513a5135dcb9032f0fbc4c5ae55fc7bbeb15e26d85904acda3ac55170e58d8901e5549ceaaafa34aa038ec8987da9dfdded5349080f12d2
+  data.tar.gz: 5557b97bb51b8feb757a2d16dccfefd7dfd31655a833b379681d89cc924717e234baa19523cda89368f6610481cf11c0dd9494355539d4c7364c9913a05c2ca1

data/CHANGELOG.md

@@ -1 +1,44 @@
-## [Unreleased]
+## [0.3.0] - 2023-10-05
+
+* authentication improvements & changes:
+  - Minisky now automatically manages access tokens, calling `check_access` manually is not necessary (set `auto_manage_tokens` to `false` to disable this)
+  - `check_access` now just checks token's expiry time instead of making a request to `getSession`
+  - added `send_auth_headers` option - set to `false` to not set auth header automatically, which is the default
+  - removed default config file name - explicit file name is now required
+  - Minisky can now be used in unauthenticated mode - pass `nil` as the config file name
+  - added `reset_tokens` helper method
+* refactored response handling - typed errors are now raised on non-success response status
+* `user` wrapper can also be used for writing fields to the config
+* improved error handling
+
+## [0.2.0] - 2023-09-02
+
+* more consistent handling of parameters in the main methods:
+  - `auth` is now a named parameter
+  - access token is used by default, pass `nil` or an explicit token as `auth` to override
+  - `params` is always optional
+* progress dots in `#fetch_all`:
+  - default is now to not print anything
+  - pass `'.'` or any other character/string to show progress
+  - set `default_progress` on the client object to use for all `#fetch_all` calls
+* added `max_pages` option to `#fetch_all`
+* `#login` and `#perform_token_refresh` methods use the JSON response as return value
+* renamed `ident` field in the config hash to `id`
+* config is now accessed in `Requests` from the client object as a `config` property instead of `@config` ivar
+* config fields are exposed as a `user` wrapper object, e.g. `user.did` delegates to `@config['did']`
+  
+## [0.1.0] - 2023-09-01
+
+- extracted most code to a `Requests` module that can be included into a different client class with custom config handling
+- added `#check_access` method
+- hostname is now passed as a parameter
+- config file name can be passed as a parameter
+- added tests
+
+## [0.0.1] - 2023-08-30
+
+Initial release - extracted from original gist:
+
+- logging in and refreshing the token
+- making GET & POST requests
+- fetching paginated responses

data/README.md

@@ -1,31 +1,148 @@
 # Minisky
 
-TODO: Delete this and the text below, and describe your gem
+Minisky is a minimal client of the Bluesky (ATProto) API. It provides a simple API client class that you can use to log in to the Bluesky API and make any GET and POST requests there. It's meant to be an easy way to start playing and experimenting with the AT Protocol API.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/minisky`. To experiment with that code, run `bin/console` for an interactive prompt.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+To use Minisky, you need a reasonably new version of Ruby (2.6+). Such version should be preinstalled on macOS Big Sur and above and some Linux systems. Otherwise, you can install one using tools such as [RVM](https://rvm.io), [asdf](https://asdf-vm.com), [ruby-install](https://github.com/postmodern/ruby-install) or [ruby-build](https://github.com/rbenv/ruby-build), or `rpm` or `apt-get` on Linux.
 
-Install the gem and add to the application's Gemfile by executing:
+To install the Minisky gem, run the command:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+    [sudo] gem install minisky
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+Or alternatively, add it to the `Gemfile` file for Bundler:
+
+    gem 'minisky', '~> 0.3'
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
 
 ## Usage
 
-TODO: Write usage instructions here
+First, you need to create a `.yml` config file with the authentication data, e.g. `bluesky.yml`. It should look like this:
+
+```yaml
+id: my.bsky.username
+pass: very-secret-password
+```
+
+The `id` can be either your handle, or your DID, or the email you've used to sign up. It's recommended that you use the "app password" that you can create in the settings instead of your main account password.
+
+After you log in, this file will also be used to store your access & request tokens and DID. The data in the config file can be accessed through a `user` wrapper property that exposes them as methods, e.g. the password is available as `user.pass` and the DID as `user.did`.
+
+Next, create the Minisky client instance, passing the server name and the config file name (at the moment there is only one server at `bsky.social`, but there will be more once federation support goes live):
+
+```rb
+require 'minisky'
+
+bsky = Minisky.new('bsky.social', 'bluesky.yml')
+bsky.check_access
+```
+
+`check_access` will check if an access token is saved, if not - it will log you in using the login & password, otherwise it will check if the token is still valid and refresh it if needed.
+
+Now, you can make requests to the Bluesky API using `get_request` and `post_request`:
+
+```rb
+json = bsky.get_request('com.atproto.repo.listRecords', {
+  repo: bsky.user.did,
+  collection: 'app.bsky.feed.like'
+})
+
+json['records'].each do |r|
+  puts r['value']['subject']['uri']
+end
+
+bsky.post_request('com.atproto.repo.createRecord', {
+  repo: bsky.user.did,
+  collection: 'app.bsky.feed.post',
+  record: {
+    text: "Hello world!",
+    createdAt: Time.now.iso8601,
+    langs: ["en"]
+  }
+})
+```
+
+The requests use the saved access token for authentication automatically. You can also pass `auth: false` or `auth: nil` to not send any authentication headers, or `auth: sometoken` to use a specific other token.
+
+The third useful method you can use is `#fetch_all`, which loads multiple paginated responses and collects all returned items on a single list (you need to pass the name of the field that contains the items in the response). Optionally, you can also specify a limit of pages to load as `max_pages: n`, or a break condition `break_when` to stop fetching when any item matches it. You can use it to e.g. to fetch all of your posts from the last 30 days, but not earlier:
+
+```rb
+time_limit = Time.now - 86400 * 30
+
+posts = bsky.fetch_all('com.atproto.repo.listRecords',
+  { repo: bsky.user.did, collection: 'app.bsky.feed.post' },
+  field: 'records',
+  max_pages: 10,
+  break_when: ->(x) { Time.parse(x['value']['createdAt']) < time_limit })
+```
+
+There is also a `progress` option you can use to print some kind of character for every page load. E.g. pass `progress: '.'` to print dots as the pages are loading:
+
+```rb
+likes = bsky.fetch_all('com.atproto.repo.listRecords',
+  { repo: bsky.user.did, collection: 'app.bsky.feed.like' },
+  field: 'records',
+  progress: '.')
+```
+
+This will output a line like this:
+
+```
+.................
+```
+
+You can find more examples in the [example](https://github.com/mackuba/minisky/tree/master/example) directory.
+
+
+## Customization
+
+The `Minisky` client currently supports one configuration option:
+
+- `default_progress` - a progress character to automatically use for `#fetch_all` calls (default: `nil`)
+
+Instead of using the `Minisky` class, you can also make your own class that includes the `Minisky::Requests` module and provides a different way to load & save the config, e.g. from a JSON file:
+
+```rb
+class BlueskyClient
+  include Minisky::Requests
+
+  attr_reader :config
+
+  def initialize(config_file)
+    @config_file = config_file
+    @config = JSON.parse(File.read(@config_file))
+  end
+
+  def host
+    'bsky.social'
+  end
+
+  def save_config
+    File.write(@config_file, JSON.pretty_generate(@config))
+  end
+end
+```
+
+It can then be used just like the `Minisky` class:
+
+```rb
+bsky = BlueskyClient.new('config/access.json')
+bsky.check_access
+bsky.get_request(...)
+```
+
+The class needs to provide:
+
+- a `host` method or property that returns the hostname of the server
+- a `config` property which returns a hash or a hash-like object with the configuration and user data - it needs to support reading and writing arbitrary key-value pairs with string keys
+- a `save_config` method which persists the config object to the chosen storage
 
-## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+## Credits
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Copyright © 2023 Kuba Suder ([@mackuba.eu](https://bsky.app/profile/mackuba.eu)).
 
-## Contributing
+The code is available under the terms of the [zlib license](https://choosealicense.com/licenses/zlib/) (permissive, similar to MIT).
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/minisky.
+Bug reports and pull requests are welcome 😎

data/example/fetch_my_posts.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+# Example: sync all posts from your account (excluding replies and reposts) to a local JSON file. When run again, it
+# will only fetch new posts since the last time and append them to the file.
+#
+# Requires a bluesky.yml config file in the same directory with contents like this:
+# id: your.handle
+# pass: secretpass
+
+# load minisky from a local folder - you normally won't need this
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'minisky'
+
+CONFIG_FILE = File.join(__dir__, 'bluesky.yml')
+POSTS_FILE = File.join(__dir__, 'posts.json')
+
+# create a client instance
+bsky = Minisky.new('bsky.social', CONFIG_FILE)
+
+# print progress dots when loading multiple pages
+bsky.default_progress = '.'
+
+# load previously saved posts; we will only fetch posts newer than the last saved before
+posts = File.exist?(POSTS_FILE) ? JSON.parse(File.read(POSTS_FILE)) : []
+latest_date = posts[0] && posts[0]['indexedAt']
+
+# fetch all posts from my timeline (without replies) until the target timestamp
+results = bsky.fetch_all('app.bsky.feed.getAuthorFeed',
+  { actor: bsky.user.did, filter: 'posts_no_replies', limit: 100 },
+  field: 'feed',
+  break_when: latest_date && proc { |x| x['post']['indexedAt'] <= latest_date }
+)
+
+# trim some data to save space
+new_posts = results.map { |x| x['post'] }
+  .reject { |x| x['author']['did'] != bsky.user.did }   # skip reposts
+  .map { |x| x.except('author') }                       # skip author profile info
+
+posts = new_posts + posts
+
+puts
+puts "Fetched #{new_posts.length} new posts (total = #{posts.length})"
+
+# save all new and old posts back to the file
+File.write(POSTS_FILE, JSON.pretty_generate(posts))

data/example/post_skeet.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+# Example: make a new post (aka "skeet") with text passed in the argument to the script.
+#
+# Requires a bluesky.yml config file in the same directory with contents like this:
+# id: your.handle
+# pass: secretpass
+
+# load minisky from a local folder - you normally won't need this
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'minisky'
+
+if ARGV[0].to_s.empty?
+  puts "Usage: #{$PROGRAM_NAME} <text>"
+  exit 1
+end
+
+text = ARGV[0]
+
+# create a client instance
+bsky = Minisky.new('bsky.social', File.join(__dir__, 'bluesky.yml'))
+
+bsky.post_request('com.atproto.repo.createRecord', {
+  repo: bsky.user.did,
+  collection: 'app.bsky.feed.post',
+  record: {
+    text: text,
+    langs: ["en"],
+    createdAt: Time.now.iso8601
+  }
+})
+
+puts "Posted ✓"

data/example/science_feed.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+# Example: load last 10 posts from the "What's Science" feed and print the post text, data and author handle to the
+# terminal. Does not require any authentication.
+#
+# It's definitely not the most efficient way to do this, but it demonstrates how to load single records from the API.
+
+# load minisky from a local folder - you normally won't need this
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'minisky'
+require 'time'
+
+# the "What's Science" custom feed by @bossett.bsky.social
+# the service host is hardcoded here, ideally you should fetch the feed record and read the hostname from there
+FEED_HOST = "bs.bossett.io"
+FEED_URI = "at://did:plc:jfhpnnst6flqway4eaeqzj2a/app.bsky.feed.generator/for-science"
+
+# fetch the feed from the feed server (getFeedSkeleton returns only a list or URIs of posts)
+# pass nil as the config file parameter to create an unauthenticated client
+feed_api = Minisky.new(FEED_HOST, nil)
+feed = feed_api.get_request('app.bsky.feed.getFeedSkeleton', { feed: FEED_URI, limit: 10 })
+
+# second client instance for the Bluesky API - again, pass nil to use without authentication
+bsky = Minisky.new('bsky.social', nil)
+
+# for each post URI, fetch the post record and the profile of its author
+entries = feed['feed'].map do |r|
+  # AT URI is always: at://<did>/<collection>/<rkey>
+  did, collection, rkey = r['post'].gsub('at://', '').split('/')
+
+  print '.'
+  post = bsky.get_request('com.atproto.repo.getRecord', { repo: did, collection: collection, rkey: rkey })
+  author = bsky.get_request('com.atproto.repo.describeRepo', { repo: did })
+
+  [post, author]
+end
+
+puts
+
+entries.each do |post, author|
+  handle = author['handle']
+  timestamp = Time.parse(post['value']['createdAt']).getlocal
+  link = "https://bsky.app/profile/#{handle}/post/#{post['uri'].split('/').last}"
+
+  puts "@#{handle} • #{timestamp} • #{link}"
+  puts
+  puts post['value']['text']
+  puts
+  puts "=" * 120
+  puts
+end

data/lib/minisky/errors.rb

@@ -0,0 +1,55 @@
+require_relative 'minisky'
+
+class Minisky
+  class Error < StandardError
+  end
+
+  class AuthError < Error
+    def initialize(message)
+      super(message)
+    end
+  end
+
+  class BadResponse < Error
+    attr_reader :status, :data
+
+    def initialize(status, status_message, data)
+      @status = status
+      @data = data
+
+      message = if error_message
+        "#{status} #{status_message}: #{error_message}"
+      else
+        "#{status} #{status_message}"
+      end
+
+      super(message)
+    end
+
+    def error_type
+      @data['error'] if @data.is_a?(Hash)
+    end
+
+    def error_message
+      @data['message'] if @data.is_a?(Hash)
+    end
+  end
+
+  class ClientErrorResponse < BadResponse
+  end
+
+  class ServerErrorResponse < BadResponse
+  end
+
+  class ExpiredTokenError < ClientErrorResponse
+  end
+
+  class UnexpectedRedirect < BadResponse
+    attr_reader :location
+
+    def initialize(status, status_message, location)
+      super(status, status_message, { 'message' => "Unexpected redirect: #{location}" })
+      @location = location
+    end
+  end
+end

data/lib/minisky/minisky.rb

@@ -1,102 +1,28 @@
-require 'json'
-require 'net/http'
-require 'open-uri'
 require 'yaml'
 
 class Minisky
-  CONFIG_FILE = 'bluesky.yml'
-
-  def initialize
-    @config = YAML.load(File.read(CONFIG_FILE))
-    @base_url = "https://#{@config['host']}/xrpc"
-  end
-
-  def my_id
-    @config['ident']
-  end
-
-  def my_did
-    @config['did']
-  end
-
-  def access_token
-    @config['access_token']
-  end
-
-  def refresh_token
-    @config['refresh_token']
-  end
-
-  def save_config
-    File.write(CONFIG_FILE, YAML.dump(@config))
-  end
-
-  def log_in
-    json = post_request('com.atproto.server.createSession', {
-      identifier: @config['ident'],
-      password: @config['pass']
-    })
-
-    @config['did'] = json['did']
-    @config['access_token'] = json['accessJwt']
-    @config['refresh_token'] = json['refreshJwt']
-    save_config
-  end
-
-  def perform_token_refresh
-    json = post_request('com.atproto.server.refreshSession', nil, refresh_token)
-    @config['access_token'] = json['accessJwt']
-    @config['refresh_token'] = json['refreshJwt']
-    save_config
-  end
-
-  def fetch_all(method, params, auth = nil, field:, break_when: ->(x) { false }, progress: true)
-    data = []
-
-    loop do
-      print '.' if progress
-
-      response = get_request(method, params, auth)
-      records = response[field]
-      cursor = response['cursor']
-
-      data.concat(records)
-      params[:cursor] = cursor
-
-      break if cursor.nil? || records.empty? || records.any? { |x| break_when.call(x) }
+  attr_reader :host, :config
+
+  def initialize(host, config_file)
+    @host = host
+    @config_file = config_file
+
+    if @config_file
+      @config = YAML.load(File.read(@config_file))
+
+      if user.id.nil? || user.pass.nil?
+        raise AuthError, "Missing user id or password in the config file #{@config_file}"
+      end
+    else
+      @config = {}
+      @send_auth_headers = false
+      @auto_manage_tokens = false
     end
-
-    data.reject { |x| break_when.call(x) }
   end
 
-  def get_request(method, params = nil, auth = nil)
-    headers = {}
-    headers['Authorization'] = "Bearer #{auth}" if auth
-
-    url = "#{@base_url}/#{method}"
-
-    if params && !params.empty?
-      url += "?" + params.map { |k, v|
-        if v.is_a?(Array)
-          v.map { |x| "#{k}=#{x}" }.join('&')
-        else
-          "#{k}=#{v}"
-        end
-      }.join('&')
-    end
-
-    JSON.parse(URI.open(url, headers).read)
-  end
-
-  def post_request(method, params, auth = nil)
-    headers = { "Content-Type" => "application/json" }
-    headers['Authorization'] = "Bearer #{auth}" if auth
-
-    body = params ? params.to_json : ''
-
-    response = Net::HTTP.post(URI("#{@base_url}/#{method}"), body, headers)
-    raise "Invalid response: #{response.code} #{response.body}" if response.code.to_i / 100 != 2
-
-    JSON.parse(response.body)
+  def save_config
+    File.write(@config_file, YAML.dump(@config)) if @config_file
   end
 end
+
+require_relative 'requests'

data/lib/minisky/requests.rb

@@ -0,0 +1,212 @@
+require_relative 'minisky'
+require_relative 'errors'
+
+require 'base64'
+require 'json'
+require 'net/http'
+require 'time'
+require 'uri'
+
+class Minisky
+  class User
+    def initialize(config)
+      @config = config
+    end
+
+    def logged_in?
+      !!(access_token && refresh_token)
+    end
+
+    def method_missing(name, *args)
+      if name.end_with?('=')
+        @config[name.to_s.chop] = args[0]
+      else
+        @config[name.to_s]
+      end
+    end
+  end
+
+  module Requests
+    attr_accessor :default_progress
+    attr_writer :send_auth_headers
+    attr_writer :auto_manage_tokens
+
+    def send_auth_headers
+      instance_variable_defined?('@send_auth_headers') ? @send_auth_headers : true
+    end
+
+    def auto_manage_tokens
+      instance_variable_defined?('@auto_manage_tokens') ? @auto_manage_tokens : true
+    end
+
+    def base_url
+      @base_url ||= "https://#{host}/xrpc"
+    end
+
+    def user
+      @user ||= User.new(config)
+    end
+
+    def get_request(method, params = nil, auth: default_auth_mode)
+      check_access if auto_manage_tokens && auth == true
+
+      headers = authentication_header(auth)
+      url = URI("#{base_url}/#{method}")
+
+      if params && !params.empty?
+        url.query = URI.encode_www_form(params)
+      end
+
+      response = Net::HTTP.get_response(url, headers)
+      handle_response(response)
+    end
+
+    def post_request(method, params = nil, auth: default_auth_mode)
+      check_access if auto_manage_tokens && auth == true
+
+      headers = authentication_header(auth).merge({ "Content-Type" => "application/json" })
+      body = params ? params.to_json : ''
+
+      response = Net::HTTP.post(URI("#{base_url}/#{method}"), body, headers)
+      handle_response(response)
+    end
+
+    def fetch_all(method, params = nil, field:,
+                  auth: default_auth_mode, break_when: nil, max_pages: nil, progress: @default_progress)
+      data = []
+      params = {} if params.nil?
+      pages = 0
+
+      loop do
+        print(progress) if progress
+
+        response = get_request(method, params, auth: auth)
+        records = response[field]
+        cursor = response['cursor']
+
+        data.concat(records)
+        params[:cursor] = cursor
+        pages += 1
+
+        break if !cursor || records.empty? || pages == max_pages
+        break if break_when && records.any? { |x| break_when.call(x) }
+      end
+
+      data.delete_if { |x| break_when.call(x) } if break_when
+      data
+    end
+
+    def check_access
+      if !user.logged_in?
+        log_in
+      elsif token_expiration_date(user.access_token) < Time.now + 60
+        perform_token_refresh
+      end
+    end
+
+    def log_in
+      if user.id.nil? || user.pass.nil?
+        raise AuthError, "To log in, please provide a user id and password"
+      end
+
+      data = {
+        identifier: user.id,
+        password: user.pass
+      }
+
+      json = post_request('com.atproto.server.createSession', data, auth: false)
+
+      user.did = json['did']
+      user.access_token = json['accessJwt']
+      user.refresh_token = json['refreshJwt']
+
+      save_config
+      json
+    end
+
+    def perform_token_refresh
+      if user.refresh_token.nil?
+        raise AuthError, "Can't refresh access token - refresh token is missing"
+      end
+
+      json = post_request('com.atproto.server.refreshSession', auth: user.refresh_token)
+
+      user.access_token = json['accessJwt']
+      user.refresh_token = json['refreshJwt']
+
+      save_config
+      json
+    end
+
+    def reset_tokens
+      user.access_token = nil
+      user.refresh_token = nil
+      save_config
+      nil
+    end
+
+    private
+
+    def default_auth_mode
+      !!send_auth_headers
+    end
+
+    def authentication_header(auth)
+      if auth.is_a?(String)
+        { 'Authorization' => "Bearer #{auth}" }
+      elsif auth
+        if user.access_token
+          { 'Authorization' => "Bearer #{user.access_token}" }
+        else
+          raise AuthError, "Can't send auth headers, access token is missing"
+        end
+      else
+        {}
+      end
+    end
+
+    def token_expiration_date(token)
+      parts = token.split('.')
+      raise AuthError, "Invalid access token format" unless parts.length == 3
+
+      begin
+        payload = JSON.parse(Base64.decode64(parts[1]))
+      rescue JSON::ParserError
+        raise AuthError, "Couldn't decode payload from access token"
+      end
+
+      exp = payload['exp']
+      raise AuthError, "Invalid token expiry data" unless exp.is_a?(Numeric) && exp > 0
+
+      Time.at(exp)
+    end
+
+    def handle_response(response)
+      status = response.code.to_i
+      message = response.message
+
+      case response
+      when Net::HTTPSuccess
+        JSON.parse(response.body)
+      when Net::HTTPRedirection
+        raise UnexpectedRedirect.new(status, message, response['location'])
+      else
+        data = (response.content_type == 'application/json') ? JSON.parse(response.body) : response.body
+
+        error_class = if data.is_a?(Hash) && data['error'] == 'ExpiredToken'
+          ExpiredTokenError
+        elsif response.is_a?(Net::HTTPClientError)
+          ClientErrorResponse
+        elsif response.is_a?(Net::HTTPServerError)
+          ServerErrorResponse
+        else
+          BadResponse
+        end
+
+        raise error_class.new(status, message, data)
+      end
+    end
+  end
+
+  include Requests
+end

data/lib/minisky/version.rb

@@ -1,5 +1,5 @@
 require_relative 'minisky'
 
 class Minisky
-  VERSION = "0.0.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minisky
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Kuba Suder
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-30 00:00:00.000000000 Z
+date: 2023-10-05 00:00:00.000000000 Z
 dependencies: []
 description: A very simple client class that lets you log in to the Bluesky API and
   make any requests there.
@@ -21,8 +21,13 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- example/fetch_my_posts.rb
+- example/post_skeet.rb
+- example/science_feed.rb
 - lib/minisky.rb
+- lib/minisky/errors.rb
 - lib/minisky/minisky.rb
+- lib/minisky/requests.rb
 - lib/minisky/version.rb
 - sig/minisky.rbs
 homepage: https://github.com/mackuba/minisky