weeb 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9d900a7f70e3ae873dbb55e26a6f24feeef6981f
+  data.tar.gz: 5af3916cb1ded4612981e94edb9e99a46763e029
+SHA512:
+  metadata.gz: 5a596fd7ec93ff32b3182a89439a5576b7f82192c70c87d0515ecd6719a87a7f000ff7f9f47524c2afc883c27c8a6236c89d8aba4ae5efa49e58bcc323bb0042
+  data.tar.gz: f6e6029ed3a7a0cf1d7e63fb556356494ccd81196692cc5208e78bf90583e2256da9c18b1aa419d1d7a2ba29b0047c507816e5f7a622c467c1a8ee0ffa993892

data/lib/weeb.rb

@@ -0,0 +1 @@
+require 'weeb/interfaces/client'

data/lib/weeb/api.rb

@@ -0,0 +1,54 @@
+require 'weeb/err'
+require 'weeb/ver'
+require 'uri'
+require 'json'
+require 'rest-client'
+
+module WeebSh
+  module API
+
+    module_function
+
+    def request(type, *attributes)
+      parse_json(RestClient.send(type, *attributes))
+    rescue RestClient::RequestEntityTooLarge
+      raise WeebSh::Err::TooLarge, 'Requested files are too large!'
+    rescue RestClient::Unauthorized => e
+      json = parse_json(e.response)
+      if json.is_a?(Hash)
+        raise WeebSh::Err::BadAuth, 'Token is invalid!' if json['message'] == 'Unauthorized'
+      end
+    rescue RestClient::BadRequest => e
+      json = parse_json(e.response)
+      if json.is_a?(Hash)
+        raise WeebSh::Err::InvalidMIME, json['message'] if json['message'].start_with? 'The mimetype' and json['message'].end_with? 'is not supported'
+        raise WeebSh::Err::TagExists, json['message'] if json['message'] == 'Tags existed already or had no content'
+        raise WeebSh::Err::ImagePrivate, json['message'] if json['message'] == 'This image is private'
+        raise WeebSh::Err::InvalidImage, json['message'] if json['message'] == 'No image found for your query'
+      end
+      raise e
+    rescue RestClient::Forbidden => e
+      json = parse_json(e.response)
+      if json.is_a?(Hash)
+        raise WeebSh::Err::MissingScope, json['message'] if json['message'].start_with? 'missing scope'
+      end
+      raise e
+    rescue RestClient::InternalServerError
+      raise WeebSh::Err::ServerFail, 'Server Error!'
+    rescue RuntimeError => e
+      raise e
+    end
+
+    def format_user_agent(user_agent)
+      user_agent = "#{user_agent['botname']}/#{user_agent['version']}#{"/#{user_agent['env']}" if user_agent['env']}" if user_agent.is_a?(Hash)
+      return nil unless user_agent.is_a?(String) && !user_agent.empty?
+      user_agent
+    end
+
+    def parse_json(raw)
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      raw
+    end
+  end
+end

data/lib/weeb/api/korra.rb

@@ -0,0 +1,13 @@
+require 'weeb/api'
+require 'uri'
+
+module WeebSh
+  module API
+    module Korra
+      BASE = '/auto-image'.freeze
+
+      module_function
+
+    end
+  end
+end

data/lib/weeb/api/shimakaze.rb

@@ -0,0 +1,13 @@
+require 'weeb/api'
+require 'uri'
+
+module WeebSh
+  module API
+    module Shimakaze
+      BASE = '/reputation'.freeze
+
+      module_function
+
+    end
+  end
+end

data/lib/weeb/api/tama.rb

@@ -0,0 +1,13 @@
+require 'weeb/api'
+require 'uri'
+
+module WeebSh
+  module API
+    module Tama
+      BASE = '/settings'.freeze
+
+      module_function
+
+    end
+  end
+end

data/lib/weeb/api/toph.rb

