josh-kindler 0.1.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Joshua Peek
+
+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.rdoc

@@ -0,0 +1,3 @@
+= KindleR
+
+KindleR is a library for packaging and formatting MOBI files.

data/bin/kindler

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'mobi'
+
+unless file = ARGV[0]
+  raise ArgumentError
+end
+
+mobi = Mobi.new
+mobi.title = File.basename(file, '.html')
+mobi.content = File.open(file).read
+mobi.write_file "#{File.basename(file, '.html')}.mobi"

data/bin/kindler-dropbox

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'pathname'
+
+module Kindler
+  class Dropbox
+    SUPPORTED_FILE_FORMATS = {
+      :documents => ['mobi', 'prc', 'pdf', 'txt', 'azw', 'azw1'],
+      :music => ['mp3'],
+      :audible => ['aa', 'aax']
+    }
+
+    def self.run
+      new.run
+    end
+
+    def run
+      if kindle_is_connected? && dropbox.exist?
+        process_files
+      end
+
+      run_post_mount_hook
+    end
+
+    protected
+      def drive
+        @drive ||= Pathname.new('/Volumes/Kindle')
+      end
+
+      def dropbox
+        @dropbox ||= Pathname.new(ENV['KINDLE_DROPBOX'] || "/Users/#{ENV['USER']}/Documents/Kindle")
+      end
+
+      def kindle_is_connected?
+        drive.directory?
+      end
+
+      def process_files
+        files_to_be_processed.each do |file|
+          target_folder = map_folder_to File.extname(file)
+
+          if target_folder
+            FileUtils.mv(file, target_folder, :force => true)
+          end
+        end
+      end
+
+      def files_to_be_processed
+        @files_to_be_processed ||= dropbox.entries.reject { |f| f.to_s.match(/^\./) }.map { |file| dropbox.join(file) }
+      end
+
+      def map_folder_to(file_extension)
+        return nil unless file_extension
+        file_extension = file_extension.delete('.')
+        folder = SUPPORTED_FILE_FORMATS.find(proc {[]}) { |folder_map| folder_map[1].include?(file_extension) }[0]
+        folder ? drive.join(folder.to_s)  : nil
+      end
+
+      def run_post_mount_hook
+        if post_mount_hook.exist?
+          system(post_mount_hook)
+        end
+      end
+
+      def post_mount_hook
+        drive.join(".post-mount")
+      end
+  end
+end
+
+Kindler::Dropbox.run

data/bin/kindler-rename

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'mobi'
+require 'optparse'
+
+name = nil
+
+opts = OptionParser.new("", 24, '  ') { |opts|
+  opts.banner = "Usage: kindler-rename book.mobi [options]"
+
+  opts.on("--title NAME", "New title") { |n| name = m }
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.parse!
+}
+
+unless file = ARGV[0]
+  puts opts
+  exit
+end
+
+mobi = Palm::PDB.new(file)
+Mobi.rename(mobi, name || mobi.name)
+mobi.write_file(file)

data/lib/mobi.rb

