rindle 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format nested
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create --install 1.9.3@rindle

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,19 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Arthur Andersen
+
+MIT License
+
+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,19 @@
+# Rindle: A Gem packaging multiple kindle tools
+
+Rindle is a package of useful classes to manage the kindles content.
+In mature versions it should provide an object-oriented interface to
+access the collections and documents on the kindle with all their
+metadata. And it should provide a convenient way for converting
+various eBook formats.
+
+## Libraries for kindle access
+
+First load the kindle:
+
+    Rindle::Kindle.load '/path/to/root'
+
+Then just use `Kindle::Collection` or `Kindle::File` with an
+ActiveRecord like interface:
+
+    Rindle::Collection.first named: 'Test Collection'
+    Rindle::Collection.all named: /(.*)[1|2]$/

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/rindle/collection.rb

@@ -0,0 +1,156 @@
+module Rindle
+  class Collection
+    class << self
+      def all options = {}
+        filtered = []
+        Rindle.collections.each_pair do |name, collection|
+          match = true
+          options.each_pair do |key,value|
+            case key
+            when :named
+              match = match && name =~ /#{value}/
+            when :including
+              match = match && collection.include?(value)
+            when :accessed
+              time = value.is_a?(Integer) ? Time.at(value) : value
+              match = match && collection.last_access == time
+            end
+          end
+          filtered << collection if match
+        end
+        filtered
+      end
+
+      def first options = {}
+        Rindle.collections.each_pair do |name, collection|
+          match = true
+          options.each_pair do |key,value|
+            case key
+            when :named
+              match = match && collection.name =~ /#{value}/
+            when :including
+              match = match && collection.include?(value)
+            when :accessed
+              time = value.is_a?(Integer) ? Time.at(value) : value
+              match = match && collection.last_access == time
+            end
+          end
+          return collection if match
+        end
+        nil
+      end
+
+      def find(method = :all, options={})
+        self.send method, options
+      end
+
+      def find_by_name name
+        find(:first, :named => name)
+      end
+
+      def create name, options = {}
+        collection = Collection.new(name, options)
+        Rindle.collections[collection.name] = collection
+      end
+
+      def exists? options
+        !Collection.first(options).nil?
+      end
+    end
+
+    attr_reader :name, :indices, :last_access
+
+    def == other
+      other.is_a?(Rindle::Collection) &&
+        name == other.name &&
+        indices == other.indices &&
+        last_access == other.last_access
+    end
+
+    def initialize name, options = {}
+      { :indices => [], :last_access => nil }.merge!(options)
+      @name = name.gsub('@en-US', '')
+      @indices = options[:indices] || []
+      @last_access = Time.at(options[:last_access]) if options[:last_access]
+    end
+
+    # Returns a hash that may be saved to `collections.json` file.
+    def to_hash
+      {
+        "#{@name}@en-US" => {
+          "items" => @indices,
+          "lastAccess" => @last_access.to_i
+        }
+      }
+    end
+
+    # Renames the collection. This changes the collections name and
+    # updates the Collections hash.
+    def rename! new_name
+      Rindle.collections.delete @name
+      @name = new_name
+      Rindle.collections[@name] = self
+    end
+
+    # Destroys the collection. This removes the collections key from
+    # the collections hash.
+    def destroy!
+      Rindle.collections.delete @name
+    end
+
+    # Adds an index or a document to the collection.
+    def add index
+      index = index.index if index.is_a?(Document)
+      unless indices.include?(index)
+        indices << obj.index
+        @documents = nil
+      end
+    end
+
+    # Removes an entry from this collection.
+    def remove index
+      index = index.index if index.is_a?(Document)
+      if indices.include?(index)
+        indices.delete index
+        @documents = nil
+      end
+    end
+
+    # Sets the indices array and resets the documents memoized array
+    # of `Document` objects.
+    def indices= indices
+      @documents = nil
+      @indices = indices
+    end
+
+    # Returns an `Array` of `Document` objects.
+    def documents
+      @documents ||= @indices.map { |i| Rindle.index[i] }
+    end
+
+    # Sets the array of `Document` objects.
+    def documents= documents
+      indices = documents.map(&:index)
+      @documents = documents
+    end
+
+    # Returns true if the collection includes the given indec,
+    # `Document` or `Array`.
+    def include? obj
+      if obj.is_a?(Array)
+        obj.inject(true) { |acc, o| acc = acc and include?(o) }
+      elsif obj.is_a?(Document)
+        indices.include? obj.index
+      elsif obj.is_a?(String)
+        indices.include? obj
+      else
+        false
+      end
+    end
+
+    # Update the last access timestamp.
+    def touch
+      last_access = Time.now
+    end
+  end
+end

