keybase-unofficial 0.4.0 → 0.5.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1762edac1ac71c3ef4105b96ac9e9fd5852c11f4
-  data.tar.gz: c6728d7afd5340830e6d494e2208efb75576a6e9
+  metadata.gz: e8c5d0eafbde60f44f654e0b8fbc85298f24135b
+  data.tar.gz: 4a078ac321524233bec84f4965dd44d789d32d77
 SHA512:
-  metadata.gz: bc1a2d07cc9a79f009039451f7260e9735cd208e3fb6a78f55aa5c2e2f5b5b8f761e92cf5831dc8298b289958212177cde890c4f26815b176c38d69d03e4fa23
-  data.tar.gz: 9cf31fc1d6ba53271f030b0c390f0a256a75480c81b5199ef1bc1fb7fe77ca7dc03ec56d69a72a13f7b090d4a7abf022140049d3108929371fd5fdb936b8ceba
+  metadata.gz: d3c1cd280c1c5f52ce45db1098641756530e30d81c86c3b0d582db9ddc3f566712e1ebff9f14a4785fad64fb6897dd4be4c379b63f545bf153ad46f70fdab4b6
+  data.tar.gz: 51c48d6fcd9ec1fc7a46b24a2fe1ca8c90543ca2224f85c4808fa2fdc7c5f02a4f58d3079d98236abe5d8e632cb2defec4e4b3517e0a377f0e074d9a98a5704a

data/README.md

@@ -15,19 +15,22 @@ $ gem install keybase-unofficial
 
 ### Documentation
 
