slackup 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 227551c418ddd3f0a6eeabe2fd4695302f336bad
-  data.tar.gz: d1df8e777fd3f2a3056cb52bee0e81c671851455
+  metadata.gz: e065eb49b0187dd348830f1c73a3f0548e7a2906
+  data.tar.gz: ff1f53897bb4911be878785dbdc2d954abec5596
 SHA512:
-  metadata.gz: 6195c397e38e9c35938c59b83d36befd34ed4953d2eed8ff0c7e1a5636379294c7aad8e3da94a5b2b6c3c0c4b99ddd4fd2cc2c58829fc3f55f4141d4d8b22733
-  data.tar.gz: 255e5b4e693b5717f3533eeb5b97c6bb6d40af1782f8948f50444b3f5c595b130361ffba1f4ab5db6f2f3ec08e6deba492010dcb0a2efb8d724b1c0896ecd351
+  metadata.gz: 686a4114820035ef6a59ca866811ab93ce4f3ed72d1206f08c3c3213dd7c77d03e6b5d3175d39ddef57878729472443f93b4e405e94d372859955de56c03e939
+  data.tar.gz: 3e02401f1c62c5613d8faf0f9af2685a59f49d25b7be35f28bc89e3e351fcc45f97396182b829832f1339626820f84626b7e63905c3c753f54853e3c40b85ea1

data/lib/slackup/channels.rb

@@ -0,0 +1,26 @@
+class Slackup::Channels < Slackup
+
+  def list
+    @list ||= client.channels_list["channels"]
+  end
+  alias channels list
+
+  def write!
+    channels.each do |channel|
+      write_messages(channel)
+    end
+  end
+
+  def messages(channel)
+    client.channels_history(channel: channel["id"], count: "1000")
+  end
+
+  def write_messages(channel)
+    with_messages channel["name_normalized"], messages(channel) do |messages|
+      File.open(backup_filename(channel["name"]), "w")  do |f|
+        formatted_messages = format_messages(messages)
+        f.write serialize(formatted_messages)
+      end
+    end
+  end
+end

data/lib/slackup/groups.rb

@@ -0,0 +1,61 @@
+class Slackup::Groups < Slackup
+
+  # {
+  #     "ok": true,
+  #     "groups": [
+  #         {
+  #             "id": "G0ABC",
+  #             "name": "some-group",
+  #             "is_group": true,
+  #             "created": 1436923155,
+  #             "creator": "UABC",
+  #             "is_archived": false,
+  #             "members": [
+  #             ],
+  #             "topic": {
+  #                 "value": "",
+  #                 "creator": "",
+  #                 "last_set": 0
+  #             },
+  #             "purpose": {
+  #                 "value": "Some group",
+  #                 "creator": "UABC",
+  #                 "last_set": 1437105751
+  #             }
+  #         }
+  #     ]
+  # }
+  def list
+    @list ||= client.groups_list["groups"]
+  end
+  alias groups list
+
+  def write!
+    Dir.chdir(groups_dir) do
+      groups.each do |group|
+        write_messages(group)
+      end
+    end
+  end
+
+  def messages(group)
+    client.groups_history(channel: group["id"], count: "1000")
+  end
+
+  # https://api.slack.com/methods/groups.history
+  def write_messages(group)
+    with_messages group, messages(group) do |messages|
+      File.open(backup_filename(group["name"]), "w")  do |f|
+        formatted_messages = format_messages(messages)
+        f.write serialize(formatted_messages)
+      end
+    end
+  end
+
+  def groups_dir
+    @groups_dir ||= "groups"
+    FileUtils.mkdir_p(@groups_dir)
+    @groups_dir
+  end
+
+end

data/lib/slackup/ims.rb

