moostodon 0.1.0

data/lib/mastodon/rest/search.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'mastodon/rest/utils'
+require 'mastodon/status'
+
+module Mastodon
+  module REST
+    module Search
+      include Mastodon::REST::Utils
+
+      # Search for content
+      # @param options [Hash]
+      # @option options :q [String] The search query
+      # @option options :resolve [Boolean] Whether to resolve non-local accounts
+      # @return [Mastodon::Results] If q is a URL, Mastodon will
+      #   attempt to fetch the provided account or status. Otherwise, it
+      #   will do a local account and hashtag search.
+      def search(query, options = {})
+        opts = {
+          q: query
+        }.merge(options)
+
+        perform_request_with_object(:get, '/api/v1/search', opts,
+                                    Mastodon::Results)
+      end
+    end
+  end
+end

data/lib/mastodon/rest/statuses.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'mastodon/rest/utils'
+require 'mastodon/status'
+
+module Mastodon
+  module REST
+    module Statuses
+      include Mastodon::REST::Utils
+
+      # @overload create_status(text, in_reply_to_id, media_ids, visibility)
+      #   Create new status
+      # @param text [String]
+      # @param in_reply_to_id [Integer]
+      # @param media_ids [Array<Integer>]
+      # @param visibility [String]
+      # @return [Mastodon::Status]
+      # @overload create_status(text, args)
+      #   Create new status
+      # @param text [String]
+      # @param options [Hash]
+      # @option options :in_reply_to_id [Integer]
+      # @option options :media_ids [Array<Integer>]
+      # @option options :visibility [String]
+      # @return <Mastodon::Status>
+      def create_status(text, *args)
+        params = normalize_status_params(*args)
+        params[:status] = text
+        params['media_ids[]'] ||= params.delete(:media_ids)
+
+        perform_request_with_object(:post, '/api/v1/statuses',
+                                    params, Mastodon::Status)
+      end
+
+      # Retrieve status
+      # @param id [Integer]
+      # @return [Mastodon::Status]
+      def status(id)
+        perform_request_with_object(:get, "/api/v1/statuses/#{id}",
+                                    {}, Mastodon::Status)
+      end
+
+      # Destroy status
+      # @param id [Integer]
+      # @return [Boolean]
+      def destroy_status(id)
+        !perform_request(:delete, "/api/v1/statuses/#{id}").nil?
+      end
+
+      # Reblog a status
+      # @param id [Integer]
+      # @return [Mastodon::Status]
+      def reblog(id)
+        perform_request_with_object(:post, "/api/v1/statuses/#{id}/reblog",
+                                    {}, Mastodon::Status)
+      end
+
+      # Undo a reblog of a status
+      # @param id [Integer]
+      # @return [Mastodon::Status]
+      def unreblog(id)
+        perform_request_with_object(:post, "/api/v1/statuses/#{id}/unreblog",
+                                    {}, Mastodon::Status)
+      end
+
+      # Favourite a status
+      # @param id [Integer]
+      # @return [Mastodon::Status]
+      def favourite(id)
+        perform_request_with_object(:post, "/api/v1/statuses/#{id}/favourite",
+                                    {}, Mastodon::Status)
+      end
+
+      # Undo a favourite of a status
+      # @param id [Integer]
+      # @return [Mastodon::Status]
+      def unfavourite(id)
+        perform_request_with_object(:post,
+                                    "/api/v1/statuses/#{id}/unfavourite",
+                                    {}, Mastodon::Status)
+      end
+
+      # Get a list of accounts that reblogged a toot
+      # @param id [Integer]
+      # @param options [Hash]
+      # @return [Mastodon::Collection<Mastodon::Account>]
+      def reblogged_by(id, options = {})
+        perform_request_with_collection(:get,
+                                        "/api/v1/statuses/#{id}/reblogged_by",
+                                        options, Mastodon::Account)
+      end
+
+      # Get a list of accounts that favourited a toot
+      # @param id [Integer]
+      # @param options [Hash]
+      # @return [Mastodon::Collection<Mastodon::Account>]
+      def favourited_by(id, options = {})
+        perform_request_with_collection(:get,
+                                        "/api/v1/statuses/#{id}/favourited_by",
+                                        options, Mastodon::Account)
+      end
+
+      # Get a list of statuses by a user
+      # @param account_id [Integer]
+      # @param options [Hash]
+      # @option options :max_id [Integer]
+      # @option options :since_id [Integer]
+      # @option options :limit [Integer]
+      # @return [Mastodon::Collection<Mastodon::Status>]
+      def statuses(account_id, options = {})
+        url = "/api/v1/accounts/#{account_id}/statuses"
+        perform_request_with_collection(:get, url, options, Mastodon::Status)
+      end
+
+      private
+
+      def normalize_status_params(*args)
+        if args.length == 1 && args.first.is_a?(Hash)
+          args.shift
+        else
+          {
+            in_reply_to_id: args.shift,
+            'media_ids[]' => args.shift,
+            visibility: args.shift
+          }
+        end
+      end
+    end
+  end
+end