@@ -0,0 +1,147 @@
+require 'weeb/api'
+require 'uri'
+
+module WeebSh
+  module API
+    module Toph
+      BASE = '/images'.freeze
+
+      module_function
+
+      def upload(i, resource, type, hidden, tags, nsfw, source)
+        resource.is_a?(File) ? WeebSh::API.request(
+          :post,
+          "#{i.api_url}#{BASE}/upload",
+          {
+            'file'.to_sym => resource,
+            'baseType'.to_sym => type,
+            'hidden'.to_sym => hidden,
+            'tags'.to_sym => tags,
+            'nsfw'.to_sym => nsfw,
+            'source'.to_sym => source
+          },
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        ) : WeebSh::API.request(
+          :post,
+          "#{i.api_url}#{BASE}/upload",
+          {
+            url: resource,
+            baseType: type,
+            hidden: hidden,
+            tags: tags,
+            nsfw: nsfw,
+            source: source
+          }.to_json,
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+
+      def types(i, query)
+        WeebSh::API.request(
+          :get,
+          "#{i.api_url}#{BASE}/types?#{URI.encode_www_form(query)}",
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+
+      def tags(i, query)
+        WeebSh::API.request(
+          :get,
+          "#{i.api_url}#{BASE}/tags?#{URI.encode_www_form(query)}",
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+
+      def random(i, query)
+        WeebSh::API.request(
+          :get,
+          "#{i.api_url}#{BASE}/random?#{URI.encode_www_form(query)}",
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+
+      def image(i, id)
+        WeebSh::API.request(
+          :get,
+          "#{i.api_url}#{BASE}/info/#{id}",
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+
+      def add_tags_to_image(i, id, tags)
+        WeebSh::API.request(
+          :post,
+          "#{i.api_url}#{BASE}/info/#{id}",
+          { tags: tags }.to_json,
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+
+      def remove_tags_to_image(i, id, tags)
+        WeebSh::API.request(
+          :delete,
+          "#{i.api_url}#{BASE}/info/#{id}",
+          { tags: tags }.to_json,
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+
+      def remove_image(i, id)
+        WeebSh::API.request(
+          :delete,
+          "#{i.api_url}#{BASE}/info/#{id}",
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+
+      def list(i, query)
+        WeebSh::API.request(
+          :get,
+          "#{i.api_url}#{BASE}/list?#{URI.encode_www_form(query)}",
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+
+      def list_user(i, id, query)
+        WeebSh::API.request(
+          :get,
+          "#{i.api_url}#{BASE}/list/#{id}?#{URI.encode_www_form(query)}",
+          {
+            Authorization: i.auth,
+            'User-Agent': i.user_agent
+          }
+        )
+      end
+    end
+  end
+end

data/lib/weeb/data.rb

@@ -0,0 +1,177 @@
+require 'weeb/api'
+
+module WeebSh
+  # Mixin for objects with IDs
+  module IDObject
+    # @return [String] the ID which uniquely identifies this object in toph.
+    attr_reader :id
+    alias_method :resolve_id, :id
+    alias_method :hash, :id
+
+    # ID based comparison
+    def ==(other)
+      other.respond_to?(:resolve_id) ? (@id.resolve_id == other.resolve_id) : (@id == other)
+    end
+  end
+
+  # Represents a generic interface
+  class Interface
+    # @return [String] the authorization used in weeb.sh.
+    attr_accessor :auth
+
+    # @return [String] the user agent used in weeb.sh.
+    attr_accessor :user_agent
+
+    # @return [String] the URL being used for weeb.sh.
+    attr_reader :api_url
+
+    # @param token [String] the token required to use weeb.sh.
+    # @param user_agent [String, Hash] the user agent to use on endpoints.
+    # @param api_url [String] the URL to use when using the weeb.sh API.
+    def initialize(auth, user_agent = nil, api_url: 'https://api.weeb.sh', client: nil)
+      @user_agent = WeebSh::API.format_user_agent(user_agent)
+      @auth = auth
+      @api_url = api_url
+      @client = client
+
+      return if client
+      raise WeebSh::Err::BadAuth, 'Authorization is empty!' if auth.empty?
+      puts "[#{self.class.name}] Your User Agent is empty. Please consider adding a user agent to help identify issues easier." if user_agent.nil?
+      puts "[#{self.class.name}] Your User Agent is not ideal. Please consider adding a user agent to help identify issues easier." if !user_agent.nil? && user_agent.split('/').count < 2
+    end
+
+    def inspect
+      "#<#{self.class.name} @api_url=#{@api_url.inspect} @user_agent=#{@user_agent.inspect}>"
+    end
+  end
+
+  # Represents a preview image for toph
+  class PreviewImage
+    include IDObject
+
+    # @return [Symbol] the type of image this is
+    attr_reader :type
+
+    # @return [String] the file extension of the image
+    attr_reader :file_type
+
+    # @return [String] the url of the image
+    attr_reader :url
+
+    # @!visibility private
+    def initialize(data, interface)
+      @interface = interface
+      @id = data['id']
+      @type = data['type']
+      @file_type = data['fileType']
+      @url = data['url']
+    end
+
+    def inspect
+      "#<WeebSh::PreviewImage @url=#{@url.inspect} @type=#{@type.inspect}>"
+    end
+  end
+
+  # Represents an image for toph
+  class WeebImage < PreviewImage
+
+    # @return [true, false] whether or not this image is nsfw
+    attr_reader :nsfw
+    alias_method :nsfw?, :nsfw
+
+    # @return [String] the mime type of the image
+    attr_reader :mime_type
+
+    # @return [Array<String>] the tags on image
+    attr_reader :tags
+
+    # @return [true, false] whether or not this image can only be seen by the uploader
+    attr_reader :hidden
+    alias_method :hidden?, :hidden
+
+    # @return [String, nil] the source of the image
+    attr_reader :source
+
+    # @return [String] the ID of the uploader
+    attr_reader :account
+    alias_method :uploader, :account
+    alias_method :author, :account
+
+    # @!visibility private
+    def initialize(data, interface)
+      @interface = interface
+      @id = data['id']
+      @type = data['type']
+      @nsfw = data['nsfw']
+      @file_type = data['fileType']
+      @mime_type = data['mimeType']
+      @url = data['url']
+      @hidden = data['hidden']
+      @file_type = data['fileType']
+      @source = data['source'] || nil
+      @account = data['account']
+      @tags = data['tags'].map { |r| Tag.new(r, interface) }
+    end
+
+    # Add tags to the image
+    # @param tags [Array<String, Tag>] the affected tags
+    def add_tags(tags)
+      @interface.add_tags_to_image(self, tags)
+    end
+
+    # Remove tags from the image
+    # @param tags [Array<String, Tag>] the affected tags
+    def remove_tags(tags)
+      @interface.remove_tags_to_image(self, tags)
+    end
+
+    # Add a tag to the image
+    # @param tag [String, Tag] the affected tag
+    def add_tag(tag)
+      @interface.add_tags_to_image(self, [tag])
+    end
+
+    # Remove a tag to the image
+    # @param tags [String, Tag] the affected tag
+    def remove_tag(tag)
+      @interface.remove_tags_to_image(self, [tag])
+    end
+
+    # Delete this image
+    def delete()
+      @interface.delete_image(self)
+    end
+    alias_method :remove, :delete
+
+    def inspect
+      "#<WeebSh::WeebImage @url=#{@url.inspect} @type=#{@type.inspect} @nsfw=#{@nsfw.inspect}>"
+    end
+  end
+
+  # Represents an Image tag for toph
+  class Tag
+    # @return [String] the name of the tag
+    attr_reader :name
+
+    # @return [true, false] whether or not this tag can only be seen by the uploader
+    attr_reader :hidden
+    alias_method :hidden?, :hidden
+
+    # @return [String] the ID of the creator
+    attr_reader :account
+    alias_method :creator, :account
+    alias_method :author, :account
+
+    # @!visibility private
+    def initialize(data, interface)
+      @interface = interface
+      @name = data['name']
+      @hidden = data['hidden']
+      @account = data['account']
+    end
+
+    def inspect
+      "#<WeebSh::Tag @name=#{@name.inspect} @hidden=#{@hidden.inspect} @account=#{@account.inspect}>"
+    end
+  end
+end

data/lib/weeb/err.rb

@@ -0,0 +1,60 @@
+module WeebSh
+  # Custom errors raised in various places
+  module Err
+    # Raised when a token is invalid or incorrect.
+    class BadAuth < RuntimeError
+      def message
+        'Token invalid'
+      end
+    end
+
+    # Raised when too many files were uploaded.
+    class MissingScope < RuntimeError
+      def message
+        'Too many files requested!'
+      end
+    end
+
+    # Raised when a server error occurs
+    class ServerFail < RuntimeError
+      def message
+        'Server tried to do a thing and borked!'
+      end
+    end
+
+    # Raised when requested file(s) have too much bytes.
+    class TooLarge < RuntimeError
+      def message
+        'File(s) are too large!'
+      end
+    end
+
+    # Raised when an invalid mime type was given.
+    class InvalidMIME < RuntimeError
+      def message
+        'You gave an unsupported MIME type!'
+      end
+    end
+
+    # Raised when trying to add an existing tag to an image
+    class TagExists < RuntimeError
+      def message
+        'Tags existed already or had no content!'
+      end
+    end
+
+    # Raised when trying to interact with a non-existant image
+    class InvalidImage < RuntimeError
+      def message
+        'Non-existant image!'
+      end
+    end
+
+    # Raised when loading a file recieves an error
+    class FileError < RuntimeError
+      def message
+        'Unknown'
+      end
+    end
+  end
+end

data/lib/weeb/interfaces/client.rb

@@ -0,0 +1,82 @@
+require 'weeb/interfaces/toph'
+require 'weeb/interfaces/korra'
+require 'weeb/interfaces/shimakaze'
+require 'weeb/interfaces/tama'
+
+module WeebSh
+  class Client
+    # @return [String] the authorization used in weeb.sh.
+    attr_reader :auth
+
+    # @return [String] the user agent used in weeb.sh.
+    attr_reader :user_agent
+
+    # @return [String] the URL being used for weeb.sh.
+    attr_reader :api_url
+
+    # @return [Topc] the toph class tied with the client.
+    attr_reader :toph
+    alias_method :image, :toph
+    alias_method :images, :toph
+
+    # @return [String] the korra class tied with the client.
+    attr_reader :korra
+    alias_method :image_gen, :korra
+    alias_method :auto_image, :korra
+
+    # @return [String] the shimakaze class tied with the client.
+    attr_reader :shimakaze
+    alias_method :reputation, :shimakaze
+    alias_method :rep, :shimakaze
+
+    # @return [String] the tama class tied with the client.
+    attr_reader :tama
+    alias_method :settings, :tama
+
+    # Groups all interfaces into one.
+    # @param token [String] the token required to use weeb.sh.
+    # @param user_agent [String, Hash] the user agent to use with requests.
+    def initialize(auth, user_agent = nil, api_url: 'https://api.weeb.sh')
+      @user_agent = WeebSh::API.format_user_agent(user_agent)
+      @auth = auth
+      @api_url = api_url
+
+      raise WeebSh::Err::BadAuth, 'Authorization is empty!' if auth.empty?
+      puts '[WeebSh::Client] Your User Agent is empty. Please consider adding a user agent to help identify issues easier.' if user_agent.nil?
+      puts '[WeebSh::Client] Your User Agent is not ideal. Please consider adding a user agent to help identify issues easier.' if !user_agent.nil? && user_agent.split('/').count < 2
+
+      @toph = WeebSh::Toph.new(auth, user_agent, api_url: api_url, client: self)
+      @korra = WeebSh::Korra.new(auth, user_agent, api_url: api_url, client: self)
+      @shimakaze = WeebSh::Shimakaze.new(auth, user_agent, api_url: api_url, client: self)
+      @tama = WeebSh::Tama.new(auth, user_agent, api_url: api_url, client: self)
+    end
+
+    def user_agent=(user_agent)
+      @user_agent = user_agent
+      @toph.user_agent = user_agent
+      @korra.user_agent = user_agent
+      @shimakaze.user_agent = user_agent
+      @tama.user_agent = user_agent
+    end
+
+    def auth=(auth)
+      @auth = auth
+      @toph.auth = auth
+      @korra.auth = auth
+      @shimakaze.auth = auth
+      @tama.auth = auth
+    end
+
+    def api_url=(api_url)
+      @api_url = api_url
+      @toph.api_url = api_url
+      @korra.api_url = api_url
+      @shimakaze.api_url = api_url
+      @tama.api_url = api_url
+    end
+
+    def inspect
+      "#<WeebSh::Client @api_url=#{@api_url.inspect} @user_agent=#{@user_agent.inspect}>"
+    end
+  end
+end

data/lib/weeb/interfaces/korra.rb

@@ -0,0 +1,9 @@
+require 'weeb/api/korra'
+require 'weeb/data'
+
+module WeebSh
+  # Image Generation API
+  class Korra < Interface
+
+  end
+end

data/lib/weeb/interfaces/shimakaze.rb

@@ -0,0 +1,9 @@
+require 'weeb/api/shimakaze'
+require 'weeb/data'
+
+module WeebSh
+  # Reputation API
+  class Shimakaze < Interface
+
+  end
+end

data/lib/weeb/interfaces/tama.rb

@@ -0,0 +1,9 @@
+require 'weeb/api/tama'
+require 'weeb/data'
+
+module WeebSh
+  # Settings API
+  class Tama < Interface
+
+  end
+end

data/lib/weeb/interfaces/toph.rb

@@ -0,0 +1,144 @@
+require 'weeb/api/toph'
+require 'weeb/data'
+
+module WeebSh
+  # Image API
+  class Toph < Interface
+
+    # Uploads an image.
+    # @param resource [File, String] the file to upload, this can either be a File, a URL or a path.
+    # @param type [String] the type of image this is in.
+    # @param hidden [true, false] whether or not this image will be only seen to the uploader.
+    # @param tags [Array<String, Tag>] the tags that this image applies to.
+    # @param nsfw [true, false] whether or not this image is NSFW.
+    # @param source [String] the source URL of the image
+    # @return [Image] Returns image that was uploaded.
+    def upload(resource, type, hidden: false, tags: [], nsfw: false, source: nil)
+      tags = tags.map { |t| t.name if t.is_a(Tag) }
+      if resource.is_a?(String) and URI(resource).host.nil?
+        begin
+          resource = File.new(File.absolute_path(resource), 'rb')
+        rescue Errno::ENOENT, Errno::EACCES, Errno::ENAMETOOLONG => e
+          errstring = 'Unknown'
+          case e.class.name
+            when 'Errno::ENOENT'
+              errstring = 'File Not Found'
+            when 'Errno::EACCES'
+              errstring = 'Permission Denied'
+            when 'Errno::ENAMETOOLONG'
+              errstring = 'Name Too Long'
+          end
+          raise WeebSh::Err::FileError, "Error initializing file '${resource}' | #{errstring} | #{e.class.name}"
+        end
+      end
+
+      Image.new(API::Toph.upload(self, resource, type, hidden, tags, nsfw, source)['file'], self)
+    end
+
+    # Gets a list of available types of images.
+    # @param preview [true, false] whether or not to return an array ofpreview images instead of and array of strings
+    # @param hidden [true, false] if true, you only get back hidden preview images you uploaded
+    # @param nsfw [true, false, String] whether or not preview images could be NSFW. Setting this to "only" restricts it to NSFW images.
+    # @return [Array<String>, Array<PreviewImage>] Returns all available types.
+    def types(hidden: false, nsfw: false, preview: false)
+      response = API::Toph.types(self, {
+        hidden: hidden,
+        nsfw: nsfw,
+        preview: preview
+      })
+      preview ? response['preview'].map { |p| PreviewImage.new(p, self) } : response['types']
+    end
+
+    # Gets a list of available types of images.
+    # @param hidden [true, false] if true, you only get back hidden tags you added
+    # @param nsfw [true, false, String] whether or not preview images could be NSFW. Setting this to "only" restricts it to NSFW images.
+    # @return [Array<String>, Array<PreviewImage>] Returns all available tags.
+    def tags(hidden: false, nsfw: false)
+      API::Toph.types(self, {
+        hidden: hidden,
+        nsfw: nsfw
+      })['tags']
+    end
+
+    # Get a random image based on type or a set of tags.
+    # @param type [String] the type of images to recieve
+    # @param tags [Array<String, Tag>] the tags a image should require to be for selection
+    # @param hidden [true, false] if true, you can only get back hidden tags you added
+    # @param nsfw [true, false, String] whether or not preview images could be NSFW. Setting this to "only" restricts it to NSFW images.
+    # @param file_type [String] the file type an image is required to be for selection
+    # @return [WeebImage] Returns image that was randomly selected.
+    def random(type: nil, tags: [], hidden: false, nsfw: false, file_type: nil)
+      tags = tags.map { |t| t.name if t.is_a(Tag) }
+      WeebImage.new(API::Toph.random(self, {
+        type: type,
+        tags: tags,
+        hidden: hidden,
+        nsfw: nsfw,
+        file_type: file_type
+      }), self)
+    end
+
+    # Get an image.
+    # @param id [String, WeebImage, PreviewImage, #resolve_id] the image's ID to recieve
+    # @return [WeebImage] Returns the image with the given ID.
+    def image(id)
+      id = id.resolve_id if id.respond_to?(:resolve_id)
+      WeebImage.new(API::Toph.image(self, id), self)
+    end
+
+    # Delete an image.
+    # @param id [String, WeebImage, PreviewImage, #resolve_id] the image's ID to delete
+    # @return [WeebImage] Returns the image with the given ID.
+    def delete_image(id)
+      id = id.resolve_id if id.respond_to?(:resolve_id)
+      WeebImage.new(API::Toph.delete_image(self, id), self)
+    end
+    alias_method :remove_image, :delete_image
+
+    # Add tags to an image.
+    # @param image [String, WeebImage, PreviewImage, #resolve_id] the image being referred
+    # @param tags [Array<String, Tag>] the affected tags
+    # @return [WeebImage] Returns the image with the given ID.
+    def add_tags_to_image(image, tags)
+      id = id.resolve_id if id.respond_to?(:resolve_id)
+      tags = tags.map { |t| t.name if t.is_a(Tag) }
+      WeebImage.new(API::Toph.add_tags_to_image(self, image, tags), self)
+    end
+
+    # Remove tags off of an image.
+    # @param image [String, WeebImage, PreviewImage, #resolve_id] the image being referred
+    # @param tags [Array<String, Tag>] the affected tags
+    # @return [WeebImage] Returns the image with the given ID.
+    def remove_tags_to_image(image, tags)
+      id = id.resolve_id if id.respond_to?(:resolve_id)
+      tags = tags.map { |t| t.name if t.is_a(Tag) }
+      WeebImage.new(API::Toph.remove_tags_to_image(self, image, tags), self)
+    end
+
+    # Get a list of images based on arguments.
+    # @param type [String] the type of images to recieve
+    # @param tags [Array<String, Tag>] the tags a image should require to be for selection
+    # @param hidden [true, false] if true, you can only get back hidden tags you added
+    # @param nsfw [true, false, String] whether or not preview images could be NSFW. Setting this to "only" restricts it to NSFW images.
+    # @param file_type [String] the file type an image is required to be for selection
+    # @param page [Number] the page number of images to use
+    # @param account [String] the account ID to get images from
+    # @return [WeebImage] Returns image that was randomly selected.
+    def list(type: nil, tags: [], hidden: false, nsfw: false, file_type: nil, page: 0, account: nil)
+      tags = tags.map { |t| t.name if t.is_a(Tag) }
+      object = {
+        type: type,
+        tags: tags,
+        hidden: hidden,
+        nsfw: nsfw,
+        file_type: file_type,
+        page: page
+      }
+      repsonse = account ? API::Toph.list_user(self, account, object) : API::Toph.list(self, object)
+      repsonse.map { |i| WeebImage.new(i, self) }
+    end
+  end
+
+  # Alias for the class {Toph}
+  Image = Toph
+end

data/lib/weeb/ver.rb

@@ -0,0 +1,3 @@
+module WeebSh
+  VERSION = '0.0.1'.freeze
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: weeb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Snazzah
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A gem that utilizes the weeb.sh API.
+email: suggesttosnazzy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/weeb.rb
+- lib/weeb/api.rb
+- lib/weeb/api/korra.rb
+- lib/weeb/api/shimakaze.rb
+- lib/weeb/api/tama.rb
+- lib/weeb/api/toph.rb
+- lib/weeb/data.rb
+- lib/weeb/err.rb
+- lib/weeb/interfaces/client.rb
+- lib/weeb/interfaces/korra.rb
+- lib/weeb/interfaces/shimakaze.rb
+- lib/weeb/interfaces/tama.rb
+- lib/weeb/interfaces/toph.rb
+- lib/weeb/ver.rb
+homepage: https://github.com/Snazzah/weeb.rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A gem that utilizes the weeb.sh API.
+test_files: []