-Documentation for the current release can be found on
-[RubyDoc](http://www.rubydoc.info/gems/keybase-unofficial/).
+Documentation for keybase-unofficial is split across its three sublibraries:
 
-### Example
+* [keybase-unofficial-core docs](http://www.rubydoc.info/gems/keybase-unofficial-core/)
+* [keybase-unofficial-api docs](http://www.rubydoc.info/gems/keybase-unofficial-api/)
+* [keybase-unofficial-local docs](http://www.rubydoc.info/gems/keybase-unofficial-local/)
+
+### Examples
 
 ```ruby
 require "keybase"
 
 # reads your local configuration
-Keybase.current_user # => "yossarian"
+Keybase::Local.current_user # => "yossarian"
 
 # Chatting API
-Keybase::Chat.send_message ["yossarian", "you"], "hello"
+Keybase::Local::Chat.send_message ["yossarian", "you"], "hello"
 
 # REST API
 person = Keybase::API.lookup username: "yossarian"

data/lib/keybase.rb

@@ -1,17 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "keybase/exceptions"
-require_relative "keybase/config"
-require_relative "keybase/u"
-require_relative "keybase/local_user"
-require_relative "keybase/kbfs"
-require_relative "keybase/api"
-require_relative "keybase/chat"
+require "keybase/core"
+require "keybase/api"
+require "keybase/local"
 
-# The primary namespace for keybase-unofficial.
+# The primary namespace.
 module Keybase
-  # keybase-unofficial's current version
-  VERSION = "0.4.0"
-
-  extend Config
+  # The current version of `keybase-unofficial`.
+  VERSION = "0.5.0.pre.1"
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: keybase-unofficial
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0.pre.1
 platform: ruby
 authors:
 - William Woodruff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-02 00:00:00.000000000 Z
+date: 2017-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: keybase-unofficial-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -24,7 +24,42 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
-description: A unofficial library for Keybase
+- !ruby/object:Gem::Dependency
+  name: keybase-unofficial-api
+  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'
+- !ruby/object:Gem::Dependency
+  name: keybase-unofficial-local
+  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: |
+  An unofficial library for Keybase.
+
+  This library is a wrapper over three individual libraries.
+  keybase-unofficial-core provides core utility methods,
+  keybase-unofficial-api provides an interface to Keybase's
+  REST API, and keybase-unofficial-local provides an interface
+  to a local Keybase installation's functionality.
 email: william@tuffbizz.com
 executables: []
 extensions: []
@@ -34,13 +69,6 @@ files:
 - LICENSE
 - README.md
 - lib/keybase.rb
-- lib/keybase/api.rb
-- lib/keybase/chat.rb
-- lib/keybase/config.rb
-- lib/keybase/exceptions.rb
-- lib/keybase/kbfs.rb
-- lib/keybase/local_user.rb
-- lib/keybase/u.rb
 homepage: https://github.com/woodruffw/keybase-unofficial
 licenses:
 - MIT
@@ -56,9 +84,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.13

data/lib/keybase/api.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "json"
-require "ostruct"
-
-module Keybase
-  # Represents (parts of) the Keybase REST API.
-  # @see https://keybase.io/docs/api/1.0
-  class API
-    # The base URL for the majority of API calls.
-    BASE_URL = "https://keybase.io/_/api/1.0"
-
-    class << self
-      # Look up a user, users, or external identity.
-      # @param query [Hash] the request parameters
-      # @option query username [String] the username to look up
-      # @option query usernames [Array<String>] multiple usernames to look up
-      # @return [OpenStruct] a struct mapping of the JSON response
-      # @example
-      #  Keybase::API.lookup username: "yossarian"
-      #  Keybase::API.lookup github: "woodruffw"
-      # @note Any identity supported by keybase should work (e.g, `domain`,
-      #  `hackernews`, `reddit`, `github`, etc.)
-      # @see https://keybase.io/docs/api/1.0/call/user/lookup
-      def lookup(**query)
-        query[:usernames] = U[query[:usernames]]
-
-        fetch_and_structify "/user/lookup.json", query
-      end
-
-      # Test whether the given user exists on Keybase.
-      # @param user [String] the username to test
-      # @return [Boolean] whether or not the user exists
-      # @example
-      #  Keybase::API.user? "yossarian" # => true
-      #  Keybase::API.user? "idonotexist" # => false
-      # @note This call only works on Keybase usernames, not external identities.
-      def user?(user)
-        lookup(username: user).status.code.zero?
-      end
-
-      # Search Keybase for identity components.
-      # @param query [String] the string to search for
-      # @return [OpenStruct] a struct mapping of the JSON response
-      # @example
-      #  Keybase::API.autocomplete "William Woodruff"
-      # @see https://keybase.io/docs/api/1.0/call/user/autocomplete
-      def autocomplete(query)
-        fetch_and_structify "/user/autocomplete.json", q: query
-      end
-
-      # Discover Keybase users from external identities.
-      # @param query [Hash] the request parameters
-      # @option query flatten [Boolean] whether or not to remove duplicates
-      # @option query usernames_only [Boolean] whether or not to reply with
-      #  only names
-      # @return [OpenStruct] a struct mapping of the JSON response
-      # @example
-      #  Keybase::API.discover github: "woodruffw", flatten: true
-      # @note Any identity supported by keybase should work (e.g, `domain`,
-      #  `hackernews`, `reddit`, `github`, etc.)
-      # @see https://keybase.io/docs/api/1.0/call/user/discover
-      def discover(**query)
-        fetch_and_structify "/user/discover.json", query
-      end
-
-      # Retrieve the current site-wide Merkle root hash.
-      # @param query [Hash] the request parameters
-      # @option query seqno [Integer] a specific Merkle root to return, if found
-      # @option query ctime [Integer] return the first root on or after the
-      #  given time (UTC)
-      # @return [OpenStruct] a struct mapping of the JSON response
-      # @see https://keybase.io/docs/api/1.0/call/merkle/root
-      def merkle_root(**query)
-        fetch_and_structify "/merkle/root.json", query
-      end
-
-      # Retrieve a Merkle node corresponding to a given hash.
-      # @param query [Hash] the request parameters
-      # @option query hash [String] the hash of the block to look up
-      # @return [OpenStruct] a struct mapping of the JSON response
-      # @see https://keybase.io/docs/api/1.0/call/merkle/block
-      def merkle_block(**query)
-        fetch_and_structify "/merkle/block.json", query
-      end
-
-      # Make a GET request to the given endpoint with the given parameters.
-      # @param endpoint [String] the keybase API endpoint
-      # @param query [Hash] the request parameters
-      # @return [OpenStruct] a struct mapping of the JSON response
-      # @api private
-      def fetch_and_structify(endpoint, query)
-        response = Faraday.get "#{BASE_URL}#{endpoint}", query
-        JSON.parse(response.body, object_class: OpenStruct)
-      end
-    end
-  end
-end

data/lib/keybase/chat.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "json"
-require "ostruct"
-
-module Keybase
-  # Represents Keybase's JSON chat API.
-  class Chat
-    # The initial arguments to pass when executing Keybase for chatting.
-    CHAT_EXEC_ARGS = %w[keybase chat api].freeze
-
-    class << self
-      # @param meth [Symbol] the chat method
-      # @param options [Hash] the options hash
-      # @return [String] the JSON serialized envelope
-      # @api private
-      def envelope(meth, options: {})
-        {
-          method: meth,
-          params: {
-            options: options,
-          },
-        }.to_json
-      end
-
-      # @param payload [String] the JSON payload to send to the chat API
-      # @return [OpenStruct] a struct mapping of the JSON response
-      # @api private
-      def chat_call(payload)
-        response = Open3.popen3(*CHAT_EXEC_ARGS) do |stdin, stdout, _, _|
-          stdin.write payload
-          stdin.close # close after writing to let keybase know we're done
-          stdout.read
-        end
-
-        JSON.parse response, object_class: OpenStruct
-      end
-
-      # List the user's inbox.
-      # @param topic_type [String] the topic type to list by
-      # @return [OpenStruct] a struct mapping of the JSON response
-      def list_inbox(topic_type: nil)
-        payload = envelope :list, options: {
-          topic_type: topic_type,
-        }
-
-        chat_call payload
-      end
-
-      # Read a conversation.
-      # @param users [Array<String>] a list of the users in the conversation
-      # @param peek [Boolean] whether to mark the conversation read
-      # @param unread_only [Boolean] whether to fetch unread messages only
-      # @return [OpenStruct] a struct mapping of the JSON response
-      def conversation(users, peek: false, unread_only: false)
-        payload = envelope :read, options: {
-          channel: {
-            name: U[*users],
-          },
-          peek: peek,
-          unread_only: unread_only,
-        }
-
-        chat_call payload
-      end
-
-      # Send a message to a conversation.
-      # @param users [Array<String>] a list of the users in the conversation
-      # @param message [String] the message to send
-      # @param public [Boolean] whether to send the message to a public channel
-      # @return [OpenStruct] a struct mapping of the JSON response
-      def send_message(users, message, public: false)
-        payload = envelope :send, options: {
-          channel: {
-            name: U[*users],
-            public: public,
-          },
-          message: {
-            body: message,
-          },
-        }
-
-        chat_call payload
-      end
-
-      # Delete a message from a conversation.
-      # @param users [Array<String>] a list of the users in the conversation
-      # @param id [Integer] the id of the message to delete
-      # @return [OpenStruct] a struct mapping of the JSON response
-      def delete_message(users, id)
-        payload = envelope :delete, options: {
-          channel: {
-            name: U[*users],
-          },
-          message_id: id,
-        }
-
-        chat_call payload
-      end
-
-      # Edit a message in a conversation.
-      # @param users [Array<String>] a list of the users in the conversation
-      # @param id [Integer] the id of the message to delete
-      # @param message [String] the message to send
-      # @return [OpenStruct] a struct mapping of the JSON response
-      def edit_message(users, id, message)
-        payload = envelope :edit, options: {
-          channel: {
-            name: U[*users],
-          },
-          message_id: id,
-          message: {
-            body: message,
-          },
-        }
-
-        chat_call payload
-      end
-
-      # Upload a file to a conversation.
-      # @param users [Array<String>] a list of the users in the conversation
-      # @param path [String] the pathname of the file to upload
-      # @param title [String] the uploaded file's title
-      # @return [OpenStruct] a struct mapping of the JSON response
-      def upload_attachment(users, path, title)
-        payload = envelope :attach, options: {
-          channel: {
-            name: U[*users],
-          },
-          filename: path,
-          title: title,
-        }
-
-        chat_call payload
-      end
-
-      # Download a file from a conversation.
-      # @param users [Array<String>] a list of the users in the conversation
-      # @param id [Integer] the id of the message to download from
-      # @param path [String] the pathname to download to
-      # @return [OpenStruct] a struct mapping of the JSON response
-      def download_attachment(users, id, path)
-        payload = envelope :download, options: {
-          channel: {
-            name: U[*users],
-          },
-          message_id: id,
-          output: path,
-        }
-
-        chat_call payload
-      end
-
-      # Make a conversation as read up to a specific ID.
-      # @param users [Array<String>] a list of the users in the conversation
-      # @param id [Integer] the id of the message to mark up to
-      # @return [OpenStruct] a struct mapping of the JSON response
-      def mark_conversation(users, id)
-        payload = envelope :mark, options: {
-          channel: {
-            name: U[*users],
-          },
-          message_id: id,
-        }
-
-        chat_call payload
-      end
-
-      # Mute a conversation.
-      # @param users [Array<String>] a list of the users in the conversation
-      # @return [OpenStruct] a struct mapping of the JSON response
-      def mute_conversation(users)
-        payload = envelope :setstatus, options: {
-          channel: {
-            name: U[*users],
-          },
-          status: "muted",
-        }
-
-        chat_call payload
-      end
-    end
-  end
-end

data/lib/keybase/config.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Keybase
-  # Methods and constants related to a local Keybase installation.
-  module Config
-    # The Keybase configuration directory.
-    CONFIG_DIR = if Gem.win_platform?
-                   File.expand_path("#{ENV["LOCALAPPDATA"]}/Keybase").freeze
-                 else
-                   File.expand_path("~/.config/keybase").freeze
-                 end
-
-    # The Keybase configuration file.
-    CONFIG_FILE = File.join(CONFIG_DIR, "config.json").freeze
-
-    # there's not much this library can do without a local config
-    raise Exceptions::KeybaseNotInstalledError unless File.file?(CONFIG_FILE)
-
-    # The hash from Keybase's configuration file.
-    CONFIG_HASH = JSON.parse(File.read(CONFIG_FILE)).freeze
-
-    # The mountpoint for KBFS.
-    KBFS_MOUNT = "/keybase"
-
-    # @return [String] the currently logged-in user
-    def current_user
-      CONFIG_HASH["current_user"]
-    end
-
-    # @return [Array<Keybase::LocalUser>] a list of all local users known
-    #  to Keybase
-    def local_users
-      CONFIG_HASH["users"].map { |_, v| Keybase::LocalUser.new(v) }
-    end
-
-    # @return [String] the user's private KBFS directory
-    def private_dir
-      File.join(KBFS_MOUNT, "private", current_user)
-    end
-
-    # @return [String] the user's public KBFS directory
-    def public_dir
-      File.join(KBFS_MOUNT, "public", current_user)
-    end
-
-    # @return [Boolean] whether or not Keybase is currently running
-    def running?
-      if Gem.win_platform?
-        !`tasklist | find "keybase.exe"`.empty?
-      else
-        # is there a more efficient way to do this that doesn't involve an exec?
-        Dir["/proc/[0-9]*/comm"].any? do |comm|
-          File.read(comm).chomp == "keybase" rescue false # hooray for TOCTOU
-        end
-      end
-    end
-
-    # @return [String] the running Keybase's version string
-    # @raise [Exceptions::KeybaseNotRunningError] if Keybase is not running
-    def running_version
-      raise Exceptions::KeybaseNotRunningError unless Keybase.running?
-      `keybase --version`.split[2]
-    end
-  end
-end

data/lib/keybase/exceptions.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Keybase
-  # A namespace for all exceptions defined by {Keybase}.
-  module Exceptions
-    # A top-level exception for the library.
-    class KeybaseError < RuntimeError
-    end
-
-    # Raised if a Keybase installation can't be found.
-    class KeybaseNotInstalledError < KeybaseError
-      def initialize
-        super "keybase needs to be installed"
-      end
-    end
-
-    # Raised whenever Keybase is not running locally.
-    class KeybaseNotRunningError < KeybaseError
-      def initialize
-        super "keybase needs to be running"
-      end
-    end
-
-    # Raised whenever KBFS is not running locally.
-    class KBFSNotRunningError < KeybaseError
-      def initialize
-        super "KBFS needs to be enabled and running"
-      end
-    end
-  end
-end

data/lib/keybase/kbfs.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Keybase
-  # Represents the Keybase filesystem.
-  # @note This is just a stub for the time being.
-  class KBFS
-    # @raise [Exceptions::KeybaseNotRunningError] unless Keybase is running
-    # @raise [Exceptions::KBFSNotRunningError] unless KBFS is running
-    def initialize
-      raise Exceptions::KeybaseNotRunningError unless Keybase.running?
-      raise Exceptions::KBFSNotRunningError unless Dir.exist?("/keybase")
-    end
-  end
-end

data/lib/keybase/local_user.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Keybase
-  # Represents a user known to the local Keybase process.
-  # These are (presumably) users that have been logged into locally.
-  class LocalUser
-    # @return [String] the device's unique identifier
-    attr_reader :device
-
-    # @return [String] the user's unique identifier
-    attr_reader :id
-
-    # @return [String] the user's Keybase username
-    attr_reader :name
-
-    # @return [String] some kind of salt
-    # @note I have no idea what this field does.
-    attr_reader :salt
-
-    # @param fields [Hash] the user's configuration fields
-    # @option fields device [String] the device's unique identifier
-    # @option fields id [String] the user's unique identifier
-    # @option fields name [String] the user's Keybase username
-    # @option fields salt [String] some kind of salt
-    def initialize(fields)
-      @device = fields["device"]
-      @id     = fields["id"]
-      @name   = fields["name"]
-      @salt   = fields["salt"]
-    end
-  end
-end

data/lib/keybase/u.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Keybase
-  # A class for converting arrays of users into Keybase-style strings.
-  class U
-    class << self
-      # @param args [Array<String>] the list of users to merge
-      # @return [String] the Keybase-style user string
-      # @example
-      #  Keybase::U["a", "b"] # => "a,b"
-      def [](*args)
-        args.join(",")
-      end
-    end
-  end
-end