data/lib/rindle/collections.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'json'
+
+require 'rindle/collection'
+
+module Rindle
+  class Collections < Hash
+
+    class NoSuchFile < Exception; end
+
+    def initialize(kindle_root)
+      @collections_file = File.join(kindle_root, 'system', 'collections.json')
+    end
+
+    def self.load(kindle_root)
+      Collections.new(kindle_root).load
+    end
+
+    def save
+      hash = {}
+      values.each do |coll|
+        hash.merge! col.to_hash
+      end
+      File.open(@collections_file, 'w+') do |f|
+        JSON.dump(hash, f)
+      end
+    end
+
+    def load
+      unless File.exists?(@collections_file)
+        raise NoSuchFile, "Not found: #{@collections_file}"
+      end
+
+      hash = File.open(@collections_file, 'r') { |file| JSON.load(file) }
+      hash.each_pair do |name, data|
+        col = Collection.new name, :indices => data['items'],
+                                   :last_access => data['lastAccess']
+        self[col.name] = col
+      end
+      self
+    end
+  end
+end

data/lib/rindle/document.rb

@@ -0,0 +1,131 @@
+require "digest/sha1"
+
+module Rindle
+  class Document
+    class NotFound < Exception; end
+
+    class << self
+      def all options = {}
+        filtered = []
+        Rindle.index.each_pair do |index, doc|
+          match = true
+          options.each_pair do |key, value|
+            case key
+            when :named
+              match = match && doc.filename =~ /#{value.is_a?(String) ? Regexp.escape(value) : value}/
+            when :indexed
+              match = match && index =~ /#{value.is_a?(String) ? Regexp.escape(value) : value}/
+            end
+          end
+          filtered << doc if match
+        end
+        filtered
+      end
+
+      def first options = {}
+        Rindle.index.each_pair do |index, doc|
+          match = true
+          options.each_pair do |key, value|
+            case key
+            when :named
+              match = match && doc.filename =~ /#{value.is_a?(String) ? Regexp.escape(value) : value}/
+            when :indexed
+              match = match && index =~ /#{value.is_a?(String) ? Regexp.escape(value) : value}/
+            end
+          end
+          return doc if match
+        end
+        nil
+      end
+
+      def find method = :all, options = {}
+        self.send method, options
+      end
+
+      def unassociated
+        unassociated = []
+        Rindle.index.each_pair do |index, doc|
+          unless Rindle.collections.values.inject(false) { |acc, col| acc = acc or col.include?(index) }
+            unassociated << doc
+          end
+        end
+        unassociated
+      end
+
+      def find_by_name name
+        Rindle.index.values.each do |doc|
+          return doc if doc.filename =~ /#{name.is_a?(String) ? Regexp.escape(name) : name}/
+        end
+        nil
+      end
+
+      def find_by_path path
+        Rindle.index.values.each do |doc|
+          return doc if doc.path =~ /#{path.is_a?(String) ? Regexp.escape(path) : path}/
+        end
+        nil
+      end
+
+      def find_by_index index
+        Rindle.index[index]
+      end
+    end
+
+    attr_reader :index, :path
+
+    def initialize path
+      self.path = path
+    end
+
+    # Sets the path variable and updates the index
+    def path= path
+      @path  = path
+      @index = generate_index
+    end
+
+    # Generates the index for the current path
+    def generate_index
+      if path =~ /([\w\s]+)-asin_([A-Z0-9]+)-type_([A-Z]+)-v_[0-9]+.azw/
+        "##{$2}^#{$3}"
+      else
+        "*#{Digest::SHA1.hexdigest(File.join('/mnt/us', path))}"
+      end
+    end
+
+    # Two documents are the same if the indices are equal.
+    def == other
+      @index == other.index
+    end
+
+    # Returns the filesize of this document.
+    def filesize
+      @filesize ||= File.size(File.join(Rindle.root_path, @path))
+    end
+
+    # Returns the filename of this document.
+    def filename
+      File.basename(@path)
+    end
+
+    # Returns true if the `path` looks like an amazon kindle store file.
+    def amazon?
+      !(path !~ /([\w\s]+)-asin_([A-Z0-9]+)-type_([A-Z]+)-v_[0-9]+.azw/)
+    end
+
+    # Renames the document. This also means that the index is changed
+    # and the Index-hash is updated.
+    def rename! new_name
+      Rindle.index.delete(@index)
+      self.path = @path.gsub filename, new_name
+      # TODO: update references in Rindle.collections
+      Rindle.index[@index] = self
+    end
+
+    # Returns an array of all the collections, this document is in.
+    def collections
+      Rindle.collections.select do |col|
+        col.include? self.index
+      end
+    end
+  end
+end

