slacks 0.0.1

data/lib/slacks/event.rb

@@ -0,0 +1,34 @@
+require "slacks/conversation"
+
+module Slacks
+  class Event
+    attr_reader :message, :channel, :sender
+
+    def initialize(session: nil, message: nil, channel: nil, sender: nil)
+      @session = session
+      @message = message
+      @channel = channel
+      @sender = sender
+    end
+
+    def user
+      return @user if defined?(@user)
+      @user = sender && ::User.find_by_slack_username(sender.username)
+    end
+
+    def reply(*args)
+      channel.reply(*args)
+    end
+
+    def random_reply(*args)
+      channel.random_reply(*args)
+    end
+
+    def start_conversation!
+      Conversation.new(session, channel, sender)
+    end
+
+  private
+    attr_reader :session
+  end
+end

data/lib/slacks/guest_channel.rb

@@ -0,0 +1,34 @@
+# This is a channel that the bot is aware of
+# but is not a member of — and cannot reply to.
+#
+# It should expose the same API as channel,
+# but you will not be able to reply on this
+# channel or start a conversation on it.
+
+module Slacks
+  class GuestChannel < Channel
+
+    def initialize(attributes)
+      @id = attributes["channel_id"]
+      @name = attributes["channel_name"]
+
+      @type = :channel
+      @type = :group if id.start_with?("G")
+      @type = :direct_message if id.start_with?("D")
+    end
+
+    def reply(*args)
+      raise NotInChannelError, self
+    end
+    alias :say :reply
+
+    def random_reply(*args)
+      raise NotInChannelError, self
+    end
+
+    def guest?
+      true
+    end
+
+  end
+end

data/lib/slacks/listener.rb

@@ -0,0 +1,44 @@
+module Slacks
+  class Listener
+    attr_reader :matcher, :flags
+    attr_accessor :conversation
+
+    def initialize(listeners, matcher, direct, flags, callback)
+      # flags.each do |flag|
+      #   unless Slacks::Message.can_apply?(flag)
+      #     raise ArgumentError, "#{flag.inspect} is not a recognized flag"
+      #   end
+      # end
+
+      @listeners = listeners
+      @matcher = matcher.freeze
+      @flags = flags.sort.freeze
+      @direct = direct
+      @callback = callback
+    end
+
+    def match(message)
+      matcher.match message.to_s(flags)
+    end
+
+    def direct?
+      @direct
+    end
+
+    def indirect?
+      !direct?
+    end
+
+    def stop_listening!
+      listeners.delete self
+      self
+    end
+
+    def call(e)
+      @callback.call(e)
+    end
+
+  private
+    attr_reader :listeners
+  end
+end

data/lib/slacks/listener_collection.rb

@@ -0,0 +1,31 @@
+require "thread_safe"
+
+module Slacks
+  class ListenerCollection
+
+    def initialize
+      @listeners = ThreadSafe::Array.new
+    end
+
+    def listen_for(matcher, flags=[], &block)
+      Listener.new(self, matcher, true, flags, block).tap do |listener|
+        @listeners.push listener
+      end
+    end
+
+    def overhear(matcher, flags=[], &block)
+      Listener.new(self, matcher, false, flags, block).tap do |listener|
+        @listeners.push listener
+      end
+    end
+
+    def each(&block)
+      @listeners.each(&block)
+    end
+
+    def delete(listener)
+      @listeners.delete listener
+    end
+
+  end
+end

data/lib/slacks/message.rb

@@ -0,0 +1,71 @@
+module Slacks
+  class Message
+
+    def initialize(session, data)
+      @session = session
+      @data = data
+      @processed_text = Hash.new do |hash, flags|
+        hash[flags] = flags.inject(text) { |text, flag| session.apply(flag, text) }.strip
+      end
+    end
+
+
+    def channel
+      return @channel if defined?(@channel)
+      @channel = session.slack.find_channel data["channel"]
+    end
+
+    def sender
+      return @sender if defined?(@sender)
+      @sender = session.slack.find_user data["user"]
+    end
+
+    def timestamp
+      data["ts"]
+    end
+
+    def type
+      data.fetch("subtype", "message")
+    end
+
+    def text
+      return @text if defined?(@text)
+      @text = self.class.normalize(data["text"])
+    end
+    alias :to_str :text
+
+    def to_s(flags=[])
+      processed_text[flags]
+    end
+
+    def inspect
+      "#{text.inspect} (from: #{sender}, channel: #{channel})"
+    end
+
+    def add_reaction(emoji)
+      session.slack.add_reaction(emoji, self)
+    end
+
+
+    def respond_to_missing?(method, include_all)
+      return true if text.respond_to?(method)
+      super
+    end
+
+    def method_missing(method, *args, &block)
+      return text.public_send(method, *args, &block) if text.respond_to?(method)
+      super
+    end
+
+
+    def self.normalize(text)
+      text
+        .gsub(/[“”]/, "\"")
+        .gsub(/[‘’]/, "'")
+        .strip
+    end
+
+  private
+    attr_reader :session, :data, :processed_text
+  end
+end

