browser.rb 0.16.0

data/Rakefile

@@ -0,0 +1,182 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test
+
+namespace :fixtures do
+  desc "Build test/fixtures/ChromiumBased_history.sqlite"
+  task :chromium_based_history do
+    require 'fileutils'
+    require 'sqlite3'
+    path = File.join(__dir__, 'test/fixtures/ChromiumBased_history.sqlite')
+    FileUtils.rm_f(path)
+    db = SQLite3::Database.new(path)
+    # The urls table as Chromium creates it, shared by every Chromium-based browser.
+    db.execute_batch(<<~SQL)
+      CREATE TABLE urls(
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        url LONGVARCHAR,
+        title LONGVARCHAR,
+        visit_count INTEGER DEFAULT 0 NOT NULL,
+        typed_count INTEGER DEFAULT 0 NOT NULL,
+        last_visit_time INTEGER NOT NULL,
+        hidden INTEGER DEFAULT 0 NOT NULL
+      );
+      CREATE INDEX urls_url_index ON urls (url);
+    SQL
+    # last_visit_time is microseconds since 1601-01-01, which is Chromium's epoch.
+    [
+      ['https://www.chromium.org/chromium-projects/', 'Home', 3, 1, 13403232000000000, 0],
+      ['chrome://welcome/', 'Welcome', 1, 0, 13403231000000000, 0],
+    ].each do |row|
+      db.execute('INSERT INTO urls (url, title, visit_count, typed_count, last_visit_time, hidden) VALUES (?, ?, ?, ?, ?, ?)', row)
+    end
+    db.close
+    puts "Wrote #{path} (#{File.size(path)} bytes)."
+  end
+
+  desc "Build test/fixtures/FirefoxBased_places.sqlite"
+  task :firefox_based_places do
+    require 'fileutils'
+    require 'sqlite3'
+    path = File.join(__dir__, 'test/fixtures/FirefoxBased_places.sqlite')
+    FileUtils.rm_f(path)
+    db = SQLite3::Database.new(path)
+    # moz_places, moz_bookmarks and moz_historyvisits as Firefox creates them.  A
+    # bookmark's label is moz_bookmarks.title; moz_places.title is the page's own, and
+    # is empty until the page has been visited.
+    db.execute_batch(<<~SQL)
+      CREATE TABLE moz_origins (
+        id INTEGER PRIMARY KEY, prefix TEXT NOT NULL, host TEXT NOT NULL,
+        frecency INTEGER NOT NULL, recalc_frecency INTEGER NOT NULL DEFAULT 0,
+        alt_frecency INTEGER, recalc_alt_frecency INTEGER NOT NULL DEFAULT 0,
+        block_until_ms INTEGER, block_pages_until_ms INTEGER, UNIQUE (prefix, host)
+      );
+      CREATE TABLE moz_places (
+        id INTEGER PRIMARY KEY, url LONGVARCHAR, title LONGVARCHAR,
+        rev_host LONGVARCHAR, visit_count INTEGER DEFAULT 0,
+        hidden INTEGER DEFAULT 0 NOT NULL, typed INTEGER DEFAULT 0 NOT NULL,
+        frecency INTEGER DEFAULT -1 NOT NULL, last_visit_date INTEGER, guid TEXT,
+        foreign_count INTEGER DEFAULT 0 NOT NULL, url_hash INTEGER DEFAULT 0 NOT NULL,
+        description TEXT, preview_image_url TEXT, site_name TEXT,
+        origin_id INTEGER REFERENCES moz_origins(id),
+        recalc_frecency INTEGER NOT NULL DEFAULT 0, alt_frecency INTEGER,
+        recalc_alt_frecency INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE moz_bookmarks (
+        id INTEGER PRIMARY KEY, type INTEGER, fk INTEGER DEFAULT NULL,
+        parent INTEGER, position INTEGER, title LONGVARCHAR, keyword_id INTEGER,
+        folder_type TEXT, dateAdded INTEGER, lastModified INTEGER, guid TEXT,
+        syncStatus INTEGER NOT NULL DEFAULT 0, syncChangeCounter INTEGER NOT NULL DEFAULT 1
+      );
+      CREATE TABLE moz_historyvisits (
+        id INTEGER PRIMARY KEY, from_visit INTEGER, place_id INTEGER,
+        visit_date INTEGER, visit_type INTEGER, session INTEGER,
+        source INTEGER DEFAULT 0 NOT NULL, triggeringPlaceId INTEGER
+      );
+    SQL
+
+    # dateAdded and visit_date are microseconds since 1970-01-01, which is Firefox's epoch.
+    added = 1787449000000000
+
+    [
+      [1, 'https://support.mozilla.org/products/firefox', nil, 'gro.allizom.troppus.'],
+      [2, 'https://support.mozilla.org/kb/customize-firefox-controls-buttons-and-toolbars', nil, 'gro.allizom.troppus.'],
+      [3, 'https://www.mozilla.org/contribute/', nil, 'gro.allizom.www.'],
+      [4, 'https://www.mozilla.org/about/', nil, 'gro.allizom.www.'],
+      [5, 'https://addons.mozilla.org/en-US/firefox/', 'Extension Starter Pack', 'gro.allizom.snodda.'],
+    ].each do |id, url, title, rev_host|
+      db.execute('INSERT INTO moz_places (id, url, title, rev_host) VALUES (?, ?, ?, ?)', [id, url, title, rev_host])
+    end
+
+    # type 2 is a folder, type 1 a bookmark and type 3 a separator.  The roots are
+    # fixed ids with padded guids.  Under tags, a folder per tag holds a copy of
+    # each bookmark so tagged.
+    [
+      [1, 2, nil, 0, 0, nil, 'root________'],
+      [2, 2, nil, 1, 0, 'menu', 'menu________'],
+      [3, 2, nil, 1, 1, 'toolbar', 'toolbar_____'],
+      [4, 2, nil, 1, 2, 'tags', 'tags________'],
+      [5, 2, nil, 1, 3, 'unfiled', 'unfiled_____'],
+      [6, 2, nil, 1, 4, 'mobile', 'mobile______'],
+      [7, 2, nil, 2, 0, 'Mozilla Firefox', 'j47T12MG8hux'],
+      [8, 1, 1, 7, 0, 'Get Help', '50OxxDFUahwc'],
+      [9, 1, 2, 7, 1, 'Customize Firefox', 'dTBx_Z-u_6U6'],
+      [10, 1, 3, 7, 2, 'Get Involved', 'l00bhg3kKbYX'],
+      [11, 1, 4, 7, 3, 'About Us', 'pJ9IZ7ivzMw6'],
+      [12, 2, nil, 4, 0, 'firefox', 'Q2r8sT5vWx1y'],
+      [13, 1, 1, 12, 0, 'Get Help', 'Zb3cD6eF9gH2'],
+      [14, 3, nil, 3, 0, nil, 'Kj4mN7pQ0rS3'],
+      [15, 1, 5, 3, 1, 'Extension Starter Pack', 'Tu5vW8xY1zA4'],
+    ].each do |id, type, fk, parent, position, title, guid|
+      db.execute(
+        'INSERT INTO moz_bookmarks (id, type, fk, parent, position, title, dateAdded, lastModified, guid) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
+        [id, type, fk, parent, position, title, added + id, added + id, guid]
+      )
+    end
+
+    db.execute('INSERT INTO moz_historyvisits (id, place_id, visit_date, visit_type) VALUES (?, ?, ?, ?)', [1, 5, added + 152741667, 1])
+    db.close
+    puts "Wrote #{path} (#{File.size(path)} bytes)."
+  end
+
+  desc "Build test/fixtures/Safari_history.sqlite"
+  task :safari_history do
+    require 'fileutils'
+    require 'sqlite3'
+    path = File.join(__dir__, 'test/fixtures/Safari_history.sqlite')
+    FileUtils.rm_f(path)
+    db = SQLite3::Database.new(path)
+    # history_items and history_visits as Safari creates them.
+    db.execute_batch(<<~SQL)
+      CREATE TABLE history_items (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        url TEXT NOT NULL UNIQUE,
+        domain_expansion TEXT NULL,
+        visit_count INTEGER NOT NULL,
+        daily_visit_counts BLOB NOT NULL,
+        weekly_visit_counts BLOB NULL,
+        autocomplete_triggers BLOB NULL,
+        should_recompute_derived_visit_counts INTEGER NOT NULL,
+        visit_count_score INTEGER NOT NULL
+      );
+      CREATE TABLE history_visits (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        history_item INTEGER NOT NULL REFERENCES history_items(id) ON DELETE CASCADE,
+        visit_time REAL NOT NULL,
+        title TEXT NULL,
+        load_successful BOOLEAN NOT NULL DEFAULT 1,
+        http_non_get BOOLEAN NOT NULL DEFAULT 0,
+        synthesized BOOLEAN NOT NULL DEFAULT 0,
+        redirect_source INTEGER NULL UNIQUE,
+        redirect_destination INTEGER NULL UNIQUE,
+        origin INTEGER NOT NULL DEFAULT 0,
+        generation INTEGER NOT NULL DEFAULT 0,
+        attributes INTEGER NOT NULL DEFAULT 0,
+        score INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE INDEX history_visits_history_item_index ON history_visits (history_item);
+    SQL
+    [
+      [1, 'https://www.apple.com/', 'apple', 3, 1],
+      [2, 'https://support.apple.com/', 'support.apple', 1, 0],
+    ].each do |id, url, domain, visit_count, score|
+      db.execute(
+        'INSERT INTO history_items (id, url, domain_expansion, visit_count, daily_visit_counts, should_recompute_derived_visit_counts, visit_count_score) VALUES (?, ?, ?, ?, ?, 0, ?)',
+        [id, url, domain, visit_count, SQLite3::Blob.new(''), score]
+      )
+    end
+    # visit_time is seconds since 2001-01-01, which is Core Data's epoch.
+    [
+      [1, 1, 780451200.0, 'Apple'],
+      [2, 2, 780450000.0, 'Apple Support'],
+    ].each do |id, item, time, title|
+      db.execute('INSERT INTO history_visits (id, history_item, visit_time, title) VALUES (?, ?, ?, ?)', [id, item, time, title])
+    end
+    db.close
+    puts "Wrote #{path} (#{File.size(path)} bytes)."
+  end
+end

data/browser.rb.gemspec

@@ -0,0 +1,54 @@
+# browser.rb.gemspec
+
+require_relative './lib/Browser/VERSION'
+
+class Gem::Specification
+  def dependencies=(gems)
+    gems.each{|gem| add_dependency(*gem)}
+  end
+
+  def development_dependencies=(gems)
+    gems.each{|gem| add_development_dependency(*gem)}
+  end
+end
+
+Gem::Specification.new do |spec|
+  spec.name = 'browser.rb'
+  spec.version = Browser::VERSION
+
+  spec.summary = "Read web browser bookmarks and history with Ruby."
+  spec.description = "Read the bookmarks and history of the web browsers on a machine, Brave, Chrome, Chromium, Firefox, Safari and Tor Browser, and render them to CSV, JSON or a property list.  Bookmarks come through as one representation whatever the browser; history as each browser stores it."
+
+  spec.author = 'thoran'
+  spec.email = 'code@thoran.com'
+  spec.homepage = 'https://github.com/thoran/browser'
+  spec.license = 'MIT'
+
+  spec.required_ruby_version = '>= 3.2'
+  spec.require_paths = ['lib']
+
+  spec.files = [
+    'browser.rb.gemspec',
+    Dir['lib/**/*.rb'],
+    Dir['test/**/*'],
+    'CHANGELOG',
+    'Gemfile',
+    'LICENSE',
+    'Rakefile',
+    'README.md',
+  ].flatten
+
+  spec.dependencies = %w{
+    CFPropertyList
+    csv
+    json
+    sqlite3
+  }
+
+  spec.development_dependencies = %w{
+    minitest
+    rake
+    minitest-spec-context
+    rspec-expectations
+  }
+end

data/lib/Browser/Base.rb

@@ -0,0 +1,50 @@
+# Browser/Base.rb
+# Browser::Base
+
+require_relative './Bookmarks'
+require_relative './History'
+
+class Browser
+  class Base < Browser
+    class << self
+      def default_profile_name
+        self::DEFAULT_PROFILE_NAME
+      end
+    end
+
+    def bookmarks
+      Browser::Bookmarks.new(self)
+    end
+
+    def history
+      Browser::History.new(self)
+    end
+
+    # Each is what was given, or else derived when first wanted, so that making a
+    # browser costs nothing and a default which has to be looked up is looked up
+    # only for a read.
+    def profile_name
+      @profile_name ||= self.class.default_profile_name
+    end
+
+    def bookmarks_location
+      @bookmarks_location ||= self.class.bookmarks_location(profile_name: profile_name)
+    end
+
+    def history_location
+      @history_location ||= self.class.history_location(profile_name: profile_name)
+    end
+
+    def name
+      self.class.to_s.split('::').last
+    end
+
+    private
+
+    def initialize(bookmarks_location: nil, history_location: nil, profile_name: nil)
+      @bookmarks_location = bookmarks_location
+      @history_location = history_location
+      @profile_name = profile_name
+    end
+  end
+end

data/lib/Browser/Bookmark.rb

@@ -0,0 +1,41 @@
+# Browser/Bookmark.rb
+# Browser::Bookmark
+
+# It knows nothing of how a browser stores bookmarks, only the shape they share
+# once read.  The title is what the browser shows; the name is what it stores,
+# which is the title but for Firefox's roots, where menu is shown as Bookmarks
+# Menu, and which writing back into a browser would need.
+
+class Browser
+  class Bookmark
+    attr_accessor :title, :name, :url, :children
+
+    def leaf?
+      !@url.nil?
+    end
+
+    def folder?
+      !leaf?
+    end
+
+    # The root's own title is not a folder anyone filed under, so a titleless or
+    # rootless node adds nothing to the path.
+    def flatten(path = [])
+      if leaf?
+        [{title: @title, url: @url, folder: path.join('/')}]
+      else
+        here = @title.to_s.empty? ? path : path + [@title]
+        @children.flat_map{|child| child.flatten(here)}
+      end
+    end
+
+    private
+
+    def initialize(title: nil, name: title, url: nil, children: [])
+      @title = title
+      @name = name
+      @url = url
+      @children = children
+    end
+  end
+end

data/lib/Browser/Bookmarks.rb

@@ -0,0 +1,112 @@
+# Browser/Bookmarks.rb
+# Browser::Bookmarks
+
+require 'json'
+require 'cfpropertylist'
+require 'sqlite3'
+
+require_relative './Bookmark'
+require_relative './Rendering'
+require_relative './Unreadable'
+
+class Browser
+  class Bookmarks
+    include Rendering
+
+    class << self
+
+      def from_json(browser_instance)
+        data = ::JSON.parse(File.read(browser_instance.bookmarks_location))
+        roots = data.fetch('roots', {}).values.select{|value| value.is_a?(Hash)}
+        Browser::Bookmark.new(children: roots.collect{|root| json_node(root)})
+      end
+
+      def from_plist(browser_instance)
+        data = CFPropertyList.native_types(CFPropertyList::List.new(file: browser_instance.bookmarks_location).value)
+        Browser::Bookmark.new(children: plist_children(data))
+      end
+
+      def from_sqlite(browser_instance)
+        database = SQLite3::Database.new(browser_instance.bookmarks_location)
+        column_names, *rows = database.execute2(browser_instance.class.send(:bookmarks_sql))
+        records = rows.collect{|row| column_names.zip(row).to_h}
+        children = records.group_by{|record| record['parent']}
+        Browser::Bookmark.new(children: Array(children[0]).flat_map{|root| sqlite_children(root, children)})
+      end
+
+      private
+
+      def json_node(node)
+        if node['url']
+          Browser::Bookmark.new(title: node['name'], url: node['url'])
+        else
+          Browser::Bookmark.new(title: node['name'], children: Array(node['children']).collect{|child| json_node(child)})
+        end
+      end
+
+      def plist_children(node)
+        Array(node['Children']).filter_map{|child| plist_node(child)}
+      end
+
+      # moz_bookmarks is one table of folders and bookmarks, each row naming its
+      # parent and its position within it, and the root the row with no parent.
+      # The tags root is left out: a tag is a folder holding a copy of every
+      # bookmark so tagged, and Firefox does not show it as one.
+      def sqlite_children(record, children)
+        Array(children[record['id']]).filter_map{|child| sqlite_node(child, children)}
+      end
+
+      # type 1 is a bookmark, 2 a folder and 3 a separator.
+      def sqlite_node(record, children)
+        case record['type']
+        when 1
+          Browser::Bookmark.new(title: record['title'], url: record['url'])
+        when 2
+          sqlite_folder(record, children) unless record['guid'] == 'tags________'
+        end
+      end
+
+      # The roots are stored under names Firefox never shows; these are the names it does.
+      SQLITE_ROOT_TITLES = {
+        'menu________' => 'Bookmarks Menu',
+        'toolbar_____' => 'Bookmarks Toolbar',
+        'unfiled_____' => 'Other Bookmarks',
+        'mobile______' => 'Mobile Bookmarks',
+      }
+
+      def sqlite_folder(record, children)
+        title = SQLITE_ROOT_TITLES.fetch(record['guid'], record['title'])
+        Browser::Bookmark.new(title: title, name: record['title'], children: sqlite_children(record, children))
+      end
+
+      def plist_node(node)
+        case node['WebBookmarkType']
+        when 'WebBookmarkTypeLeaf'
+          Browser::Bookmark.new(title: node.dig('URIDictionary', 'title'), url: node['URLString'])
+        when 'WebBookmarkTypeList'
+          Browser::Bookmark.new(title: node['Title'], children: plist_children(node))
+        end
+      end
+    end
+
+    def to_objects
+      results.flatten
+    end
+
+    private
+
+    def initialize(browser_instance)
+      @browser_instance = browser_instance
+    end
+
+    def results
+      @results ||= self.class.public_send("from_#{@browser_instance.class.send(:bookmarks_format)}", @browser_instance)
+    rescue IOError, SystemCallError, SQLite3::Exception => e
+      raise Browser::Unreadable, "#{@browser_instance.bookmarks_location} is not readable: #{e.message}"
+    end
+
+    def column_names
+      %i{title url folder}
+    end
+  end
+end

data/lib/Browser/Brave.rb

@@ -0,0 +1,16 @@
+# Browser/Brave.rb
+# Browser::Brave
+
+require_relative './ChromiumBased'
+
+class Browser
+  class Brave < ChromiumBased
+    class << self
+      private
+
+      def root_path
+        "~/Library/Application Support/BraveSoftware/Brave-Browser"
+      end
+    end
+  end
+end

data/lib/Browser/Chrome.rb

@@ -0,0 +1,16 @@
+# Browser/Chrome.rb
+# Browser::Chrome
+
+require_relative './ChromiumBased'
+
+class Browser
+  class Chrome < ChromiumBased
+    class << self
+      private
+
+      def root_path
+        "~/Library/Application Support/Google/Chrome"
+      end
+    end
+  end
+end

data/lib/Browser/Chromium.rb

@@ -0,0 +1,16 @@
+# Browser/Chromium.rb
+# Browser::Chromium
+
+require_relative './ChromiumBased'
+
+class Browser
+  class Chromium < ChromiumBased
+    class << self
+      private
+
+      def root_path
+        "~/Library/Application Support/Chromium"
+      end
+    end
+  end
+end

data/lib/Browser/ChromiumBased.rb

@@ -0,0 +1,48 @@
+# Browser/ChromiumBased.rb
+# Browser::ChromiumBased
+
+require_relative './Base'
+
+class Browser
+  class ChromiumBased < Base
+    DEFAULT_PROFILE_NAME = "Default"
+
+    class << self
+      def bookmarks_location(profile_name: nil)
+        profile_name ||= DEFAULT_PROFILE_NAME
+        File.expand_path("#{profiles_path}/#{profile_name}/Bookmarks")
+      end
+
+      def history_location(profile_name: nil)
+        profile_name ||= DEFAULT_PROFILE_NAME
+        File.expand_path("#{profiles_path}/#{profile_name}/History")
+      end
+
+      private
+
+      def root_path
+        raise NotImplementedError, "#{self} must implement root_path"
+      end
+
+      def profiles_path
+        root_path
+      end
+
+      def bookmarks_format
+        :json
+      end
+
+      def history_format
+        :sqlite
+      end
+
+      def bookmarks_sql
+        nil
+      end
+
+      def history_sql
+        'SELECT * FROM urls ORDER BY last_visit_time DESC;'
+      end
+    end
+  end
+end

data/lib/Browser/Firefox.rb

@@ -0,0 +1,16 @@
+# Browser/Firefox.rb
+# Browser::Firefox
+
+require_relative './FirefoxBased'
+
+class Browser
+  class Firefox < FirefoxBased
+    class << self
+      private
+
+      def root_path
+        "~/Library/Application Support/Firefox"
+      end
+    end
+  end
+end

data/lib/Browser/FirefoxBased.rb

@@ -0,0 +1,86 @@
+# Browser/FirefoxBased.rb
+# Browser::FirefoxBased
+
+require_relative './Base'
+
+class Browser
+  class FirefoxBased < Base
+    class << self
+      def bookmarks_location(profile_name: nil)
+        profile_name ||= default_profile_name
+        File.expand_path("#{profiles_path}/#{profile_name}/places.sqlite")
+      end
+
+      def history_location(profile_name: nil)
+        profile_name ||= default_profile_name
+        File.expand_path("#{profiles_path}/#{profile_name}/places.sqlite")
+      end
+
+      # The profile Firefox itself would open, which profiles.ini records: the one an
+      # [Install] section names, as Firefox has written since 67; else the one
+      # [Profile] flagged Default=1, as it wrote before and still does; else the only
+      # profile there is.  A directory is named for a hash, so nothing else could
+      # stand in for a name.
+      def default_profile_name(profiles_ini = read_profiles_ini)
+        File.basename(default_profile_path(profiles_ini))
+      end
+
+      private
+
+      def profiles_ini_path
+        File.expand_path("#{root_path}/profiles.ini")
+      end
+
+      def read_profiles_ini
+        File.read(profiles_ini_path)
+      rescue Errno::ENOENT
+        raise Browser::Unreadable, "#{profiles_ini_path} is not there, so no profile is the default: pass profile_name:"
+      end
+
+      # Two installations each naming a default, or two profiles flagged, or three
+      # profiles and no flag, are a question only the caller can answer.
+      def default_profile_path(profiles_ini)
+        candidates = default_profile_candidates(ini_sections(profiles_ini))
+        unless candidates.size == 1
+          raise Browser::Unreadable, "#{profiles_ini_path} names #{candidates.size} profiles as the default: pass profile_name:"
+        end
+        candidates.first
+      end
+
+      def default_profile_candidates(sections)
+        installs = sections.select{|name, _| name.start_with?('Install')}.values.filter_map{|section| section['Default']}
+        profiles = sections.select{|name, _| name.start_with?('Profile')}.values
+        flagged = profiles.select{|section| section['Default'] == '1'}.filter_map{|section| section['Path']}
+        [installs, flagged, profiles.filter_map{|section| section['Path']}].find{|candidates| candidates.any?} || []
+      end
+
+      def ini_sections(text)
+        text.scan(/^\[([^\]]+)\]\n((?:[^\[\n].*\n?)*)/).to_h{|name, body| [name, body.scan(/^(\w+)=(.*)$/).to_h]}
+      end
+
+      def root_path
+        raise NotImplementedError, "#{self} must implement root_path"
+      end
+
+      def profiles_path
+        "#{root_path}/Profiles"
+      end
+
+      def bookmarks_format
+        :sqlite
+      end
+
+      def history_format
+        :sqlite
+      end
+
+      def bookmarks_sql
+        'SELECT moz_bookmarks.id, moz_bookmarks.parent, moz_bookmarks.position, moz_bookmarks.type, moz_bookmarks.title, moz_bookmarks.guid, moz_places.url FROM moz_bookmarks LEFT JOIN moz_places ON moz_bookmarks.fk = moz_places.id ORDER BY moz_bookmarks.parent, moz_bookmarks.position;'
+      end
+
+      def history_sql
+        'SELECT moz_historyvisits.id, moz_places.url, moz_places.title, moz_historyvisits.visit_date FROM moz_historyvisits LEFT JOIN moz_places ON moz_historyvisits.place_id = moz_places.id ORDER BY moz_historyvisits.visit_date DESC;'
+      end
+    end
+  end
+end

data/lib/Browser/History.rb

@@ -0,0 +1,41 @@
+# Browser/History.rb
+# Browser::History
+
+require 'sqlite3'
+
+require_relative './Rendering'
+require_relative './Unreadable'
+
+class Browser
+  class History
+    include Rendering
+
+    def to_objects
+      rows.collect{|row| column_names.zip(row).to_h}
+    end
+
+    private
+
+    def initialize(browser_instance)
+      @browser_instance = browser_instance
+    end
+
+    def database
+      @database ||= SQLite3::Database.new(@browser_instance.history_location)
+    end
+
+    def results
+      @results ||= database.execute2(@browser_instance.class.send(:history_sql))
+    rescue IOError, SystemCallError, SQLite3::Exception => e
+      raise Browser::Unreadable, "#{@browser_instance.history_location} is not readable: #{e.message}"
+    end
+
+    def column_names
+      results.first
+    end
+
+    def rows
+      results.drop(1)
+    end
+  end
+end