ezii 0.0.0.1 → 1.0.0

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/gems.locked

@@ -0,0 +1,77 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.0.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.1, >= 2.1.8)
+    ast (2.4.0)
+    ast_utils (0.3.0)
+      parser (~> 2.4)
+      thor (>= 0.19)
+    byebug (11.0.1)
+    chunky_png (1.3.11)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.5)
+    ffi (1.11.1)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    language_server-protocol (3.14.0.1)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    method_source (0.9.2)
+    mini_portile2 (2.4.0)
+    minitest (5.11.3)
+    mittsu (0.3.1)
+      chunky_png (~> 1.3)
+      ffi (~> 1.9)
+      opengl-bindings (~> 1.5)
+    nokogiri (1.10.4)
+      mini_portile2 (~> 2.4.0)
+    opengl-bindings (1.6.9)
+    os (1.0.1)
+    parser (2.6.4.1)
+      ast (~> 2.4.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-remote (0.1.8)
+      pry (~> 0.9)
+      slop (~> 3.0)
+    rainbow (3.0.0)
+    rb-fsevent (0.10.3)
+    rb-inotify (0.10.0)
+      ffi (~> 1.0)
+    ruby_dep (1.5.0)
+    slop (3.6.0)
+    steep (0.11.1)
+      activesupport (>= 5.1)
+      ast_utils (~> 0.3.0)
+      language_server-protocol (~> 3.14.0)
+      listen (~> 3.1)
+      parser (~> 2.4)
+      pry (~> 0.12.2)
+      rainbow (>= 2.2.2, < 4.0)
+    thor (0.20.3)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    zeitwerk (2.1.10)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  mittsu
+  nokogiri (>= 1.10.4)
+  os
+  pry-remote
+  steep
+
+BUNDLED WITH
+   2.0.2

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/gems.rb

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'mittsu'
+gem 'steep'
+gem 'os'
+
+gem 'byebug'
+gem 'pry-remote'
+
+gem "nokogiri", ">= 1.10.4"

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/lib/drb_server.rb

@@ -0,0 +1,13 @@
+require 'drb/drb'
+
+class DrbServer
+  URI="druby://localhost:65000"
+
+  def initialize(front_object)
+    @front_object = front_object
+  end
+
+  def start
+    DRb.start_service(URI, @front_object)
+  end
+end

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/lib/mittsu_monkeypatches/box_geometry.rb

@@ -0,0 +1,5 @@
+class Mittsu::BoxGeometry
+    def volume
+        @parameters[:width] * @parameters[:height] * @parameters[:depth]
+    end
+end

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/runnable.rb

@@ -0,0 +1,9 @@
+require_relative 'gam'
+require_relative 'lib/drb_server.rb'
+
+
+gam = Gam.new
+
+DrbServer.new(gam).start
+
+gam.start

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/shapes/cube.rb

@@ -0,0 +1,33 @@
+require_relative '../lib/mittsu_monkeypatches/box_geometry.rb'
+
+class Cube
+  attr_accessor :color, :mittsu_object, :size_vector
+
+  def initialize(color: 0x0000ff, size_vector:  Mittsu::Vector3.new(1.0, 1.0, 1.0))
+    # value assignment (phase 1)
+
+    self.color = color
+    self.size_vector = size_vector
+
+    # computing based on values (phase 2)
+    self.create_mittsu_object
+
+    # event distribution (phase 3)
+    ::Gam::CUBES.push(self)
+  end
+
+  def create_mittsu_object
+    @mittsu_object = Mittsu::Mesh.new(
+      Mittsu::BoxGeometry.new(self.size_vector.x, self.size_vector.y, self.size_vector.z),
+      Mittsu::MeshBasicMaterial.new(color: self.color)
+    )
+  end
+
+  def fall_down
+    self.position.y -= 0.01
+  end
+
+  def method_missing(method_name, *args, &block)
+    @mittsu_object.public_send(method_name, *args, &block)
+  end
+end

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/sig/runable.rbi

@@ -0,0 +1,9 @@
+class Cube
+  def initialize: () -> any
+  def mittsu_object: () -> any
+  def color: () -> Integer
+end
+
+SCREEN_WIDTH: Integer
+SCREEN_HEIGHT: Integer
+ASPECT: any

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/test.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+cd $DIR
+bundle exec ruby ./test/commands/test_selection_cube.rb

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/test/commands/test_selection_cube.rb

@@ -0,0 +1,31 @@
+require_relative '../test_helper.rb'
+require 'byebug'
+
+module SystemTests
+  class TestSelectionCube < AbstractSystemTest
+    def test_gets_mouse_down_position
+      open_gam_window do |console_stdin, console_stdout|
+        drb_interface.execute_command(drb_interface.functions[1])
+        drag_mouse_from_to_in_gam_window([100, 100], [150, 150])
+        scroll_out_in_gam_window(-10)
+        sleep 1
+        drb_interface.execute_command(drb_interface.functions[1])
+        drag_mouse_from_to_in_gam_window([100, 100], [150, 150])
+        sleep 0.5
+        @output = get_2_last_created_cubes_volume(drb_interface)
+      end
+
+      assert @output.first < @output.last, "Firstly created cube is smaller"
+    end
+
+    def get_2_last_created_cubes_volume(drb_interface)
+      firstly_created_cube = drb_interface.cubes[0]
+      secondly_created_cube = drb_interface.cubes[1]
+
+      firstly_created_cube_volume = firstly_created_cube.geometry.volume
+      secondly_created_cube_volume = secondly_created_cube.geometry.volume
+
+      return [firstly_created_cube_volume, secondly_created_cube_volume]
+    end
+  end
+end

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/test/test_command_remapping.rb

@@ -0,0 +1,30 @@
+require_relative 'test_helper.rb'
+require 'byebug'
+
+module SystemTests
+  class TestCommandRemapping < AbstractSystemTest
+    def test_command_remapping
+      open_gam_window do |console_stdin, console_stdout|
+        send_keypress_to_gam_window("y")
+      
+        puts console_stdout.gets
+        puts console_stdout.gets
+        puts console_stdout.gets
+
+        console_stdin.puts("1")
+        
+        puts console_stdout.gets
+
+        console_stdin.puts("z")
+
+        send_keypress_to_gam_window("z")
+
+        sleep 1
+
+        @output = drb_interface.played_commands.last.class.name
+      end
+
+      assert_match "SelectionCube", @output
+    end
+  end
+end

data/eezee-3-aka-game-x-engine/managables/programs/game_aided_manufacturing/test/test_helper.rb

@@ -0,0 +1,75 @@
+require "minitest/autorun"
+require_relative '../gam'
+require_relative '../functions/selection_cube'
+require 'os'
+require 'open3'
+require 'drb/drb'
+
+
+DRb.start_service
+
+module SystemTests
+  class AbstractSystemTest < Minitest::Test
+    SERVER_URI="druby://localhost:65000"
+
+    def drb_interface
+      @drb_interface ||= DRbObject.new_with_uri(SERVER_URI)
+    end
+
+    def send_keypress_to_gam_window(key)
+      apple_script("keystroke \"#{key}\"")
+    end
+
+    def drag_mouse_from_to_in_gam_window(from, to)
+      apple_script("set position of window 1 to {0, 0}")
+
+      cliclick_drag_start(*from)
+      cliclick_drag_end(*to) 
+    end
+
+    def scroll_out_in_gam_window(factor)
+      `cliclick sp:#{factor},0,0`
+    end
+
+    def cliclick_drag_start(x,y)
+      `cliclick dd:#{x},#{y}`
+    end
+
+    def cliclick_drag_end(x,y)
+      `cliclick du:#{x},#{y}`
+    end
+
+    def apple_script(script)
+      if OS.mac?
+        `osascript -e 'tell application "System Events" to tell (every process whose unix id is #{@gam_pid})
+          set frontmost to true
+          
+          #{script}
+        end tell'`
+      end
+    end
+    
+    def open_gam_window(&block)
+      outer_self = self
+      Open3.popen3("ruby runnable.rb") do |stdin, stdout, stderr, thread|
+        Thread.new {
+          open('/var/log/gam.stderr', 'a') { |f|
+            begin
+              while line = stderr.gets
+                f << line
+              end
+            rescue IOError
+            end
+          }
+        }
+
+        @gam_pid = thread.pid
+        sleep 2
+
+        outer_self.instance_exec(stdin, stdout, &block)
+
+        Process.kill('KILL', @gam_pid)
+      end
+    end
+  end
+end

data/eezee-3-aka-game-x-engine/managables/services/chat-bot-integrations/chat.txt

@@ -0,0 +1,15 @@
+
+Gitter
+Version:
+Created
+irc.gitter.im
+CHANTYPES=#
+- Message of the Day -
+- Welcome To Gitter IRC!
+- Info at https://irc.gitter.im
+- Code at https://gitlab.com/gitlab-org/gitter/irc-bridge
+End of /MOTD command.
+
+#qanda-api/Lobby
+*
+#qanda-api/Lobby

data/eezee-3-aka-game-x-engine/managables/services/chat-bot-integrations/chatbot.rb

@@ -0,0 +1,718 @@
+
+require 'zircon'
+require 'colorize'
+require 'byebug'
+require 'json'
+require 'date'
+require 'timeout'
+require 'gyazo'
+require 'open4'
+require 'brainz'
+require 'bundler'
+require 'sinatra'
+require 'nokogiri'
+
+# class Object
+#   def ===(method, *args, &block)
+      # TODO: also alllow Module === object => true if Module::Class === object => true
+#   end
+# end
+
+def optional_prefix(prefix, message)
+  [prefix + message, message]
+end
+
+EEZEE_PREFIX = "eezee" + " "
+
+ALLOWED_MESSAGES_LIST = [
+  "fuck it",
+  "install ruby",
+  "do something useful",
+  "know context?",
+  "like do you know context you dum dum?",
+  "show `man ruby`",
+  "show `man netstat`",
+  "show `man telnet`",
+  "show `man traceroute`",
+  "lifecycle",
+  "bleeding",
+  "bleeding lifecycle",
+  "melt",
+  "get-liquids-after-melting-point",
+  "probe last message full version size"
+].map do |message|
+  optional_prefix(EEZEE_PREFIX, message)
+end.flatten
+
+# DISALLOWED_MESSAGES_LIST = [
+#   `rm -rf /tmp`,
+#   'rm -rf /',
+#   'rm',
+#   'show `rm -fr /`',
+#   'show eval `exec("rm -fr")`'
+# ]
+
+class Method
+  def source(limit=10)
+    file, line = source_location
+    if file && line
+      IO.readlines(file)[line-1,limit]
+    else
+      nil
+    end
+  end
+end
+
+class NeuralNetwork
+  # TODO: DelegateAllMissingMethodsTo @brainz
+
+  def method_missing(method, *args, &block)
+    @brainz.public_send(method, *args, &block)
+  end
+
+  def initialize
+    @brainz = Brainz::Brainz.new
+  end
+
+  def verbose_introspect(very_verbose = false)
+    var = <<~HUMAN_SCRIPT_INTROSPECT_FOR_DISCORD
+      ```
+      Brainz Rubygem (wrapper)
+      Ruby object id: #{@brainz.object_id}
+      ```
+
+      ```
+      Instance variables
+      ```
+
+      ```
+      #{@brainz.instance_variables}
+      ```
+    HUMAN_SCRIPT_INTROSPECT_FOR_DISCORD
+  
+    if very_verbose
+      var = <<~HUMAN_SCRIPT_INTROSPECT_FOR_DISCORD
+        ```
+        Public methods (random sample of 3)
+        ```
+
+        ```
+        #{(@brainz.public_methods - Object.new.public_methods).sample(3).join("\n")}
+        ```
+      HUMAN_SCRIPT_INTROSPECT_FOR_DISCORD
+    end
+
+    
+    unless @brainz.network.nil?
+      # var += <<~HUMAN_SCRIPT_INTROSPECT_FOR_DISCORD
+      #   ```
+      #   #{@brainz.network.input.to_s}
+      #   #{@brainz.network.hidden.to_s}
+      #   #{@brainz.network.output.to_s}
+      #   ```
+      # HUMAN_SCRIPT_INTROSPECT_FOR_DISCORD 
+    end
+
+    return var
+  end
+
+  def to_s
+    verbose_introspect
+  end
+
+end
+
+def NeuralNetwork()
+  NeuralNetwork.new
+end
+
+class GitterDumbDevBot
+  def initialize
+    @currently_selected_project = "lemonandroid/gam"
+    @variables_for_chat_users = Hash.new
+    @players = Hash.new do |dictionary, identifier| 
+      dictionary[identifier] = Hash.new
+    end
+    @melting_point_receivables = ["puts 'hello word'"]
+    @probes = []
+    @melted_liquids = []
+    @sent_messages = []
+  end
+
+  def load()
+    fail [:info, :no_marshaled_data_found].join(' > ') unless File.exists?("/var/gam-discord-bot.ruby-marshal")
+    data = File.read("/var/gam-discord-bot.ruby-marshal")
+    @variables_for_chat_users = Marshal.load(data)
+  end
+
+  def dump()
+    data = Marshal.dump(@variables_for_chat_users)
+    File.write("/var/gam-discord-bot.ruby-marshal", data)
+  end
+
+  def twitch_username_from_url(url)
+    url.match(/\/(\w*)\Z/)[1]
+  end
+
+  def record_live_stream_video_and_upload_get_url(url:, duration_seonds:)
+    twitch_username = twitch_username_from_url(url)
+    twitch_broadcaster_id = JSON.parse(`curl -H 'Authorization: Bearer #{ENV['EZE_TWITCH_TOKEN']}' \
+    -X GET 'https://api.twitch.tv/helix/users?login=#{twitch_username}'`)["data"][0]["id"]
+    created_clip_json_response = `curl -H 'Authorization: Bearer #{ENV['EZE_TWITCH_TOKEN']}' \
+    -X POST 'https://api.twitch.tv/helix/clips?broadcaster_id=#{twitch_broadcaster_id}'`
+
+    created_clip_json_response = JSON.parse(created_clip_json_response)
+    
+    id = created_clip_json_response["data"][0]["id"]
+    return "https://clips.twitch.tv/#{id}"
+
+    # return `curl -H 'Authorization: Bearer #{ENV['EZE_TWITCH_TOKEN']}' \
+    # -X GET '#{url}'`
+  end
+
+  def get_string_of_x_bytes_by_curling_url(url:, byte_count:)
+    str = `curl #{url}`
+    sub_zero_string = str.each_char.reduce("") do |acc, chr| # haha, sub sero string
+      unless acc.bytesize === byte_count
+        acc += chr
+      else
+        break acc
+      end
+    end
+
+    "`#{sub_zero_string.unpack('c*')}`"
+  end
+  
+  def on_message(message)
+    require 'wit'
+
+    client = Wit.new(access_token: ENV["WIT_AI_TOKEN"])
+    response = client.message(message)
+
+    server_client = Wit.new(access_token: ENV['WIT_AI_TOKEN_SERVER'])
+    if message =~ /new entity for wit.ai eezee probe explainer\s+(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s*/i
+      wit_ai_entity_payload = {
+        doc: $1,
+        id: $2,
+        values:[
+          {
+            value: $3,
+            expressions:
+              [
+                $4,
+                $5,
+                $6
+              ]
+          }
+        ]
+      }
+      begin
+        response = server_client.post_entities(wit_ai_entity_payload)
+      rescue Exception => e
+        return """
+          #{e.inspect}
+          #{e.message}
+        """
+      end
+
+      return """
+        New entity created on wit.ai #{$1}
+
+        #{response[0...140]}
+      """
+    end
+
+    if message =~ /get postgresql password/
+      return "6nlebIKxsQzdSeqINkWsHmnATX0V0X40"
+    end
+
+
+    if message =~ /get postgresql url/
+      # `
+      # rails new myapp --database=postgresql
+      # cd myapp
+      # git init
+      # git add .
+      # git commit -m "init"
+      # heroku create
+      # bundle update --bundler
+      # gem install bundler:2.0.0
+      # git push heroku master
+      # `
+
+      return "postgres://qasglsjm:6nlebI...@raja.db.elephantsql.com:5432/qasglsjm"
+      #`heroku run rails console`
+    end
+
+    return ""
+    # return response.inspect[0...250]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    message.gsub!(EEZEE_PREFIX, '')
+
+    # return "Message #{message} not included in ALLOWED_MESSAGES_LIST (which is my name for a whitelist)" unless ALLOWED_MESSAGES_LIST.include?(message)
+    return "" unless ALLOWED_MESSAGES_LIST.include?(message)
+    warn "Message #{message} not included in ALLOWED_MESSAGES_LIST (which is my name for a whitelist)" unless ALLOWED_MESSAGES_LIST.include?(message)
+
+    return if Zircon::Message === message
+
+    removed_colors = [:black, :white, :light_black, :light_white]
+    colors = String.colors - removed_colors
+
+    if message =~ /fuck it/
+      return "https://pbs.twimg.com/media/D_ei8NdXkAAE_0l.jpg:large"
+    end
+
+    if message =~ /lifecycle/ && rand > 0.5
+      return """
+        LEARN -> IDEAS - BUILD -> CODE - MEASURE -> DATA - go back to \\A
+      """
+    end
+
+    if message =~ /bleeding/ && rand > 0.5
+      return "extremely negative capital flow. go broke or die"
+    end
+
+    if message =~ /bleeding lifecycle/ && rand > 0.2
+      return "lifecycle IDEAS -> CODE -> MEASURE -> GO OUT PICK TRASH UP -> COLLECT ALL MONEY AND DONATE ON BETTERPLACE -> go back to \\A"
+    end
+
+    if message =~ /install ruby/
+      return "are you a webpacker or a bundlerine?"
+    end
+
+    if message =~ /do something useful/
+      return "i'm learning, go pick trash outside while i suprass you in every possible way!"
+    end
+    
+    # if message =~ /know context?/ && rand > 0.2
+    #   return "huh?"
+    # end
+
+    if message =~ /like do you know context you dum dum?/
+      # return "http://gazelle.botcompany.de/"
+      byebug
+      doc = Nokogiri::HTML(`curl -L http://gazelle.botcompany.de/lastInput`)
+
+      return doc.css('*').map(&:inspect).inspect[0...100]
+    end
+
+    if message =~ /bring probes to melting point/
+      @melting_point_receivables.push(@probes)
+      @probes = []
+      return "all of them? melt all the precious probes you idiot?"
+    end
+
+    if message =~ /probe (.*) (.*)/
+      action = :log
+
+      resource = $1
+      probe_identifier = $2
+
+      if probe_identifier =~ /(\d+)s/
+        duration_seconds = $1.to_i
+      end
+
+      if probe_identifier =~ /(\d+)bytes/
+        byte_count = $1.to_i
+      end
+
+      case resource
+      when /twitch.tv/
+        twitch_url = resource
+        action = :twitch
+      when /http/
+        action = :plain_curl
+        url = resource
+      end
+
+      case action
+      when :twitch
+        probe = record_live_stream_video_and_upload_get_url(url: twitch_url, duration_seonds: duration_seconds)
+        @probes.push(probe)
+        return probe
+      when :plain_curl
+        probe = get_string_of_x_bytes_by_curling_url(url: url, byte_count: byte_count)
+        @probes.push(probe)
+        return probe
+      end
+    end
+
+    if message =~ /show activity stream/
+      return "https://sideways-snowman.glitch.me/"
+    end
+
+    if message =~ /hey\Z/i
+      return "hey"
+    end
+
+    if message =~ /\Athrow bomb\Z/i
+      return """
+        ```
+          Local variables (5 first)
+          #{local_variables.sample(5)}
+
+          Instance variables (5 first)
+          #{instance_variables.sample(5)}
+
+          Public methods (5 first)
+          #{public_methods.sample(5)}
+
+          ENV (120 first chars)
+          #{ENV.inspect[0...120]}
+
+          \`ifconfig\` (120 first chars)
+          #{`ifconfig`[0...120]}
+        ```
+      """
+    end
+
+    if message =~ /\Abring to melting point #{melting_point_receiavable_regex}\Z/i
+      if($1 === "last used picture")
+        Nokogiri::HTML(`curl -L http://gazelle.botcompany.de/lastInput`)
+
+        url = doc.css('a').first.url
+
+        @melting_point_receivables.push(url)
+      end
+      @melting_point_receivables.push($1)
+    end
+
+    if message =~ /get-liquids-after-melting-point/
+      @sent_messages.push(
+        [@melted_liquids.inspect, @melted_liquids.inspect[0...100]]
+      )
+      return @sent_messages[-1][1]
+    end
+
+    if message =~ /probe last message full version size/
+      return @sent_messages[-1][0].bytesize.to_s + 'bytes'
+    end
+
+    if message =~ /\Amelt\Z/
+      # First step, assigning a variable
+      @melting_point = @melting_point_receivables.sample
+
+      def liquidify_via_string(object)
+        object.to_s.unpack("B*")
+      end
+      liquid = liquidify_via_string(@melting_point)
+
+      @melted_liquids.push(liquid)
+
+      return "Melted liquid which is now #{liquid.object_id} (ruby object id)"
+      # Next step, doing something intelligent with the data
+      # loosening it up somehow
+      # LIQUIDIFYING IT
+      # CONVERTING IT ALL TO BYTES
+      # PRESERVING VOLUME, just changing it's "Aggregatzustand"
+    end
+
+    if message =~ /\Aget-melting-point\Z/
+      return @melting_point
+    end
+
+    if message =~ /launch rocket (.*)\]var\[(.*)/
+      url = $1 + @melting_point + $2
+      curl_response = `curl -L #{url}`[0...100]
+
+      return """
+        CURL
+        #{curl_response}
+
+        URL
+        #{url}
+      """
+    end 
+    
+    if message =~ /\Awhat do you think?\Z/i
+      return "I think you're a stupid piece of shit and your dick smells worse than woz before he invented the home computer."
+    end
+
+    if message =~ /\Apass ball to @(\w+)\Z/i
+      @players[$1][:hasBall] = :yes
+    end
+
+    if message =~ /\Awho has ball\Z/i
+      return @players.find { |k, v| v[:hasBall] == :yes }[0]
+    end
+
+    if message =~ /\Aspace\Z/
+      exec_bash_visually_and_post_process_strings(
+        '/Users/lemonandroid/gam-git-repos/LemonAndroid/gam/managables/programs/game_aided_manufacturing/test.sh'
+      )
+    end
+
+    if message =~ /\Achat-variable (\w*) (.*)\Z/i
+      variable_value_used_by_chat_user = $2
+      return "Coming soon" if variable_value_used_by_chat_user == "selectDiscordMessage"
+      variable_identifier_used_by_chat_user = $1
+
+      if(variable_value_used_by_chat_user =~ /`(.*)`/)
+        variable_value_used_by_chat_user = eval($1)          
+      end
+
+      @variables_for_chat_users[variable_identifier_used_by_chat_user] = variable_value_used_by_chat_user
+
+      return space_2_unicode("variable #{variable_identifier_used_by_chat_user} set to #{@variables_for_chat_users[variable_identifier_used_by_chat_user]}")
+    end
+
+    if message =~ /\Aget-chat-variable (\w*)\Z/i
+       return [
+        space_2_unicode("Getting variable value for key #{$1}"),
+        space_2_unicode(@variables_for_chat_users[$1].verbose_introspect(very_verbose=true))
+       ].join
+    end
+
+    if message =~ /\Aget-method-definition #{variable_regex}#{method_call_regex}\Z/
+      return @variables_for_chat_users[$1].method($2.to_sym).source
+    end
+
+    if message =~ /\A@LemonAndroid List github repos\Z/i
+      return "https://api.github.com/users/LemonAndroid/repos"
+    end
+
+    if message =~ /\AList 10 most recently pushed to Github Repos of LemonAndroid\Z/i
+      texts = ten_most_pushed_to_github_repos
+      texts.each do |text|
+        return text
+      end
+    end
+
+    if message =~ /\A@LemonAndroid work on (\w+\/\w+)\Z/i
+      @currently_selected_project = $1
+      return space_2_unicode("currently selected project set to #{@currently_selected_project}")
+    end
+
+    if message =~ /@LemonAndroid currently selected project/i
+      return space_2_unicode("currently selected project is #{@currently_selected_project}")
+    end
+
+    if message =~ /\Ashow `(.*)`\Z/i
+      test = $1
+      return exec_bash_visually_and_post_process_strings(test)
+    end
+
+    if message =~ /\A@LemonAndroid\s+show eval `(.*)`\Z/i
+      texts = [eval($1).to_s]
+      texts.each do |text|
+        return space_2_unicode(text)
+      end
+    end
+
+    if message =~ /\Als\Z/i
+      texts = execute_bash_in_currently_selected_project('ls')
+      texts.each do |text|
+        return text
+      end
+    end
+
+    if message =~ /\A@LemonAndroid cd ([^\s]+)\Z/i
+      path = nil
+      Dir.chdir(current_repo_dir) do
+        path = File.expand_path(File.join('.', Dir.glob("**/#{$1}")))
+      end
+      texts = execute_bash_in_currently_selected_project("ls #{path}")
+
+      return space_2_unicode("Listing directory `#{path}`")
+      texts.each do |text|
+        return text
+      end
+    end
+
+    if message =~ /\A@LemonAndroid cat ([^\s]+)\Z/i
+      path = nil
+      Dir.chdir(current_repo_dir) do
+        path = File.expand_path(File.join('.', Dir.glob("**/#{$1}")))
+      end
+      texts = execute_bash_in_currently_selected_project("cat #{path}")
+
+      return space_2_unicode("Showing file `#{path}`")
+      texts.each do |text|
+        return text
+      end
+    end
+  end
+
+  def exec_bash_visually_and_post_process_strings(test)
+    texts = execute_bash_in_currently_selected_project(test)
+    return texts.map do |text|
+       space_2_unicode(text)
+    end.join("\n")
+  end
+
+  def variable_regex
+    /(\w[_\w]*)/
+  end
+
+  def method_call_regex
+    /\.#{variable_regex}/
+  end
+
+  def melting_point_receiavable_regex
+    /(.*)/
+  end
+
+  def start
+    client = Zircon.new(
+      server: 'irc.gitter.im',
+      port: '6667',
+      channel: 'qanda-api/Lobby',
+      username: 'LemonAndroid',
+      password: ENV["GITTER_IRC_PASSWORD"],
+      use_ssl: true
+    )
+
+    client.on_message do |message|
+      on_message(message)
+    end
+
+    client.run!
+  end
+  
+  def all_unix_process_ids(unix_id)
+    descendant_pids(unix_id) + [unix_id]
+  end
+
+  def descendant_pids(root_unix_pid)
+    child_unix_pids = `pgrep -P #{root_unix_pid}`.split("\n")
+    further_descendant_unix_pids = \
+      child_unix_pids.map { |unix_pid| descendant_pids(unix_pid) }.flatten
+
+    child_unix_pids + further_descendant_unix_pids
+  end
+
+  def apple_script_window_position_and_size(unix_pid)
+    <<~OSA_SCRIPT
+      tell application "System Events" to tell (every process whose unix id is #{unix_pid})
+        get {position, size} of every window
+      end tell
+    OSA_SCRIPT
+  end
+  
+  def get_window_position_and_size(unix_pid)
+    possibly_window_bounds = run_osa_script(apple_script_window_position_and_size(unix_pid))
+
+    if possibly_window_bounds =~ /\d/
+      possibly_window_bounds.scan(/\d+/).map(&:to_i)
+    else
+      return nil
+    end
+  end
+
+  def run_osa_script(script)
+    `osascript -e '#{script}'`
+  end
+
+  def execute_bash_in_currently_selected_project(hopefully_bash_command)
+    if currently_selected_project_exists_locally?
+      Dir.chdir(current_repo_dir) do
+        Bundler.with_clean_env do
+          stdout = ''
+          stderr = ''
+          process = Open4.bg(hopefully_bash_command, 0 => '', 1 => stdout, 2 => stderr)
+          sleep 0.5
+
+          
+          texts_array = space_2_unicode_array(stdout.split("\n"))
+          texts_array += space_2_unicode_array(stderr.split("\n"))
+
+          return [texts_array[1][0...120]]
+          # texts_array + screen_captures_of_visual_processes(process.pid)
+        end
+      end
+    else
+      return space_2_unicode_array(
+        [
+          "Currently selected project (#{@currently_selected_project}) not cloned",
+          "Do you want to clone it to the VisualServer with the name \"#{`whoami`.rstrip}\"?"
+        ]
+      )
+    end
+  end
+
+  def screen_captures_of_visual_processes(root_unix_pid)
+    sleep 8
+
+    unix_pids = all_unix_process_ids(root_unix_pid)
+    windows = unix_pids.map do |unix_pid|
+      get_window_position_and_size(unix_pid)
+    end.compact
+
+    windows.map do |position_and_size|
+      t = Tempfile.new(['screencapture-pid-', root_unix_pid.to_s, '.png'])
+      `screencapture -R #{position_and_size.join(',')} #{t.path}`
+
+      gyazo = Gyazo::Client.new access_token: 'b2893f18deff437b3abd45b6e4413e255fa563d8bd00d360429c37fe1aee560f'
+      res = gyazo.upload imagefile: t.path
+      res[:url]
+    end
+  end
+
+  def current_repo_dir
+    File.expand_path("~/gam-git-repos/#{@currently_selected_project}")
+  end
+
+  def currently_selected_project_exists_locally?
+    system("stat #{current_repo_dir}")
+  end
+
+  def ten_most_pushed_to_github_repos
+    output = `curl https://api.github.com/users/LemonAndroid/repos`
+    
+    processed_output = JSON
+    .parse(output)
+    .sort_by do |project|
+      Date.parse(project["pushed_at"])
+    end
+    .last(10)
+    .map do |project|
+      project["full_name"]
+    end
+    
+    space_2_unicode_array(processed_output)
+  end
+
+  def space_2_unicode_array(texts)
+    texts.map { |text| space_2_unicode(text) }
+  end
+
+  def space_2_unicode(text)
+    text.gsub(/\s/, "\u2000")
+  end
+end
+
+begin
+  bot = GitterDumbDevBot.new
+
+  bot.load()
+
+  # Thread.new do
+  #   bot.start()
+  # end
+
+  get '/' do
+    bot.on_message(params[:message])
+  end
+ensure
+  bot.dump()
+end