cosgrove 0.0.1rc1

data/Rakefile

@@ -0,0 +1,43 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'yard'
+require 'cosgrove'
+
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.ruby_opts << if ENV['HELL_ENABLED']
+    '-W2'
+  else
+    '-W1'
+  end
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+end
+
+task default: :test
+
+task :console do
+  exec "irb -r cosgrove -I ./lib"
+end
+
+task :build do
+  exec 'gem build cosgrove.gemspec'
+end
+
+task :push do
+  exec "gem push cosgrove-#{Cosgrove::VERSION}.gem"
+end
+
+# We're not going to yank on a regular basis, but this is how it's done if you
+# really want a task for that for some reason.
+
+# task :yank do
+#   exec "gem yank cosgrove -v #{Cosgrove::VERSION}"
+# end

data/cosgrove.gemspec

@@ -0,0 +1,49 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cosgrove/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'cosgrove'
+  spec.version = Cosgrove::VERSION
+  spec.authors = ['Anthony Martin']
+  spec.email = ['cosgrove@martin-studio.com']
+
+  spec.summary = %q{Cosgrove Discord Bo t}
+  spec.description = %q{STEEM centric Discord bot.}
+  spec.homepage = 'https://github.com/steem-third-party/cosgrove'
+  spec.license = 'CC0 1.0'
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test)/}) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 11.2.2'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-line'
+  spec.add_development_dependency 'minitest-proveit'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'vcr'
+  spec.add_development_dependency 'faraday'
+  spec.add_development_dependency 'typhoeus'
+  spec.add_development_dependency 'simplecov'
+  # spec.add_development_dependency 'codeclimate-test-reporter'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'byebug'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'awesome_print'
+
+  spec.add_dependency 'radiator'
+  spec.add_dependency 'steemdata-rb'
+  spec.add_dependency 'discordrb'
+  spec.add_dependency 'ai4r'
+  spec.add_dependency 'mongoid'
+  spec.add_dependency 'ruby-cleverbot-api'
+  spec.add_dependency 'steem-slap'
+  spec.add_dependency 'activeview'
+  spec.add_dependency 'rdiscount'
+  spec.add_dependency 'phantomjs'
+  spec.add_dependency 'mechanize'
+  spec.add_dependency 'wolfram-alpha'
+  spec.add_dependency 'rmagick'
+end

data/lib/cosgrove.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'yaml'
+require 'action_view'
+require 'radiator'
+require 'awesome_print'
+# require 'pry'
+
+Bundler.require
+
+SteemData.load
+
+module Cosgrove
+  PWD = Dir.pwd.freeze
+  KNOWN_CHAINS = [:steem, :golos, :test]
+  
+  require 'cosgrove/version'
+  require 'cosgrove/phantomjs'
+  require 'cosgrove/agent'
+  require 'cosgrove/config'
+  require 'cosgrove/utils'
+  require 'cosgrove/account'
+  require 'cosgrove/support'
+  require 'cosgrove/market'
+  require 'cosgrove/upvote_job'
+  require 'cosgrove/comment_job'
+  require 'cosgrove/bot'
+end

data/lib/cosgrove/account.rb

