root/lang/ruby/ffhist/mork.rb @ 30649

#!ruby -Ku
=begin
Mork フォーマットパーサ

Mork とかいう Mozilla につかわれているクソフォーマットを
Ruby でパースする

# mork.rb
# See modifiers http://coderepos.org/share/log/lang/ruby/misc/mork.rb
#
# Based on http://www.jwz.org/hacks/mork.pl
# Copyright © 2004 Jamie Zawinski <jwz@jwz.org>
#
# Permission to use, copy, modify, distribute, and sell this software and its
# documentation for any purpose is hereby granted without fee, provided that
# the above copyright notice appear in all copies and that both that
# copyright notice and this permission notice appear in supporting
# documentation.  No representations are made about the suitability of this
# software for any purpose.  It is provided "as is" without express or 
# implied warranty.
#
# Created:  3-Mar-2004 by Jamie Zawinski, Anonymous, and Jacob Post.
=end

require "strscan"

class Mork
        RE = {
                :comment => %r|//.*\n|,
                :key_table => %r/  < \s* <             # "< <"
                                  \( a=c \) >          # "(a=c)>"
                                  (?> ([^>]*) ) > \s*  # Grab anything that's not ">"
                                /mx,

                :value_table => %r/ < ( .*?\) )> \s* /mx,

                :table => %r/ \{ -?        # "{" or "{-"
                             [\da-f]+ :    # hex, ":"
                             (?> .*?\{ )   # Eat up to a {...
                            ((?> .*?\} )   # and then the closing }...
                             (?> .*?\} ))  # Finally, grab the table section
                         \s* /mix,

                :row => %r/ ( (?> \[ [^\]]* \]  # "["..."]"
                                  \s*)+ )      # Perhaps repeated many times
                          /mx,

                :section_begin => %r/ \@\$\$\{    # "@$${"
                                      ([\dA-F]+)  # hex
                                      \{\@ \s*    # "{@"
                                   /mix,
                :section_end => nil # variable
        }

        def initialize(str, age=nil)
                @str = str
                @since = age ? Time.now - age : 0
                @age = age
        end

        def parse_key_table(key_table)
                key_table.gsub!(%r|\s+//.*$|, "")
                pairs = key_table.split(/\(([^\)]+)\)/)
                pairs.each do |pair|
                        next unless pair =~ /\S/m
                        _, key, val = *pair.match(/([\dA-F]*)[\t\n ]*=[\t\n ]*(.*)/i);

                        raise "Unparsable" unless val

                        @key_table[key] = val
                end

        end

        def parse_value_table(val_part)
                return unless val_part

                pairs = val_part.split(/\(([^\)]+)\)/)
                pairs.each do |pair|
                        next unless pair =~ /\S/m
                        _, key, val = *pair.match(/([\dA-F]*)[\t\n ]*=[\t\n ]*(.*)/i);

                        unless val
                                $stderr.puts "Unparsable"
                                next
                        end

                        if val.gsub!(/\$([\dA-F]{2})/) { $1.hex.chr }
                                val = val.unpack("S*").pack("U*")
                        end

                        @val_table[key] = val
                end
        end

        def parse_table(table_part)
                table_part.gsub!(/\s+/, "")
                re = %r/[^\[]*   \[  # find a "["
                      ( [^\]]+ ) \]  # capture up to "]"
                       /x
                table_part.scan(re) do |m,|
                        hash = {}
                        id, *cells = m.split(/[()]+/)
                        next unless cells
                        id.gsub!(/^-/, "")
                        id.gsub!(/:.*/, "")

                        if @row_hash[id]
                                hash = @row_hash[id]
                        else
                                hash = {
                                        "ID" => id,
                                        "LastVisitDate" => 0,
                                }
                        end

                        cells.each do |cell|
                                next unless cell

                                _, keyi, which, vali = *cell.match(
                                        /^\^ ([-\dA-F]+)
                                        ([\^=])
                                        (.*)
                                        $/xi)

                                unless vali
                                        $stderr.puts "Unparsable"
                                        next
                                end

                                key = @key_table[keyi]
                                next unless key

                                val = (which == "=") ? vali : @val_table[vali]

                                hash[key] = val
                        end

                        @block.call(hash)

                        @row_hash[id] = hash
                end
        end
        alias parse_row parse_table

        def parse_section_begin(section)
                @section = section
                @re[:section_end] = %r/\@\$\$\}#{section}\}\@\s*/s;
        end

        def parse_section_end(e)
                @re[:section_end] = nil
                @section = "top level"
        end

        def parse_comment(e)
                # Nice boat.
        end

        def parse(&block)
                @block = block
                @block = proc {} unless @block
                @str.gsub!(/\r\n/, "\n")
                @str.gsub!(/\r/, "\n")
                @str.gsub!(/\\\\/, "$5C")
                @str.gsub!(/\\\)/, "$29")
                @str.gsub!(/\\\n/, "")

                @s = StringScanner.new(@str)
                @section = "top level"
                @re = RE.dup
                @row_hash = {}
                @key_table = {}
                @val_table = {}
                until @s.eos?
                        [:key_table, :value_table, :table, :row, :section_begin, :section_end, :comment].each do |k|
                                next unless @re[k]
                                if @s.scan(@re[k])
                                        self.send("parse_#{k}", @s[1])
                                        break
                                end
                        end
                end
                @row_hash
        end
end


if $0 == __FILE__
        profile_dir =
                case RUBY_PLATFORM
                when /darwin/
                        "~/Library/Application Support/Firefox/Profiles"
                when /win/
                        "~/Application Data/Mozilla/Firefox/Profiles"
                when
                        "~/.mozilla/firefox"
                end


        require "pp"
        require "pathname"
        histfiles = Pathname.glob(File.expand_path("*/history.dat", profile_dir))
        puts histfiles

#       history = File.read(histfiles.first)
#       pp Mork.new(history).parse
        
#       pp histfiles.inject([]) {|r,i|
#               r.concat Mork.new(i.read).parse.map {|k,v|
#                       v["URL"]
#               }
#       }

        histfiles.each do |i|
                Mork.new(i.read).parse do |hash|
                        pp hash
                end
        end
end