data/lib/rindle/index.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+require "rubygems"
+require "json"
+
+module Rindle
+  class Index < Hash
+    def initialize
+      @index = {}
+    end
+
+    def self.load(root_path)
+      Index.new.load(root_path)
+    end
+
+    def load(root_path)
+      @root_path = root_path
+      documents = Dir[File.join(@root_path, '{documents,pictures}', '*.{mobi,azw,azw1,pdf,rtf}')]
+      documents.each do |element|
+        add(element.gsub(@root_path, ''))
+      end
+      self
+    end
+
+    # Adds a path to the index. This means that the correct sha1 sum
+    # is generated and used as index for the newly created document
+    # object.
+    def add path
+      doc = Document.new path
+      self[doc.index] = doc
+      doc.index
+    end
+
+    # Removes either an entry either by `Document` or index.
+    def remove obj
+      if obj.is_a?(Document)
+        delete(index(obj))
+      else
+        delete(obj)
+      end
+    end
+
+  end
+end

data/lib/rindle/mixins/regexp.rb

@@ -0,0 +1,16 @@
+module Rindle
+  module Mixins
+    module Regexp
+
+      # converts the expressin to a string and
+      # strips the special characters for marking
+      # the beginning and end of a string
+      def strip
+        self.source.gsub(/^\^/,'').gsub(/\$$/,'')
+      end
+      
+    end
+  end
+end
+
+Regexp.send :include, Rindle::Mixins::Regexp

data/lib/rindle/version.rb

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

data/lib/rindle.rb

@@ -0,0 +1,58 @@
+require 'rindle/version'
+require 'rindle/index'
+require 'rindle/collections'
+require 'rindle/collection'
+require 'rindle/document'
+
+require 'rindle/mixins/regexp'
+
+# This module is used to load the Kindles state into the
+# data structures, which are used to let you access the Kindles
+# content in a way, that reminds one of the ActiveRecord usage
+#
+# Load from a specific path
+#
+#   Rindle.load(path)
+#
+# After that you may use the models Collection, Document, Album
+module Rindle
+  @@root_path = nil
+  @@collections = nil
+  @@index = nil
+
+  class NotLoaded < Exception; end
+
+  def self.root_path
+    if @@root_path
+      @@root_path
+    else
+      raise NotLoaded
+    end
+  end
+
+  def self.index
+    if @@index
+      @@index
+    else
+      raise NotLoaded
+    end
+  end
+
+  def self.collections
+    if @@collections
+      @@collections
+    else
+      raise NotLoaded
+    end
+  end
+
+  def self.load root_path
+    @@root_path = root_path
+    @@index = Index.load(root_path)
+    @@collections = Collections.load(root_path)
+  end
+
+  def self.save
+    @@collections.save
+  end
+end

data/rindle.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rindle/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Arthur Leonard Andersen"]
+  gem.email         = ["leoc.git@gmail.com"]
+  gem.description   = %q{The Rindle gem provides an object-oriented way to manage kindle collection data.}
+  gem.summary       = %q{Access kindle collection data}
+  gem.homepage      = "https://github.com/leoc/rindle"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rindle"
+  gem.require_paths = ["lib"]
+  gem.version       = Rindle::VERSION
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'guard-rspec'
+end

data/spec/data/README.md

@@ -0,0 +1 @@
+This directory contains dummy data for the specs.

data/spec/data/kindle/system/collections.json

@@ -0,0 +1,14 @@
+{
+    "collection1@en-US":{
+        "items":["*18be6fcd5d5df39c1a96cd22596bbe7fe01db9b7", "*0849dd9b85fc341d10104f56985e423b3848e1f3"],
+        "lastAccess": 1298745909919
+    },
+    "collection2@en-US":{
+        "items":["*440f49b58ae78d34f4b8ad3233f04f6b8f5490c2"],
+        "lastAccess": 1298745909918
+    },
+    "amazon books@en-US":{
+        "items":["#B001UQ5HVA^EBSP","#B000JQU1VS^EBOK"],
+        "lastAccess": 1298745909917
+    }
+}