@@ -0,0 +1,103 @@
+require 'digest/bubblebabble'
+
+module Cosgrove
+  class Account
+    include Cosgrove::Config
+
+    ACCOUNTS_FILE ||= "#{Cosgrove::PWD}/accounts.yml".freeze
+    DISCORD_IDS = 'discord_ids'.freeze
+    
+    attr_accessor :chain, :account_name, :discord_ids
+    
+    def initialize(account_name, chain = :steem)
+      raise "Unknown Chain: #{chain}" unless Cosgrove::KNOWN_CHAINS.include? chain.to_sym
+      
+      @account_name = account_name.to_s.downcase
+      @chain = chain
+      @discord_ids = []
+      
+      if !!details
+        @discord_ids = details[DISCORD_IDS] || []
+      end
+    end
+    
+    def self.find_by_discord_id(discord_id, chain = :steem)
+      return if Account.yml[chain.to_s].nil?
+      
+      discord_id = discord_id.to_s.split('@').last.split('>').first.to_i
+      
+      Account.yml[chain.to_s].each do |k, v|
+        ids = v[DISCORD_IDS]
+        return Account.new(k, chain) if !!ids && ids.include?(discord_id)
+      end
+      
+      return nil
+    end
+    
+    def self.find_by_memo_key(memo_key, secure, chain = :steem)
+      Account.yml[chain.to_s].each do |k, v|
+        v[DISCORD_IDS].each do |discord_id|
+          return Account.new(k, chain) if Account.gen_memo_key(k, discord_id, chain, secure) == memo_key
+        end
+      end
+      
+      return nil
+    end
+    
+    def chain_data
+      @chain_data ||= Account.yml[@chain.to_s] || {}
+    end
+    
+    def details
+      chain_data[@account_name] ||= {}
+      chain_data[@account_name]
+    end
+    
+    def hidden?
+      !!details['hidden']
+    end
+    
+    def novote?
+      !!details['novote']
+    end
+    
+    def add_discord_id(discord_id)
+      details[DISCORD_IDS] ||= []
+      details[DISCORD_IDS] << discord_id.to_i
+      details[DISCORD_IDS] = details[DISCORD_IDS].uniq
+      
+      Account.save_yml!
+    end
+    
+    def memo_key(discord_id)
+      Account.gen_memo_key(@account_name, discord_id, cosgrove_secure, @chain)
+    end
+    
+    def chain_account
+      if !!@account_name
+        response = api(chain).get_accounts([@account_name])
+        account = response.result.first
+      end
+    end
+  private
+    def self.gen_memo_key(account_name, discord_id, secure, chain)
+      raise "Unknown Chain: #{chain}" unless Cosgrove::KNOWN_CHAINS.include? chain.to_sym
+      
+      Digest.bubblebabble(Digest::SHA1::hexdigest(account_name + discord_id.to_s + chain.to_s + secure)[8..12])
+    end
+    
+    def self.save_yml!
+      File.open(ACCOUNTS_FILE, 'w') do |f|
+        f.write @yml.to_yaml
+      end
+    end
+    
+    def self.yml
+      @yml = if File.exist?(ACCOUNTS_FILE)
+        YAML.load_file(ACCOUNTS_FILE)
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/cosgrove/agent.rb

@@ -0,0 +1,25 @@
+require 'mechanize'
+
+module Cosgrove
+  class Agent < Mechanize
+    COOKIE_FILE ||= 'cookies.yml'
+    
+    def initialize
+      super('cosgrove')
+      
+      @agent.user_agent = 'Mozilla/5.0 (iPad; U; CPU OS 3_2_1 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Mobile/7B405'
+      @agent.keep_alive = false
+      @agent.open_timeout = 10
+      @agent.read_timeout = 10
+      
+      # Cookie management, see: https://gist.github.com/makevoid/4282237
+      @agent.pre_connect_hooks << Proc.new do 
+        @agent.cookie_jar.load COOKIE_FILE if ::File.exist?(COOKIE_FILE)
+      end
+      
+      @agent.post_connect_hooks << Proc.new do
+        @agent.cookie_jar.save COOKIE_FILE
+      end
+    end
+  end
+end

data/lib/cosgrove/bot.rb