data/lib/slacks/rtm_event.rb

@@ -0,0 +1,30 @@
+require "slacks/event"
+
+module Slacks
+  class RtmEvent < Event
+    attr_reader :match, :message_object
+
+    def initialize(session: nil, message: nil, match_data: nil, listener: nil)
+      super(session: session, message: message.text, channel: message.channel, sender: message.sender)
+      @message_object = message
+      @match = match_data
+      @listener = listener
+    end
+
+    def matched?(key)
+      match[key].present?
+    end
+
+    def stop_listening!
+      listener.stop_listening!
+    end
+
+    def react(emoji)
+      message_object.add_reaction(emoji)
+    end
+
+  private
+    attr_reader :listener
+
+  end
+end

data/lib/slacks/session.rb

@@ -0,0 +1,147 @@
+require "slacks/connection"
+require "slacks/listener_collection"
+
+module Slacks
+  class Session
+    attr_reader :listeners, :typing_speed, :token, :slack
+
+    def initialize(token, &block)
+      @typing_speed = 100.0
+      @token = token
+      @listeners = Slacks::ListenerCollection.new
+
+      if block_given?
+        listeners.instance_eval(&block)
+        start!
+      end
+    end
+
+    def listen_for(matcher, flags=[], &block)
+      listeners.listen_for(matcher, flags, &block)
+    end
+
+    def overhear(matcher, flags=[], &block)
+      listeners.overhear(matcher, flags, &block)
+    end
+
+    def start!
+      @slack = Slacks::Connection.new(self, token)
+
+      slack.listen! do |message|
+        process_message(message)
+      end
+    end
+
+    def error(message)
+      # TODO
+      puts "\e[33m[slack:error] #{message}\e[0m"
+    end
+
+    def apply(flag, text)
+      send :"_apply_#{flag}", text
+    end
+
+    def can_apply?(flag)
+      respond_to? :"_apply_#{flag}", true
+    end
+
+  protected
+
+    def process_message(data)
+
+      # Don't respond to things that another bot said
+      return if data.fetch("subtype", "message") == "bot_message"
+
+      # Normalize mentions of users
+      data["text"].gsub!(/<@U[^|]+\|([^>]*)>/, "@\\1")
+
+      # Normalize mentions of channels
+      data["text"].gsub!(/<[@#]?([UC][^>]+)>/) do |match|
+        begin
+          slack.find_channel($1)
+        rescue ArgumentError
+          match
+        end
+      end
+
+      message = Slacks::Message.new(self, data)
+
+      # Is someone talking directly to the bot?
+      direct_mention = message.channel.direct_message? || message[slack.bot.name]
+
+      listeners.each do |listener|
+        # Listeners come in two flavors: direct and indirect
+        #
+        # To trigger a direct listener, the but must be directly
+        # spoken to: as when the bot is mentioned or it is in
+        # a conversation with someone.
+        #
+        # An indirect listener is triggered in any context
+        # when it matches.
+        #
+        # We can ignore any listener that definitely doesn't
+        # meet these criteria.
+        next unless listener.indirect? or direct_mention or listener.conversation
+
+        message = Slacks::Message.new(self, data)
+
+        # Does the message match one of our listeners?
+        match_data = listener.match message
+        next unless match_data
+
+        # TODO: Want event.message to be the processed text
+        event = Slacks::RtmEvent.new(
+          session: self,
+          message: message,
+          match_data: match_data,
+          listener: listener)
+
+        # Skip listeners if they are not part of this conversation
+        next unless listener.indirect? or direct_mention or listener.conversation.includes?(event)
+
+        invoke! listener, event
+      end
+    # rescue Exception
+    #   # TODO
+    #   # Houston.report_exception $!
+    #   puts "\e[31m[slack:exception] (#{$!.class}) #{$!.message}\n  #{$!.backtrace.join("\n  ")}\e[0m"
+    end
+
+    def invoke!(listener, event)
+      # # TODO
+      # puts "\e[35m[slack:hear:#{event.message_object.type}] #{event.message_object.inspect}\e[0m"
+
+      listener.call(event)
+      # Thread.new do
+      #   begin
+      #     @callback.call(e)
+      #   rescue Exception # rescues StandardError by default; but we want to rescue and report all errors
+      #     # TODO
+      #     # Houston.report_exception $!, parameters: {channel: e.channel, message: e.message, sender: e.sender}
+      #     puts "\e[31m[slack:exception] (#{$!.class}) #{$!.message}\n  #{$!.backtrace.join("\n  ")}\e[0m"
+      #     e.reply "An error occurred when I was trying to answer you"
+      #   ensure
+      #     ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord)
+      #   end
+      # end
+    end
+
+    def _apply_downcase(text)
+      text.downcase
+    end
+
+    def _apply_no_punctuation(text)
+      # Need to leave @ and # in @mentions and #channels
+      text.gsub(/[^\w\s@#]/, "")
+    end
+
+    def _apply_no_mentions(text)
+      text.gsub(/(?:^|\W+)#{slack.bot}\b/, "")
+    end
+
+    def _apply_no_emoji(text)
+      text.gsub(/(?::[^:]+:)/, "")
+    end
+
+  end
+end

data/lib/slacks/team.rb

@@ -0,0 +1,12 @@
+module Slacks
+  class Team
+    attr_reader :id, :name, :domain
+
+    def initialize(data)
+      @id = data.fetch("id")
+      @name = data.fetch("name")
+      @domain = data.fetch("domain")
+    end
+
+  end
+end

data/lib/slacks/user.rb

@@ -0,0 +1,29 @@
+module Slacks
+  class User
+    attr_reader :id, :username, :email, :first_name, :last_name
+
+    def initialize(session, attributes={})
+      @session = session
+
+      profile = attributes["profile"]
+      @id = attributes["id"]
+      @username = attributes["name"]
+      @email = profile["email"]
+      @first_name = profile["first_name"]
+      @last_name = profile["last_name"]
+    end
+
+    def name
+      "#{first_name} #{last_name}"
+    end
+
+    def inspect
+      "<Slacks::User id=\"#{id}\" name=\"#{name}\">"
+    end
+
+    def to_s
+      "@#{username}"
+    end
+
+  end
+end

data/lib/slacks/version.rb

@@ -0,0 +1,3 @@
+module Slacks
+  VERSION = "0.0.1"
+end

data/lib/slacks.rb

@@ -0,0 +1,3 @@
+require "slacks/version"
+require "slacks/core_ext/exception"
+require "slacks/session"

data/slacks.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "slacks/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "slacks"
+  spec.version       = Slacks::VERSION
+  spec.authors       = ["Bob Lail"]
+  spec.email         = ["bob.lailfamily@gmail.com"]
+
+  spec.summary       = %q{A library for communicating via Slack}
+  spec.homepage      = "https://github.com/houston/slacks"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # https://blog.jcoglan.com/2013/05/06/websocket-driver-an-io-agnostic-websocket-module-or-why-most-protocol-libraries-arent/
+  spec.add_dependency "websocket-driver"
+  spec.add_dependency "multi_json"
+  spec.add_dependency "faraday"
+  spec.add_dependency "faraday-raise-errors"
+  spec.add_dependency "thread_safe"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: slacks
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Bob Lail
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket-driver
+  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: multi_json
+  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: faraday
+  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: faraday-raise-errors
+  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: thread_safe
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.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'
+description: 
+email:
+- bob.lailfamily@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/slacks.rb
+- lib/slacks/bot_user.rb
+- lib/slacks/channel.rb
+- lib/slacks/connection.rb
+- lib/slacks/conversation.rb
+- lib/slacks/core_ext/exception.rb
+- lib/slacks/driver.rb
+- lib/slacks/errors.rb
+- lib/slacks/event.rb
+- lib/slacks/guest_channel.rb
+- lib/slacks/listener.rb
+- lib/slacks/listener_collection.rb
+- lib/slacks/message.rb
+- lib/slacks/rtm_event.rb
+- lib/slacks/session.rb
+- lib/slacks/team.rb
+- lib/slacks/user.rb
+- lib/slacks/version.rb
+- slacks.gemspec
+homepage: https://github.com/houston/slacks
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A library for communicating via Slack
+test_files: []