@@ -0,0 +1,66 @@
+class Slackup::Ims < Slackup
+  Im = Struct.new(:im_hash) do
+    def id; im_hash["id"]; end
+
+    def user; im_hash["user"]; end
+  end
+  # @return [Hash]
+  # @example
+  # {
+  #   "ok"=>true,
+  #   "ims"=>[
+  #     {"id"=>"D1234567890", "is_im"=>true, "user"=>"USLACKBOT", "created"=>1372105335, "is_user_deleted"=>false},
+  #   ]
+  # }
+  def list
+    @list ||= client.im_list["ims"].map { |im| Im.new(im) }
+  end
+  alias ims list
+
+  def write!
+    Dir.chdir(ims_dir) do
+      ims.each do |im|
+        write_messages(im)
+      end
+    end
+  end
+
+  # @param im_id [String] is the 'channel' of the im, e.g. "D1234567890"
+  # @return [Hash]
+  # @example return
+  # {
+  #   "ok": true,
+  #   "latest": "1358547726.000003",
+  #   "messages": [
+  #     {
+  #       "type": "message",
+  #       "ts": "1358546515.000008",
+  #       "user": "U2147483896",
+  #       "text": "<@U0453RHGQ> has some thoughts on that kind of stuff"
+  #     },
+  #     ]
+  #   "has_more": false
+  def messages(im_id)
+    client.im_history(channel: im_id)
+  end
+
+  def write_messages(im)
+    im_username = format_username(im.user)
+    with_messages im_username, messages(im.id) do |messages|
+      formatted_messages = format_messages(messages)
+      File.open(backup_filename(im_username), "w")  do |f|
+        f.write serialize(formatted_messages)
+      end unless formatted_messages.empty?
+    end
+  end
+
+  def format_username(user)
+    user_name(user).downcase.gsub(/\s+/, "-")
+  end
+
+  def ims_dir
+    @ims_dir ||= "ims"
+    FileUtils.mkdir_p(@ims_dir)
+    @ims_dir
+  end
+end

data/lib/slackup/stars.rb

@@ -0,0 +1,15 @@
+class Slackup::Stars < Slackup
+
+  def list
+    client.stars_list(count: "1000", page: "1")
+  end
+  alias stars list
+
+  def write!
+    with_messages "stars", list do |messages|
+      File.open(backup_filename("stars"), "w")  do |f|
+        f.write(serialize(messages))
+      end
+    end
+  end
+end

data/lib/slackup/users.rb

@@ -0,0 +1,71 @@
+class Slackup::Users < Slackup
+  User = Struct.new(:user_hash) do
+    def id; user_hash["id"]; end
+
+    def name; user_hash["name"]; end
+
+    def deleted; user_hash["deleted"]; end
+
+    def color; user_hash["color"]; end
+
+    def profile; user_hash["profile"]; end
+
+    def admin?; user_hash["is_admin"]; end
+
+    def owner?; user_hash["is_owner"]; end
+
+    def has_2fa?; user_hash["has_2fa"]; end
+
+    def has_files?; user_hash["has_files"]; end
+
+    def to_hash; user_hash; end
+  end
+  # {
+  #   "ok": true,
+  #   "members": [
+  #     {
+  #       "id": "U023BECGF",
+  #       "name": "bobby",
+  #       "deleted": false,
+  #       "color": "9f69e7",
+  #       "profile": {
+  #         "first_name": "Bobby",
+  #         "last_name": "Tables",
+  #         "real_name": "Bobby Tables",
+  #         "email": "bobby@slack.com",
+  #         "skype": "my-skype-name",
+  #         "phone": "+1 (123) 456 7890",
+  #         "image_24": "https:\/\/...",
+  #         "image_32": "https:\/\/...",
+  #         "image_48": "https:\/\/...",
+  #         "image_72": "https:\/\/...",
+  #         "image_192": "https:\/\/..."
+  #       },
+  #       "is_admin": true,
+  #       "is_owner": true,
+  #       "has_2fa": false,
+  #       "has_files": true
+  #     },
+  #   ]
+  # }
+  def list
+    @list ||= client.users_list["members"].map { |member| User.new(member) }
+  end
+  alias users list
+
+  def write!
+    File.open(backup_filename("users"), "w")  do |f|
+      f.write(serialize(users.map(&:to_hash)))
+    end
+  end
+
+  # gets user name for an id, if mapping is known, else returns the input
+  def user_name(user_id)
+    @user_names ||= users.each_with_object({}) {|user, lookup|
+      lookup[user.id] = user.name
+    }
+    @user_names.fetch(user_id) {
+      user_id
+    }
+  end
+end

data/lib/slackup/version.rb

@@ -1,3 +1,3 @@
-module Slackup
-  VERSION = "0.0.6"
+class Slackup
+  VERSION = "0.0.7"
 end

data/lib/slackup.rb

@@ -3,10 +3,15 @@
 require "pathname"
 require "yaml"
 require "fileutils"
-gem "slack-api", "~> 1.1", ">= 1.1.3"
+gem "slack-api", "~> 1.6", ">= 1.6.0"
 require "slack"
-
 class Slackup
+  require_relative 'slackup/users'
+  require_relative 'slackup/channels'
+  require_relative 'slackup/groups'
+  require_relative 'slackup/ims'
+  require_relative 'slackup/stars'
+
   Error = Class.new(StandardError)
   RUN_ROOT  = Pathname Dir.pwd
   def self.run_root
@@ -14,12 +19,6 @@ class Slackup
   end
 
   SEMAPHORE = Mutex.new