@@ -0,0 +1,149 @@
+require 'discordrb'
+
+module Cosgrove
+  require 'cosgrove/snark_commands'
+  
+  cattr_accessor :latest_steemit_link, :latest_golos_link
+  
+  @@latest_steemit_link = {}
+  @@latest_golosio_link = {}
+  
+  class Bot < Discordrb::Commands::CommandBot
+    include Support
+    include SnarkCommands
+    
+    def initialize(options = {})
+      options[:token] ||= cosgrove_token
+      options[:client_id] ||= cosgrove_client_id
+      super(options)
+      
+      @on_success_upvote_job = options[:on_success_upvote_job]
+      
+      self.bucket :voting, limit: 4, time_span: 8640, delay: 10
+
+      add_all_commands
+      add_all_messages
+      SnarkCommands::add_all_snark_commands(self)
+    end
+    
+    def add_all_messages
+      # A user typed a link to steemit.com
+      self.message(content: /http[s]*:\/\/steemit\.com\/.*/, ignore_bots: false) do |event|
+        link = event.content.split(' ').first
+        Cosgrove::latest_steemit_link[event.channel.name] = link
+        append_link_details(event, link)
+      end
+
+      # A user typed a link to golos.io.
+      self.message(content: /http[s]*:\/\/golos\.io\/.*/, ignore_bots: false) do |event|
+        link = event.content.split(' ').first
+        Cosgrove::latest_golosio_link[event.channel.name] = link
+      end
+    end
+    
+    def add_all_commands
+      self.command :help do |_event, *args|
+        help = []
+        help << "`$slap [target]` - does a slap on the `target`"
+        help << "`$verify <account> [chain]` - check `account` association with Discord users (`chain` default `steem`)"
+        help << "`$register <account> [chain]` - associate `account` with your Discord user (`chain` default `steem`)"
+        help << "`$upvote [url]` - upvote from #{steem_account}; empty or `^` to upvote last steemit link"
+        help.join("\n")
+      end
+      
+      self.command :version do |_|
+        "cosgrove: #{Cosgrove::VERSION} :: https://github.com/steem-third-party/cosgrove"
+      end
+      
+      self.command :verify do |event, key, chain = :steem|
+        mongo_behind_warning(event)
+        if key.nil?
+          event.respond "To create an account: https://steemit.com/enter_email?r=#{steem_account}"
+          return
+        end
+        
+        account = find_account(key, event)
+        
+        if !!account && account.respond_to?(:name)
+          cb_account = Cosgrove::Account.new(account.name, chain)
+        else
+          discord_id = key.split('@').last.split('>').first.to_i
+          cb_account = Cosgrove::Account.find_by_discord_id(discord_id, chain)
+          
+          account = if !!cb_account
+            find_account(cb_account.account_name, event)
+          end
+        end
+        
+        if !!account && !!cb_account && cb_account.discord_ids.any?
+          if cb_account.hidden?
+            "#{chain.to_s.upcase} account `#{account.name}` has been registered."
+          else
+            discord_ids = cb_account.discord_ids.map { |id| "<@#{id}>" }
+            
+            "#{chain.to_s.upcase} account `#{account.name}` has been registered with #{discord_ids.to_sentence}."
+          end
+        elsif !!account
+          "#{chain.to_s.upcase} account `#{account.name}` has not been registered with any Discord account.  To register:\n`$register #{account.name}`"
+        elsif discord_id.to_i > 0
+          "<@#{discord_id}> has not been associated with a #{chain.to_s.upcase} account.  To register:\n`$register <account>`"
+        else
+          "No association found.  To register:\n`$register <account>`"
+        end
+      end
+      
+      self.command :register do |event, account_name, chain = :steem|
+        mongo_behind_warning(event)
+        account = find_account(account_name, event)
+        discord_id = event.author.id
+        
+        return nil unless !!account
+        
+        cb_account = Cosgrove::Account.new(account.name, chain)
+        
+        if cb_account.discord_ids.include? discord_id
+          event.respond "Already registered `#{account.name}` on `#{chain.upcase}` with <@#{discord_id}>"
+          return
+        end
+        
+        memo_key = cb_account.memo_key(discord_id)
+        op = SteemData::AccountOperation.type('transfer').
+          where(account: steem_account, from: account.name, to: steem_account, memo: {'$regex' => ".*#{memo_key}.*"}).last
+          
+        if op.nil?
+          # Fall back to RPC.  The transaction is so new, SteemData hasn't seen it
+          # yet, SteemData is behind, or there is no such transfer.
+          
+          response = api(chain).get_account_history(steem_account, -1000, 1000)
+          op = response.result.map do |history|
+            e = history.last.op
+            type = e.first
+            next unless type == 'transfer'
+            o = e.last
+            next unless o.from == account.name
+            next unless o.to == steem_account
+            next unless o.memo =~ /.*#{memo_key}.*/
+            
+            o
+          end.compact.last
+        end
+          
+        if !!op
+          cb_account.add_discord_id(discord_id)
+          "Ok.  #{chain.to_s.upcase} account #{account.name} has been registered with <@#{discord_id}>."
+        else
+          "To register `#{account.name}` with <@#{discord_id}>, send `0.001 #{chain.upcase}` to `#{steem_account}` with memo: `#{memo_key}`\n\nThen type `$register #{account.name}` again."
+        end
+      end
+      
+      self.command(:upvote, bucket: :voting, rate_limit_message: 'Sorry, you are in cool-down.  Please wait %time% more seconds.') do |event, slug = nil|
+        slug = Cosgrove::latest_steemit_link[event.channel.name] if slug.nil? || slug.empty? || slug == '^'
+        options = {
+          on_success: @on_success_upvote_job
+        }
+
+        Cosgrove::UpvoteJob.new(options).perform(event, slug)
+      end
+    end
+  end
+end

data/lib/cosgrove/comment_job.rb