@@ -0,0 +1,89 @@
+require 'palm'
+
+class Mobi < Palm::PDB
+  autoload :ExtendedHeader, 'mobi/extended_header'
+  autoload :Header, 'mobi/header'
+
+  # Optimized version of Mobi#title= that does not parse the
+  # entire document.
+  def self.rename(pdb, name)
+    header = pdb.data[0].data
+
+    offset = header.unpack('@84N')[0]
+    length = header.unpack('@88N')[0]
+    header[offset...offset+length] = ("\000" * length)
+
+    header[88...88+4] = [name.length].pack('N*')
+    header[offset...offset+name.length] = name
+
+    pdb.name = name
+
+    pdb
+  end
+
+  def initialize(from = nil)
+    super
+
+    self.creator = 'MOBI'
+    self.type = 'BOOK'
+    self.data[0] ||= Header.new
+  end
+
+  def header
+    data[0]
+  end
+
+  def title
+    header.full_name
+  end
+
+  def title=(title)
+    header.full_name = title
+    self.name = title
+  end
+
+  def content
+    text = ''
+    header.record_count.times do |n|
+      text << data[n + 1].data
+    end
+    text
+  end
+
+  def content=(text)
+    header.text_length = text.length
+    record_size = header.record_size
+    io = StringIO.new(text)
+    index = 1
+
+    while str = io.read(record_size)
+      record = Palm::RawRecord.new(str)
+      record.record_id = index
+      index += 1
+      data << record
+    end
+
+    header.record_count = index
+
+    nil
+  end
+
+  protected
+    def unpack_entry(byte_string)
+      header = byte_string.unpack('@16a4') == ['MOBI'] rescue false
+      header ? Header.from_binary(byte_string) :
+        Palm::RawRecord.new(byte_string)
+    end
+
+    def unpack_header(header)
+      super
+    end
+
+    def pack_header(app_info_offset, sort_offset)
+      super
+    end
+
+    def pack_entry(entry)
+      entry.data
+    end
+end

data/lib/mobi/extended_header.rb

@@ -0,0 +1,77 @@
+class Mobi
+  class ExtendedHeader
+    TYPES = {
+      1 => "drm_server_id",
+      2 => "drm_commerce_id",
+      3 => "drm_ebookbase_book_id",
+      100 => "author",
+      101 => "publisher",
+      102 => "imprint",
+      103 => "description",
+      104 => "isbn",
+      105 => "subject",
+      106 => "publishingdate",
+      107 => "review",
+      108 => "contributor",
+      109 => "rights",
+      110 => "subjectcode",
+      111 => "type",
+      112 => "source",
+      113 => "asin",
+      114 => "versionnumber",
+      115 => "sample",
+      116 => "startreading",
+      118 => "price",
+      119 => "currency",
+      201 => "coveroffset",
+      202 => "thumboffset",
+      203 => "hasfakecover",
+      401 => "clippinglimit",
+      402 => "publisherlimit",
+      404 => "ttsflag",
+      501 => "cdecontenttype",
+      502 => "lastupdatetime",
+      503 => "updatedtitle",
+      504 => "cdecontentkey"
+    }
+
+    def self.from_binary(data, offset, max = nil)
+      type = data.unpack("@#{offset + 4}N")[0]
+      length = data.unpack("@#{offset + 8}N")[0]
+      raise RangeError if max && (offset - 256 + length) > max
+      data = data.unpack("@#{offset + 12}C#{length - 8}")
+      new(type, data)
+    end
+
+    def initialize(type = 0, data = [])
+      @type, @data = type, data
+    end
+
+    def type
+      TYPES[@type] || @type
+    end
+    attr_writer :type
+
+    def length
+      @data.length + 8
+    end
+    alias_method :size, :length
+
+    def data
+      if type.is_a?(String)
+        @data.pack('C*').unpack('a*').join
+      else
+        @data.pack('C*').unpack('N*')
+      end
+    end
+    attr_writer :data
+
+    def to_a
+      [@type, length] + @data.pack('C*').unpack('N*')
+    end
+
+    def to_s
+      to_a.pack("N*")
+    end
+  end
+end

data/lib/mobi/header.rb

