replyr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05a40f3b1f0148dcff5d4643db55547ab76c7b1e
+  data.tar.gz: bad9440558e05ca2e926517dda94d662339e02a7
+SHA512:
+  metadata.gz: 43442dddff869b36e478e8e415f2d680ca64a9d5a0e8f45ff2303ee4739684c66a2865e28069785964c901a1ea1596f09c5623259a30dacc5a3336dbf2e120b9
+  data.tar.gz: a62949cae32390d4639d08eb3836002ade91b9674555e4187f21cba87224d8350bd3cade18425b82c87ea9360592f999d5767ff137f4f9f5572a53261ba58892

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1
+
+initial release

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+# Declare your gem's dependencies in replyr.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Philipp Wüllner
+
+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,94 @@
+#Replyr [![Build Status](https://travis-ci.org/wursttheke/replyr.png?branch=master)](https://travis-ci.org/wursttheke/replyr)
+
+Replyr lets you receive and process reply emails with Rails. And with ease!
+
+#### Here's an example
+
+> A User gets an email notification about a comment being posted on his page. Now he answers this email directly from his email client with a followup comment. Replyr receives the anwser and creates a new comment on his page.
+
+#### How does this work?
+
+Replyr generates a special `reply_to` email address which is unique to the user receiving the notification and the object in question (e.g. a comment). The resulting reply email address looks something like this:
+
+reply-comment-12-56-01ce26dc69094af9246ea7e7ce9970aff2b81cc9@example.com
+
+This address will be set as the reply_to address in the outgoing email from the rails app. When the user answers the email, the message will be sent to this address and Replyr will be able to handle it accordingly. It will check the mail for validity and then pass it to your custom code, which will then create a new comment.
+
+#### How do the emails get into my app?
+
+Replyr uses the awesome [Mailman Gem](https://github.com/titanous/mailman) to receive the reply emails. It can be configured to get the emails via Maildir, from a POP3- or from an IMAP-Server. It runs as a background daemon and observes your email directory or polls your email server for new emails. Take a look at the documentation to find out about its features and how to set it up:
+
+https://github.com/titanous/mailman
+
+## Requirements
+
+  - Ruby >= 1.9.3
+  - Rails 3 >= 3.1 or Rails 4.x
+
+## Installtion
+
+#### Add the gem to your `Gemfile`
+
+```ruby
+gem 'replyr'
+```
+
+#### Install
+
+```bash
+$ bundle
+$ rails g replyr:install
+```
+
+#### Edit initializer 
+
+Open up `config/initializers/replyr.rb` and set the host name of your reply email address.
+
+```ruby
+Ryplr.config.host = "yourdomain.com"
+```
+
+#### Setup Mailman Gem
+
+The Install Generator will already have created a `script/mailman_server` file which boots up the Mailman background job. According to your setup you will have to configure the file to your needs. By default it is setup to observe the `~/Maildir` folder in your home directory.
+
+## Usage
+
+#### Make a model accept replies
+
+Update your ActiveRecord models you want to reply to by adding a `handle_reply` like this:
+
+```ruby
+class Comment < ActiveRecord::Base
+  belongs_to :user
+  
+  handle_reply do |comment, user, text, files|
+    Comment.create(body: text)
+  end
+end
+```
+
+The `handle_reply` method takes a block with 4 parameters. The first one is the original object (in this case the comment). The second is the user who is sending the reply. The third is the reply plain text from the email (HTML mails are not supported). The fourth and last argument is an Array of `StringIO` objects representing all files attached to the emails.
+
+What you put in the `handle_reply` block is completely up to you. In this example we are just creating a new comment, but you could also handle attached files by passing them to carrierwave, etc.
+
+#### Make your mailers send the `reply_to` address
+
+To add the unique reply address to your outgoing emails and make them 'replyable', add the reply_to option to your mailers methods:
+
+```ruby
+class CommentMailer < ActionMailer::Base
+  def new_comment(user, comment)
+    mail(to: user.email, reply_to: comment.reply_address_for_user(user))
+  end
+end
+```
+
+## Start up
+
+Start/Stop up the Mailman background worker with the following commands:
+
+```bash
+$ RAILS_ENV=production script/mailman_daemon start
+$ RAILS_ENV=production script/mailman_daemon stop
+```

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Replyr'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/email_reply_parser/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) GitHub
+
+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/lib/email_reply_parser/email_reply_parser.rb

@@ -0,0 +1,475 @@
+# -*- encoding : utf-8 -*-
+require 'strscan'
+
+# EmailReplyParser is a small library to parse plain text email content.  The
+# goal is to identify which fragments are quoted, part of a signature, or
+# original body content.  We want to support both top and bottom posters, so
+# no simple "REPLY ABOVE HERE" content is used.
+#
+# Beyond RFC 5322 (which is handled by the [Ruby mail gem][mail]), there aren't
+# any real standards for how emails are created.  This attempts to parse out
+# common conventions for things like replies:
+#
+#     this is some text
+#
+#     On <date>, <author> wrote:
+#     > blah blah
+#     > blah blah
+#
+# ... and signatures:
+#
+#     this is some text
+#
+#     --
+#     Bob
+#     http://homepage.com/~bob
+#
+# Each of these are parsed into Fragment objects.
+#
+# EmailReplyParser also attempts to figure out which of these blocks should
+# be hidden from users.
+#
+class EmailReplyParser
+  # Public: Splits an email body into a list of Fragments.
+  #
+  # text - A String email body.
+  # from_address - from address of the email (optional)
+  #
+  # Returns an Email instance.
+  def self.read(text, from_address = "")
+    Email.new.read(text, from_address)
+  end
+
+  # Public: Get the text of the visible portions of the given email body.
+  #
+  # text - A String email body.
+  # from_address - from address of the email (optional)
+  #
+  # Returns a String.
+  def self.parse_reply(text, from_address = "")
+    self.read(text.to_s, from_address).visible_text
+  end
+
+  def self.parse_new_content(text, from_address = "")
+    self.read(text, from_address).new_content
+  end
+
+  ### Emails
+
+  # An Email instance represents a parsed body String.
+  class Email
+    # Emails have an Array of Fragments.
+    attr_reader :fragments
+
+    def initialize
+      @fragments = []
+    end
+
+    # Public: Gets the combined text of the visible fragments of the email body.
+    #
+    # Returns a String.
+    def visible_text
+      fragments.select{|f| !f.hidden?}.map{|f| f.to_s}.join("\n").rstrip
+    end
+
+    def new_content
+      fragments.select{|f| !f.quoted? && !f.hidden? && !f.signature?}.map{|f| f.to_s}.join("\n").rstrip
+    end
+
+    # Splits the given text into a list of Fragments.  This is roughly done by
+    # reversing the text and parsing from the bottom to the top.  This way we
+    # can check for 'On <date>, <author> wrote:' lines above quoted blocks.
+    #
+    # text - A String email body.
+    # from_address - from address of the email (optional)
+    #
+    # Returns this same Email instance.
+    def read(text, from_address = "")
+      # parse out the from name if one exists and save for use later
+      @from_name_raw = parse_raw_name_from_address(from_address)
+      @from_name_normalized = normalize_name(@from_name_raw)
+      @from_email = parse_email_from_address(from_address)
+
+      text = normalize_text(text)
+
+      # The text is reversed initially due to the way we check for hidden
+      # fragments.
+      text = text.reverse
+
+      # This determines if any 'visible' Fragment has been found.  Once any
+      # visible Fragment is found, stop looking for hidden ones.
+      @found_visible = false
+
+      # This instance variable points to the current Fragment.  If the matched
+      # line fits, it should be added to this Fragment.  Otherwise, finish it
+      # and start a new Fragment.
+      @fragment = nil
+
+      # Use the StringScanner to pull out each line of the email content.
+      @scanner = StringScanner.new(text)
+      while line = @scanner.scan_until(/\n/n)
+        scan_line(line)
+      end
+
+      # Be sure to parse the last line of the email.
+      if (last_line = @scanner.rest.to_s).size > 0
+        scan_line(last_line, true)
+      end
+
+      # Finish up the final fragment.  Finishing a fragment will detect any
+      # attributes (hidden, signature, reply), and join each line into a
+      # string.
+      finish_fragment
+
+      @scanner = @fragment = nil
+
+      # Now that parsing is done, reverse the order.
+      @fragments.reverse!
+      self
+    end
+
+  private
+    EMPTY = "".freeze
+
+    COMMON_REPLY_HEADER_REGEXES = [
+      /^On(.+)wrote:$/nm,
+      /^Am(.+)schrieb(.+):$/nm,
+      /^Le(.+)a(.+)crit( )?:$/nm,
+      /\A\d{4}\/\d{1,2}\/\d{1,2}\s+.{1,80}\s<[^@]+@[^@]+>\Z/,
+    ]
+
+    # Line optionally starts with whitespace, contains two or more hyphens or
+    # underscores, and ends with optional whitespace.
+    # Example: '---' or '___' or '---   '
+    MULTI_LINE_SIGNATURE_REGEX = /^\s*[-_]{2,}\s*$/
+
+    # Line optionally starts with whitespace, followed by one hyphen, followed by a word character
+    # Example: '-Sandro'
+    ONE_LINE_SIGNATURE_REGEX = /^\s*-\w/
+
+    ORIGINAL_MESSAGE_SIGNATURE_REGEXES = [
+      /^[\s_-]+(Original Message)?[\s_-]+$/,
+      /^[\s_-]+(Original Nachricht)?[\s_-]+$/,
+      /^[\s_-]+(Reply Message)?[\s_-]+$/,
+      /^[\s_-](.+)(ngliche Nachricht)[\s_-]+$/,
+    ]
+
+    # No block-quotes (> or <), followed by up to three words, followed by "Sent from my".
+    # Example: "Sent from my iPhone 3G"
+    SENT_FROM_REGEXES = [
+      /^Sent from my (\s*\w+){1,3}(\s*<.*>)?$/,
+      /^Von (\s*\w+){1,3}(\s*<.*>)? gesendet$/,
+      /^Gesendet von meinem (\s*\w+){1,3}(\s*<.*>)?$/,
+      /^Gesendet mit meinem (\s*\w+){1,3}(\s*<.*>)?$/,
+    ]
+
+    if defined?(Regexp::NOENCODING)
+      SIGNATURE_REGEX = Regexp.new(Regexp.union(MULTI_LINE_SIGNATURE_REGEX, ONE_LINE_SIGNATURE_REGEX, Regexp.union(ORIGINAL_MESSAGE_SIGNATURE_REGEXES), Regexp.union(SENT_FROM_REGEXES)).source, Regexp::NOENCODING)
+    else
+      SIGNATURE_REGEX = Regexp.new(Regexp.union(MULTI_LINE_SIGNATURE_REGEX, ONE_LINE_SIGNATURE_REGEX, Regexp.union(ORIGINAL_MESSAGE_SIGNATURE_REGEXES), Regexp.union(SENT_FROM_REGEXES)).source)
+    end
+
+    # TODO: refactor out in a i18n.yml file
+    # Supports English, French, Es-Mexican, Pt-Brazilian
+    # Maps a label to a label-group
+    QUOTE_HEADER_LABELS = Hash[*{
+      :from => ["From", "De", "Von"],
+      :to => ["To", "Para", "A", "An"],
+      :cc => ["CC"],
+      :reply_to => ["Reply-To"],
+      :date => ["Date", "Sent", "Gesendet", "Enviado", "Enviada em", "Fecha", "Datum"],
+      :subject => ["Subject", "Assunto", "Asunto", "Objet", "Betreff"]
+    }.map {|group, labels| labels.map {|label| [label.downcase, group]}}.flatten]
+
+    # normalize text so it is easier to parse
+    #
+    # text - text to normalize
+    #
+    # Returns a String
+    def normalize_text(text)
+      # in 1.9 we want to operate on the raw bytes
+      text = text.dup.force_encoding('binary') if text.respond_to?(:force_encoding)
+
+      # Normalize line endings.
+      text.gsub!("\r\n", "\n")
+
+      # Check for multi-line reply headers. Some clients break up
+      # the "On DATE, NAME <EMAIL> wrote:" line into multiple lines.
+      if match = text.match(/^(On\s(.+)wrote:)$/m)
+        # Remove all new lines from the reply header. as long as we don't have any double newline
+        # if we do they we have grabbed something that is not actually a reply header
+        text.gsub! match[1], match[1].gsub("\n", " ") unless match[1] =~ /\n\n/
+      end
+
+      # Some users may reply directly above a line of underscores or dashes.
+      # In order to ensure that these fragments are split correctly,
+      # make sure that all lines of underscores are preceded by
+      # at least two newline characters.
+      text.gsub!(/([^\n])(?=\n_{7}_+)$/m, "\\1\n")
+      text.gsub!(/([^\n])(?=\n-+)$/m, "\\1\n")
+
+      text
+    end
+
+    # Parse a person's name from an e-mail address
+    #
+    # email - email address.
+    #
+    # Returns a String.
+    def parse_name_from_address(address)
+      normalize_name(parse_raw_name_from_address(address))
+    end
+
+    def parse_raw_name_from_address(address)
+      match = address.match(/^["']*([\w\s,]+)["']*\s*</)
+      match ? match[1].strip.to_s : EMPTY
+    end
+
+    def parse_email_from_address(address)
+      match = address.match /<(.*)>/
+      match ? match[1] : address
+    end
+
+    # Normalize a name to First Last
+    #
+    # name - name to normailze.
+    #
+    # Returns a String.
+    def normalize_name(name)
+      if name.include?(',')
+        make_name_first_then_last(name)
+       else
+        name
+      end
+    end
+
+    def make_name_first_then_last(name)
+      split_name = name.split(',')
+      if split_name[0].include?(" ")
+        split_name[0].to_s
+      else
+        split_name[1].strip + " " + split_name[0].strip
+      end
+    end
+
+    ### Line-by-Line Parsing
+
+    # Scans the given line of text and determines which fragment it belongs to.
+    def scan_line(line, last = false)
+      line.chomp!("\n")
+      line.reverse!
+      line.rstrip!
+
+      # Mark the current Fragment as a signature if the current line is empty
+      # and the Fragment starts with a common signature indicator.
+      # Mark the current Fragment as a quote if the current line is empty
+      # and the Fragment starts with a multiline quote header.
+      scan_signature_or_quote if @fragment && line == EMPTY
+
+      # We're looking for leading `>`'s to see if this line is part of a
+      # quoted Fragment.
+      is_quoted = !!(line =~ /^>+/n)
+
+      # Note that a common reply header also counts as part of the quoted
+      # Fragment, even though it doesn't start with `>`.
+      unless @fragment &&
+          ((@fragment.quoted? == is_quoted) ||
+           (@fragment.quoted? && (line_is_reply_header?(line) || line == EMPTY)))
+        finish_fragment
+        @fragment = Fragment.new
+        @fragment.quoted = is_quoted
+      end
+
+      @fragment.add_line(line)
+      scan_signature_or_quote if last
+    end
+
+    def scan_signature_or_quote
+      if signature_line?(@fragment.lines.first)
+        @fragment.signature = true
+        finish_fragment
+      elsif multiline_quote_header_in_fragment?
+        @fragment.quoted = true
+        finish_fragment
+      end
+    end
+
+    # Returns +true+ if the current block in the current fragment has
+    # a multiline quote header, +false+ otherwise.
+    #
+    # The quote header we're looking for is mainly generated by Outlook
+    # clients. It's considered a quote header if the first 4 folded lines
+    # have one of the following forms:
+    #
+    # label: some text
+    #  *label:* some text
+    #
+    # where a line like this:
+    #
+    # label: some text
+    #   possibly indented text that belongs to the previous line
+    #
+    # is folded into:
+    #
+    # label: some text possibly indented text that belongs to the previous line
+    #
+    # and where label is a value from +QUOTE_HEADER_LABELS+ that appears
+    # only once in the first 4 lines and where each group of a label
+    # is represented at most once.
+    def multiline_quote_header_in_fragment?
+      folding = false
+      label_groups = []
+      @fragment.current_block.split("\n").each do |line|
+        if line =~ /\A\s*\*?([^:]+):(\s|\*)/
+          label = QUOTE_HEADER_LABELS[$1.downcase]
+          if label
+            return false if label_groups.include?(label)
+            return true if label_groups.length == 3
+            label_groups << label
+            folding = true
+          elsif !folding
+            return false
+          end
+        elsif !folding
+          return false
+        else
+          folding = true
+        end
+      end
+      return false
+    end
+
+    # Detects if a given line is the beginning of a signature
+    #
+    # line - A String line of text from the email.
+    #
+    # Returns true if the line is the beginning of a signature, or false.
+    def signature_line?(line)
+      line =~ SIGNATURE_REGEX || line_is_signature_name?(line)
+    end
+
+    # Detects if a given line is a common reply header.
+    #
+    # line - A String line of text from the email.
+    #
+    # Returns true if the line is a valid header, or false.
+    def line_is_reply_header?(line)
+      COMMON_REPLY_HEADER_REGEXES.each do |regex|
+        return true if line =~ regex
+      end
+      false
+    end
+
+    # Detects if the @from name is a big part of a given line and therefore the beginning of a signature
+    #
+    # line - A String line of text from the email.
+    #
+    # Returns true if @from_name is a big part of the line, or false.
+    def line_is_signature_name?(line)
+      regexp = generate_regexp_for_name()
+      @from_name_normalized != "" && (line =~ regexp) && ((@from_name_normalized.size.to_f / line.size) > 0.25)
+    end
+
+    #generates regexp which always for additional words or initials between first and last names
+    def generate_regexp_for_name
+      name_parts = @from_name_normalized.split(" ")
+      seperator = '[\w.\s]*'
+      regexp = Regexp.new(name_parts.join(seperator), Regexp::IGNORECASE)
+    end
+
+    # Builds the fragment string, after all lines have been added.
+    # It also checks to see if this Fragment is hidden.  The hidden
+    # Fragment check reads from the bottom to the top.
+    #
+    # Any quoted Fragments or signature Fragments are marked hidden if they
+    # are below any visible Fragments.  Visible Fragments are expected to
+    # contain original content by the author.  If they are below a quoted
+    # Fragment, then the Fragment should be visible to give context to the
+    # reply.
+    #
+    #     some original text (visible)
+    #
+    #     > do you have any two's? (quoted, visible)
+    #
+    #     Go fish! (visible)
+    #
+    #     > --
+    #     > Player 1 (quoted, hidden)
+    #
+    #     --
+    #     Player 2 (signature, hidden)
+    #
+    def finish_fragment
+      if @fragment
+        @fragment.finish
+        if !@found_visible
+          if @fragment.quoted? || @fragment.signature? ||
+              @fragment.reply_header? || @fragment.to_s.strip == EMPTY
+            @fragment.hidden = true
+          else
+            @found_visible = true
+          end
+        end
+        @fragments << @fragment
+      end
+      @fragment = nil
+    end
+  end
+
+  # Represents a group of paragraphs in the email sharing common attributes.
+  # Paragraphs should get their own fragment if they are a quoted area or a
+  # signature.
+  class Fragment < Struct.new(:quoted, :signature, :reply_header, :hidden)
+    # Array of string lines that make up the content of this fragment.
+    attr_reader :lines
+
+    # Array of string lines that is being processed not having
+    # an empty line.
+    attr_reader :current_block
+
+    # This is reserved for the joined String that is build when this Fragment
+    # is finished.
+    attr_reader :content
+
+    def initialize
+      self.quoted = self.signature = self.reply_header = self.hidden = false
+      @lines = []
+      @current_block = []
+      @content = nil
+    end
+
+    alias quoted?    quoted
+    alias signature? signature
+    alias reply_header? reply_header
+    alias hidden?    hidden
+
+    def add_line(line)
+      return unless line
+      @lines.insert(0, line)
+      if line == ""
+        @current_block.clear
+      else
+        @current_block.insert(0, line)
+      end
+    end
+
+    def current_block
+      @current_block.join("\n")
+    end
+
+    # Builds the string content by joining the lines and reversing them.
+    def finish
+      @content = @lines.join("\n")
+      @lines = @current_block = nil
+    end
+
+    def to_s
+      @lines ? @lines.join("\n") : @content
+    end
+
+    def inspect
+      "#{super.inspect} : #{to_s.inspect}"
+    end
+  end
+end
+

data/lib/generators/replyr/install_generator.rb

@@ -0,0 +1,15 @@
+module Replyr
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      def self.source_root
+        File.dirname(__FILE__) + "/templates"
+      end
+
+      def copy_files
+        copy_file "mailman_server", "script/mailman_server"
+        copy_file "mailman_daemon", "script/mailman_daemon"
+        template "replyr.rb.erb", "config/initializers/replyr.rb"
+      end
+    end
+  end
+end