data/spec/rindle/collection_spec.rb

@@ -0,0 +1,100 @@
+require "spec_helper"
+
+describe Rindle::Collection do
+  before(:all) do
+    Rindle.load(kindle_root)
+  end
+
+
+  context '#exists?' do
+    it 'returns true if the collection exists' do
+      Rindle::Collection.exists?(:named => 'collection1').should == true
+    end
+
+    it 'returns false if the collection does not exist' do
+      Rindle::Collection.exists?(:named => 'collection5').should == false
+    end
+  end
+
+  context '#all' do
+    it 'invokes Collection.find with parameter :all' do
+      Rindle::Collection.find(:all).map(&:name).should == Rindle::Collection.all.map(&:name)
+    end
+  end
+
+  context '#first' do
+    it 'invokes Collection.find with parameter :first' do
+      Rindle::Collection.find(:first).should == Rindle::Collection.first
+    end
+  end
+
+  context '#find' do
+    it 'returns an array of Kindle::Collection objects' do
+      Rindle::Collection.find
+    end
+
+    context 'finds all filtered' do
+      it 'by name with string' do
+        name = "collection"
+        collections = Rindle::Collection.find(:all, :named => name)
+        collections.map(&:name).should == ['collection1', 'collection2']
+      end
+
+      it 'by name with regular expression' do
+        name = /collection[1|3]/
+        collections = Rindle::Collection.find(:all, :named => name)
+        collections.map(&:name).should == ['collection1']
+      end
+
+      it 'by including index' do
+        collections = Rindle::Collection.find(:all, :including => '#B001UQ5HVA^EBSP')
+        collections.map(&:name).should == ['amazon books']
+      end
+
+      it 'by including all of an array of indices' do
+        collections = Rindle::Collection.find(:all, :including => ["*18be6fcd5d5df39c1a96cd22596bbe7fe01db9b7", "*0849dd9b85fc341d10104f56985e423b3848e1f3"])
+        collections.map(&:name).should == ['collection1']
+      end
+
+      it 'by last access time' do
+        collections = Rindle::Collection.find(:all, :accessed => 1298745909917)
+        collections.map(&:name).should == ['amazon books']
+      end
+    end
+
+    context 'finds first filtered' do
+      it 'by name' do
+        collection = Rindle::Collection.find(:first, :named => 'collection1')
+        collection.name.should == 'collection1'
+      end
+
+      it 'by included index' do
+        collection = Rindle::Collection.find(:first, :including => '*440f49b58ae78d34f4b8ad3233f04f6b8f5490c2')
+        collection.name.should == 'collection2'
+      end
+
+      it 'by last access time' do
+        collection = Rindle::Collection.find(:first, :accessed => 1298745909917)
+        collection.name.should == 'amazon books'
+      end
+    end
+  end
+
+  context '#documents' do
+    it 'returns an array of Rindle::Document objects' do
+      collection = Rindle::Collection.find(:first, :named => 'collection1')
+      collection.documents.each do |document|
+        document.should be_a(Rindle::Document)
+      end
+    end
+  end
+
+  context '#to_hash' do
+    it 'returns a hash that could be found in collections.json' do
+      now = Time.now.to_i
+      collection = Rindle::Collection.new("test", :indices => ['a','b','c'],
+                                                  :last_access => now)
+      collection.to_hash.should == { "test@en-US" => { "items" => ['a', 'b', 'c'], "lastAccess" => now } }
+    end
+  end
+end

data/spec/rindle/collections_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Rindle::Collections do
+  it 'loads the kindles collections.json file' do
+    collections = Rindle::Collections.load(kindle_root)
+    Hash[collections.map{|k,c| [k,c.indices] } ].should == {
+      "collection1"  => ["*18be6fcd5d5df39c1a96cd22596bbe7fe01db9b7", "*0849dd9b85fc341d10104f56985e423b3848e1f3"],
+      "collection2"  => ["*440f49b58ae78d34f4b8ad3233f04f6b8f5490c2"],
+      "amazon books" => ["#B001UQ5HVA^EBSP","#B000JQU1VS^EBOK"]
+    }
+  end
+end