@@ -0,0 +1,140 @@
+require 'rdiscount'
+
+module Cosgrove
+  class CommentJob
+    include Cosgrove::Utils
+    include Cosgrove::Support
+    
+    def perform(event, slug, template, message = nil)
+      author_name, permlink = parse_slug slug
+      muted = muted by: steem_account, chain: :steem
+      
+      posts = SteemData::Post.root_posts.where(author: author_name, permlink: permlink)
+      
+      post = posts.first
+      author = SteemData::Account.find_by(name: author_name)
+      
+      if post.nil?
+        # Fall back to RPC
+        response = api(:steem).get_content(author_name, permlink)
+        unless response.result.author.empty?
+          post = response.result
+          created = Time.parse(post.created + 'Z')
+          cashout_time = Time.parse(post.cashout_time + 'Z')
+        end
+      end
+      
+      if post.nil?
+        cannot_find_input(event)
+        return
+      end
+      
+      created ||= post.created
+      cashout_time ||= post.cashout_time
+      
+      nope = if post.nil?
+        "Sorry, couldn't find that."
+      elsif cashout_time < Time.now.utc
+        'Unable to comment on that.  Too old.'
+      elsif post.parent_permlink == 'nsfw'
+        puts "Won't comment because parent_permlink: nsfw"
+        'Unable to comment on that.'
+      elsif post.json_metadata.include?('nsfw')
+        puts "Won't comment because json_metadata includes: nsfw"
+        'Unable to comment on that.'
+      elsif post.active_votes.map{ |v| v['voter'] }.include?('blacklist-a')
+        puts "Won't comment blacklist-a voted."
+        'Unable to comment on that.'
+      elsif (rep = to_rep(post.author_reputation).to_f) < 25.0
+        puts "Won't comment because rep too low: #{rep}"
+        'Unable to comment on that.'
+      elsif muted.include? author_name
+        puts "Won't vote because author muted."
+        'Unable to vote.'
+      # elsif template == :welcome && author.post_count != 1
+      #   'Sorry, this function is intended to welcome new authors.'
+      elsif SteemData::Post.where(author: steem_account, parent_permlink: post.permlink).any?
+        title = post.title
+        title = post.permlink if title.empty?
+        "I already commented on #{title} by #{post.author}."
+      end
+
+      if !!nope
+        event.respond nope
+        return
+      end
+      
+      now = Time.now
+      comment = {
+        type: :comment,
+        parent_permlink: post.permlink,
+        author: steem_account,
+        permlink: "re-#{post.author.gsub(/[^a-z0-9\-]+/, '-')}-#{post.permlink}-#{now.utc.strftime('%Y%m%dt%H%M%S%Lz')}", # e.g.: 20170225t235138025z
+        title: '',
+        body: merge(template, message, event.author.username),
+        json_metadata: "{\"tags\":[\"#{post.parent_permlink}\"],\"app\":\"#{Cosgrove::AGENT_ID}\"}",
+        parent_author: post.author
+      }
+      
+      ap comment
+      
+      tx = new_tx :steem
+      op = Radiator::Operation.new(comment)
+      tx.operations << op
+      
+      response = tx.process(true)
+      
+      ap response.inspect
+      
+      if !!response.error
+        'Unable to comment right now.  Maybe I already commented on that.  Try again later.'
+      elsif !!response.result.id
+        "Wrote #{template} comment on: #{post.title} by #{author_name}"
+      else
+        ':question:'
+      end
+    end
+    
+    def merge(template, message = nil, username = 'someone', markup = :html)
+      @comment_md ||= "support/#{template}.md"
+      @comment_body ||= {}
+      @comment_body[template] ||= if File.exist?(@comment_md)
+        File.read(@comment_md)
+      end
+      
+      raise "Cannot read #{template} template or template is empty." unless @comment_body[template].present?
+      
+      merged = @comment_body[template]
+      merged = merged.gsub('${message}', message) unless message.nil?
+      merged = merged.gsub('${username}', username) unless username.nil?
+      
+      case markup
+      when :html then RDiscount.new(merged).to_html
+      when :markdown then merged
+      end
+    end
+    
+    def preview(template, event, message)
+      m = "Your Message Here"
+      discord_id = event.author.id
+      
+      @author = if (a = Cosgrove::Account.find_by_discord_id(discord_id)).nil?
+        event.author.username
+      else
+        "@#{a.account_name}"
+      end
+      
+      if message.present?
+        @message = message
+      end
+      
+      preview = []
+      preview << "Set by **#{@author}**" if @author.present?
+      preview << "```md\n"
+      preview << merge(template, @message || m, @author, :markdown)
+      preview << "\n```"
+      
+      preview.join('')
+    end
+  end
+end