sms_backup_renderer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca777b9b54c07e23ee9cd6ad8d5f759d35dda975
+  data.tar.gz: f0d1547ec2f8a012c58b3f09b3306b72db59c640
+SHA512:
+  metadata.gz: e46fced0b335e29123b6435254010ce42e6ea857103f98efae0cdf32b5da8f09378b9ac12925d96e1222780cb08805ab3070ac524a3c6a768d0947fe0a48954d
+  data.tar.gz: 5345ec20e294ecf62d5fcd3c3086f1d56171d09afa86ad8bc897f150726ebdd214b1f18c75bb5ae7f363b41dc3ecc5dd4f39ae5b212e8c8b1501119557606514

data/.gitignore

@@ -0,0 +1,11 @@
+.DS_Store
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/examples.txt
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sms_backup_renderer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Jacob Williams
+
+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,57 @@
+# SmsBackupRenderer
+
+This tool reads backup files created by [SMS Backup & Restore](https://www.carbonite.com/en/apps/call-log-sms-backup-restore) and generates static HTML files for viewing their contents.
+
+It supports both SMS and MMS messages, including images and videos.
+It attempts to create readable conversation-style views.
+
+(I am not affiliated with Carbonite in any way.)
+
+## Installation
+
+    $ gem install sms_backup_renderer
+
+## Usage
+
+    $ sms_backup_renderer PATH_TO_XML_ARCHIVE PATH_TO_OUTPUT_DIRECTORY
+
+I suggest creating a new, empty directory to use as the output directory the first time you run this, since multiple files and subdirectories will be created within it.
+
+After the command runs, the output directory will contain an `index.html` file you can open in your browser.
+
+## Caveats
+
+The backup files may represent the same number in different ways (e.g `+1 (234) 567-8901` and `2345678901`) at different times.
+In order to group all messages for the same number into the same conversation, `sms_backup_renderer` must try to normalize the numbers into a consistent format.
+Currently, the way this is done is pretty hacky and only knows about the US country code.
+Non-US numbers might be grouped incorrectly in some cases.
+
+Determining the contact names for group MMS messages also relies on some pretty hacky code.
+It probably won't work right if you have contact names containing commas.
+It may not work right anyway - I'm not sure if the assumptions it makes about the backup archive are always true, or if they are coincidental implementation details that may be affected by the messaging software on your phone.
+
+Videos do not currently play in Chrome, and possibly other browsers, though they do in Safari. I haven't figured out why yet. You can still open the video file directly in the output directory (or download it through your browser) to play it.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Testing
+
+There are some very basic rspec tests which run the renderer on a sample archive. To view the generated HTML in your browser, run
+
+    $ KEEP_TEST_OUTPUT=1 bundle exec rspec
+
+Then open `tmp/test-output/index.html`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/brokensandals/sms_backup_renderer.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sms_backup_renderer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/sms_backup_renderer

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'sms_backup_renderer'
+
+optparse = OptionParser.new do |opts|
+  opts.banner = 'Usage: sms_backup_renderer INPUT_FILE OUTPUT_DIR [options]'
+
+  opts.on('--version', "Print program version and exit") do
+    puts "sms_backup_renderer #{SmsBackupRenderer::VERSION}"
+    exit 0
+  end
+end
+
+optparse.parse!
+if ARGV.length != 2
+  puts optparse
+  exit -1
+end
+
+input_file_path = ARGV.shift
+output_dir_path = ARGV.shift
+
+SmsBackupRenderer.generate_html_from_archive(input_file_path, output_dir_path)

data/lib/sms_backup_renderer/assets/conversation.css

@@ -0,0 +1,50 @@
+h1 {
+  text-align: center;
+}
+
+body {
+  max-width: 600px;
+}
+
+.message {
+  margin-left: 40px;
+  max-width: 450px;
+}
+
+.message.outgoing {
+  margin-left: 150px;
+}
+
+.sender, .message-date-time {
+  font-size: 90%;
+  display: block;
+  margin: 0px;
+}
+
+.message-part {
+  margin: 10px 0px 10px 0px;
+}
+
+.message-part-image {
+  max-width: 100%;
+}
+
+.message-part-video {
+  max-width: 100%;
+}
+
+.message-part-text {
+  border-radius: 10px;
+  padding: 5px;
+  margin: 0;
+}
+
+.incoming .message-part-text {
+  background-color: beige;
+  display: inline-block;
+}
+
+.outgoing .message-part-text {
+  color: white;
+  background-color: darkgoldenrod;
+}

data/lib/sms_backup_renderer/models.rb

@@ -0,0 +1,112 @@
+module SmsBackupRenderer
+  # Represents a single sender or recipient of an SMS or MMS message.
+  class Participant
+    # Returns the String address of the participant, such as '1 (234) 567-890'.
+    attr_reader :address
+
+    # Returns the String contact name for the participant, or nil if unknown.
+    attr_reader :name
+
+    # Returns true if this participant is the owner of the archive, otherwise false.
+    attr_reader :owner
+
+    # Returns true if this participant is a sender of the message, false if they are a recipient.
+    attr_reader :sender
+
+    def initialize(args)
+      @address = args[:address]
+      @name = args[:name]
+      @owner = args[:owner]
+      @sender = args[:sender]
+    end
+
+    def normalized_address
+      @normalized_address ||= Participant.normalize_address(address)
+    end
+
+    # Normalizes a given address, for example '1 (234) 567-890' to '1234567890'.
+    #
+    # TODO: This is currently done in a very hacky, incomplete, embarrassingly-US-centric way.
+    #
+    # address - String address to normalize
+    #
+    # Returns the String normalized address.
+    def self.normalize_address(address)
+      address.gsub(/[\s\(\)\+\-]/, '')
+          .gsub(/\A1(\d{10})\z/, '\\1')
+    end
+  end
+
+  # Represents an SMS or MMS message.
+  class Message
+    # Returns a Time instance indicating when the message was sent or received.
+    attr_reader :date_time
+
+    # Returns true if the message was sent to address, false if received from address.
+    attr_reader :outgoing
+
+    # Returns an Array of Participant instances representing the senders and recipients of the message.
+    #   For MMS messages there may be multiple recipients. For SMS messages, the originator of the archive
+    #   is never represented, so there will only be a sender (for incoming messages) or a recipient
+    #   (for outgoing messages).
+    attr_reader :participants
+
+    # Returns an Array of MessagePart instances representing the contents of the message.
+    attr_reader :parts
+
+    # Returns the String subject/title of the message, likely nil.
+    attr_reader :subject
+
+    def initialize(args)
+      @contact_name = args[:contact_name]
+      @date_time = args[:date_time]
+      @outgoing = args[:outgoing]
+      @participants = args[:participants]
+      @parts = args[:parts] || []
+      @subject = args[:subject]
+    end
+
+    # Returns the Participant instance for the message sender, or nil.
+    def sender
+      @sender ||= participants.detect(&:sender)
+    end
+  end
+
+  # Represents a piece of content in a message, such as text or an image. See subclasses.
+  class MessagePart
+  end
+
+  class UnsupportedPart < MessagePart
+    # Returns a String containing the XML data of the message part.
+    attr_reader :xml
+
+    def initialize(xml)
+      @xml = xml
+    end
+  end
+
+  class TextPart < MessagePart
+    # Returns the String content of the message part such as "Hey Jacob, don't you have something better to do?".
+    attr_reader :text
+
+    def initialize(text)
+      @text = text
+    end
+  end
+
+  class MediaPart < MessagePart
+    # Returns the String content type for the message part such as 'image/jpeg'.
+    attr_reader :content_type
+
+    # Returns the String file path at which the content has been stored.
+    attr_reader :path
+
+    def initialize(content_type, path)
+      @content_type = content_type
+      @path = path
+    end
+  end
+
+  class ImagePart < MediaPart; end
+  class VideoPart < MediaPart; end
+end

data/lib/sms_backup_renderer/parser.rb

@@ -0,0 +1,159 @@
+require 'base64'
+require 'digest'
+require 'nokogiri'
+require 'time'
+
+module SmsBackupRenderer
+  HIGH_SURROGATES = 0xD800..0xDFFF
+
+  # Although the files claim to be UTF-8, SMS Backup & Restore produces files that incorrectly represent
+  # characters such as emoji using surrogate pairs, such that a single character is represented by two
+  # adjacent, separately-escaped characters which are supposed to be interpreted as a single
+  # Unicode surrogate pair. Nokogiri crashes when it encounters these, since it tries to interpret
+  # each part of the pair as a separate character. This method is a hacky workaround that simply searches
+  # the whole file for strings that look like escaped surrogate pairs and replaces them with the literal
+  # character they represent.
+  def self.fix_surrogate_pairs(string)
+    string.gsub!(/\&\#(\d{5})\;\&\#(\d{5})\;/) do |match|
+      high = Regexp.last_match[1].to_i
+      if HIGH_SURROGATES.include?(high)
+        low = Regexp.last_match[2].to_i
+        code_point = ((high - 0xD800) << 10) + (low - 0xDC00) + 0x010000
+        [code_point].pack('U*')
+      else
+        match[0]
+      end
+    end
+  end
+
+  def self.parse(input, data_dir_path)
+    messages = []
+    Nokogiri::XML::Reader(input).each do |node|
+      next unless node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
+      case node.name
+      when 'sms'
+        sms = Nokogiri::XML(node.outer_xml).at('/sms')
+        outgoing = sms_outgoing_type?(sms.attr('type'))
+        messages << Message.new(
+          date_time: Time.strptime(sms.attr('date'), '%Q'),
+          parts: sms.attr('body') ? [TextPart.new(sms.attr('body'))] : [],
+          outgoing: outgoing,
+          participants: [Participant.new(
+            address: sms.attr('address'),
+            name: sms.attr('contact_name'),
+            owner: false,
+            sender: !outgoing)],
+          subject: sms.attr('subject'))
+      when 'mms'
+        mms = Nokogiri::XML(node.outer_xml).at('/mms')
+        unless mms.attr('ct_t') == 'application/vnd.wap.multipart.related'
+          raise "Unrecognized MMS ct_t #{mms.attr('ct_t')}"
+        end
+        
+        parts = mms.xpath('parts/part').map do |part|
+          case part.attr('ct')
+          when 'application/smil'
+            # should probably use this, but I think I can get by without it
+            nil
+          when 'text/plain'
+            TextPart.new(part.attr('text'))
+          when /\Aimage\/(.+)\z/
+            data = Base64.decode64(part.attr('data'))
+            digest = Digest::MD5.hexdigest(data)
+            path = File.join(data_dir_path, "#{digest}.#{$1}")
+            File.write(path, data)
+            ImagePart.new(part.attr('ct'), path)
+          when /\Avideo\/(.+)\z/
+            data = Base64.decode64(part.attr('data'))
+            digest = Digest::MD5.hexdigest(data)
+            path = File.join(data_dir_path, "#{digest}.#{$1}")
+            File.write(path, data)
+            VideoPart.new(part.attr('ct'), path)
+          else
+            UnsupportedPart.new(part.to_xml)
+          end
+        end.compact
+
+        non_owner_addresses = parse_mms_combined_address(mms.attr('address'))
+        address_contact_names = mms_address_contact_names(mms)
+        participants = mms.xpath('addrs/addr').map do |addr|
+          Participant.new(
+            address: addr.attr('address'),
+            name: address_contact_names[Participant.normalize_address(addr.attr('address'))],
+            owner: !non_owner_addresses.include?(Participant.normalize_address(addr.attr('address'))),
+            sender: mms_sender_addr_type?(addr.attr('type')))
+        end
+
+        messages << Message.new(
+          date_time: Time.strptime(mms.attr('date'), '%Q'),
+          outgoing: mms_outgoing_type?(mms.attr('m_type')),
+          participants: participants,
+          parts: parts)
+      end
+    end
+    messages
+  end
+
+  def self.sms_outgoing_type?(type)
+    case type
+    when '1'
+      false
+    when '2'
+      true
+    else
+      raise "Unrecognized SMS type #{type}"
+    end
+  end
+
+  def self.mms_outgoing_type?(type)
+    case type
+    when '132'
+      false
+    when '128'
+      true
+    else
+      raise "Unrecognized MMS m_type #{type}"
+    end
+  end
+
+  def self.mms_sender_addr_type?(type)
+    case type
+    when '137'
+      true
+    else
+      false
+    end
+  end
+
+  # Build a hash of normalized addresses to contact names using information in an MMS XML record.
+  # The data in the archive does not provide any explicit mapping of addresses to contact names, but
+  # at least for me it seems like the tilde-separated address attribute and the comma-separated
+  # contact_name attribute are provided in the same order, so we can try to use those to build
+  # a mapping. Obviously, this is error-prone, but seems better than nothing.
+  #
+  # mms - nokogiri object representing the MMS element
+  #
+  # Returns a Hash of String normalized addresses to String contact names.
+  def self.mms_address_contact_names(mms)
+    addresses = parse_mms_combined_address(mms.attr('address'))
+    contact_names = mms.attr('contact_name').split(',').map(&:strip)
+
+    # There may be more addresses than contact names. It seems like the addresses for unknown contacts
+    # are placed at the end of the list. We'll omit them from the hash.
+    addresses = addresses.take(contact_names.count)
+
+    addresses.zip(contact_names).to_h
+  end
+
+  # The XML for MMSes contains an 'address' attribute containing a list of addresses separated by
+  # tildes. Although there are also separate 'addr' elements for each address, the combined attribute
+  # can be useful because it appears to exclude the owner of the archive's address, and because the
+  # order can be correlated with the contact_name attribute.
+  #
+  # address_attribute - the value of the 'address' attribute from the XML element for the MMS message
+  #
+  # Returns an Array of String normalized addresses.
+  def self.parse_mms_combined_address(address_attribute)
+    address_attribute.split('~').map {|a| Participant.normalize_address(a)}
+  end
+end

data/lib/sms_backup_renderer/renderer.rb

@@ -0,0 +1,120 @@
+require 'digest'
+require 'erb'
+require 'pathname'
+
+module SmsBackupRenderer
+  class BasePage
+    # Returns the String path to where this file will be written.
+    attr_reader :output_file_path
+
+    # Returns the String path to the folder where static assets have been copied to.
+    attr_reader :assets_dir_path
+
+    def initialize(output_file_path, assets_dir_path)
+      @output_file_path = output_file_path
+      @assets_dir_path = assets_dir_path
+    end
+
+    def render
+      ERB.new(File.read(File.join(File.dirname(__FILE__), 'templates', template_name))).result(binding)
+    end
+
+    def write
+      File.write(output_file_path, render)
+    end
+
+    def relative_path(path)
+      Pathname.new(path).relative_path_from(Pathname.new(File.dirname(output_file_path))).to_s
+    end
+
+    def asset_path(filename)
+      Pathname.new(File.join(assets_dir_path, filename))
+        .relative_path_from(Pathname.new(File.dirname(output_file_path))).to_s
+    end
+
+    def template_name
+      raise 'not implemented'
+    end
+  end
+
+  class IndexPage < BasePage
+    # Returns an Array ConversationPage instances which this page should link to.
+    attr_reader :conversation_pages
+
+    def initialize(output_file_path, assets_dir_path, conversation_pages)
+      super(output_file_path, assets_dir_path)
+      @conversation_pages = conversation_pages.sort_by(&:title)
+    end
+
+    def template_name
+      'index.html.erb'
+    end
+  end
+
+  class ConversationPage < BasePage
+    # Returns an Array of Message instances to be shown on this page.
+    attr_reader :messages
+
+    def initialize(output_file_path, assets_dir_path, messages)
+      super(output_file_path, assets_dir_path)
+      @messages = messages.sort_by(&:date_time)
+    end
+
+    def template_name
+      'conversation.html.erb'
+    end
+
+    def title
+      messages.first.participants.reject(&:owner).map do |participant|
+        if participant.name
+          "#{participant.name} (#{participant.normalized_address})"
+        else
+          participant.normalized_address
+        end
+      end.sort.join(', ')
+    end
+
+    def message_date_time_span(message, previous_message)
+      formatted = if previous_message && message.date_time.to_date == previous_message.date_time.to_date
+        if message.date_time.to_time - previous_message.date_time.to_time < 600
+          nil
+        else
+          message.date_time.strftime('%-I:%M%P')
+        end
+      else
+        message.date_time.strftime('%A, %b %-d, %Y at %-I:%M%P %Z')
+      end
+      return '' unless formatted
+      "<span class=\"message-date-time\">#{formatted}</span>"
+    end
+
+    def sender_span(message, previous_message)
+      if previous_message &&
+          message.outgoing == previous_message.outgoing &&
+          (message.outgoing || message.sender.normalized_address == previous_message.sender.normalized_address)
+        ''
+      else
+        sender = message.outgoing ? 'You' : (message.sender.name || message.sender.normalized_address)
+        "<span class=\"sender\">#{ERB::Util.html_escape(sender)}</span>"
+      end
+    end
+
+    # Returns a filename for a conversation page for the given participants, such as '123456789.html'.
+    # Should always return the same name for the same list of participants. The normalized addresses
+    # are used when they are numeric, but non-numeric addresses (such as email addresses) will be hex-encoded
+    # to avoid any problems with file name restrictions.
+    #
+    # participants - an Array of Participant instances
+    #
+    # Returns a String filename.
+    def self.build_filename(participants)
+      participants.map do |participant|
+        if participant.normalized_address =~ /\A\d+\z/
+          participant.normalized_address
+        else
+          '0x' + Digest.hexencode(participant.address)
+        end
+      end.sort.join('_') + '.html'
+    end
+  end
+end

data/lib/sms_backup_renderer/templates/conversation.html.erb

@@ -0,0 +1,36 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="UTF-8"/>
+  <title><%= title %></title>
+  <link href="<%= asset_path('conversation.css') %>" rel="stylesheet"/>
+</head>
+<body>
+<h1><%= title %></h1>
+<% messages.zip([nil] + messages).each do |(message, previous_message)| %>
+  <div class="message <%= message.outgoing ? 'outgoing' : 'incoming' %>">
+    <%= sender_span(message, previous_message) %>
+    <%= message_date_time_span(message, previous_message) %>
+    <% message.parts.each do |part| %>
+      <div class="message-part">
+        <% case part
+           when TextPart %>
+          <p class="message-part-text">
+            <%= part.text.lines.map { |line| ERB::Util.html_escape(line) }.join('<br/>') %>
+          </p>
+        <% when ImagePart %>
+          <img class="message-part-image" src="<%= relative_path(part.path)%>" type="<%= part.content_type%>"/>
+        <% when VideoPart %>
+          <video class="message-part-video" controls>
+            <source src="<%= relative_path(part.path) %>" type="<%= part.content_type %>" />
+            Message contains a video, but your browser can't/won't display it.
+          </video>
+        <% else %>
+          <p class="message-part-unsupported">Message contains unsupported media type.</p>
+        <% end %>
+      </div>
+    <% end %>
+  </div>
+<% end %>
+</body>
+</html>

data/lib/sms_backup_renderer/templates/index.html.erb

@@ -0,0 +1,15 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="UTF-8"/>
+  <title>SMS/MMS Conversations</title>
+</head>
+<body>
+<h1>SMS/MMS Conversations</h1>
+<ul>
+  <% conversation_pages.each do |page| %>
+    <li><a href="<%= relative_path(page.output_file_path) %>"><%= page.title %></a></li>
+  <% end %>
+</ul>
+</body>
+</html>

data/lib/sms_backup_renderer/version.rb

@@ -0,0 +1,3 @@
+module SmsBackupRenderer
+  VERSION = "0.1.0"
+end

data/lib/sms_backup_renderer.rb

@@ -0,0 +1,42 @@
+require 'sms_backup_renderer/models'
+require 'sms_backup_renderer/parser'
+require 'sms_backup_renderer/renderer'
+require 'sms_backup_renderer/version'
+
+require 'fileutils'
+require 'tempfile'
+
+module SmsBackupRenderer
+  def self.generate_html_from_archive(input_file_path, output_dir_path)
+    input_tempfile = Tempfile.new('sms_backup_renderer')
+    input_text = File.read(input_file_path)
+    SmsBackupRenderer.fix_surrogate_pairs(input_text)
+    File.write(input_tempfile.path, input_text)
+
+    data_dir_path = File.join(output_dir_path, 'data')
+    FileUtils.mkdir_p(data_dir_path)
+
+    input_file = File.open(input_tempfile.path)
+    messages = SmsBackupRenderer.parse(input_file, data_dir_path)
+    input_file.close
+    input_tempfile.close
+
+    message_groups = messages.group_by {|m| m.participants.reject(&:owner).map(&:normalized_address).sort}.values
+
+    assets_dir_path = File.join(output_dir_path, 'assets')
+    FileUtils.cp_r(File.join(File.dirname(__FILE__), 'sms_backup_renderer', 'assets'), output_dir_path)
+    conversations_dir_path = File.join(output_dir_path, 'conversations')
+    FileUtils.mkdir_p(conversations_dir_path)
+
+    conversation_pages = message_groups.map do |group_messages|
+      filename = ConversationPage.build_filename(group_messages.first.participants.reject(&:owner))
+      path = File.join(conversations_dir_path, filename)
+      SmsBackupRenderer::ConversationPage.new(path, assets_dir_path, group_messages)
+    end
+
+    conversation_pages.each(&:write)
+
+    SmsBackupRenderer::IndexPage.new(
+      File.join(output_dir_path, 'index.html'), assets_dir_path, conversation_pages).write
+  end
+end

data/sms_backup_renderer.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sms_backup_renderer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sms_backup_renderer"
+  spec.version       = SmsBackupRenderer::VERSION
+  spec.authors       = ["Jacob Williams"]
+  spec.email         = ["jacobaw@gmail.com"]
+
+  spec.summary       = %q{Generates static HTML pages for the contents of an SMS Backup & Restore archive.}
+  spec.homepage      = "https://github.com/brokensandals/sms_backup_renderer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'nokogiri', '~> 1.8'
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rspec', '~> 3.6'
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: sms_backup_renderer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jacob Williams
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+description: 
+email:
+- jacobaw@gmail.com
+executables:
+- sms_backup_renderer
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/sms_backup_renderer
+- lib/sms_backup_renderer.rb
+- lib/sms_backup_renderer/assets/conversation.css
+- lib/sms_backup_renderer/models.rb
+- lib/sms_backup_renderer/parser.rb
+- lib/sms_backup_renderer/renderer.rb
+- lib/sms_backup_renderer/templates/conversation.html.erb
+- lib/sms_backup_renderer/templates/index.html.erb
+- lib/sms_backup_renderer/version.rb
+- sms_backup_renderer.gemspec
+homepage: https://github.com/brokensandals/sms_backup_renderer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Generates static HTML pages for the contents of an SMS Backup & Restore archive.
+test_files: []