data/spec/rindle/document_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe Rindle::Document do
+  before(:all) do
+    Rindle.load(kindle_root)
+  end
+
+  after(:all) do
+    Rindle.reset
+  end
+
+  it 'equals another if the index is the same' do
+    doc1 = Rindle::Document.new('documents/ABC-asin_B001UQ5HVA-type_EBSP-v1.azw')
+    doc2 = Rindle::Document.new('documents/ABC-asin_B001UQ5HVA-type_EBSP-v1.azw')
+    doc1.should == doc2
+  end
+
+  describe '.find' do
+    context 'finds :all filtered' do
+      it 'by name with string' do
+        docs = Rindle::Document.find(:all, :named => 'A test aswell.mobi')
+        docs.map(&:filename).should == ['A test aswell.mobi']
+      end
+
+      it 'by name with regular expression' do
+        docs = Rindle::Document.find(:all, :named => /t([es]+)t/)
+        docs.map(&:filename).should == ['A test aswell.mobi',
+                                        'This is a test document.rtf']
+      end
+
+      it 'by index' do
+        docs = Rindle::Document.find(:all, :indexed => '*18be6fcd5d5df39c1a96cd22596bbe7fe01db9b7')
+        docs.map(&:filename).should == ['A test aswell.mobi']
+      end
+    end
+
+    context 'finds :first filtered' do
+      it 'by name with string' do
+        doc = Rindle::Document.find(:first, :named => 'A test aswell.mobi')
+        doc.filename.should == 'A test aswell.mobi'
+      end
+      it 'by name with regular expression' do
+        doc = Rindle::Document.find(:first, :named => /t([es]+)t/)
+        doc.filename.should == 'A test aswell.mobi'
+      end
+      it 'by index' do
+        doc = Rindle::Document.find(:first, :indexed => '*18be6fcd5d5df39c1a96cd22596bbe7fe01db9b7')
+        doc.filename.should == 'A test aswell.mobi'
+      end
+    end
+  end
+
+  describe '.unassociated' do
+    it 'should return unassociated documents' do
+      docs = Rindle::Document.unassociated
+      docs.map(&:filename).should == [ 'This is a test document.rtf' ]
+    end
+  end
+end

data/spec/rindle/index_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Rindle::Index do
+  before(:each) do
+    @index = Rindle::Index.new
+  end
+
+  context '#add' do
+    it 'generates and adds for sha1 sum for custom books' do
+      index = @index.add('documents/A test aswell.mobi')
+      index.should == "*18be6fcd5d5df39c1a96cd22596bbe7fe01db9b7"
+      @index.should have_key("*18be6fcd5d5df39c1a96cd22596bbe7fe01db9b7")
+    end
+    it 'generates and adds amazon indices for EBOK and EBSP files' do
+      index = @index.add('documents/Salvia Divinorum Shamanic Plant-asin_B001UQ5HVA-type_EBSP-v_0.azw')
+      index.should == "#B001UQ5HVA^EBSP"
+      @index.should have_key("#B001UQ5HVA^EBSP")
+    end
+  end
+
+  context '#new' do
+    it 'creates an empty index' do
+      @index.should be_empty
+    end
+
+    it 'derives from Hash' do
+      @index.should be_a(Hash)
+    end
+  end
+
+  it 'is not empty after #load if there are documents on the kindle' do
+    Dir[File.join(kindle_root, '{documents,pictures}', '*.{mobi,azw,azw1,pdf,rtf}')].should_not be_empty
+    Rindle::Index.load(kindle_root).should_not == {}
+  end
+
+
+  it 'indexes the dummy files from spec data' do
+    @index = Rindle::Index.load(kindle_root)
+    @index.values.map { |o| [ o.index, o.filename ] }.should =~
+      [
+       [ "*18be6fcd5d5df39c1a96cd22596bbe7fe01db9b7", "A test aswell.mobi" ],
+       [ "#B001UQ5HVA^EBSP", "Salvia Divinorum Shamanic Plant-asin_B001UQ5HVA-type_EBSP-v_0.azw" ],
+       [ "*440f49b58ae78d34f4b8ad3233f04f6b8f5490c2", "A book in another collection.mobi" ],
+       [ "#B000JQU1VS^EBOK", "The Adventures of Sherlock Holme-asin_B000JQU1VS-type_EBOK-v_0.azw" ],
+       [ "*0849dd9b85fc341d10104f56985e423b3848e1f3", "Definitely a Test.pdf" ],
+       [ "*3a102b4032d485025650409b2f7753a1158b199d", "This is a test document.rtf" ]
+      ]
+  end
+end

