elephrame 0.4.6 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c1ed54678e256a816845886696ca58289d035a7351deb2ec8180915a36f2471
-  data.tar.gz: 15cf11fd775bf2ec0716aa524af6a35ff7996ad724b311cccac89a087039eb5f
+  metadata.gz: da4cb8e7330a90534de1df0dfcd992669f3406081d8b84432026961116976184
+  data.tar.gz: '08828035932340977b30d9db147c5df568b08d5b5dfa835967ab6940d808ac1e'
 SHA512:
-  metadata.gz: 3664bc68bad91273c4b99084729f01f21e2a7ab77f1e98397eb4f32b7c3906522c0105b049954d64bce0e4b5d1b83af7be548bf3ad1659f597e31dfe496c418e
-  data.tar.gz: 57063548c113a5819ad8c73a94f07082fd2071ac7acc3ffaa70b09eaf0cd9a72caf163911f03ec9cdf6358a9e478fc5b54c5d8d0e384ad055006525bc024859d
+  metadata.gz: 447b5a423594675b6d949ad2bb29a67d74db3cb278484c133f9213b10a622d3607a0a09ad2e55c363d7c76651fb1690091965f09e17d1534a2f9ed20b2ed017d
+  data.tar.gz: ed0d5bd6ee5869626d235de919b468ca768f14b8bb1b5da5dd6574edd8eccf3f10f6fa7ac6e3badf769ea6879ce5b233cb05436b0eb3fa4ece2e9be5972e7847

data/Gemfile

@@ -4,3 +4,5 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in elephrame.gemspec
 gemspec
+
+gem 'tzinfo-data', :platforms => [:mingw, :x64_mingw, :mswin]

data/Gemfile.lock

@@ -1,7 +1,9 @@
 PATH
   remote: .
   specs:
-    elephrame (0.4.6)
+    elephrame (0.5)
+      htmlentities (~> 4.0)
+      moo_ebooks (~> 1)
       moostodon (~> 0.4.0)
       rufus-scheduler
       tracery (~> 0.7)
@@ -13,13 +15,16 @@ GEM
       public_suffix (>= 2.0.2, < 4.0)
     buftok (0.2.0)
     concurrent-ruby (1.1.5)
-    domain_name (0.5.20180417)
+    domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
-    et-orbi (1.1.7)
+    et-orbi (1.2.1)
       tzinfo
-    fugit (1.1.8)
-      et-orbi (~> 1.1, >= 1.1.7)
+    fugit (1.3.1)
+      et-orbi (~> 1.1, >= 1.1.8)
       raabro (~> 1.1)
+    highscore (1.2.1)
+      whatlanguage (>= 1.0.0)
+    htmlentities (4.3.4)
     http (3.3.0)
       addressable (~> 2.3)
       http-cookie (~> 1.0)
@@ -30,32 +35,40 @@ GEM
     http-form_data (2.1.1)
     http_parser.rb (0.6.0)
     minitest (5.11.3)
+    moo_ebooks (1.1.0)
+      highscore (~> 1.2)
+      htmlentities (~> 4.3)
     moostodon (0.4.0)
       addressable (~> 2.5)
       buftok (~> 0)
       http (~> 3.0)
       oj (~> 3.3)
-    oj (3.7.10)
-    public_suffix (3.0.3)
+    oj (3.8.1)
+    public_suffix (3.1.1)
     raabro (1.1.6)
     rake (10.5.0)
-    rufus-scheduler (3.5.2)
-      fugit (~> 1.1, >= 1.1.5)
+    rufus-scheduler (3.6.0)
+      fugit (~> 1.1, >= 1.1.6)
     tracery (0.7.7)
     tzinfo (2.0.0)
       concurrent-ruby (~> 1.0)
+    tzinfo-data (1.2019.2)
+      tzinfo (>= 1.0.0)
     unf (0.1.4)
       unf_ext
-    unf_ext (0.0.7.5)
+    unf_ext (0.0.7.6)
+    whatlanguage (1.0.6)
 
 PLATFORMS
   ruby