@@ -0,0 +1,263 @@
+class Mobi
+  class Header < Palm::Record
+    TYPES = {
+      2 => 'BOOK',
+      3 => 'PALMDOC',
+      4 => 'AUDIO',
+      257 => 'NEWS',
+      258 => 'NEWS_FEED',
+      259 => 'NEWS_MAGAZINE',
+      513 => 'PICS',
+      514 => 'WORD',
+      515 => 'XLS',
+      516 => 'PPT',
+      517 => 'TEXT',
+      518 => 'HTML'
+    }
+
+    ENCODING = {
+      1252 => 'ISO-8859-1',
+      65001 => 'UTF-8'
+    }
+
+    LANGUAGES = {
+      'es'    => 0x000a,
+      'sv'    => 0x001d,
+      'sv-se' => 0x041d,
+      'sv-fi' => 0x081d,
+      'fi'    => 0x000b,
+      'en'    => 0x0009,
+      'en-au' => 0x0C09,
+      'en-bz' => 0x2809,
+      'en-ca' => 0x1009,
+      'en-cb' => 0x2409,
+      'en-ie' => 0x1809,
+      'en-jm' => 0x2009,
+      'en-nz' => 0x1409,
+      'en-ph' => 0x3409,
+      'en-za' => 0x1c09,
+      'en-tt' => 0x2c09,
+      'en-us' => 0x0409,
+      'en-gb' => 0x0809,
+      'en-zw' => 0x3009,
+      'da'    => 0x0006,
+      'da-dk' => 0x0406,
+      'da'    => 0x0006,
+      'da'    => 0x0006,
+      'nl'    => 0x0013,
+      'nl-be' => 0x0813,
+      'nl-nl' => 0x0413,
+      'fi'    => 0x000b,
+      'fi-fi' => 0x040b,
+      'fr'    => 0x000c,
+      'fr-fr' => 0x040c,
+      'de'    => 0x0007,
+      'de-at' => 0x0c07,
+      'de-de' => 0x0407,
+      'de-lu' => 0x1007,
+      'de-ch' => 0x0807,
+      'no'    => 0x0014,
+      'nb-no' => 0x0414,
+      'nn-no' => 0x0814
+    }
+
+    NO_DRM = 0xffffffff
+
+    DEFAULTS = {
+      :compression => 1,
+      :text_length => 0,
+      :record_count => 1,
+      :record_size => 4096,
+      :encryption => 0,
+
+      :identifier => 'MOBI',
+      :length => 232,
+      :type => 'BOOK',
+      :encoding => 'ISO-8859-1',
+      :generator_version => 4,
+
+      :first_non_book_index => 2,
+      :full_name_offset => 352,
+      :full_name => 'untitled',
+
+      :language => 'en-us',
+      :format_version => 4,
+      :image_record_index => 2,
+      :extended_flags => 0x50,
+
+      :drm_offset => NO_DRM,
+      :drm_count => 0,
+      :drm_size => 0,
+      :drm_flags => 0,
+
+      :exth_identifier => 'EXTH',
+      :exth_length => 0,
+      :exth_count => 0,
+      :extended_headers => []
+    }
+
+    def self.from_binary(data)
+      h = new
+
+      h.compression  = data.unpack('n2')[0]
+      h.text_length  = data.unpack('@4N')[0]
+      h.record_count = data.unpack('@8n2')[0]
+      h.record_size  = data.unpack('@10n2')[0]
+      h.encryption   = data.unpack('@12n2')[0]
+
+      h.identifier = data.unpack('@16a4')[0]
+      h.length = data.unpack('@20N')[0]
+      h.type = data.unpack('@24N')[0]
+      h.encoding = data.unpack('@28N')[0]
+      h.id = data.unpack('@32N')[0]
+      h.generator_version = data.unpack('@36N')[0]
+
+      h.first_non_book_index = data.unpack('@80N')[0]
+      h.full_name_offset = data.unpack('@84N')[0]
+      full_name_length = data.unpack('@88N')[0]
+      h.full_name = data.unpack("@#{h.full_name_offset}a#{full_name_length}")[0]
+
+      h.language = data.unpack('@92N')[0]
+      h.format_version = data.unpack('@104N')[0]
+      h.image_record_index = data.unpack('@108N')[0]
+      h.extended_flags = data.unpack('@128N')[0]
+
+      h.drm_offset = data.unpack('@168N')[0]
+      h.drm_count = data.unpack('@172N')[0]
+      h.drm_size = data.unpack('@174N')[0]
+      h.drm_flags = data.unpack('@176N')[0]
+
+      h.exth_identifier = data.unpack('@248a4')[0]
+      h.exth_length = data.unpack('@252N')[0]
+      h.exth_count = data.unpack('@256N')[0]
+
+      h.extended_headers = []
+      offset = 256
+      h.exth_count.times do
+        offset += h.extended_headers.last.length if h.extended_headers.last
+        begin
+          header = ExtendedHeader.from_binary(data, offset, h.exth_length)
+        rescue Exception => e
+          warn "Corrupted EXTH Header" if $DEBUG
+          header = ExtendedHeader.new
+        end
+        h.extended_headers << header
+      end
+
+      h
+    end
+
+    def initialize
+      super
+
+      @type, @language, @encoding = nil
+
+      @expunged = @dirty = @deleted = @private = false
+
+      DEFAULTS.each do |attr, value|
+        send("#{attr}=", value) unless send(attr)
+      end
+
+      @id ||= (rand() * 1_000_000_000).floor
+    end
+
+    attr_accessor :compression, :text_length, :record_count, :record_size, :encryption
+    attr_accessor :identifier, :length, :id, :generator_version
+    attr_accessor :first_non_book_index
+    attr_accessor :full_name_offset, :full_name
+    attr_accessor :format_version, :image_record_index, :extended_flags
+    attr_accessor :drm_offset, :drm_count, :drm_size, :drm_flags
+    attr_accessor :exth_identifier, :exth_length, :exth_count, :extended_headers
+    alias_method :size, :length
+
+    def compressed?
+      compression != 1
+    end
+
+    def encrypted?
+      encryption != 0
+    end
+
+    def type
+      TYPES[@type]
+    end
+
+    def type=(type)
+      @type = TYPES.index(type) || type
+    end
+
+    def encoding
+      ENCODING[@encoding]
+    end
+
+    def encoding=(encoding)
+      @encoding = ENCODING.index(encoding) || encoding
+    end
+
+    def language
+      LANGUAGES.index(@language)
+    end
+
+    def language=(language)
+      @language = LANGUAGES[language] || language
+    end
+
+    def full_name_length
+      full_name.length
+    end
+
+    def to_s
+      [
+        repack_as_int([compression, 0], 'n2'),
+        text_length,
+        repack_as_int([record_count, record_size], 'n2'),
+        repack_as_int([encryption, 0], 'n2'),
+        repack_as_int([identifier], 'a4'),
+        length,
+        TYPES.index(type),
+        ENCODING.index(encoding),
+        id,
+        generator_version,
+        0xffffffff,
+        0xffffffff,
+        0xffffffff,
+        0xffffffff,
+        0xffffffff,
+        0xffffffff,
+        0xffffffff,
+        0xffffffff,
+        0xffffffff,
+        0xffffffff,
+        first_non_book_index,
+        full_name_offset,
+        full_name_length,
+        LANGUAGES[language],
+        0, 0,
+        format_version,
+        image_record_index,
+        0, 0, 0, 0,
+        extended_flags,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        drm_offset,
+        drm_count,
+        drm_size,
+        drm_flags,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        repack_as_int([exth_identifier], 'a4'),
+        exth_length,
+        exth_count,
+        extended_headers.map { |exth| exth.to_a }
+      ].flatten.pack('N*')
+    end
+    alias_method :data, :to_s
+
+    def to_a
+      to_s.unpack('N*')
+    end
+
+    private
+      def repack_as_int(ary, format)
+        ary.pack(format).unpack('N')[0]
+      end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: josh-kindler
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Joshua Peek
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-06 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: palm
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.4
+    version: 
+description: KindleR is a library for packaging and formatting MOBI files.
+email: josh@joshpeek.com
+executables: 
+- kindler
+- kindler-dropbox
+- kindler-rename
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- lib/mobi.rb
+- lib/mobi/extended_header.rb
+- lib/mobi/header.rb
+- README.rdoc
+- MIT-LICENSE
+has_rdoc: false
+homepage: http://github.com/josh/kindler
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Ruby Kindle library
+test_files: []
+