hipbot 1.0.0.rc2 → 1.0.0

data/lib/hipbot/plugin.rb

@@ -11,10 +11,10 @@ module Hipbot
 
       attr_accessor :response
 
-      delegate :sender, :recipients, :body, :room, :to => :response
-      delegate :bot, :to => Hipbot
+      delegate :sender, :recipients, :body, :room, :reply, to: :response
+      delegate :bot, to: Hipbot
 
-      Hipbot.plugins.prepend(self.instance)
+      Hipbot.plugins.unshift(self.instance)
     end
 
     module ClassMethods

data/lib/hipbot/reactable.rb

@@ -1,17 +1,10 @@
 module Hipbot
   module Reactable
-    def default *params, &block
-      scope *params do
-        default_reactions << to_reaction(block)
-      end
-    end
-
-    def default_reactions
-      @default_reactions ||= []
-    end
+    include Cache
 
-    def desc text = nil
-      @description.tap{ @description = text }
+    attr_cache :reactions, :default_reactions, :options_stack
+    attr_cache :reaction_factory do
+      ReactionFactory.new(self)
     end
 
     def on *params, &block
@@ -20,26 +13,26 @@ module Hipbot
       end
     end
 
-    def reactions
-      @reactions ||= []
+    def default *params, &block
+      scope *params do
+        default_reactions << to_reaction(block)
+      end
     end
 
     def scope *params, &block
-      options = params.last.kind_of?(Hash) ? params.pop : {}
-      options_stack << options.merge({ regexps: params, desc: desc })
+      options_stack << reaction_factory.get_reaction_options(params)
       yield
       options_stack.pop
     end
 
+    def desc text
+      reaction_factory.description(text)
+    end
+
     protected
 
     def to_reaction block
-      current_options = options_stack.inject{ |all, h| all.merge(h) }
-      Reaction.new(self, current_options, block)
-    end
-
-    def options_stack
-      @options_stack ||= []
+      reaction_factory.build(options_stack, block)
     end
   end
 end

data/lib/hipbot/reaction.rb

@@ -1,23 +1,33 @@
 module Hipbot
   class Reaction < Struct.new(:plugin, :options, :block)
-    def any_room?
+    include Cache
+
+    def in_any_room?
       options[:room] == true
     end
 
-    def anything?
-      regexps.blank?
+    def to_anything?
+      regexps.empty?
     end
 
-    def anywhere?
+    def from_anywhere?
       options[:room].nil?
     end
 
+    def condition
+      options[:if] || Proc.new{ true }
+    end
+
+    def delete
+      plugin.reactions.delete(self)
+    end
+
     def desc
       options[:desc]
     end
 
     def from_all?
-      options[:from].blank?
+      options[:from].nil?
     end
 
     def global?
@@ -36,30 +46,32 @@ module Hipbot
       Match.new(self, message)
     end
 
-    def private_message_only?
+    def to_private_message?
       options[:room] == false
     end
 
-    def readable_command
-      regexps.to_s.gsub(/(?<!\\)(\/|\[|\]|\^|\\z|\$|\\)/, '')
+    attr_cache :readable_command do
+      regexps.map(&:source).join(' or ').gsub(/\^|\\z|\$|\\/, '')
     end
 
-    def regexps
-      options[:regexps]
+    attr_cache :regexps do
+      Array(options[:regexps]).map do |regexp|
+        Regexp.new(regexp.source, Regexp::IGNORECASE)
+      end
     end
 
-    def rooms
-      replace_symbols options[:room], Hipbot.rooms
+    attr_cache :rooms do
+      replace_symbols(options[:room], Hipbot.rooms)
     end
 
-    def users
-      replace_symbols options[:from], Hipbot.teams
+    attr_cache :users do
+      replace_symbols(options[:from], Hipbot.teams)
     end
 
     protected
 
     def replace_symbols values, replacements_hash
-      Array(values).flat_map{ |v| replacements_hash[v].presence || v.to_s }
+      Array(values).flat_map{ |v| replacements_hash[v] || v }.uniq
     end
   end
 end

data/lib/hipbot/reaction_factory.rb

@@ -0,0 +1,38 @@
+module Hipbot
+  class ReactionFactory < Struct.new(:reactable)
+    attr_reader :current_description
+    private :reactable, :current_description
+
+    def build(options_stack, block)
+      options = get_options(options_stack)
+      block ||= options.delete(:block)
+      @current_description = nil
+      Reaction.new(reactable, options, block)
+    end
+
+    def description(text)
+      @current_description = text
+    end
+
+    def get_reaction_options(params)
+      options = params.extract_options!
+      get_reaction_method_proc(params) do |block|
+        options[:block] = block
+      end
+      options[:regexps] = params if params.any?
+      options.merge(desc: current_description)
+    end
+
+    protected
+
+    def get_reaction_method_proc(params)
+      return unless params.last.kind_of?(Symbol)
+      method_name = params.pop
+      yield ->(*attributes){ plugin.send(method_name, *attributes) }
+    end
+
+    def get_options(stack)
+      stack.inject{ |all, h| all.merge(h) } || {}
+    end
+  end
+end

data/lib/hipbot/response.rb