-  attr_reader :name
-  def initialize(name, token)
-    @name = name
-    @token = token
-    FileUtils.mkdir_p(name)
-  end
 
   def self.team_token_pairs_file
     Pathname.glob(run_root.join("slack_teams.{json,yml,yaml}")).first
@@ -33,42 +32,53 @@ class Slackup
     end
   end
 
+  def self.configure_client(token)
+    client = nil
+    SEMAPHORE.synchronize do
+      Slack.configure do |config|
+        config.token = token
+      end
+      client = Slack.client
+    end
+    client
+  end
+
   def self.backup(team_token_pairs = team_token_pairs())
     team_token_pairs.each do |name, token|
-      new(name, token).execute
+      fork do
+        client = configure_client(token)
+        new(name, client).execute
+      end
     end
+    p Process.waitall
+  end
+
+  attr_reader :name, :client
+  alias dirname name
+  def initialize(name, client)
+    @name = name
+    @client = client
+    FileUtils.mkdir_p(name)
   end
 
   def execute
-    SEMAPHORE.synchronize do
-      authorize! &&
-        Dir.chdir(name) do
-          channels.each do |channel|
-            write_channel_messages(channel)
-          end
-          Dir.chdir(groups_dir) do
-            groups.each do |group|
-              write_group_messages(group)
-            end
-          end
-          write_stars
-          write_users
-          Dir.chdir(ims_dir) do
-            im_list.each do |im|
-              write_im_messages(im)
-            end
-          end
-        end
+    authorize! && write!
+  end
+
+  def write!
+    Dir.chdir(dirname) do
+      Channels.new(name, client).write!
+      Groups.new(name, client).write!
+      Stars.new(name, client).write!
+      user_client.write!
+      Ims.new(name, client).write!
     end
   end
 
   private
 
   def authorize!
-    Slack.configure do |config|
-      config.token = @token
-    end
-    auth_test = Slack.auth_test
+    auth_test = client.auth_test
     if auth_test["ok"] === true
       p [name]
       true
@@ -78,146 +88,23 @@ class Slackup
     end
   end
 
-  User = Struct.new(:user_hash) do
-    def id; user_hash["id"]; end
-
-    def name; user_hash["name"]; end
-
-    def deleted; user_hash["deleted"]; end
-
-    def color; user_hash["color"]; end
-
-    def profile; user_hash["profile"]; end
-
-    def admin?; user_hash["is_admin"]; end
-
-    def owner?; user_hash["is_owner"]; end
-
-    def has_2fa?; user_hash["has_2fa"]; end
-
-    def has_files?; user_hash["has_files"]; end
-
-    def to_hash; user_hash; end
-  end
-  # {
-  #   "ok": true,
-  #   "members": [
-  #     {
-  #       "id": "U023BECGF",
-  #       "name": "bobby",
-  #       "deleted": false,
-  #       "color": "9f69e7",
-  #       "profile": {
-  #         "first_name": "Bobby",
-  #         "last_name": "Tables",
-  #         "real_name": "Bobby Tables",
-  #         "email": "bobby@slack.com",
-  #         "skype": "my-skype-name",
-  #         "phone": "+1 (123) 456 7890",
-  #         "image_24": "https:\/\/...",
-  #         "image_32": "https:\/\/...",
-  #         "image_48": "https:\/\/...",
-  #         "image_72": "https:\/\/...",
-  #         "image_192": "https:\/\/..."
-  #       },
-  #       "is_admin": true,
-  #       "is_owner": true,
-  #       "has_2fa": false,
-  #       "has_files": true
-  #     },
-  #   ]
-  # }
-  def users
-    @users ||= Slack.users_list["members"].map { |member| User.new(member) }
-  end
-
-  def channels
-    @channels ||= Slack.channels_list["channels"]
-  end
-
-  # {
-  #     "ok": true,
-  #     "groups": [
-  #         {
-  #             "id": "G0ABC",
-  #             "name": "some-group",
-  #             "is_group": true,
-  #             "created": 1436923155,
-  #             "creator": "UABC",
-  #             "is_archived": false,
-  #             "members": [
-  #             ],
-  #             "topic": {
-  #                 "value": "",
-  #                 "creator": "",
-  #                 "last_set": 0
-  #             },
-  #             "purpose": {
-  #                 "value": "Some group",
-  #                 "creator": "UABC",
-  #                 "last_set": 1437105751
-  #             }
-  #         }
-  #     ]
-  # }
-  def groups
-    @groups ||= Slack.groups_list["groups"]
-  end
-
-  Im = Struct.new(:im_hash) do
-    def id; im_hash["id"]; end
-
-    def user; im_hash["user"]; end
-  end
-  # @return [Hash]
-  # @example
-  # {
-  #   "ok"=>true,
-  #   "ims"=>[
-  #     {"id"=>"D1234567890", "is_im"=>true, "user"=>"USLACKBOT", "created"=>1372105335, "is_user_deleted"=>false},
-  #   ]
-  # }
-  def im_list
-    @im_list ||= Slack.im_list["ims"].map { |im| Im.new(im) }
-  end
-
-  # @param im_id [String] is the 'channel' of the im, e.g. "D1234567890"
-  # @return [Hash]
-  # @example return
-  # {
-  #   "ok": true,
-  #   "latest": "1358547726.000003",
-  #   "messages": [
-  #     {
-  #       "type": "message",
-  #       "ts": "1358546515.000008",
-  #       "user": "U2147483896",
-  #       "text": "<@U0453RHGQ> has some thoughts on that kind of stuff"
-  #     },
-  #     ]
-  #   "has_more": false
-  def im_history(im_id)
-    Slack.im_history(channel: im_id)
-  end
-
-  def write_channel_messages(channel)
-    messages = Slack.channels_history(channel: channel["id"], count: "1000")["messages"]
-    File.open(backup_filename(channel["name"]), "w")  do |f|
-      formatted_messages = format_channel_messages(messages)
-      f.write serialize(formatted_messages)
-    end
-  end
-
-  # https://api.slack.com/methods/groups.history
-  def write_group_messages(group)
-    messages = Slack.groups_history(channel: group["id"], count: "1000")["messages"]
-    File.open(backup_filename(group["name"]), "w")  do |f|
-      formatted_messages = format_group_messages(messages)
-      f.write serialize(formatted_messages)
+  # {"ok"=>false, "error"=>"ratelimited"}
+  # {"ok"=>false, "error"=>"token_revoked"
+  def with_messages(name, query_result)
+    if query_result["ok"]
+      yield query_result["messages"]
+    else
+      error = query_result["error"]
+      $stderr.puts "#{name}, error: #{error}"
+      exit 1 if error =~ /ratelimited/
     end
   end
 
   def format_messages(messages)