data/lib/mastodon/rest/suggestions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'mastodon/rest/utils'
+require 'mastodon/account'
+
+module Mastodon
+  module REST
+    module Suggestions
+      include Mastodon::REST::Utils
+
+      # Get "who to follow" suggestions for authenticated user
+      # @return [Mastodon::Collection<Mastodon::Account>]
+      def suggestions
+        perform_request_with_collection(:get, '/api/v1/accounts/suggestions',
+                                        {}, Mastodon::Account)
+      end
+    end
+  end
+end

data/lib/mastodon/rest/timelines.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'mastodon/rest/utils'
+require 'mastodon/status'
+
+module Mastodon
+  module REST
+    module Timelines
+      include Mastodon::REST::Utils
+
+      # Retrieve statuses from the home timeline
+      # @param options [Hash]
+      # @option options :max_id [Integer]
+      # @option options :since_id [Integer]
+      # @option options :limit [Integer]
+      # @return [Mastodon::Collection<Mastodon::Status>]
+      def home_timeline(options = {})
+        perform_request_with_collection(:get, '/api/v1/timelines/home',
+                                        options, Mastodon::Status)
+      end
+
+      # Retrieve statuses from the public timeline
+      # @param options [Hash]
+      # @option options :max_id [Integer]
+      # @option options :since_id [Integer]
+      # @option options :limit [Integer]
+      # @return [Mastodon::Collection<Mastodon::Status>]
+      def public_timeline(options = {})
+        perform_request_with_collection(:get, '/api/v1/timelines/public',
+                                        options, Mastodon::Status)
+      end
+
+      # Retrieve statuses from a hashtag
+      # @param hashtag [String]
+      # @param options [Hash]
+      # @option options :max_id [Integer]
+      # @option options :since_id [Integer]
+      # @option options :limit [Integer]
+      # @return [Mastodon::Collection<Mastodon::Status>]
+      def hashtag_timeline(hashtag, options = {})
+        perform_request_with_collection(:get,
+                                        "/api/v1/timelines/tag/#{hashtag}",
+                                        options, Mastodon::Status)
+      end
+    end
+  end
+end

data/lib/mastodon/rest/utils.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'mastodon/rest/request'
+
+module Mastodon
+  module REST
+    module Utils
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param options [Hash]
+      def perform_request(request_method, path, options = {})
+        Mastodon::REST::Request.new(self, request_method, path, options).perform
+      end
+
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param options [Hash]
+      # @param klass [Class]
+      def perform_request_with_object(request_method, path, options, klass)
+        response = perform_request(request_method, path, options)
+        klass.new(response)
+      end
+
+      # @param request_method [Symbol]
+      # @param path [String]
+      # @param options [Hash]
+      # @param klass [Class]
+      def perform_request_with_collection(request_method, path, options, klass)
+        response = perform_request(request_method, path, options)
+        Mastodon::Collection.new(response, klass)
+      end
+
+      # Format an array of values into a query param
+      # @param key [Symbol]
+      # @param values [Enumerable]
+      # @return [Array]
+      def array_param(key, values)
+        values.map.with_index { |value, _i| ["#{key}[]", value] }
+      end
+    end
+  end
+end

data/lib/mastodon/results.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'mastodon/account'
+require 'mastodon/status'
+
+module Mastodon
+  class Results < Mastodon::Base
+    # @!attribute [r] accounts
+    #   @return [Mastodon::Collection<Mastodon::Account>]
+    # @!attribute [r] statuses
+    #   @return [Mastodon::Collection<Mastodon::Status>]
+    # @!attribute [r] hashtags
+    #   @return [Mastodon::Collection<String>]
+
+    collection_attr_reader :accounts, Mastodon::Account
+    collection_attr_reader :statuses, Mastodon::Status
+    collection_attr_reader :hashtags, String
+  end
+end

