slack_neuralyzer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f34f12786efe803fc3109712824067b26c27e228
+  data.tar.gz: 9e84e469278787d33e1438b8306110ce7c2b0c41
+SHA512:
+  metadata.gz: 9d2c9932289e8bdbbee6e12318eaf4192b8466eac8fe6f9037acfe764a530c8a1bd1c823d1841c23302f16c39a7edb45d740f3a9978bf93b55a38316c85c267b
+  data.tar.gz: d88b648cc1f468161e75477b37c6265a44b72a2b02ac7c929299f7a61f72c2ce18e596621b37379f712cf38d16a1b2c5c1ab55cba369d659e88b534cb025bcba

data/.codeclimate.yml

@@ -0,0 +1,16 @@
+engines:
+  rubocop:
+    enabled: true
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+ratings:
+  paths:
+  - lib/**
+  - "**.rb"
+exclude_paths:
+- spec/**/*
+- topic/**/*
+- "**/vendor/**/*"

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.11.2
+script: bundle exec rspec --color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in slack_neuralyzer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Leon Ji
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,216 @@
+# Slack Neuralyzer
+
+[![Build Status](https://travis-ci.org/mgleon08/slack_neuralyzer.svg?branch=master)](https://travis-ci.org/mgleon08/slack_neuralyzer)
+[![Coverage Status](https://coveralls.io/repos/github/mgleon08/slack_neuralyzer/badge.svg?branch=master)](https://coveralls.io/github/mgleon08/slack_neuralyzer?branch=master)
+[![Code Climate](https://codeclimate.com/github/mgleon08/slack_neuralyzer/badges/gpa.svg)](https://codeclimate.com/github/mgleon08/slack_neuralyzer)
+[![security](https://hakiri.io/github/mgleon08/slack_neuralyzer/master.svg)](https://hakiri.io/github/mgleon08/slack_neuralyzer/master)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/mgleon08/slack_neuralyzer/blob/master/LICENSE.txt)
+
+Slack Neuralyzer is a ruby gem for bulk delete messages and files on Slack channels.
+
+The easiest way to clean up messages and files on Slack.
+
+![](https://media.giphy.com/media/65NO1TrKrJUT6/giphy.gif)
+
+## Installation
+
+```
+$ gem install slack_neuralyzer
+```
+
+## Slack token
+
+<a href='https://api.slack.com/web' target='_blank'><img src='screenshots/general_test_token.png' alt='general_test_token' width = '20%' /></a>
+
+##Getting Started
+
+![](screenshots/slack_neuralyzer_demo.gif)
+
+### Show all channel names
+
+`slack_neuralyzer -t <TOKEN> -s`
+
+```ruby
+All user direct:
+  001. leon
+  002. slackbot
+  003. cleanerbot
+
+All channels (public):
+  001. general
+  002. random
+
+All groups (private):
+  001. private_channel
+
+All multiparty direct:
+  001. mpdm-leon--cleanerbot-1
+  002. mpdm-leon--slackbot-1
+```
+
+### Delete message(s)
+
+>Rerun below command and use `-e | --execute` to actually delete the message(s).
+
+* Channel
+
+`-C | --channel` `-D | --direct` `-G | --group` `-M | --mpdirect`
+
+```ruby
+# Delete all user messages in general channel
+slack_neuralyzer -t <TOKEN> -m -C general -u all
+
+# Delete all user messages in leon direct channel
+slack_neuralyzer -t <TOKEN> -m -D leon -u all
+
+# Delete all user messages in private_channel groups channel
+slack_neuralyzer -t <TOKEN> -m -G private_channel -u all
+
+# Delete all user messages in mpdm-leon--cleanerbot-1 multiparty direct channel
+# (can `use slack_neuralyzer -t <TOKEN> -s` to see mpdirect channle name)
+slack_neuralyzer -t <TOKEN> -m -M mpdm-leon--cleanerbot-1 -u all
+```
+
+* Specific user
+
+`-u | --user`
+
+```ruby
+# Delete leon messages in general channel
+slack_neuralyzer -t <TOKEN> -m -C general -u leon
+
+# if you want to specific all users, you can type 'all'
+slack_neuralyzer -t <TOKEN> -m -C general -u all
+```
+
+* Specific Bot
+
+`-b | --bot`
+
+```ruby
+# Delete bots messages in general channel
+slack_neuralyzer -t <TOKEN> -m -C general -b cleanerbot
+
+# if you want to specific all bots, you can type 'all' (not bot users)
+slack_neuralyzer -t <TOKEN> -m -C general -b all
+```
+
+* Delete message(s) between two dates
+
+`-A | --after` `-B | --before`
+
+```ruby
+# Delete all user messages in general channel at 20160101 to 20161212
+slack_neuralyzer -t <TOKEN> -m -C general -u all -A 20160101 -B 20161212
+```
+
+* Delete message(s) with specified text
+
+`-R | --regex`
+
+```ruby
+# Delete all user messages with hello string in general channel
+slack_neuralyzer -t <TOKEN> -m -C general -u all -R hello
+```
+
+### Delete file(s)
+
+> File types: all, spaces, snippets, images, gdocs, docs, zips, pdfs
+
+>Rerun below command and use `-e | --execute` to actually delete the message(s).
+
+* Channel
+
+`-C | --channel` `-D | --direct` `-G | --group` `-M | --mpdirect`
+
+```ruby
+# Delete all user upload all type file in general channel
+slack_neuralyzer -t <TOKEN> -f all -C general -u all
+
+# Delete leon upload all images file in leon direct channel
+slack_neuralyzer -t <TOKEN> -f images -D leon -u leon
+
+# Delete all user upload all pdfs file in private_channel groups channel
+slack_neuralyzer -t <TOKEN> -f pdfs -G private_channel -u all
+
+# Delete all user upload all zips file in mpdm-leon--cleanerbot-1 multiparty direct channel
+# (can `use slack_neuralyzer -t <TOKEN> -s` to see mpdirect channle name)
+slack_neuralyzer -t <TOKEN> -f zips -M mpdm-leon--cleanerbot-1 -u all
+```
+
+* Specific user and file type
+
+`-u | --user` `-f | --file`
+
+```ruby
+# Delete leon upload images file in general channel
+slack_neuralyzer -t <TOKEN> -f images -C general -u leon
+```
+
+* Delete file between two dates
+
+`-A | --after` `-B | --before`
+
+```ruby
+# Delete all user upload all type file in general channel at 20160101 to 20161212
+slack_neuralyzer -t <TOKEN> -f all -C general -u all -A 20160101 -B 20161212
+```
+
+### Generate log file
+
+`-l | --log`
+
+```ruby
+# Generate a log file in the current directory in ./slack_neuralyzer/YYYY-MM-DDTHH:MM:SS
+slack_neuralyzer -t <TOKEN> -m -C general -u all -A 20160101 -B 20161212 -l
+```
+
+
+### Rate
+
+`-r | --rate`
+
+```ruby
+# Delay between API calls in seconds (default:0.05)
+slack_neuralyzer -t <TOKEN> -m -C general -u all -r 0.01
+```
+
+
+### Help
+
+`-h | --help`
+
+```
+usage:
+    slack_neuralyzer [options]
+    See https://github.com/mgleon08/slack_neuralyzer for more information.
+
+options:
+    -t, --token TOKEN                Slack API token (https://api.slack.com/web)
+    -s, --show                       Show all users, channels, groups and multiparty direct names
+    -m, --message                    Specifies that the delete object is messages
+    -f, --file TYPE                  Specifies that the delete object is files of a certain type (Type: all, spaces, snippets, images, gdocs, docs, zips, pdfs)
+    -C, --channel CHANNEL            Public channel name (e.g., general, random)
+    -D, --direct DIRECT              Direct messages channel name (e.g., leon)
+    -G, --group GROUP                Private groups channel name
+    -M, --mpdirect MPDIRECT          Multiparty direct messages channel name (e.g., mpdm-leon--bot-1 [--show option to see name])
+    -u, --user USER                  Delete messages/files from the specific user (if you want to specific all users, you can type 'all')
+    -b, --bot BOT                    Delete messages from the specific bot (not bot users, if you want to specific all bots, you can type 'all')
+    -A, --after DATE                 Delete messages/files after than this time (YYYYMMDD)
+    -B, --before DATE                Delete messages/files before than this time (YYYYMMDD)
+    -R, --regex TEXT                 Delete messages with specified text (regular expression)
+    -e, --execute                    Execute the delete task
+    -l, --log                        Generate a log file in the current directory
+    -r, --rate RATE                  Delay between API calls in seconds (default:0.1)
+    -v, --version                    Show the SlackNeuralyzer version
+    -h, --help                       Show this message
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [`https://github.com/mgleon08/slack_neuralyzer/pulls`](https://github.com/mgleon08/slack_neuralyzer/pulls)
+
+## Copyright & License
+
+* Copyright (c) 2016 Leon Ji. See [LICENSE.txt](https://github.com/mgleon08/slack_neuralyzer/blob/master/LICENSE.txt) for further details.
+* The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "slack_neuralyzer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/slack_neuralyzer

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require_relative '../lib/slack_neuralyzer'
+
+begin
+  args   = SlackNeuralyzer::ArgsParser.new(ARGV)
+  logger = SlackNeuralyzer::Logger.default(args.log)
+  dict   = SlackNeuralyzer::Dict.new(args.token)
+  cli    = SlackNeuralyzer::Cli.new(args, dict, logger)
+  cli.run
+rescue => e
+  $stderr.puts e.message
+  exit
+end

data/lib/slack_api/errors/not_found.rb

@@ -0,0 +1,9 @@
+module SlackApi
+  module Errors
+    class NotFoundError < StandardError
+      def initialize(message)
+        super("SlackAPI: #{message}")
+      end
+    end
+  end
+end

data/lib/slack_api/errors/response.rb

@@ -0,0 +1,9 @@
+module SlackApi
+  module Errors
+    class ResponseError < StandardError
+      def initialize(message)
+        super("SlackAPI: #{message}")
+      end
+    end
+  end
+end

data/lib/slack_api/slack_api.rb

@@ -0,0 +1 @@
+require 'slack'

data/lib/slack_neuralyzer.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH << File.dirname(__FILE__)
+
+require 'optparse'
+require 'time'
+require 'colorize'
+require 'logger'
+
+require 'slack_api/slack_api'
+require 'slack_api/errors/not_found'
+require 'slack_api/errors/response'
+
+require 'slack_neuralyzer/logger'
+require 'slack_neuralyzer/multi_io'
+
+require 'slack_neuralyzer/helper'
+require 'slack_neuralyzer/colorizable'
+require 'slack_neuralyzer/args_parser'
+require 'slack_neuralyzer/dict'
+require 'slack_neuralyzer/cli'
+require 'slack_neuralyzer/cleaner/base'
+require 'slack_neuralyzer/cleaner/messages'
+require 'slack_neuralyzer/cleaner/files'
+require 'slack_neuralyzer/errors/mutually_exclusive_arguments'
+require 'slack_neuralyzer/errors/required_arguments'
+
+require 'slack_neuralyzer/version'

data/lib/slack_neuralyzer/args_parser.rb

@@ -0,0 +1,98 @@
+module SlackNeuralyzer
+  class ArgsParser
+    attr_accessor :token, :show, :message, :file, :channel, :direct,
+                  :group, :mpdirect, :user, :bot, :after, :before,
+                  :execute, :log, :rate, :regex
+
+    def initialize(args)
+      @args = args
+      init_arg_groups
+      parse_args
+      validates_mutex_args
+      validates_required_args
+    end
+
+    def init_arg_groups
+      @arg_groups = {
+        'required': [
+          [:token],
+          [:message, :file],
+          [:channel, :direct, :group, :mpdirect],
+          [:user, :bot]
+        ],
+        'mutex': [
+          [:message, :file],
+          [:channel, :direct, :group, :mpdirect],
+          [:file, :bot],
+          [:file, :regex]
+        ]
+      }
+    end
+
+    def rate_limit
+      rate || 0.05
+    end
+
+    private
+
+    def parse_args
+      opts = OptionParser.new
+      opts.banner = usage_msg
+      opts.separator ''
+      opts.separator 'options:'
+      opts.on('-t', '--token TOKEN', 'Slack API token (https://api.slack.com/web)') { |token| self.token = token }
+      opts.on('-s', '--show', 'Show all users, channels, groups and multiparty direct names') { self.show = true }
+
+      opts.on('-m', '--message', 'Specifies that the delete object is messages') { self.message = true }
+      opts.on('-f', '--file TYPE', "Specifies that the delete object is files of a certain type (Type: all, spaces, snippets, images, gdocs, docs, zips, pdfs)") { |file| self.file = file }
+
+      opts.on('-C', '--channel CHANNEL', 'Public channel name (e.g., general, random)') { |channel| self.channel = channel }
+      opts.on('-D', '--direct DIRECT', 'Direct messages channel name (e.g., leon)') { |direct| self.direct = direct }
+      opts.on('-G', '--group GROUP', 'Private groups channel name') { |group| self.group = group }
+      opts.on('-M', '--mpdirect MPDIRECT', 'Multiparty direct messages channel name (e.g., mpdm-leon--bot-1 [--show option to see name])') { |mpdirect| self.mpdirect = mpdirect }
+
+      opts.on('-u', '--user USER', "Delete messages/files from the specific user (if you want to specific all users, you can type 'all')") { |user| self.user = user }
+      opts.on('-b', '--bot BOT', "Delete messages from the specific bot (not bot users, if you want to specific all bots, you can type 'all')") { |bot| self.bot = bot }
+
+      opts.on('-A', '--after DATE', 'Delete messages/files after than this time (YYYYMMDD)') { |after| self.after = after }
+      opts.on('-B', '--before DATE', 'Delete messages/files before than this time (YYYYMMDD)') { |before| self.before = before }
+
+      opts.on('-R', '--regex TEXT', 'Delete messages with specified text (regular expression)') { |regex| self.regex = regex }
+
+      opts.on('-e', '--execute', 'Execute the delete task') { self.execute = true }
+      opts.on('-l', '--log', 'Generate a log file in the current directory') { self.log = true }
+      opts.on('-r', '--rate RATE', Float, 'Delay between API calls in seconds (default:0.1)') { |rate| self.rate = rate }
+      opts.on('-v', '--version', 'Show the SlackNeuralyzer version') { puts("slack_neuralyzer #{SlackNeuralyzer::VERSION}"); exit }
+      opts.on('-h', '--help', 'Show this message') { puts(opts); exit }
+      opts.parse!(@args)
+    end
+
+    def usage_msg
+      <<-USAGE.freeze
+usage:
+    slack_neuralyzer [options]
+    See https://github.com/mgleon08/slack_neuralyzer for more information.
+      USAGE
+    end
+
+    def validates_required_args
+      @arg_groups[:required].each do |opts|
+        filters = opts.select{ |opt| !self.public_send(opt).nil? }
+        raise SlackNeuralyzer::Errors::RequiredArgumentsError.new(double_dash(opts).join(', ')) if filters.empty?
+        return unless self.show.nil?
+      end
+    end
+
+    def validates_mutex_args
+      @arg_groups[:mutex].each do |opts|
+        return unless self.show.nil?
+        filters = opts.select{ |opt| !self.public_send(opt).nil? }
+        raise SlackNeuralyzer::Errors::MutuallyExclusiveArgumentsError.new(double_dash(filters).join(', ')) if filters.size > 1
+      end
+    end
+
+    def double_dash(arrays)
+      arrays.map{ |array| array.to_s.prepend('--') }
+    end
+  end
+end

data/lib/slack_neuralyzer/cleaner/base.rb

@@ -0,0 +1,73 @@
+module SlackNeuralyzer
+  module Cleaner
+    class Base
+      include Helper
+      include Colorizable
+      attr_reader :args, :dict, :channel_type, :logger
+
+      def initialize(args, dict, logger)
+        @args   = args
+        @dict   = dict
+        @logger = logger
+        reset_counter
+        parse_to_ts(args.after, args.before)
+      end
+
+      private
+
+      def get_user_id
+        user_id = args.user == 'all' ? -1 : dict.find_user_id(args.user)
+        raise SlackApi::Errors::NotFoundError, "#{args.user} not found." unless args.bot || user_id
+        user_id
+      end
+
+      def get_channel_id
+        if args.channel
+          @channel_type = 'channel'
+          channel_id    = dict.find_channel_id(args.channel)
+        elsif args.direct
+          @channel_type = 'direct'
+          user_id       = dict.find_user_id(args.direct)
+          channel_id    = dict.find_im_id(user_id)
+        elsif args.group
+          @channel_type = 'group'
+          channel_id    = dict.find_group_id(args.group)
+        elsif args.mpdirect
+          @channel_type = 'mpdirect'
+          channel_id    = dict.find_mpim_id(args.mpdirect)
+        end
+        raise SlackApi::Errors::NotFoundError, "#{current_channel} not found." unless channel_id
+        channel_id
+      end
+
+      def current_channel
+        light_green("#{args.public_send(channel_type)} #{channel_type}")
+      end
+
+      def time_format(time)
+        light_cyan("[#{parse_to_date(time)}]")
+      end
+
+      def delete_format
+        args.execute ? '(delete) '.light_red : ''
+      end
+
+      def not_have_any(type)
+        logger.info "#{current_channel} does not have any #{type}(s)"
+        exit
+      end
+
+      def finish_text(type)
+        text = "\n#{light_green(counter)} #{type}(s) in #{current_channel} "
+        if args.execute.nil? && counter.nonzero?
+          text << 'will be deleted.'
+          text << light_red("\nNow, you can rerun the command and use `-e | --execute` to actually delete the #{type}(s).")
+        else
+          text << 'have been deleted.'
+        end
+        text << light_blue("\nThe log file has been generated in the current directory") if args.log
+        text
+      end
+    end
+  end
+end

data/lib/slack_neuralyzer/cleaner/files.rb

@@ -0,0 +1,41 @@
+module SlackNeuralyzer
+  module Cleaner
+    class Files < Base
+      def clean
+        user_id    = get_user_id
+        channel_id = get_channel_id
+        clean_channel_file(channel_id, user_id)
+      end
+
+      private
+
+      def clean_channel_file(channel_id, user_id)
+        page, total_page = 0, nil
+        until page == total_page
+          page += 1
+          res = Slack.files_list(page: page, channel: channel_id, types: args.file, ts_from: start_time, ts_to: end_time)
+          raise SlackApi::Errors::ResponseError, res['error'] unless res['ok']
+          total_page = res['paging']['pages']
+          not_have_any('file') if total_page.zero?
+          res['files'].each do |file|
+            if args.user && (file['user'] == user_id || user_id == -1)
+              delete_file(file)
+            end
+          end
+        end
+
+        logger.info finish_text('file')
+      end
+
+      def delete_file(file)
+        file_time = time_format(file['timestamp'])
+        file_url  = light_magenta("(#{file['permalink']})")
+        delete    = delete_format
+        Slack.files_delete(file: file['id']) if args.execute
+        logger.info "#{delete}#{file_time} #{dict.find_user_name(file['user'])}: #{file['name']} #{file_url}"
+        increase_counter
+        sleep(args.rate_limit)
+      end
+    end
+  end
+end

data/lib/slack_neuralyzer/cleaner/messages.rb

@@ -0,0 +1,83 @@
+module SlackNeuralyzer
+  module Cleaner
+    class Messages < Base
+      def clean
+        user_id    = get_user_id
+        channel_id = get_channel_id
+        end_point  = get_history_end_point
+        clean_channel_messages(channel_id, user_id, end_point)
+      end
+
+      private
+
+      def clean_channel_messages(channel_id, user_id, end_point)
+        has_more = true
+
+        while has_more
+          res = Slack.public_send(end_point, channel: channel_id, oldest: start_time, latest: end_time)
+          raise SlackApi::Errors::ResponseError, res['error'] unless res['ok']
+          has_more = res['has_more']
+          messages = res['messages']
+          not_have_any('message') if messages.empty?
+
+          messages.each do |msg|
+            @end_time = msg['ts']
+            dict.scan_user_id_to_transform(msg['text'])
+            next unless msg['type'] == 'message'
+            next if args.regex && !match_regex(msg['text'])
+
+            if args.user && user_msg?(msg, user_id)
+              name = dict.find_user_name(msg['user'])
+              delete_message(channel_id, msg, name)
+            end
+
+            next unless args.bot && bot_msg?(msg)
+
+            name = dict.find_bot_name(msg['bot_id'])
+            if args.bot == name || args.bot == 'all'
+              delete_message(channel_id, msg, name)
+            end
+          end
+        end
+
+        logger.info finish_text('message')
+      end
+
+      def user_msg?(msg, user_id)
+        !bot_msg?(msg) && (msg['user'] == user_id || user_id == -1)
+      end
+
+      def bot_msg?(msg)
+        msg['subtype'] == 'bot_message'
+      end
+
+      def delete_message(channel_id, msg, name)
+        Slack.chat_delete(channel: channel_id, ts: msg['ts']) if args.execute
+        logger.info "#{delete_format}#{time_format(msg['ts'])} #{name}: #{msg['text']}"
+        increase_counter
+        sleep(args.rate_limit)
+      end
+
+      def get_history_end_point
+        if args.channel
+          :channels_history
+        elsif args.direct
+          :im_history
+        elsif args.group
+          :groups_history
+        elsif args.mpdirect
+          :mpim_history
+        end
+      end
+
+      def match_regex(text)
+        match_word = text.scan(/#{args.regex}/).flatten
+        return false if match_word.empty?
+        match_word.uniq.each do |word|
+          text.gsub!(/#{word}/, light_magenta(word.to_s))
+        end
+        text
+      end
+    end
+  end
+end

data/lib/slack_neuralyzer/cli.rb

@@ -0,0 +1,23 @@
+module SlackNeuralyzer
+  class Cli
+    attr_reader :args, :dict, :logger
+
+    def initialize(args, dict, logger)
+      @args   = args
+      @dict   = dict
+      @logger = logger
+    end
+
+    def run
+      logger.info "Running slack_neuralyzer v#{SlackNeuralyzer::VERSION}\n"
+      sleep(1)
+      if args.show
+        puts dict.show_all_channels
+      elsif args.message
+        Cleaner::Messages.new(args, dict, logger).clean
+      elsif args.file
+        Cleaner::Files.new(args, dict, logger).clean
+      end
+    end
+  end
+end

data/lib/slack_neuralyzer/colorizable.rb

@@ -0,0 +1,16 @@
+module SlackNeuralyzer
+  module Colorizable
+    [
+      :light_green,
+      :light_cyan,
+      :light_red,
+      :light_blue,
+      :light_yellow,
+      :light_magenta
+    ].each do |color|
+      define_method(color) do |text|
+        text.to_s.public_send(color)
+      end
+    end
+  end
+end

data/lib/slack_neuralyzer/dict.rb

@@ -0,0 +1,118 @@
+module SlackNeuralyzer
+  class Dict
+    include Colorizable
+    attr_reader :channels, :ims, :groups, :mpims, :users, :bots
+
+    def initialize(token)
+      Slack.token = token
+      @users = {}
+      @channels = {}
+      @groups = {}
+      @ims = {}
+      @mpims = {}
+      @bots = {}
+      init_all_dict
+    end
+
+    def show_all_channels
+      text = ''
+      text << light_blue("All user direct:\n")
+      text << list_names(users)
+      text << light_blue("\nAll channels (public):\n")
+      text << list_names(channels)
+      text << light_blue("\nAll groups (private):\n")
+      text << list_names(groups)
+      text << light_blue("\nAll multiparty direct:\n")
+      text << list_names(mpims)
+    end
+
+    [:channel, :im, :group, :mpim, :user].each do |channel|
+      define_method("find_#{channel}_id".to_sym) do |name|
+        public_send("#{channel}s").key(name)
+      end
+
+      define_method("find_#{channel}_name".to_sym) do |name|
+        public_send("#{channel}s").invert.key(name)
+      end
+    end
+
+    def scan_user_id_to_transform(text)
+      return text if text.nil?
+      scan_id = text.scan(/<@(?<bot>[[:alnum:][:punct:]]*)>/i).flatten
+      if scan_id.any?
+        scan_id.uniq.each do |id|
+          name = find_user_name(id)
+          text.gsub!(/<@#{id}>/, light_yellow("@#{name}"))
+        end
+      end
+      text
+    end
+
+    def find_bot_name(bot_id)
+      build_bot_name(bot_id) unless bots.invert.key(bot_id)
+      bots.invert.key(bot_id)
+    end
+
+    def build_bot_name(bot_id)
+      res = Slack.bots_info(bot: bot_id)
+      raise SlackApi::Errors::ResponseError, res['error'] unless res['ok']
+      @bots[bot_id] = res['bot']['name']
+    end
+
+    private
+
+    def init_all_dict
+      init_users_dict
+      init_channels_dict
+      init_groups_dict
+      init_ims_dict
+      init_mpims_dict
+    end
+
+    def init_users_dict
+      res = Slack.users_list
+      raise SlackApi::Errors::ResponseError, res['error'] unless res['ok']
+      members = res['members']
+      members.each { |member| @users[member['id']] = member['name'] }
+    end
+
+    def init_channels_dict
+      res = Slack.channels_list
+      raise SlackApi::Errors::ResponseError, res['error'] unless res['ok']
+      channels = res['channels']
+      channels.each { |channel| @channels[channel['id']] = channel['name'] }
+    end
+
+    def init_groups_dict
+      res = Slack.groups_list
+      raise SlackApi::Errors::ResponseError, res['error'] unless res['ok']
+      groups = res['groups']
+      groups.each do |group|
+        next if group['is_mpim'] != false
+        @groups[group['id']] = group['name']
+      end
+    end
+
+    def init_ims_dict
+      res = Slack.im_list
+      raise SlackApi::Errors::ResponseError, res['error'] unless res['ok']
+      ims = res['ims']
+      ims.each { |im| @ims[im['id']] = im['user'] }
+    end
+
+    def init_mpims_dict
+      res = Slack.mpim_list
+      raise SlackApi::Errors::ResponseError, res['error'] unless res['ok']
+      mpims = res['groups']
+      mpims.each { |mpim| @mpims[mpim['id']] = mpim['name'] }
+    end
+
+    def list_names(names)
+      ''.tap do |text|
+        names.values.each.with_index(1) do |name, index|
+          text << "  #{index.to_s.rjust(3, '0')}. #{name}\n"
+        end
+      end
+    end
+  end
+end

data/lib/slack_neuralyzer/errors/mutually_exclusive_arguments.rb

@@ -0,0 +1,9 @@
+module SlackNeuralyzer
+  module Errors
+    class MutuallyExclusiveArgumentsError < StandardError
+      def initialize(message)
+        super("These arguments can not be required together: #{message}")
+      end
+    end
+  end
+end

data/lib/slack_neuralyzer/errors/required_arguments.rb

@@ -0,0 +1,9 @@
+module SlackNeuralyzer
+  module Errors
+    class RequiredArgumentsError < StandardError
+      def initialize(message)
+        super("Must required one of these arguments: #{message}")
+      end
+    end
+  end
+end

data/lib/slack_neuralyzer/helper.rb

@@ -0,0 +1,23 @@
+module SlackNeuralyzer
+  module Helper
+    attr_reader :counter, :start_time, :end_time
+
+    def parse_to_ts(start_time, end_time)
+      end_time ||= Time.now.to_s
+      @start_time = Time.parse(start_time).to_f if start_time
+      @end_time   = Time.parse(end_time).to_f
+    end
+
+    def parse_to_date(ts)
+      Time.at(ts.to_f).strftime('%Y-%m-%d %H:%M')
+    end
+
+    def reset_counter
+      @counter = 0
+    end
+
+    def increase_counter
+      @counter += 1
+    end
+  end
+end

data/lib/slack_neuralyzer/logger.rb

@@ -0,0 +1,23 @@
+module SlackNeuralyzer
+  class Logger < ::Logger
+    class << self
+      def default(log)
+        io = [STDOUT]
+        io << log_file if log
+        logger = Logger.new(MultiIO.new(*io))
+        logger.level = Logger::INFO
+        logger.formatter = proc do |_severity, _datetime, _progname, msg|
+          "#{msg}\n"
+        end
+        logger
+      end
+
+      def log_file
+        time = Time.now.strftime('%Y-%m-%dT%H:%M:%S')
+        FileUtils.mkdir_p('./slack_neuralyzer')
+        log_file = File.open("./slack_neuralyzer/#{time}.log", 'a')
+        log_file
+      end
+    end
+  end
+end

data/lib/slack_neuralyzer/multi_io.rb

@@ -0,0 +1,34 @@
+module SlackNeuralyzer
+  class MultiIO
+    def initialize(*targets)
+      @targets = targets
+      @shell_colors = {
+        light_red:     '\\e\\[0;91;49m',
+        light_green:   '\\e\\[0;92;49m',
+        light_yellow:  '\\e\\[0;93;49m',
+        light_blue:    '\\e\\[0;94;49m',
+        light_magenta: '\\e\\[0;95;49m',
+        light_cyan:    '\\e\\[0;96;49m',
+        out_put:       '\\e\\[0m'
+      }
+    end
+
+    def write(args)
+      @targets.each do |target|
+        pretty_file_text(args) if target.is_a? File
+        target.write(args)
+      end
+    end
+
+    def close
+      @targets.each(&:close)
+    end
+
+    def pretty_file_text(args)
+      @shell_colors.values.each do |color|
+        args.gsub!(/#{color}/, '')
+      end
+      args
+    end
+  end
+end

data/lib/slack_neuralyzer/version.rb

@@ -0,0 +1,3 @@
+module SlackNeuralyzer
+  VERSION = '0.1.0'.freeze
+end

data/slack_neuralyzer.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'slack_neuralyzer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "slack_neuralyzer"
+  spec.version       = SlackNeuralyzer::VERSION
+  spec.authors       = ["Leon Ji"]
+  spec.email         = ["mgleon08@gmail.com"]
+
+  spec.summary       = %q{The easiest way to clean up messages and files on Slack.}
+  spec.description   = %q{This is a ruby gem for bulk delete messages and files on Slack channels.}
+  spec.homepage      = "https://github.com/mgleon08/slack_neuralyzer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.require_paths = ["lib"]
+  spec.executables   = ["slack_neuralyzer"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "coveralls", "~> 0.8.1"
+  spec.add_runtime_dependency "slack-api", "~> 1.2"
+  spec.add_runtime_dependency "colorize", "~> 0.8"
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: slack_neuralyzer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Leon Ji
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: slack-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: This is a ruby gem for bulk delete messages and files on Slack channels.
+email:
+- mgleon08@gmail.com
+executables:
+- slack_neuralyzer
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codeclimate.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bin/slack_neuralyzer
+- lib/slack_api/errors/not_found.rb
+- lib/slack_api/errors/response.rb
+- lib/slack_api/slack_api.rb
+- lib/slack_neuralyzer.rb
+- lib/slack_neuralyzer/args_parser.rb
+- lib/slack_neuralyzer/cleaner/base.rb
+- lib/slack_neuralyzer/cleaner/files.rb
+- lib/slack_neuralyzer/cleaner/messages.rb
+- lib/slack_neuralyzer/cli.rb
+- lib/slack_neuralyzer/colorizable.rb
+- lib/slack_neuralyzer/dict.rb
+- lib/slack_neuralyzer/errors/mutually_exclusive_arguments.rb
+- lib/slack_neuralyzer/errors/required_arguments.rb
+- lib/slack_neuralyzer/helper.rb
+- lib/slack_neuralyzer/logger.rb
+- lib/slack_neuralyzer/multi_io.rb
+- lib/slack_neuralyzer/version.rb
+- screenshots/general_test_token.png
+- screenshots/neuralyzer.gif
+- screenshots/slack_neuralyzer_demo.gif
+- slack_neuralyzer.gemspec
+homepage: https://github.com/mgleon08/slack_neuralyzer
+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.4.8
+signing_key: 
+specification_version: 4
+summary: The easiest way to clean up messages and files on Slack.
+test_files: []