+    if messages.nil?
+      $stderr.puts "Messages nil #{caller[0..1]}"
+      return []
+    end
     messages.reverse.map { |msg|
       if msg.has_key?("text") && msg.has_key?("user")
         msg["user"] = user_name(msg["user"])
@@ -232,59 +119,22 @@ class Slackup
     }.compact
   end
 
-  alias_method :format_channel_messages, :format_messages
-  alias_method :format_group_messages, :format_messages
-  alias_method :format_im_messages, :format_messages
-
-  # gets user name for an id, if mapping is known, else returns the input
-  def user_name(user_id)
-    @user_names ||= users.each_with_object({}) {|user, lookup|
-      lookup[user.id] = user.name
-    }
-    @user_names.fetch(user_id) {
-      user_id
-    }
+  def user_client
+    @user_client ||= Users.new(name, client)
   end
 
-  def write_stars
-    File.open(backup_filename("stars"), "w")  do |f|
-      stars = Slack.stars_list(count: "1000", page: "1")
-      f.write(serialize(stars))
-    end
+  def users
+    user_client.users
   end
 
-  def write_users
-    File.open(backup_filename("users"), "w")  do |f|
-      f.write(serialize(users.map(&:to_hash)))
-    end
+  def user_name(user_id)
+    user_client.user_name(user_id)
   end
 
   def serialize(obj)
     obj.to_yaml
   end
 
-  def write_im_messages(im)
-    messages = im_history(im.id)["messages"]
-    im_username = user_name(im.user).downcase.gsub(/\s+/, "-")
-    formatted_messages = format_im_messages(messages)
-    return if formatted_messages.empty?
-    File.open(backup_filename(im_username), "w")  do |f|
-      f.write serialize(formatted_messages)
-    end
-  end
-
-  def ims_dir
-    @ims_dir ||= "ims"
-    FileUtils.mkdir_p(@ims_dir)
-    @ims_dir
-  end
-
-  def groups_dir
-    @groups_dir ||= "groups"
-    FileUtils.mkdir_p(@groups_dir)
-    @groups_dir
-  end
-
   def backup_filename(name)
     "#{name}.yml"
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slackup
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Benjamin Fleischer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-07-17 00:00:00.000000000 Z
+date: 2017-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slack-api
@@ -74,6 +74,11 @@ files:
 - Rakefile
 - exe/slackup
 - lib/slackup.rb
+- lib/slackup/channels.rb
+- lib/slackup/groups.rb
+- lib/slackup/ims.rb
+- lib/slackup/stars.rb
+- lib/slackup/users.rb
 - lib/slackup/version.rb
 - slackup.gemspec
 homepage: https://github.com/bf4/slackup
@@ -96,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: A simple tool to backup slack channels