data/lib/mastodon/status.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'mastodon/account'
+require 'mastodon/entities/media'
+require 'mastodon/entities/mention'
+require 'mastodon/entities/app'
+require 'mastodon/entities/hashtag'
+require 'mastodon/emoji'
+
+module Mastodon
+  class Status < Mastodon::Base
+    # @!attribute [r] id
+    #   @return [String]
+    # @!attribute [r] in_reply_to_id
+    #   @return [String]
+    # @!attribute [r] in_reply_to_account_id
+    #   @return [String]
+    # @!attribute [r] spoiler_text
+    #   @return [String]
+    # @!attribute [r] content
+    #   @return [String]
+    # @!attribute [r] url
+    #   @return [String]
+    # @!attribute [r] uri
+    #   @return [String]
+    # @!attribute [r] created_at
+    #   @return [String]
+    # @!attribute [r] reblogs_count
+    #   @return [Integer]
+    # @!attribute [r] favourites_count
+    #   @return [Integer]
+    # @!attribute [r] visibility
+    #   @return [String]
+    # @!attribute [r] language
+    #   @return [String]
+    # @!attribute [r] account
+    #   @return [Mastodon::Account]
+    # @!attribute [r] reblog
+    #   @return [Mastodon::Status]
+    # @!attribute [r] application
+    #   @return [Mastodon::Entities::App]
+    # @!attribute [r] favourited?
+    #   @return [Boolean]
+    # @!attribute [r] reblogged?
+    #   @return [Boolean]
+    # @!attribute [r] sensitive?
+    #   @return [Boolean]
+    # @!attribute [r] muted?
+    #   @return [Boolean]
+    # @!attribute [r] pinned?
+    #   @return [Boolean]
+    # @!attribute [r] media_attachments
+    #   @return [Mastodon::Collection<Mastodon::Entities::Media>]
+    # @!attribute [r] mentions
+    #   @return [Mastodon::Collection<Mastodon::Entities::Mention>]
+    # @!attribute [r] tags
+    #   @return [Mastodon::Collection<Mastodon::Entities::Hashtag>]
+    # @!attribute [r] emojis
+    #   @return [Mastodon::Collection<Mastodon::Emoji>]
+
+    normal_attr_reader :id,
+                       :content,
+                       :in_reply_to_id,
+                       :in_reply_to_account_id,
+                       :url,
+                       :uri,
+                       :created_at,
+                       :reblogs_count,
+                       :favourites_count,
+                       :visibility,
+                       :spoiler_text,
+                       :language
+
+    predicate_attr_reader :favourited,
+                          :reblogged,
+                          :sensitive,
+                          :muted,
+                          :pinned
+
+    object_attr_reader :account, Mastodon::Account
+    object_attr_reader :reblog, Mastodon::Status
+    object_attr_reader :application, Mastodon::Entities::App
+
+    collection_attr_reader :media_attachments, Mastodon::Entities::Media
+    collection_attr_reader :mentions, Mastodon::Entities::Mention
+    collection_attr_reader :emojis, Mastodon::Emoji
+    collection_attr_reader :tags, Mastodon::Entities::Hashtag
+
+    def initialize(attributes = {})
+      attributes.fetch('id')
+      super
+    end
+  end
+end

data/lib/mastodon/streaming/client.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'http/request'
+require 'mastodon/client'
+require 'mastodon/streaming/connection'
+require 'mastodon/streaming/deleted_status'
+require 'mastodon/streaming/message_parser'
+require 'mastodon/streaming/response'
+
+module Mastodon
+  module Streaming
+    # Streaming client class, to handle all streaming purposes.
+    class Client < Mastodon::Client
+      attr_writer :connection
+
+      # Initializes a new Client object
+      #
+      # @param options [Hash] A customizable set of options.
+      # @option options [String] :tcp_socket_class A class that Connection will
+      #  use to create a new TCP socket.
+      # @option options [String] :ssl_socket_class A class that Connection will
+      #  use to create a new SSL socket.
+      # @return [Mastodon::Streaming::Client]
+      def initialize(options = {})
+        super
+        options[:using_ssl] ||= base_url =~ /^https/
+        @connection = Streaming::Connection.new(options)
+      end
+
+      # Streams messages for a single user
+      #
+      # @yield [Mastodon::Status, Mastodon::Notification,
+      # Mastodon::Streaming::DeletedStatus] A stream of Mastodon objects.
+      def user(options = {}, &block)
+        stream('user', options, &block)
+      end
+
+      # Returns statuses that contain the specified hashtag
+      #
+      # @yield [Mastodon::Status, Mastodon::Notification,
+      # Mastodon::Streaming::DeletedStatus] A stream of Mastodon objects.
+      def hashtag(tag, options = {}, &block)
+        options['tag'] = tag
+        stream('hashtag', options, &block)
+      end
+
+      # Returns all public statuses
+      #
+      # @yield [Mastodon::Status, Mastodon::Notification,
+      # Mastodon::Streaming::DeletedStatus] A stream of Mastodon objects.
+      def firehose(options = {}, &block)
+        stream('public', options, &block)
+      end
+
+      #
+      # Calls an arbitrary streaming endpoint and returns the results
+      # @yield [Mastodon::Status, Mastodon::Notification,
+      # Mastodon::Streaming::DeletedStatus] A stream of Mastodon objects.
+      def stream(path, options = {}, &block)
+        request(:get, "/api/v1/streaming/#{path}", options, &block)
+      end
+
+      # Set a Proc to be run when connection established.
+      def before_request(&block)
+        if block_given?
+          @before_request = block
+          self
+        elsif instance_variable_defined?(:@before_request)
+          @before_request
+        else
+          proc {}
+        end
+      end
+
+      private
+
+      def request(method, path, params)
+        before_request.call
+        uri = Addressable::URI.parse(base_url + path)
+
+        headers = Mastodon::Headers.new(self).request_headers
+
+        request = HTTP::Request.new(verb: method,
+                                    uri: "#{uri}?#{to_url_params(params)}",
+                                    headers: headers)
+        response = Streaming::Response.new do |type, data|
+          # rubocop:disable AssignmentInCondition
+          if item = Streaming::MessageParser.parse(type, data)
+            yield(item)
+          end
+          # rubocop:enable AssignmentInCondition
+        end
+        @connection.stream(request, response)
+      end
+
+      def to_url_params(params)
+        uri = Addressable::URI.new
+        uri.query_values = params
+        uri.query
+      end
+    end
+  end
+end