Cinch-Automode 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 831e6ea6d01c75667b4ac3838c4b0d2b98314c7a
+  data.tar.gz: a9ca84fa21ce3a18358d0db99194f521d43bf610
+SHA512:
+  metadata.gz: 6706cfa4655d43d45cc3212bd154b9d91f5a8be6744e2ccdc32e6efb3ff99927cbcfc5130f2d24e3b8efd047cb8955462f0d797217594a0e9d507a64fa145c48
+  data.tar.gz: 1f9aeb68c3e70283c4671fafa28a51c991dd4ec431dc30d1ed74d7351bdbb5b87e18dff70fb3161dd8075cd0fde6b9c683b01859accf0624871396817a270ba5

data/Cinch-Automode.gemspec

@@ -0,0 +1,43 @@
+
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push('lib')
+require 'cinch/plugins/automode/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'Cinch-Automode'
+  s.version  = Cinch::Automode::VERSION.dup
+  s.date     = '2016-02-28'
+  s.summary  = 'Cinch plugin to automatically apply modes to people on join'
+  s.email    = 'lilian.jonsdottir@gmail.com'
+  s.homepage = 'https://github.com/lilyseki/Cinch-Automode'
+  s.authors  = ['Lily Jónsdóttir']
+  s.license  = 'MIT'
+
+  s.description = <<-EOF
+Automatically apply a mode to a user based on nick!user@host when they join a
+channel. Also has commands to add and delete users, and apply mode to anyone
+that joins a channel.
+EOF
+
+  dependencies = [
+    [:runtime, 'sequel', '~> 4.31'],
+  ]
+
+  s.files         = Dir['**/*']
+  s.test_files    = Dir['test/**/*'] + Dir['spec/**/*']
+  s.executables   = Dir['bin/*'].map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  ## Make sure you can build the gem on older versions of RubyGems too:
+  s.rubygems_version = '2.5.1'
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.specification_version = 3 if s.respond_to? :specification_version
+
+  dependencies.each do |type, name, version|
+    if s.respond_to?("add_#{type}_dependency")
+      s.send("add_#{type}_dependency", name, version)
+    else
+      s.add_dependency(name, version)
+    end
+  end
+end

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+=====================
+
+Copyright (c) 2016 Lily Jónsdottír
+
+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,59 @@
+Automode Plugin for Cinch
+========================
+Auto op/halfop/voice users based on nick!user@host or apply the mode to an
+entire channel
+
+Usage
+-----
+
+Until I figure out how to make it into a gem, download the .rb file, and place 
+it in a subdirectory of your bot entitled 
+`plugins` then require it via `require_relative`. 
+Add it to your bot like so:
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ruby
+require 'cinch'
+require_relative 'plugins/automode.rb'
+
+bot = Cinch::Bot.new do
+configure do |c|
+  c.server = 'your server'
+  c.nick = 'your nick'
+  c.realname = 'your realname'
+  c.user = 'your user'
+  c.channels = ['#yourchannel']
+  c.plugins.plugins = [Cinch::Plugins::Automode]
+end
+
+bot.start
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Contained Commands
+------------------
+
+**[automode (on|off)]**
+
+Enable/disable the plugin in the current channel. Default is off.
+
+**[add (op|halfop|voice) nick user@host]**
+
+Add nick with user@host to the auto-(op|halfop|voice) list
+
+**[del (op|halfop|voice) nick user@host]**
+
+Delete nick with user@host from the auto-(op|halfop|voice) list
+
+**[add channel (op|halfop|voice)]**
+
+Add the entire channel to the list, so anyone who joins gets the mode.
+
+**[del channel (op|halfop|voice)]**
+
+Delete the channel from the mode list.
+
+License
+-------
+
+Licensed under The MIT License (MIT)
+
+Please see LICENSE

data/lib/cinch/plugins/automode/version.rb

@@ -0,0 +1,5 @@
+module Cinch
+  module Automode
+    VERSION = '0.0.1'.freeze
+  end
+end

data/lib/cinch/plugins/automode.rb