@@ -2,23 +2,31 @@ module Hipbot
   class Response < Struct.new(:reaction, :message)
     include Helpers
 
-    delegate :sender, :recipients, :body, :room, :to => :message
-    delegate :bot, :to => Hipbot
+    delegate :sender, :room, to: :message
+    delegate :bot, to: Hipbot
+
+    def initialize *_
+      super
+      Hipbot.logger.info("RESPONSE WITH #{reaction.inspect}")
+    end
 
     def invoke arguments
-      Hipbot.logger.info("REACTION #{reaction.inspect}")
-      instance_exec(*arguments, &reaction.block)
-      true
+      handle_errors do
+        instance_exec(*arguments, &reaction.block)
+      end
     rescue Exception => e
-      Hipbot.logger.error(e)
-      instance_exec(e, &Hipbot.error_handler)
-      false
+      instance_exec(e, &Hipbot.exception_handler)
+    end
+
+    def reply message, room = self.room
+      (room || sender).send_message(message)
     end
 
     protected
 
-    def reply message, room = self.room
-      room.nil? ? Hipbot.send_to_user(sender, message) : Hipbot.send_to_room(room, message)
+    def handle_errors
+      error = catch(:error){ yield; false }
+      reply(error) if error
     end
 
     def method_missing method, *args, &block

data/lib/hipbot/room.rb

@@ -1,5 +1,21 @@
 module Hipbot
   class Room
+    include Cache
+
+    attr_cache :users
+
+    def on_join user
+      self.users << user
+    end
+
+    def on_leave user
+      if user.myself?
+        self.destroy
+      else
+        self.users.delete(user)
+      end
+    end
+
     def set_topic topic
       Hipbot.set_topic(self, topic)
     end
@@ -8,8 +24,24 @@ module Hipbot
       Hipbot.send_to_room(self, message)
     end
 
-    def users
-      @users ||= []
+    def invite users
+      Hipbot.invite_to_room(self, users)
+    end
+
+    def kick users
+      Hipbot.kick_from_room(self, users)
+    end
+
+    def join
+      Hipbot.join_room(self)
+    end
+
+    def leave
+      Hipbot.leave_room(self)
+    end
+
+    def archived?
+      !!attributes[:archived]
     end
   end
 end

data/lib/hipbot/storages/base.rb

@@ -0,0 +1,78 @@
+module Hipbot
+  module Storages
+    module Base
+      extend ActiveSupport::Concern
+
+      included do
+        extend ClassMethods
+        alias_method :to_s, :name
+      end
+
+      def initialize attributes
+        raise NotImplementedError
+      end
+
+      def attributes
+        raise NotImplementedError
+      end
+
+      def destroy
+        raise NotImplementedError
+      end
+
+      def id
+        raise NotImplementedError
+      end
+
+      def name
+        raise NotImplementedError
+      end
+
+      def name= value
+        raise NotImplementedError
+      end
+
+      def update_attribute key, value
+        raise NotImplementedError
+      end
+
+      def update_attributes attributes
+        raise NotImplementedError
+      end
+
+      module ClassMethods
+        def all
+          raise NotImplementedError
+        end
+
+        def create attributes
+          raise NotImplementedError
+        end
+
+        def find id
+          raise NotImplementedError
+        end
+
+        def find_by attributes
+          raise NotImplementedError
+        end
+
+        def find_or_create_by attributes
+          raise NotImplementedError
+        end
+
+        def find_or_initialize_by attributes
+          raise NotImplementedError
+        end
+
+        def new attributes
+          raise NotImplementedError
+        end
+
+        def where attributes
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/hipbot/storages/hash.rb

@@ -0,0 +1,89 @@
+module Hipbot
+  module Storages
+    module Hash
+      extend ActiveSupport::Concern
+
+      included do
+        extend ClassMethods
+
+        attr_accessor :attributes
+        alias_method :to_s, :name
+      end
+
+      def initialize params = {}
+        self.attributes = params.with_indifferent_access
+      end
+
+      def id
+        attributes[:id]
+      end
+
+      def name
+        attributes[:name]
+      end
+
+      def name= value
+        update_attribute(:name, value)
+      end
+
+      def update_attribute key, value
+        self.attributes[key] = value
+      end
+
+      def update_attributes hash
+        hash.each do |k, v|
+          update_attribute k, v
+        end
+      end
+
+      def destroy
+        self.class.collection.delete(id)
+      end
+
+      module ClassMethods
+        include Cache
+
+        def all
+          collection.values
+        end
+
+        def create params
+          collection[params[:id]] = new(params)
+        end
+
+        attr_cache :collection do
+          {}
+        end
+
+        def find_or_create_by params
+          find_by(params) || create(params)
+        end
+
+        def find_or_initialize_by params
+          find_by(params) || self.new(params)
+        end
+
+        def find_by params
+          where(params).first
+        end
+
+        def find id
+          where(id: id).first
+        end
+
+        def where param
+          collection.values.select do |item|
+            param.all?{ |k, v| item.attributes[k] == v }
+          end
+        end
+
+        # protected
+
+        # def method_missing name, *args, &block
+        #   return all.public_send(name, *args, &block) if Array.instance_methods.include?(name)
+        #   super
+        # end
+      end
+    end
+  end
+end