bookmark_machine 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3f5f66298a831b464d86c98800b1ab5e71ad8e39
+  data.tar.gz: a0c95f2b85fc13d8554d37ad781012dbddac5ec8
+SHA512:
+  metadata.gz: 27ab83813bde72786e43cb1fcf93445397ba2599dfb8fdb6f9f34d3520368612e8ed93e2bb0e0fc687044c5440e32763a645a9e2a8e6430d731f9b6256b31ece
+  data.tar.gz: f0b36f19b94810551431812fa40ad7cdd068f9be32bf8f820df6c8dab161c06ff858d2ddbf4b0ec9473fa41645ddb2db995e47b4bc5602afa47fea71934e00cd

data/README.markdown

@@ -0,0 +1,54 @@
+BookmarkMachine
+===============
+
+Parses Netscape bookmark files.  These are for better or worse the standard bookmark file format used by every browser.  This also happens to be roughly the file format that Delicious uses for liberating your bookmarks from their once adequate system.
+
+Usage
+-----
+
+Pass `BookmarkMachine::NetscapeParser` a string, and ask it for bookmarks:
+
+```
+html = IO.read("bookmarks.html")
+parser = BookmarkMachine::NetscapeParser.new(html)
+
+bookmarks = parser.bookmarks
+```
+
+To format a collection of bookmarks, create `BookmarkMachine::NetscapeFormatter` with a collection of bookmarks:
+
+```
+bookmarks = [
+  Bookmark.new("http://example.com", name: "Example")
+]
+
+formatter = BookmarkMachine::NetscapeFormatter.new(bookmarks)
+html = formatter.to_s
+```
+
+BookmarkMachine represents bookmarks as an object containing:
+
+* `url` - Bookmark's url
+* `name` - Page's name, defaults to an empty string
+* `created_at` - `Time` the bookmark was created
+* `updated_at` - `Time` the bookmark was last updated
+* `icon` - Either a data uri or url to an icon
+* `folders` - An `Array` of the bookmark's parent folder names
+* `tags` - An `Array` of tags (less common)
+* `description` - An extended description of the bookmark
+
+Any fields that aren't present will be `nil` unless otherwise noted.
+
+Warning 
+-------
+
+Honestly there are alternatives like [markio](https://github.com/spajus/markio) that are probably better. About half of this project was an exercise in doing some TDD.  That said, it does support outputting nested folders if that's important to you.
+
+TODO
+----
+
+It might be fun (in the questionable sense) to support other linked formats including Atom feeds and so forth.
+
+Contact
+-------
+Adam Sanderson, netghost@gmail.com | http://monkeyandcrow.com

data/bin/anonymize_html.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+
+# This is a quick an dirty script for anonymizing HTML while keeping the
+# same general shape.
+# 
+# Doing this requires a handful of dirty tricks, and the output is not
+# quite the same, but Nokogiri will roundtrip it back to the same structure
+# anyways.
+#
+# It's actually pretty amazing that browsers all implement this wickedly 
+# broken format.
+
+require 'nokogiri'
+require 'base64'
+
+# A useful sampling of words; the original ipsum lorum by Lewis Carroll
+# 
+WORDS = <<-JABBERWOCKY.split(/[\s\W]+/m).reject{|w| w =~ /\s+/ }.map(&:downcase)
+Twas brillig, and the slithy toves
+  Did gyre and gimble in the wabe:
+All mimsy were the borogoves,
+  And the mome raths outgrabe.
+
+Beware the Jabberwock, my son!
+  The jaws that bite, the claws that catch!
+Beware the Jubjub bird, and shun
+  The frumious Bandersnatch!
+He took his vorpal sword in hand:
+  Long time the manxome foe he sought --
+So rested he by the Tumtum tree,
+  And stood awhile in thought.
+And, as in uffish thought he stood,
+  The Jabberwock, with eyes of flame,
+Came whiffling through the tulgey wood,
+  And burbled as it came!
+One, two! One, two! And through and through
+  The vorpal blade went snicker-snack!
+He left it dead, and with its head
+  He went galumphing back.
+And, has thou slain the Jabberwock?
+  Come to my arms, my beamish boy!
+O frabjous day! Callooh! Callay!'
+  He chortled in his joy.
+
+Twas brillig, and the slithy toves
+  Did gyre and gimble in the wabe;
+All mimsy were the borogoves,
+  And the mome raths outgrabe.
+  
+  --Lewis Carroll
+  
+JABBERWOCKY
+
+# Substitue attributes for the given element type in the document.
+def sub_attr(tag, attr)
+  @doc.css("#{tag}[#{attr}]").each do |el|
+    el[attr] = yield el[attr]
+  end
+end
+
+# Substitue text for the given element type in the document.
+def sub_text(tag)
+  @doc.css(tag).each do |el|
+    el.content = yield el.content
+  end
+end
+
+# Generate a fake url.
+def fake_url
+  protocol = rand(10) > 8 ? "http" : "https"
+  domain   = (rand(3)+2).times.map{ rand(2 ** 12).to_s(32) }.join(".")
+  path     = words(rand(5)).join("/")
+  
+  "#{protocol}://#{domain}/#{path}"
+end
+
+# Generates a URL safe base64 encoded String.
+def fake_base_64
+  Base64.urlsafe_encode64(words(20).join)
+end
+
+# Samples from the excellent lexicon of the Jabberwocky, source
+# of all good slithy toves.
+def words(length)
+  WORDS.sample(length)
+end
+
+# Replaces a collection of words (or tags), with a new collection
+# containing the same number of beamish words.
+def replace_words(text, delimiter=" ")
+  count = text.split(delimiter).count
+  words(count).join(delimiter)
+end
+
+# Converts most elements (except for `p` tags), and their attributes
+# to uppercase. Why not `p` tags? I know not, but that's the convention.
+def upcase_elements(node)
+  node.name = node.name.upcase unless node.name == "p"
+  
+  # Make sure all the ATTRIBUTES ARE SHOUTING at you!
+  node.each do |key, value| 
+    node.delete(key)
+    node[key.upcase] = value
+  end
+  node.elements.each{|el| upcase_elements(el) }
+end
+
+# Parses the input document either from the first argument or STDIN:
+@doc = Nokogiri::HTML(ARGV.length > 0 ? IO.read(ARGV[0]) : STDIN.read)
+
+# Substitutes meaningful information with borogoves and Jubjub birds.
+sub_attr("a", "href")     { fake_url }
+sub_attr("a", "icon_uri") { fake_url }
+sub_attr("a", "icon")     { "data:image/png;base64,#{ fake_base_64 }" }
+sub_attr("a", "tags")     {|s| replace_words(s, ",") }
+sub_text("a")             {|s| replace_words(s) }
+sub_text("h3")            {|s| replace_words(s) }
+
+# Deformats this back into the mess it started with:
+
+# 1. Lower case tag names? What is this, 1998? UPCASE!
+upcase_elements(@doc.root)
+
+# 2. Strip out closing tags for DT and DD elements.
+# 3. Remove the root HTML, HEAD, and BODY elements.
+html = @doc.to_html(indent: 2)
+  .gsub(%r(\s*</p>\s*),"")      # Do not close P tags
+  .gsub(%r(\s*</DT>\s*),"")     # Do not close DT tags
+  .gsub(%r(\s*</DD>\s*),"")     # Do not close DD tags
+  .gsub(%r(\s*</?HTML>\s*),"")  # Strip HTML tags
+  .gsub(%r(\s*</?HEAD>\s*),"")  # Strip HEAD tags
+  .gsub(%r(\s*</?BODY>\s*),"")  # Strip BODY tags
+  
+# Yes, I know you shouldn't parse HTML with regexps, but this isn't exactly
+# a "10 Best Practices You Should Be Using Today!" kind of script.
+  
+# All done!
+# Enjoy the mome raths.
+puts html

data/lib/bookmark_machine.rb

@@ -0,0 +1,8 @@
+require "bookmark_machine/version"
+require "bookmark_machine/bookmark"
+require "bookmark_machine/netscape_parser"
+require "bookmark_machine/netscape_formatter"
+
+module BookmarkMachine
+  
+end

data/lib/bookmark_machine/bookmark.rb

@@ -0,0 +1,29 @@
+module BookmarkMachine
+  class Bookmark
+    attr_accessor :url, :name, :created_at, :updated_at, :icon, :folders, :tags, :description
+    
+    def initialize(url, attrs=nil)
+      self.url = url
+
+      if attrs
+        attrs.each{|key,value| self.send("#{key}=", value)}
+      end
+
+      self.name    ||= ""
+      self.folders ||= []
+    end
+    
+    # Bookmarks are considered equal if all attributes are equal.
+    # Which is probably what you would have excpected.
+    def == other
+      url         == other.url &&
+      name        == other.name &&
+      created_at  == other.created_at &&
+      updated_at  == other.updated_at &&
+      icon        == other.icon &&
+      folders     == other.folders &&
+      tags        == other.tags &&
+      description == other.description
+    end
+  end
+end

data/lib/bookmark_machine/netscape_formatter.rb

@@ -0,0 +1,184 @@
+require 'nokogiri'
+
+module BookmarkMachine
+  # Formatter for the Netscape Bookmark File format.
+  # Amusingly, the best documentation for the format comes from Microsoft.
+  # 
+  #   https://msdn.microsoft.com/en-us/library/aa753582(v=vs.85).aspx
+  #
+  # We live in interesting times.
+  class NetscapeFormatter
+    attr_reader :bookmarks
+    
+    def initialize(bookmarks)
+      @bookmarks = bookmarks
+    end
+    
+    # Returns an Array of Bookmark objects.
+    def to_html
+      writer = Writer.new(StringIO.new)
+      
+      bookmarks.each{|b| writer << b }
+      writer.done
+      
+      writer.io.string
+    end
+    
+    alias_method :to_s, :to_html
+    
+    # :nodoc:
+    # This is a simple writer for outputting bookmark appropriate HTML.
+    # Since the expected HTML doesn't have a root, uses a custom doctype,
+    # and doesn't close most tags, it's easier to just write the output 
+    # manually rather than try to get Nokogiri to format it poorly for us.
+    # 
+    # Plus this is just kind of fun in a bizarre un-fun kind of way.
+    class Writer
+      HEADER = <<-HTML.gsub(/^        /, "")
+        <!DOCTYPE NETSCAPE-Bookmark-file-1>
+        <!-- This is an automatically generated file.
+             It will be read and overwritten.
+             DO NOT EDIT! -->
+        <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
+        <TITLE>Bookmarks</TITLE>
+        <H1>Bookmarks</H1>
+      HTML
+      
+      attr_reader :io
+      attr_reader :folders
+      
+      def initialize(io)
+        @io = io
+        @folders = []
+        io.set_encoding(Encoding::UTF_8)
+        
+        start
+      end
+      
+      def done
+        close_all_folders
+      end
+      
+      def << bookmark
+        adjust_folders(bookmark.folders)
+        write_bookmark(bookmark)
+      end
+      
+      private
+      
+      def start
+        io.puts HEADER
+        open_collection
+      end
+      
+      def adjust_folders(new_folders)
+        # Find where the new and old folders differ:
+        diverge_index = folders.zip(new_folders).find_index{|a,b| a != b} || 0
+
+        # Close old folders after that point:
+        folders[diverge_index .. -1].reverse_each do |name|
+          close_folder(name)
+        end
+        
+        # Open new folders after that point:
+        new_folders[diverge_index .. -1].each do |name|
+          open_folder(name)
+        end
+      end
+      
+      def close_all_folders
+        folders.reverse_each{|name| close_folder(name)}
+        # Close root folder
+        close_collection
+      end
+      
+      def write_bookmark(bookmark)
+        open_tag(:DT)
+        
+        open_tag(:A) do 
+          write_bookmark_attrs(bookmark)
+        end
+        
+        write_text(bookmark.name)
+        close_tag(:A)
+        
+        if bookmark.description
+          open_tag(:DD)
+          write_text(bookmark.description)
+        end
+      end
+      
+      def write_bookmark_attrs(bookmark)
+        write_attr(:HREF, bookmark.url) if bookmark.url
+        write_attr(:ADD_DATE, bookmark.created_at.to_i) if bookmark.created_at
+        write_attr(:LAST_MODIFIED, bookmark.updated_at.to_i) if bookmark.updated_at
+        write_attr(:TAGS, bookmark.tags.join(",")) if bookmark.tags
+        
+        icon = bookmark.icon
+        if icon
+          attr_name = icon.start_with?("data:") ? :ICON_URI : :ICON
+          write_attr(attr_name, icon)
+        end
+      end
+      
+      def write_folder(name)
+        open_tag(:DT)
+        open_tag(:H3)
+        write_text(name)
+        close_tag(:H3)
+      end
+      
+      def open_folder(name)
+        folders.push name
+        open_collection
+        write_folder(name)
+      end
+      
+      def close_folder(name)
+        popped = folders.pop        
+        close_collection
+      end
+      
+      def open_collection
+        open_tag(:DL)
+        open_tag(:p)
+      end
+      
+      def close_collection
+        close_tag(:DL)
+      end
+      
+      def open_tag(tag, attributes={})
+        io.write("<#{tag} ")
+        yield if block_given?
+        io.write(">")
+      end
+      
+      def write_attr(name, value)
+        io.write(name)
+        io.write('="')
+        io.write(encode(value))
+        io.write('" ')
+      end
+      
+      def close_tag(tag)
+        io.write("</#{tag}>")
+        io.write("\n")
+      end
+      
+      def write_text(str)
+        io.write(encode(str))
+      end
+      
+      def encode(str)
+        str.to_s
+          .gsub('&', "&amp;")
+          .gsub('"', "&quot;")
+          .gsub("'", "&apos;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+      end
+    end
+    
+  end
+end

data/lib/bookmark_machine/netscape_parser.rb

@@ -0,0 +1,138 @@
+require 'nokogiri'
+
+module BookmarkMachine
+  # Parser for the Netscape Bookmark File format.
+  # Amusingly, the best documentation for the format comes from Microsoft.
+  # 
+  #   https://msdn.microsoft.com/en-us/library/aa753582(v=vs.85).aspx
+  #
+  # We live in interesting times.
+  class NetscapeParser
+    
+    def initialize(html)
+      @html = html
+    end
+    
+    # Returns an Array of Bookmark objects.
+    def bookmarks
+      @bookmarks ||= begin
+        doc = BookmarkDocument.new
+        parser = Nokogiri::HTML::SAX::Parser.new(doc)
+        parser.parse(@html)
+        
+        doc.bookmarks
+      end
+    end
+    
+  end
+  
+  # :nodoc:
+  # BookmarkDocument implements SAX callbacks for parsing messy bookmark files.
+  # It turns out that a SAX parser is more resilient to bizarre inputs than the
+  # typical Nokogiri parser since it doesn't bother itself with the document 
+  # structure.
+  class BookmarkDocument < Nokogiri::XML::SAX::Document
+    attr_reader :bookmarks
+    
+    def initialize
+      super
+      
+      @folders = []
+      @bookmarks = []
+      @current_bookmark = nil
+      
+      reset_state
+    end
+    
+    # Only three elements have semantic meaning, A, H3, and DD,
+    # representing Folder names, Bookmarks, and Descriptions.
+    def start_element(name, attrs = [])
+      case name
+      when "a"  then start_bookmark(attrs)
+      when "h3" then start_folder(attrs)
+      when "dd" then start_description(attrs)
+      else           done
+      end
+    end
+    
+    # Only one closing element has semantic meaning, a closed DL,
+    # which indicates the end of a folder.
+    def end_element(name, attrs = [])
+      case name
+      when "dl" then pop_folder
+      else           done
+      end
+    end
+    
+    def end_document
+      done
+    end
+    
+    def characters(string)
+      @text << string if @state
+    end
+    
+    def start_bookmark(attrs)
+      attrs = Hash[attrs]
+      
+      @current_bookmark = Bookmark.new(attrs['href'])
+      @current_bookmark.created_at = epoch_time(attrs['add_date'])
+      @current_bookmark.updated_at = epoch_time((attrs['last_modified'] || attrs['add_date']))
+      @current_bookmark.icon = attrs['icon'] || attrs['icon_uri']
+      @current_bookmark.tags = tagged_text(attrs['tags'])
+      @current_bookmark.folders = @folders.clone
+      
+      @state = :bookmark
+    end
+    
+    def start_folder(attrs)
+      @state = :folder
+    end
+    
+    def start_description(attrs)
+      @state = :description
+    end
+    
+    def done
+      case @state
+      when :bookmark
+        @current_bookmark.name = @text.strip
+        @bookmarks << @current_bookmark
+        @current_bookmark = nil
+        reset_state
+        
+      when :folder
+        @folders << @text.strip
+        reset_state
+        
+      when :description
+        description = @text.strip
+        @bookmarks.last.description = description unless description == ""
+        reset_state
+        
+      end
+    end
+    
+    def pop_folder
+      @folders.pop
+      done
+    end
+    
+    def reset_state
+      @text = ""
+      @state = nil
+    end
+    
+    # Converts from epoch seconds to a Time object.
+    # Returns nil on a nil input.
+    def epoch_time(seconds)
+      Time.at(seconds.to_i) if seconds
+    end
+    
+    def tagged_text(str)
+      str.split(",").map{|t| t.strip} if str
+    end
+    
+  end
+  
+end

data/lib/bookmark_machine/version.rb

@@ -0,0 +1,3 @@
+module BookmarkMachine
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: bookmark_machine
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Adam Sanderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !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'
+description: Parse and format bookmarks
+email:
+- netghost@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.markdown
+- bin/anonymize_html.rb
+- lib/bookmark_machine.rb
+- lib/bookmark_machine/bookmark.rb
+- lib/bookmark_machine/netscape_formatter.rb
+- lib/bookmark_machine/netscape_parser.rb
+- lib/bookmark_machine/version.rb
+homepage: https://github.com/adamsanderson/bookmark_machine
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Reads and writes netscape bookmark files.
+test_files: []