@@ -0,0 +1,259 @@
+#!/usr/bin/env ruby
+# encoding=utf-8
+
+require 'sequel'
+
+# These are all very annoying.
+# rubocop:disable Metrics/LineLength, Metrics/ClassLength, Metrics/CyclomaticComplexity
+# rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+
+module Cinch
+  module Plugins
+    # Automode plugin using Sequel + SQLite database
+    class Automode
+      include Cinch::Plugin
+      listen_to :join
+
+      private
+
+      def initialize(*args)
+        super
+        @automode = {}
+        # Initialize the db
+        @db = Sequel.sqlite('riria.db')
+        # Create the tables if they don't exist
+        @db.create_table? :users do
+          primary_key :id
+          String :name
+          String :mode
+        end
+        @db.create_table? :hostmasks do
+          primary_key :id
+          Int :user_id
+          String :mask
+        end
+        @db.create_table? :userchans do
+          primary_key :id
+          Int :user_id
+          String :chan
+        end
+        @db.create_table? :channels do
+          primary_key :id
+          String :chan
+          String :mode
+        end
+      end
+
+      # making shit stand out in the console for debug
+      def header(title)
+        puts '=' * 5 + " #{title} " + '=' * 5
+      end
+
+      # reading and writing database methods
+      def read_db(nick, hostmask, channel)
+        # header 'reading?'
+        # puts "db class: #{@db.class}"
+        # puts "db tables: #{@db.tables}"
+        return 'no' unless @db.table_exists?(:users)
+
+        users = @db[:users] # Users table
+        hosts = @db[:hostmasks] # Hostmasks table
+        userchans = @db[:userchans] # User channels table
+        chans = @db[:channels] # Automode all channels table
+
+        unless chans.where(chan: channel).all.empty?
+          return chans.where(chan: channel).first[:mode]
+        end
+
+        # header 'database'
+        # puts users.all
+        # puts hosts.all
+        # puts userchans.all
+        # header 'end database'
+
+        return 'no' if users.where(nick: nick).first.nil?
+        return 'admin' if users.where(nick: nick).first[:mode] == 'admin'
+
+        user_id = users.where(nick: nick).first[:id]
+        has_hostmasks = hosts.where(user_id: user_id).map(:mask)
+        has_channels = userchans.where(user_id: user_id).map(:chan)
+
+        # puts "hostmask: #{hostmask}"
+        # puts "hostmasks: #{has_hostmasks}"
+        # puts "channels: #{has_channels}"
+        # puts "has? #{has_hostmasks.include?(hostmask)}"
+        # puts "mode: #{users.where(nick: nick).first[:mode]}"
+
+        return 'no' unless has_hostmasks.include?(hostmask)
+        return 'no' unless has_channels.include?(channel)
+        users.where(nick: nick).first[:mode]
+      end
+
+      def write_db(nick, hostmask, mode, in_chan)
+        # header 'writing?'
+        # puts "db class: #{@db.class}"
+        # puts "db tables: #{@db.tables}"
+
+        users = @db[:users]
+        hosts = @db[:hostmasks]
+        chans = @db[:userchans]
+
+        # header 'database'
+        # puts users.all
+        # puts hosts.all
+        # puts chans.all
+        # header 'end database'
+
+        # If user isn't in db, add user to db
+        if users.where(nick: nick).first.nil?
+          users.insert(nick: nick, mode: mode)
+        else
+          # If user is in db, update mode with provided
+          users.where(nick: nick).update(mode: mode)
+        end
+
+        user_id = users.where(nick: nick).first[:id]
+        if hosts.where(user_id: user_id, mask: hostmask).first.nil?
+          hosts.insert(user_id: user_id, mask: hostmask)
+        end
+
+        if chans.where(user_id: user_id, chan: in_chan).first.nil?
+          chans.insert(user_id: user_id, chan: in_chan)
+        end
+
+        # Words to say
+        output = "User #{users.where(nick: nick).first[:nick]} added "
+        output << "hostmask #{hosts.where(user_id: user_id).all[-1][:mask]} "
+        output << "with mode #{users.where(nick: nick).first[:mode]}"
+        # header 'stuff'
+        # puts "output: #{output}"
+        # puts "user_id: #{user_id}"
+
+        # header 'database'
+        # puts users.all
+        # puts hosts.all
+        # puts chans.all
+        # header 'end database'
+
+        output
+      end
+
+      def add_channel(chan, mode)
+        chans = @db[:channels]
+        if chans.where(chan: chan).first.nil?
+          chans.insert(chan: chan, mode: mode)
+        else
+          chans.where(chan: chan).update(mode: mode)
+        end
+        output = "#{chans.where(chan: chan).first[:chan]} "
+        output << "added with mode #{chans.where(chan: chan).first[:mode]}"
+        # puts output
+        output
+      end
+
+      public
+
+      match(/automode (on|off)$/, method: :endisable)
+      def endisable(m, option)
+        hostmask = m.raw.split(' ')[0].delete(':').split('!')[1]
+        return unless read_db(m.user.nick, hostmask, nil) == 'admin'
+        @automode[m.channel] = option == 'on'
+
+        m.reply "Automode is now #{@automode[m.channel] ? 'enabled' : 'disabled'}"
+      end
+
+      def listen(m)
+        @automode[m.channel] ||= true
+        return unless @automode[m.channel]
+        return if m.user.nick == bot.nick
+        # header 'listen?'
+        hostmask = m.raw.split(' ')[0].delete(':').split('!')[1]
+        mode = read_db(m.user.nick, hostmask, m.channel.to_s)
+        case mode
+        when 'admin'
+          m.channel.op(m.user)
+        when 'op'
+          m.channel.op(m.user)
+        when 'halfop'
+          m.channel.mode("+h #{m.user}")
+        when 'voice'
+          m.channel.voice(m.user)
+        when 'no'
+          return
+        else
+          return
+        end
+      end
+
+      match(/add(?: (.+))?/, method: :add_user)
+      def add_user(m, query)
+        hostmask = m.raw.split(' ')[0].delete(':').split('!')[1]
+        return unless read_db(m.user.nick, hostmask, nil) == 'admin'
+        # .add mode nick user@host
+        query = query.split(' ')
+        mode = query[0]
+        nick = query[1]
+        hostmask = query[2]
+        goodtypes = %w(op halfop voice admin)
+        goodmask = /(.*)@(.*)/ =~ hostmask
+
+        if mode == 'channel'
+          m.reply add_channel(m.channel.to_s, query[1])
+          return
+        end
+
+        m.reply('Bad mode type!') && return unless goodtypes.include?(mode)
+        m.reply('Bad hostmask!') && return unless goodmask
+        m.reply write_db(nick, hostmask, mode, m.channel.to_s)
+      end
+
+      match(/del(?: (.+))?/, method: :del_user)
+      def del_user(m, query)
+        hostmask = m.raw.split(' ')[0].delete(':').split('!')[1]
+        return unless read_db(m.user.nick, hostmask, nil) == 'admin'
+        # .del nick user@host >>> remove host from nick
+        # .del nick >>> remove nick from db
+        nick = query.split[0]
+        host = query.split[1]
+        users = @db[:users]
+        hosts = @db[:hostmasks]
+
+        if nick == 'channel'
+          chan_todel = m.channel.to_s
+          chans = @db[:channels]
+          m.reply 'Channel not in db' && return if chans.where(chan: chan_todel).first.nil?
+          them = chans.where(chan: chan_todel).first[:mode]
+          chans.where(chan: chan_todel).delete
+          m.reply "#{chan_todel} with mode #{them} removed"
+          return
+        end
+
+        m.reply('User not in db!') && return if users.where(nick: nick).all.empty?
+
+        user_id = users.where(nick: nick).first[:id]
+        if host.nil?
+          u_num = users.where(nick: nick).delete
+          h_num = hosts.where(user_id: user_id).delete
+          if u_num.zero? && h_num.zero?
+            m.reply('Not baleeted!')
+          else
+            m.reply('Baleeted!')
+          end
+        else
+          h_num = hosts.where(user_id: user_id, mask: host).delete
+          if h_num.zero?
+            m.reply('Not baleeted!')
+          else
+            m.reply('Baleeted!')
+          end
+        end
+        # header 'database'
+        # puts users.all
+        # puts hosts.all
+        # header 'end database'
+      end
+    end
+  end
+end
+
+# vim:tabstop=2 softtabstop=2 expandtab shiftwidth=2 smarttab foldmethod=syntax:

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: Cinch-Automode
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Lily Jónsdóttir
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.31'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.31'
+description: |
+  Automatically apply a mode to a user based on nick!user@host when they join a
+  channel. Also has commands to add and delete users, and apply mode to anyone
+  that joins a channel.
+email: lilian.jonsdottir@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Cinch-Automode.gemspec
+- LICENSE.md
+- README.md
+- lib/cinch/plugins/automode.rb
+- lib/cinch/plugins/automode/version.rb
+homepage: https://github.com/lilyseki/Cinch-Automode
+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.5.1
+signing_key: 
+specification_version: 3
+summary: Cinch plugin to automatically apply modes to people on join
+test_files: []