data/spec/rindle/mixins/regexp_spec.rb

@@ -0,0 +1,11 @@
+describe 'Regexp Mixins' do
+  it 'should strip special char for beginning of string' do
+    expr = /^match/
+    expr.strip.should == 'match'
+  end
+
+  it 'should strip special char for end of string' do
+    expr = /match$/
+    expr.strip.should == 'match'
+  end
+end

data/spec/rindle_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Rindle do
+  before(:each) do
+    Rindle.reset
+  end
+  
+  context '.collections' do
+    it 'raises a NotLoaded error if not loaded' do
+      lambda { Rindle::collections }.should raise_error(Rindle::NotLoaded)
+    end
+    it 'returns an instance of Kindle::Collections if module loaded' do
+      Rindle::load(kindle_root)
+      Rindle::collections.should be_a(Rindle::Collections)
+    end
+  end
+
+  context '.index' do
+    it 'raises a NotLoaded error if not loaded' do
+      lambda { Rindle::index }.should raise_error(Rindle::NotLoaded)
+    end
+    it 'returns an instance of Kindle::Index if module loaded' do
+      Rindle::load(kindle_root)
+      Rindle::index.should be_a(Rindle::Index)
+    end
+  end
+  
+  context '.root_path' do
+    it 'provieds a string if loaded' do
+      Rindle::load(kindle_root)
+      Rindle::root_path.should be_a(String)
+    end
+    it 'raises a NotLoaded error if not loaded' do
+      lambda { Rindle::root_path }.should raise_error(Rindle::NotLoaded)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'rindle'
+
+def kindle_root; File.join(File.dirname(__FILE__), 'data', 'kindle'); end
+
+# this is to reset the Singleton'ish nature of the Kindle module
+module Rindle
+  def self.reset
+    self.class_variables.each do |var|
+      eval "#{var} = nil"
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: rindle
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Arthur Leonard Andersen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &21636720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21636720
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &21636100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21636100
+description: The Rindle gem provides an object-oriented way to manage kindle collection
+  data.
+email:
+- leoc.git@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/rindle.rb
+- lib/rindle/collection.rb
+- lib/rindle/collections.rb
+- lib/rindle/document.rb
+- lib/rindle/index.rb
+- lib/rindle/mixins/regexp.rb
+- lib/rindle/version.rb
+- rindle.gemspec
+- spec/data/README.md
+- spec/data/kindle/documents/A book in another collection.mobi
+- spec/data/kindle/documents/A test aswell.mobi
+- spec/data/kindle/documents/Definitely a Test.pdf
+- spec/data/kindle/documents/Salvia Divinorum Shamanic Plant-asin_B001UQ5HVA-type_EBSP-v_0.azw
+- spec/data/kindle/documents/The Adventures of Sherlock Holme-asin_B000JQU1VS-type_EBOK-v_0.azw
+- spec/data/kindle/documents/This is a test document.rtf
+- spec/data/kindle/system/collections.json
+- spec/data/mount/.gitkeep
+- spec/rindle/collection_spec.rb
+- spec/rindle/collections_spec.rb
+- spec/rindle/document_spec.rb
+- spec/rindle/index_spec.rb
+- spec/rindle/mixins/regexp_spec.rb
+- spec/rindle_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/leoc/rindle
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 391700311857255160
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 391700311857255160
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Access kindle collection data
+test_files:
+- spec/data/README.md
+- spec/data/kindle/documents/A book in another collection.mobi
+- spec/data/kindle/documents/A test aswell.mobi
+- spec/data/kindle/documents/Definitely a Test.pdf
+- spec/data/kindle/documents/Salvia Divinorum Shamanic Plant-asin_B001UQ5HVA-type_EBSP-v_0.azw
+- spec/data/kindle/documents/The Adventures of Sherlock Holme-asin_B000JQU1VS-type_EBOK-v_0.azw
+- spec/data/kindle/documents/This is a test document.rtf
+- spec/data/kindle/system/collections.json
+- spec/data/mount/.gitkeep
+- spec/rindle/collection_spec.rb
+- spec/rindle/collections_spec.rb
+- spec/rindle/document_spec.rb
+- spec/rindle/index_spec.rb
+- spec/rindle/mixins/regexp_spec.rb
+- spec/rindle_spec.rb
+- spec/spec_helper.rb