+  x64-mingw32
 
 DEPENDENCIES
   bundler (~> 1.17)
   elephrame!
   minitest (~> 5.0)
   rake (~> 10.0)
+  tzinfo-data
 
 BUNDLED WITH
-   1.17.2
+   1.17.3

data/README.md

@@ -19,11 +19,11 @@ gem 'elephrame'
 
 And then execute:
 
-    $ bundle
+    bundle
 
 Or install it yourself as:
 
-    $ gem install elephrame
+    gem install elephrame
 
 ## Quickstart
 
@@ -34,15 +34,17 @@ require 'elephrame'
 
 my_bot = Elephrame::Bots::Periodic.new '3h'
 
-my_bot.run { |bot|
+my_bot.run do |bot|
   bot.post("i'm gay")
-}
+end
 ```
 
 	$ INSTANCE="https://mastodon.social" TOKEN="your_access_token" ruby bot.rb
 
 Check the [examples](https://github.com/theZacAttacks/elephrame/tree/master/examples) directory for more example bots
 
+If you're new to ruby development in general there is also a [getting started](https://github.com/theZacAttacks/elephrame/tree/master/examples/getting_started.org) document in the examples folder that I would recommend you to read. It takes a high level approach to getting started with ruby, some basic syntax, working with gems, basic project structure, and more!
+
 ### Bot Types
 
 So far the framework support 6 bot types: Periodic, Interact, PeroidInteract, Reply, Command, Watcher

data/elephrame.gemspec

@@ -1,4 +1,3 @@
-
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "elephrame/version"
@@ -42,5 +41,7 @@ Gem::Specification.new do |spec|
   
   spec.add_dependency 'rufus-scheduler'
   spec.add_dependency 'moostodon', '~> 0.4.0'
+  spec.add_dependency 'moo_ebooks', '~> 1'
   spec.add_dependency 'tracery', '~> 0.7'
+  spec.add_dependency 'htmlentities', '~>4.0'
 end

data/examples/ebooks.rb

@@ -0,0 +1,24 @@
+require 'elephrame'
+
+# So, we want to create an ebook bot
+#   all of the hardwork is done in the backend by the framework!
+#
+# we just need to make sure the account we're posting from is set up right
+#  make sure that the ebooks account is following all of the accounts you
+#  want to generate posts from (e.g., if you just want it to be a personal
+#                               ebooks bot then just have it follow you,
+#                               if you want it to generate posts from everyone
+#                               in a group then make sure it follows them all)
+# 
+# once that's taken care of we need to tell the framework some options for our bot
+#  how often to post, how often to get new statuses from the accounts it's following
+#  what the CW should be for all of its posts (this is polite ;3  )
+#  what the lowest level visiblility setting we should grab to generate from
+#
+# thats just what ive supplied in this example, but there are more options!
+#  to see them all please check the documentation (see main README for link)
+bot = Elephrame::Bots::EbooksBot.new '1m', update_interval: '2d',
+                                     cw: 'ebooks post', scrape_privacy: 'unlisted'
+
+# run the bot!
+bot.run

data/examples/getting_started.org

@@ -0,0 +1,484 @@
+* Getting Started
+
+** Table of Contents
+
+- [[#ruby][Ruby]]
+  + [[#installing][Installing]]
+  + [[#playing-around][Playing around]]
+  + [[#basic-syntax][Basic Syntax]]
+  + [[#variables][Variables]]
+  + [[#constants][Constants]]
+  + [[#methods][Methods]]
+  + [[#string-interpolation][String Interpolation]]
+  + [[#blocks][Blocks]]
+  + [[#more-info][More Info]]
+- [[#gems][Gems]]
+  + [[#what-are-gems][What are Gems?]]
+  + [[#install-gems][Install Gems]]
+  + [[#bundler][Bundler]]
+- [[#running-a-script][Running a Script]]
+  + [[#without-bundler][Without Bundler]]
+  + [[#with-bundler][With Bundler]]
+- [[#elephrame][Elephrame]]
+  + [[#bot-types][Bot Types]]
+  + [[#putting-it-all-together][Putting It All Together]]
+  + [[#getting-more-advanced][Getting More Advanced]]
+
+** Ruby
+:PROPERTIES:
+:CUSTOM_ID: ruby
+:END:
+
+*** Installing
+:PROPERTIES:
+:CUSTOM_ID: installing
+:END:
+If you use Linux/BSD then use your package manager to install ruby.
+
+If you're on Mac you should have an older version of ruby installed. If you want to install a newer version I would recommend looking into [[https://brew.sh][homebrew]] and using it to install an updated ruby version.
+
+If you're on Windows there is [[https://rubyinstaller.org/downloads/][RubyInstaller]]. Make sure you choose the one that has the devkit! It's important uwu
+
+Once you have ruby installed we can check and make sure!
+
+Open up your command line (cmd on Windows, Terminal on Linux/BSD/Mac) and type in =ruby --version=
+
+If everything has been set up properly it'll print out the version of ruby you're using!
+
+*** Playing around
+:PROPERTIES:
+:CUSTOM_ID: playing-around
+:END:
+To play around in an interactive environment open up your command line and type in =irb=  (Interactive RuBy)
+
+This drops you into an interactive ruby shell where you are free to experiment and play around with new ideas without having to write an entirely new file.
+
+Feel free to play around in this! Any code I have written in here can be executed in this environment.
+
+*** Basic Syntax
+:PROPERTIES:
+:CUSTOM_ID: basic-syntax
+:END:
+There are a lot of data types in ruby:
+
+- strings
+- hash tables
+- arrays
+- integers
+- floating point numbers
+- files
+- symbols
+- ... and a lot more!
+
+I'm going to go over how a few of these different data types are represented in ruby.
+
+Strings in ruby can be written in a few different ways: 'this is a string', "So is this"  (this difference will be covered later!)
+
+Numbers (floating point or integers) are the easiest to write because it's just a number! E.g., 4, 7.5, 220, -10
+
+Arrays are just a list of other objects and are represented like this: [1, 2, 3], ["First", "Second", "Third"]
+
+Hash tables are basically arrays that allow you to reference bits of data out of them using words. They look very similar to arrays, so don't get confused! E.g., { first: 1, second: 2 }
+
+*** Variables
+:PROPERTIES:
+:CUSTOM_ID: variables
+:END:
+In ruby you can store data in 'holders' called variables. Imagine it's like putting water into a jug, you're just storing it in a place you know for later!
+
+It's as easy as this: 
+
+#+BEGIN_SRC ruby
+variable = "Testing"
+#+END_SRC
+
+Variables can be named anything, so long as they don't contain certain special characters or start with a number or a capital letter.
+
+Invalid variable names:
+
+#+BEGIN_SRC ruby
+1variable
+#+END_SRC
+
+Valid variable names:
+
+#+BEGIN_SRC ruby
+variable1
+test_variable
+really_long_variable_name
+#+END_SRC
+
+Variablese can be reused as many times as you want. So if you have some code like this:
+
+#+BEGIN_SRC ruby
+my_variable = 15
+my_variable = my_variable + 3
+#+END_SRC
+
+Then it would store the result of 18 back into =my_variable=! 
+
+*** Constants
+:PROPERTIES:
+:CUSTOM_ID: constants
+:END:
+Constants are like variables, but instead of being able to change them on the fly they remain the same (constant!).
+
+How do we tell variables apart from constants? It's easy! All constants are capitalized.
+
+This is a constant: =ImportantConstant= and this is a variable: =important_variable=
+
+Constants can only be defined once and whatever data you put into one stays there. So be careful that you won't need to modify anything after you put it into a constant.
+
+*** Methods
+:PROPERTIES:
+:CUSTOM_ID: methods
+:END:
+
+Methods are chunks of code that are grouped underneath a single name.
+They allow a developer to easily reuse code across a project.
+
+To define a method you need to do the following:
+
+#+BEGIN_SRC ruby
+def example
+end
+#+END_SRC
+
+Any code that you put between the line starting with =def= and the line starting with =end= will be able to run by just writing =example=!
+
+if you wanted to be able to pass data into methods we can do that, too!
+
+#+BEGIN_SRC ruby
+def example(param1, param2)
+end
+#+END_SRC
+
+you now would call example this: =example(1,2)= and any code inside of the method would have access to =1,2= through the variables =param1, param2=!
+
+*** String Interpolation
+:PROPERTIES:
+:CUSTOM_ID: string-interpolation
+:END:
+Okay so let's go back to strings and the differences between strings 'like this' and strings "like this".
+
+Let's say you've got a variable named =output_data= and you wanted to print it out with some text around it.
+In other programming language you'd have to do something like this: 
+
+#+BEGIN_SRC python
+"Here's the data " + output_data + " that I found!"
+#+END_SRC
+
+but ruby allows for a really nifty thing called String Interpolation. 
+Here's how it looks:
+
+#+BEGIN_SRC ruby
+"Here's the data #{output_data} that I found!"
+#+END_SRC
+
+As you can tell, it makes it look a lot nicer and a lot easier to add variables into strings! 
+
+Not only can you put variables into strings like this, you can also put method calls! Any kind of code can go in there! 
+
+#+BEGIN_SRC ruby
+"Some really cool data: #{my_cool_method()}"
+#+END_SRC
+
+*** Blocks
+:PROPERTIES:
+:CUSTOM_ID: blocks
+:END:
+
+Blocks are a fairly unique thing to ruby. They allow you do define code and pass them as parameters to methods. Here's an example:
+
+#+BEGIN_SRC ruby
+example_method do 
+  puts "Hello from a block!"
+end
+#+END_SRC
+
+Everything between (and including) =do= and =end= is a block! You can pass it to functions, and if they support accepting blocks they'll be able to run whatever code you include! This is useful, but it's made even more useful because data can be passed *in* to a block as well. Here's an example of how that looks:
+
+#+BEGIN_SRC ruby
+example_method2 do |data, data2|
+  puts "Hello from a block!"
+  puts "I recieved this data: #{data}"
+  puts "I recieved this data as well: #{data2}"
+end
+#+END_SRC
+
+Think about the syntax like this: =data= and =data2= are *sliding* into the block. That's why they need the =|= s on either side of them! Otherwise how will they safely get in there? :P
+
+*** More info
+:PROPERTIES:
+:CUSTOM_ID: more-info
+:END:
+
+If this quick intro to ruby has sparked your interest and you want to know more about it, i recommend this [[https://poignant.guide/book/chapter-3.html][guide]]. it can be a bit much at some points, but i found it a great introduction to ruby!
+
+** Gems
+:PROPERTIES:
+:CUSTOM_ID: gems
+:END:
+
+*** What are Gems?
+:PROPERTIES:
+:CUSTOM_ID: what-are-gems
+:END:
+In the world of ruby third-party libraries are referred to as gems. They are offered by many places, but the primary source of gems is [[https://rubygems.org][RubyGems]]. There are a *lot* of gems there. Go and check some of them out!
+
+*** Install Gems
+:PROPERTIES:
+:CUSTOM_ID: install-gems
+:END:
+Knowing about gems is nice and all but how do you get them onto your system? Well, when you installed ruby you got a nice little utility installed, called =gem=. 
+
+So let's go back to your command line, if you're still in =irb= you can either open a new window or type =quit= to exit it. Once you're back at the main command line interface run =gem -h= to have the gem utility print out a little help text.
+
+Let's go ahead and install a gem that we'll be using for the next section: bundler.
+
+=gem install bundler=
+
+*** Bundler
+:PROPERTIES:
+:CUSTOM_ID: bundler
+:END:
+Bundler is a cool utility that allows you to install gems on a per-project level, keeping the system gem cache clean! If you're following along then you should have it installed now, so lets see some of what it can do: =bundle -h=
+
+As you can see there are a lot of subcommands! The ones that you'll primarily be using are 'install' and 'exec'. The install command, appropriately installs a gem onto your system. The exec command is a little more abstract. It takes whatever other commands after 'exec' and runs them in the context of that project. 
+
+So if you have a certain gem installed in a project and you want to play around with using it with =irb= then you would run =bundle exec irb= and then you'd be able to have an interactive playground with all the gems from that project! 
+
+**** Gemfile
+:PROPERTIES:
+:CUSTOM_ID: gemfile
+:END:
+This is neat and all, but how does bundler know what gems a specific project needs? Well, thats where the Gemfile comes into play. The Gemfile contains the source, specifications, and versions of any gems you want to use in your project. Here is an example Gemfile that tells bundler to use the elephrame gem!
+
+#+BEGIN_SRC ruby
+source 'https://rubygems.org'
+
+gem 'elephrame'
+#+END_SRC
+
+There are a lot of extra options that you can use in a Gemfile, but at its basest this is how to use one!
+
+**** Project Structure
+:PROPERTIES:
+:CUSTOM_ID: project-structure
+:END:
+So now that we've got a basic Gemfile, where do we put it? It belongs at the top level of your project! So, assuming we have our project in its own folder and our project's main ruby file is called =main.rb=, our file structure would look something like this:
+
+#+BEGIN_SRC
+project_folder/
+project_folder/Gemfile
+project_folder/main.rb
+#+END_SRC
+
+And that's it!
+
+After you have your project setup like this, you need to tell bundler to install your gems. To do that all you have to do is have your project opened in your command line and run =bundle install= and it'll get the rest set up properly!
+
+** Running a script
+:PROPERTIES:
+:CUSTOM_ID: running-a-script
+:END:
+After you've put all the work into a cool app or project you'd want to be able to run it right? Since ruby is an interpreted language it doesn't need to be compiled before we execute it. However, this also means that we can't just execute our new program, we have to tell the ruby interpretor to read the file and start executing it.
+
+Both of the following examples assume a project strutcure like the above.
+
+*** Without Bundler
+:PROPERTIES:
+:CUSTOM_ID: without-bundler
+:END:
+If your project does not use bundler then there are a few steps you don't have to take, so we can just jump right to executing the script.
+
+Open your command line interface, go to your project's folder and execute: =ruby main.rb=
+
+
+*** With Bundler
+:PROPERTIES:
+:CUSTOM_ID: with-bundler
+:END:
+If your project does use bundler then we have to first make sure that all of your gem dependecies are up to date: =bundle install=
+
+Once that finishes, open your command line interface, go to your project's folder and execute: =bundle exec ruby main.rb=
+
+We use =bundle exec= because we need ruby to run in the context of the project and use the gems that the project needs.
+
+
+** Elephrame
+:PROPERTIES:
+:CUSTOM_ID: elephrame
+:END:
+
+elephrame is a high level framework for creating bots for mastodon/pleroma. It abstracts away a lot of the routines that a bot developer would have to write in order to get started, providing 'templates' that you can overwrite with your own custom functionality.
+
+
+*** Bot Types
+:PROPERTIES:
+:CUSTOM_ID: bot-types
+:END:
+
+elephrame has many different types of bots, here's a list of the different types and their intended purposes:
+
+- Periodic: posts statuses on a specific schedule or interval
+- Interact: provides ways to call code when an account gets an interaction (boost, favorite, reply, follow)
+- PeriodInteract: combines the above two functionalities
+- Command: provides an easy way to create bots that wait for specific commands before doing anything ('!help', '!update', etc.)
+- Watcher: watches a specific timeline (global, local, hashtag, home) for updates and runs code when it sees posts
+- TraceryBot: very similar to PeriodInteract, except it provides shortcuts for using tracery style grammar files
+- EbooksBot: scans all posts from an account or accounts and generates new posts/replies based off of that input
+- Markov-bot: scans a text file and generates posts/replies based off of that input
+
+*** Putting It All Together
+:PROPERTIES:
+:CUSTOM_ID: putting-it-all-together
+:END:
+
+Okay! Enough explanation, lets create a bot!
+
+Assuming you have ruby installed and set up properly, create a folder to hold your files. I'll name mine =getting-started-example=
+
+Once the folder is created, lets go and create our Gemfile. Open your text editor and create a new file in your folder named =Gemfile= and inside of it put the following:
+
+#+BEGIN_SRC ruby
+source 'https://rubygems.org'
+
+gem 'elephrame'
+#+END_SRC
+
+Once you have done that, make sure you save it and open up your command line. You'll want to go to your project folder, and once there do a quick =bundle install=
+
+That will install your gems that you've specified in your Gemfile. Your project folder should look something like this (I'm going to use my folder name, just pretend it's yours!):
+
+#+BEGIN_SRC
+getting-started-example/
+getting-started-example/Gemfile
+getting-started-example/Gemfile.lock
+#+END_SRC
+
+Now, back in your text editor, create a new file in your folder called =main.rb= and enter this into it (don't worry, we'll go over it line by line in a second):
+
+#+BEGIN_SRC ruby
+require 'elephrame'
+
+ExampleBot = Elephrame::Bots::Periodic.new '10s'
+
+ExampleBot.run do |bot|
+  bot.post("Hello, world!")
+end
+#+END_SRC
+
+Let's break that down!
+
+#+BEGIN_SRC ruby
+require 'elephrame'
+#+END_SRC
+
+This first line loads the elephrame library. We call the process whereby ruby loads an external library =requiring= that library. When you =require= a library it gets loaded into the current ruby process and allows us to use code that is a part of it. Usually you'll want to keep any =require= statements at the top of your ruby programs, so that anyone who reads through your code knows what all is bring loaded! 
+
+#+BEGIN_SRC ruby
+ExampleBot = Elephrame::Bots::Periodic.new '10s'
+#+END_SRC
+
+This second line shows us creating a new Periodic bot (=Elephrame::Bots::Periodic.new=), passing it ='10s'= and assigning it to the constant =ExampleBot=. In ruby objects can 'live' in a 'package'. 'Packages' are like folders in your filesystem, however instead of being separated with an '/' or '\' they're separated with '::'. So one way to look at this is 'use the Periodic object in the Bots folder of Elephrame'. The =.new= at the end is saying 'create a new instance of this object'. We're passing in ='10s'= because a Periodic bot needs to know how often it needs to post, this is saying 'post every 10 seconds'. 
+
+Putting all of that together: "create a new instance of the Periodic object from the Bots folder of Elephrame, tell it to post every 10 seconds, and put that bot inside of ExampleBot"
+
+#+BEGIN_SRC ruby
+ExampleBot.run do |bot|
+  bot.post("Hello, world!")
+end
+#+END_SRC
+
+Now we're getting to the tricky parts! =ExampleBot.run= is a method that takes a block which is what elephrame does when it runs the bot. So, like explained above, we do a block (the =do ... end= parts). This block passes out a parameter which gives us access to the bot letting us post, among other things! The next line, =bot.post("Hello, world!")= is the logic that runs every time the bot is supposed to run. It tells the framework to simply post the status "Hello, world!". There are many options that the =post= method supports, but for this simple case just providing the status to post will do.
+
+Now that we've gone over it, make sure you save it! Your project folder should now look something like this:
+
+#+BEGIN_SRC
+getting-started-example/
+getting-started-example/Gemfile
+getting-started-example/Gemfile.lock
+getting-started-example/main.rb
+#+END_SRC
+
+Now that we've got all of the files set up, we need to get our bot's token! Without a token our bot can't make or read posts. Open Mastodon (it can be your account for now, but I would encourage you to make a separate account for your bot once it's finished), and open the settings. There will be an option on the side for 'Development' settings. Open that, and then generate a new application token. Set the name to "My Elephrame Example", leaving the homepage blank and the redirect URI set to the default. You can give the bot any permissions you want, but this example bot needs (at least) the write:status permission. Once you've filled out the necessary fields go and click 'save' at the bottom. It will take you back to the main development menu, except your newly created application will be an option to click. Go ahead and click on it and copy the access token it shows. This token is very special and is what allows your bot to connect to Mastodon!
+
+Open up your command line, and run the following in your project folder:
+
+Linux/MacOS: ~INSTANCE="https://your.instance" TOKEN="yourToken" bundle exec ruby main.rb~
+
+Windows:
+
+#+BEGIN_SRC bat
+set INSTANCE=https://your.instance
+set TOKEN=yourToken
+bundle exec ruby main.rb
+#+END_SRC
+
+
+If everything worked properly then running these commands will cause your command line to appear to hang up, as though it's waiting for input. That means your bot is working!
+
+If you have your Mastodon account open (the account you got the token from) then after 10 seconds you should see a post from your account saying "Hello, World!". Since this is the only code our bot has it will continue posting this every 10 seconds forever.
+
+Congratulations! You've made your first Mastodon bot! :3
+
+*** Getting More Advanced
+:PROPERTIES:
+:CUSTOM_ID: getting-more-advanced
+:END:
+
+Now that you've gotten your first bot under your belt, let's expand on it! Let's add in the ability for the bot to respond to replies!
+
+To do this, we're going to change the base type of the bot to =PeriodInteract= and add in some code to handle what happens when we get a reply.
+
+Reopen =main.rb= in your text editor if you don't still have it open and edit it until it resembles the following:
+
+#+BEGIN_SRC ruby
+require 'elephrame'
+
+ExampleBot = Elephrame::Bots::PeriodInteract.new '10s'
+
+ExampleBot.on_reply do |bot, post|
+  bot.reply("Hello, user!")
+end
+
+ExampleBot.run do |bot|
+  bot.post("Hello, world!")
+end
+#+END_SRC
+
+Let's break those changes down a bit!
+
+First things first: we changed what kind of bot we're using from =Periodic= to =PeriodicInteract=.
+
+#+BEGIN_SRC ruby
+ExampleBot.on_reply do |bot, post|
+  bot.reply("Hello, user!")
+end
+#+END_SRC
+
+We also added in a new method, =on_reply=. It looks very similar to how we use =run= doesn't it? That's because we do use it the exact same way! PeriodInteract allows us to react whenever the bot's account receives any kind of interaction through =on_fave=, =on_boost=, =on_follow=, and =on_reply= methods. Each of these methods accept a block just like the =run= method does, however, these methods pass in another object besides just the main bot one like =run= does. They pass in =bot= (a reference to the main bot object) and =post= (a reference to the post that received the interaction [except in the case of =on_reply=, which receives the reply itself]). The code inside the block is also slightly different than that of the =run= method in that instead of using the =bot.post= method we use the =bot.reply= method. That method, as you may have guessed, this makes the bot reply to the new mention with ="Hello, user!"=.
+
+Saving and running it from your command line will have your bot posting every 10 seconds and also replying to any user who replies to one of their posts!
+
+
+This is good and all, but it feels so impersonal, but we can fix that!
+
+Change the =on_reply= code to this:
+
+#+BEGIN_SRC ruby
+ExampleBot.on_reply do |bot, post|
+  user_name = post.account.display_name
+  bot.reply("Hello, #{user_name}!")
+end
+#+END_SRC
+
+What we have now will respond back to a reply with their display name! To accomplish this we've combined a lot of the basics that we've covered above!
+
+To start with, we save the display name for the account that the reply came from (=post.account.display_name=), and put it into the reply string using string interpolation (="Hello, #{user_name}!"=).
+
+Let me explain how we got the account's display name. Each post object contains a lot of data about itself including the =account= it came from, the =content= of the post, it's =id=, it's =spoiler_text= (Content Warning), and much more! The account object is very similar, containing it's =id=, =username=, =acct= (full account handle e.g., example@test.lol), and =display_name=.
+
+*Note: most data exposed through Mastodon objects can be found [[https://docs.joinmastodon.org/api/entities/][here]].*
+

data/examples/markov.rb

@@ -0,0 +1,20 @@
+require 'elephrame'
+
+# tell the bot how often to post, and where to find it's source material,
+#  then we go and set options for it
+marxkov = Elephrame::Bots::MarkovBot.new '3h', 'markov_files',
+                                         visibility: 'unlisted', cw: 'markov post'
+
+# then we tell the bot to post
+marxkov.run
+                                         
+
+
+
+
+
+
+
+
+
+