delish 0.6.1 → 0.7.7

data/README

@@ -12,6 +12,12 @@ And then import your bookmarks.
 
 You can access these bookmarks with the <tt>delish</tt> command.  See more below.
 
+Once you have set the environment variables, you can update your bookmarks with
+
+<tt>update_delicious</tt>
+
+I recommend that you update as often as you add between one and ten bookmarks.  Updating any more than ten bookmarks will be slow and inefficient.
+
 = delish
 
 Conveniently access del.icio.us bookmarks from a local database via commandline
@@ -79,11 +85,8 @@ Dates begin with a character specifying which date to check against.  The charac
 * "search" tags
 * zsh configuration section
 * Month, minute, and second support
-* Tags table in underlying database to improve searching speed
 * Profile the code to increase speed
-* Date Unit Tests
 * "Build Script"
-* Incremental updates instead of always importing all bookmarks
 
 == Links
 

data/bin/delish

@@ -28,6 +28,7 @@ end
 #}}}
 
 require 'delish_bookmark_search.rb'
+include Delish
 
 delish_bookmark_search = Delish_Bookmark_Search.new(string, db)
 

data/bin/import_delicious

@@ -10,86 +10,8 @@ pass = ENV['delish_pass']
 
 db = SQLite3::Database.new( "#{ENV['HOME']}/.delish" )
 
-class ImportDelish
-
-  #{{{ initialize(user, pass, db)
-  def initialize(user, pass, db)
-    @user = user
-    @pass = pass
-    @db   = db
-  end
-  #}}}
-
-  #{{{ create_database
-  def create_database
-    # Create the table!!!
-    @db.execute %{
-  CREATE TABLE posts (
-    url VARCHAR(16384),
-    description VARCHAR(255),
-    extended VARCHAR(255),
-    created DATETIME,
-    hash CHAR(32) PRIMARY KEY,
-    accessed DATETIME
-  );
-  }
-
-    @db.execute %{
-  CREATE TABLE post_tags (
-    hash CHAR(32),
-    tag_id INTEGER
-  );}
-
-    @db.execute  %{
-    CREATE TABLE tags (
-    tag VARCHAR(255) UNIQUE,
-    id  INTEGER PRIMARY KEY AUTOINCREMENT
-    );}
-  end
-  #}}}
-
-  #{{{ get_all_tags
-  def get_all_tags
-    # User-Agent: required for del.icio.us api
-    agent = 'delish commandline client 0.6.1'
-
-    http = Net::HTTP.new('api.del.icio.us', 443)
-    http.use_ssl = true
-    http.start do |http|
-      request = Net::HTTP::Get.new('/v1/posts/all', {'User-Agent' => agent})
-      request.basic_auth @user, @pass
-      response = http.request(request)
-
-      data = REXML::Document.new(response.body)
-      data.elements.each("/posts/post") do |post|
-        @db.execute(
-        "INSERT INTO posts
-          (url, description, extended, created, accessed, hash) VALUES
-          (?, ?, ?, JULIANDAY(?), JULIANDAY(?), ?);",
-          post.attributes['href'],
-          post.attributes['description'],
-          post.attributes['extended'],
-          post.attributes['time'].chop,
-          post.attributes['time'].chop,
-          post.attributes['hash'])
-
-          post.attributes['tag'].split(' ').each do |tag|
-            @db.execute(
-                %{INSERT OR IGNORE INTO tags (tag) VALUES (?);},
-                tag)
-            tag_id = @db.execute( %{ SELECT id FROM tags WHERE tag = ?}, tag)[0]
-                @db.execute(
-                "INSERT INTO post_tags (hash, tag_id)
-                VALUES (?, ?);",
-                  post.attributes['hash'],
-                  tag_id)
-        end
-      end
-    end
-  end
-  #}}}
-
-end
+require 'import_delish.rb'
+include Delish
 
 import = ImportDelish.new(user, pass, db)
 import.create_database

data/bin/update_delicious

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'rexml/document'
+require 'net/https'
+require 'sqlite3'
+
+user = ENV['delish_user']
+pass = ENV['delish_pass']
+
+db = SQLite3::Database.new( "#{ENV['HOME']}/.delish" )
+
+require 'import_delish.rb'
+include Delish
+
+import = ImportDelish.new(user, pass, db)
+unless ARGV[0].nil?
+  import.update_bookmarks { |url, title| puts "New bookmark: #{title}[#{url}]" }
+else
+  import.update_bookmarks
+end
+

data/lib/delish_bookmark_search.rb

@@ -1,286 +1,289 @@
 
-
-class SuperSQL
-  def initialize(order)
-    @statement = ""
-    @variables = []
-    if order.is_a? Integer
-      @order = order
-    else
-      throw "Not a good order."
+module Delish
+
+  class SuperSQL
+    def initialize(order)
+      @statement = ""
+      @variables = []
+      if order.is_a? Integer
+        @order = order
+      else
+        throw "Not a good order."
+      end
     end
+    attr_reader :statement
+    attr_reader :variables
+    attr_reader :order
+    attr_writer :statement
+    attr_writer :variables
   end
-  attr_reader :statement
-  attr_reader :variables
-  attr_reader :order
-  attr_writer :statement
-  attr_writer :variables
-end
 
-class Delish_Bookmark_Search
-  #---
-  #{{{ initialize(search, database)
-  #+++
-  def initialize(search, database)
-    @db = database
+  class Delish_Bookmark_Search
+    #---
+    #{{{ initialize(search, database)
+    #+++
+    def initialize(search, database)
+      @db = database
 
-    @TAG_SPLIT = ','
-    @SPLIT = ':'
+      @TAG_SPLIT = ','
+      @SPLIT = ':'
 
-    @search_string = search
-    @sss = []
+      @search_string = search
+      @sss = []
 
-    @date_greater_or_equal = SuperSQL.new(0)
-    @date_greater_or_equal.statement = 'TYPE >= JULIANDAY(CURRENT_THING) - ?'
+      @date_greater_or_equal = SuperSQL.new(0)
+      @date_greater_or_equal.statement = 'TYPE >= JULIANDAY(CURRENT_THING) - ?'
 
-    @date_less_than        = SuperSQL.new(0)
-    @date_less_than.statement        = 'TYPE < JULIANDAY(CURRENT_THING) - ?'
+      @date_less_than        = SuperSQL.new(0)
+      @date_less_than.statement        = 'TYPE < JULIANDAY(CURRENT_THING) - ?'
 
-    @use_tags = false
-    @tag_count = 0
+      @use_tags = false
+      @tag_count = 0
 
-    self.search
+      self.search
 
-  end
-  #---
-  #}}}
-  #+++
-
-  #---
-  #{{{ search
-  #+++
-  def search
-    if @search_string =~ /^(.*?)(\((.*)\))?$/
-      self.main_search($1)
-      unless $2.nil?
-        @submatches = $3.split(@SPLIT)
-        self.sub_search_parse
+    end
+    #---
+    #}}}
+    #+++
+
+    #---
+    #{{{ search
+    #+++
+    def search
+      if @search_string =~ /^(.*?)(\((.*)\))?$/
+        self.main_search($1)
+        unless $2.nil?
+          @submatches = $3.split(@SPLIT)
+          self.sub_search_parse
+        end
+        self.execute(false)
       end
-      self.execute(false)
     end
-  end
-  #---
-  #}}}
-  #+++
+    #---
+    #}}}
+    #+++
 
-  #---
-  #{{{ main_search
-  #+++
-  def main_search(main_search_string)
-    @main_search = main_search_string
+    #---
+    #{{{ main_search
+    #+++
+    def main_search(main_search_string)
+      @main_search = main_search_string
 
-    ssql = SuperSQL.new(40)
-    ssql.statement = "(url LIKE ? OR description LIKE ? OR extended LIKE ?)"
-    3.times { ssql.variables << "%#{main_search_string}%" }
+      ssql = SuperSQL.new(40)
+      ssql.statement = "(url LIKE ? OR description LIKE ? OR extended LIKE ?)"
+      3.times { ssql.variables << "%#{main_search_string}%" }
 
-    @sss << ssql
-  end
-  #---
-  #}}}
-  #+++
-
-  #---
-  #{{{ sub_search_parse
-  #+++
-  def sub_search_parse
-    @submatches.each do |i|
-      if i =~ /^t(.*)$/
-        self.tag_equality_search($1)
-      elsif i =~ /^s(.*)$/
-        self.tag_begin_search($1)
-      elsif i =~ /^i(.*)$/
-        self.tag_inside_search($1)
-      elsif i =~ /^([ca])([Mwhms]|)([+-]|)(\d+)$/
-        self.date_search($1, $2, $3, $4)
+      @sss << ssql
+    end
+    #---
+    #}}}
+    #+++
+
+    #---
+    #{{{ sub_search_parse
+    #+++
+    def sub_search_parse
+      @submatches.each do |i|
+        if i =~ /^t(.*)$/
+          self.tag_equality_search($1)
+        elsif i =~ /^s(.*)$/
+          self.tag_begin_search($1)
+        elsif i =~ /^i(.*)$/
+          self.tag_inside_search($1)
+        elsif i =~ /^([ca])([Mwhms]|)([+-]|)(\d+)$/
+          self.date_search($1, $2, $3, $4)
+        end
       end
     end
-  end
-  #---
-  #}}}
-  #+++
-
-  #---
-  #{{{ tag_equality_search(tag_string
-  #+++
-  def tag_equality_search(tag_string)
-    @use_tags = true
-
-    ssql = SuperSQL.new(5)
-    ssql.variables = tag_string.split(@TAG_SPLIT)
-    ssql.statement = ssql.variables.map { @tag_count += 1; 'PLACEHOLDER = ?' }.join(' AND ')
-    @sss << ssql
-  end
-  #---
-  #}}}
-  #+++
-
-  #---
-  #{{{ tag_begin_search(i)
-  #+++
-  def tag_begin_search(tag_string)
-    @use_tags = true
-
-    ssql = SuperSQL.new(10)
-    ssql.variables = tag_string.split(@TAG_SPLIT).map { |i| "#{i}%" }
-    ssql.statement = ssql.variables.map { @tag_count += 1; 'PLACEHOLDER LIKE ?' }.join(' AND ')
-    @sss << ssql
-  end
-  #---
-  #}}}
-  #+++
-
-  #---
-  #{{{ tag_inside_search(i)
-  #+++
-  def tag_inside_search(tag_string)
-    @use_tags = true
-
-    ssql = SuperSQL.new(20)
-    ssql.variables = tag_string.split(@TAG_SPLIT).map { |i| "%#{i}%" }
-    ssql.statement = ssql.variables.map { @tag_count += 1; 'PLACEHOLDER LIKE ?' }.join(' AND ')
-    @sss << ssql
-  end
-  #---
-  #}}}
-  #+++
-
-  # This needs cleanup
-  #---
-  #{{{ date_search
-  #+++
-  def date_search(search_type, date_type, search_inner_type, amount)
-
-    type = ""
-    how_much = ""
-    date_or_time = ""
-    if search_type == 'c'
-      type = 'created'
-    else
-      type = 'accessed'
+    #---
+    #}}}
+    #+++
+
+    #---
+    #{{{ tag_equality_search(tag_string
+    #+++
+    def tag_equality_search(tag_string)
+      @use_tags = true
+
+      ssql = SuperSQL.new(5)
+      ssql.variables = tag_string.split(@TAG_SPLIT)
+      ssql.statement = ssql.variables.map { @tag_count += 1; 'PLACEHOLDER = ?' }.join(' AND ')
+      @sss << ssql
     end
-    if date_type == 'h'
-      how_much = Date.time_to_day_fraction(amount.to_i, 0, 0)
-    elsif date_type == ''
-      how_much = amount
-    elsif date_type == 'w'
-      how_much = amount * 7
+    #---
+    #}}}
+    #+++
+
+    #---
+    #{{{ tag_begin_search(i)
+    #+++
+    def tag_begin_search(tag_string)
+      @use_tags = true
+
+      ssql = SuperSQL.new(10)
+      ssql.variables = tag_string.split(@TAG_SPLIT).map { |i| "#{i}%" }
+      ssql.statement = ssql.variables.map { @tag_count += 1; 'PLACEHOLDER LIKE ?' }.join(' AND ')
+      @sss << ssql
     end
-    if search_inner_type == '-'
-      date_or_time = "CURRENT_TIMESTAMP"
-      @date_greater_or_equal.variables << how_much
-    elsif search_inner_type == '+'
-      date_or_time = "CURRENT_TIMESTAMP"
-      @date_less_than.variables << how_much
-    else
-      date_or_time = "CURRENT_DATE"
-      @date_greater_or_equal.variables << how_much
-      @date_less_than.variables << (how_much.to_i + 1).to_s
+    #---
+    #}}}
+    #+++
+
+    #---
+    #{{{ tag_inside_search(i)
+    #+++
+    def tag_inside_search(tag_string)
+      @use_tags = true
+
+      ssql = SuperSQL.new(20)
+      ssql.variables = tag_string.split(@TAG_SPLIT).map { |i| "%#{i}%" }
+      ssql.statement = ssql.variables.map { @tag_count += 1; 'PLACEHOLDER LIKE ?' }.join(' AND ')
+      @sss << ssql
     end
+    #---
+    #}}}
+    #+++
+
+    # This needs cleanup
+    #---
+    #{{{ date_search
+    #+++
+    def date_search(search_type, date_type, search_inner_type, amount)
+
+      type = ""
+      how_much = ""
+      date_or_time = ""
+      if search_type == 'c'
+        type = 'created'
+      else
+        type = 'accessed'
+      end
+      if date_type == 'h'
+        how_much = Date.time_to_day_fraction(amount.to_i, 0, 0)
+      elsif date_type == ''
+        how_much = amount
+      elsif date_type == 'w'
+        how_much = amount * 7
+      end
+      if search_inner_type == '-'
+        date_or_time = "CURRENT_TIMESTAMP"
+        @date_greater_or_equal.variables << how_much
+      elsif search_inner_type == '+'
+        date_or_time = "CURRENT_TIMESTAMP"
+        @date_less_than.variables << how_much
+      else
+        date_or_time = "CURRENT_DATE"
+        @date_greater_or_equal.variables << how_much
+        @date_less_than.variables << (how_much.to_i + 1).to_s
+      end
 
-    @date_greater_or_equal.statement["TYPE"] = type
-    @date_less_than.statement["TYPE"] = type
-    @date_greater_or_equal.statement["CURRENT_THING"] = date_or_time
-    @date_less_than.statement["CURRENT_THING"] = date_or_time
-  end
-  #---
-  #}}}
-  #+++
-
-  #---
-  #{{{ execute
-  #+++
-  def execute(access)
-    @sss << @date_greater_or_equal unless @date_greater_or_equal.variables.empty?
-    @sss << @date_less_than unless @date_less_than.variables.empty?
+      @date_greater_or_equal.statement["TYPE"] = type
+      @date_less_than.statement["TYPE"] = type
+      @date_greater_or_equal.statement["CURRENT_THING"] = date_or_time
+      @date_less_than.statement["CURRENT_THING"] = date_or_time
+    end
+    #---
+    #}}}
+    #+++
 
-    @sss.sort! { |a, b| a.order <=> b.order }
+    #---
+    #{{{ execute
+    #+++
+    def execute(access)
+      @sss << @date_greater_or_equal unless @date_greater_or_equal.variables.empty?
+      @sss << @date_less_than unless @date_less_than.variables.empty?
 
-    statement, variables = self.build_statement(access)
+      @sss.sort! { |a, b| a.order <=> b.order }
 
-    @results = @db.execute(statement, variables)
+      statement, variables = self.build_statement(access)
 
-    if access
-      hashes = []
-      @results.each { |i| hashes << i[1] }
-      self.mark_accessed(hashes)
-    end
+      @results = @db.execute(statement, variables)
 
-  end
-  #---
-  #}}}
-  #+++
+      if access
+        hashes = []
+        @results.each { |i| hashes << i[1] }
+        self.mark_accessed(hashes)
+      end
 
-  def [](index)
-    @results[index]
-  end
+    end
+    #---
+    #}}}
+    #+++
 
-  #---
-  #{{{ each_with_index
-  #+++
-  def each_with_index
-    @results.each_with_index { |result| yield(result) }
-  end
-  #---
-  #}}}
-  #+++
-
-  #---
-  #{{{ each
-  #+++
-  def each
-    @results.each { |result| yield(result) }
-  end
-  #---
-  #}}}
-  #+++
-
-  #---
-  #{{{ build_statement(access)
-  #+++
-  def build_statement(access)
-    variables = []
-
-    statement = "SELECT url"
-
-    unless access
-      statement += ", description"
-    else
-      statement += ", posts.hash"
+    def [](index)
+      @results[index]
     end
 
-    statement +=  " FROM posts"
-    @tag_count.times { |i| statement += ", post_tags AS pt#{i}, tags AS t#{i}" }
-    statement += " WHERE "
-    @tag_count.times { |i| statement += "pt#{i}.hash == posts.hash AND pt#{i}.tag_id = t#{i}.id AND " }
+    #---
+    #{{{ each_with_index
+    #+++
+    def each_with_index
+      @results.each_with_index { |result| yield(result) }
+    end
+    #---
+    #}}}
+    #+++
+
+    #---
+    #{{{ each
+    #+++
+    def each
+      @results.each { |result| yield(result) }
+    end
+    #---
+    #}}}
+    #+++
+
+    #---
+    #{{{ build_statement(access)
+    #+++
+    def build_statement(access)
+      variables = []
+
+      statement = "SELECT url"
+
+      unless access
+        statement += ", description"
+      else
+        statement += ", posts.hash"
+      end
 
-    tag_count = 0
-    @sss.each_with_index do |ssql,i|
-      while ssql.statement.include? "PLACEHOLDER"
-        ssql.statement.sub!("PLACEHOLDER", "t#{tag_count}.tag")
-        tag_count += 1
+      statement +=  " FROM posts"
+      @tag_count.times { |i| statement += ", post_tags AS pt#{i}, tags AS t#{i}" }
+      statement += " WHERE "
+      @tag_count.times { |i| statement += "pt#{i}.hash == posts.hash AND pt#{i}.tag_id = t#{i}.id AND " }
+
+      tag_count = 0
+      @sss.each_with_index do |ssql,i|
+        while ssql.statement.include? "PLACEHOLDER"
+          ssql.statement.sub!("PLACEHOLDER", "t#{tag_count}.tag")
+          tag_count += 1
+        end
+        statement += ssql.statement
+        statement += ' AND ' unless i + 1 == @sss.length
+
+        variables += ssql.variables
       end
-      statement += ssql.statement
-      statement += ' AND ' unless i + 1 == @sss.length
 
-      variables += ssql.variables
+      statement += ' ORDER BY accessed'
+      return statement, variables
+    end
+    #---
+    #}}}
+    #+++
+
+    #---
+    #{{{ mark_accessed(hashes)
+    #+++
+    def mark_accessed(hashes)
+      statement = "UPDATE posts SET accessed = JULIANDAY(CURRENT_TIMESTAMP) WHERE hash IN (" + hashes.map {"?"}.join(",") + ")"
+      @db.execute(statement, hashes)
     end
+    #---
+    #}}}
+    #+++
 
-    statement += ' ORDER BY accessed'
-    return statement, variables
-  end
-  #---
-  #}}}
-  #+++
-
-  #---
-  #{{{ mark_accessed(hashes)
-  #+++
-  def mark_accessed(hashes)
-    statement = "UPDATE posts SET accessed = JULIANDAY(CURRENT_TIMESTAMP) WHERE hash IN (" + hashes.map {"?"}.join(",") + ")"
-    @db.execute(statement, hashes)
   end
-  #---
-  #}}}
-  #+++
 
 end

data/lib/import_delish.rb

@@ -0,0 +1,169 @@
+module Delish
+
+#{{{
+  class ImportDelish
+
+    #{{{ initialize(user, pass, db)
+    def initialize(user, pass, db)
+      @user = user
+      @pass = pass
+      @db   = db
+      # Version should somehow be gotten from GEM
+      @agent = 'delish commandline client 0.7.7'
+    end
+    #}}}
+
+    #{{{ create_database
+    def create_database
+      @db.execute %{
+  CREATE TABLE posts (
+    url VARCHAR(16384),
+    description VARCHAR(255),
+    extended VARCHAR(255),
+    created DATETIME,
+    hash CHAR(32) PRIMARY KEY,
+    accessed DATETIME
+  );
+  }
+
+      @db.execute %{
+  CREATE TABLE post_tags (
+    hash CHAR(32),
+    tag_id INTEGER
+  );}
+
+      @db.execute  %{
+    CREATE TABLE tags (
+    tag VARCHAR(255) UNIQUE,
+    id  INTEGER PRIMARY KEY AUTOINCREMENT
+    );}
+
+      @db.execute "CREATE TABLE vars ( lastupdate CHAR(20));"
+
+      @db.execute "INSERT INTO vars (lastupdate) VALUES ('0000-00-00T00:00:00Z');"
+    end
+    #}}}
+
+    #{{{ insert_post(url, description, extended, created, accessed, hash, tags)
+    def insert_post(url, description, extended, created, accessed, hash, tags)
+      @db.execute(
+        "INSERT INTO posts (url, description, extended, created, accessed, hash) VALUES (?, ?, ?, JULIANDAY(?), JULIANDAY(?), ?);",
+        url,
+        description,
+        extended,
+        created,
+        accessed,
+        hash)
+
+        tags.split(' ').each do |tag|
+          @db.execute(
+              "INSERT OR IGNORE INTO tags (tag) VALUES (?);", tag)
+
+              tag_id =
+                @db.get_first_row( "SELECT id FROM tags WHERE tag = ?;", tag)
+
+              @db.execute(
+              "INSERT INTO post_tags (hash, tag_id) VALUES (?, ?);",
+              hash, tag_id)
+        end
+    end
+    #}}}
+
+    #{{{ insert_post_xml_helper
+    def insert_post_xml_helper(post)
+      self.insert_post(
+                       post.attributes['href'],
+                       post.attributes['description'],
+                       post.attributes['extended'],
+                       post.attributes['time'].chop,
+                       post.attributes['time'].chop,
+                       post.attributes['hash'],
+                       post.attributes['tag'])
+    end
+    #}}}
+
+    #{{{ get_all_tags
+    def get_all_tags
+      self.delicious_communication('/v1/posts/all') do |data|
+        data.elements.each("/posts/post") { |post| self.insert_post_xml_helper(post) }
+      end
+      self.set_last_update
+    end
+    #}}}
+
+    #{{{ update_exists?
+    def update_exists?
+      self.delicious_communication('/v1/posts/update') do |data|
+        @last_post = data.elements['update'].attributes['time']
+        @last_update = (@db.get_first_row("SELECT lastupdate FROM vars;"))[0]
+        return @last_post != @last_update
+      end
+    end
+    #}}}
+
+    #{{{ set_last_update
+    def set_last_update
+      self.update_exists? if @last_post.nil?
+      @db.execute("UPDATE vars SET lastupdate = ?;", @last_post)
+    end
+    #}}}
+
+    # This function is STILL TOO LONG
+    #{{{ update_bookmarks
+    def update_bookmarks(&block)
+
+      if self.update_exists?
+
+        found = false
+        amount = 10
+        increment = 10
+
+        # Maximum for del.icio.us api is 100
+        until found == true or amount >= 100
+          self.delicious_communication("/v1/posts/recent?count=#{amount}") do |data|
+
+            elements = data.elements.to_a("/posts/post")
+            # Remove the ones we already went through
+            elements.slice(increment, amount - increment)
+
+            elements.each do |post,i|
+              if post.attributes['time'] <= @last_update
+                found = true
+              else
+                # Output should be able to be surpressed
+                yield(post.attributes['href'], post.attributes['description']) unless block.nil?
+                self.insert_post_xml_helper(post)
+              end
+            end
+
+          end
+          amount += increment
+        end
+      end
+      self.set_last_update
+    end
+
+    #}}}
+
+    #{{{ delicious_communication(path, &block)
+    def delicious_communication(path, &block)
+      http = Net::HTTP.new('api.del.icio.us', 443)
+      http.use_ssl = true
+      http.start do |http|
+        request = Net::HTTP::Get.new(path, {'User-Agent' => @agent})
+        request.basic_auth @user, @pass
+        response = http.request(request)
+        sleep 1
+
+        data = REXML::Document.new(response.body)
+
+        yield(data)
+
+      end
+    end
+    #}}}
+
+  end
+  #}}}
+
+end

data/test/tests

@@ -4,7 +4,8 @@ require 'test/unit'
 require 'sqlite3'
 
 @@db = SQLite3::Database.new( "test_db" )
-
+# username = delish_test
+# pass = 5VRiVVd
 class Delish < Test::Unit::TestCase
 
   def test_basic_search

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: delish
 version: !ruby/object:Gem::Version 
-  version: 0.6.1
-date: 2007-07-04 00:00:00 -06:00
+  version: 0.7.7
+date: 2007-07-09 00:00:00 -06:00
 summary: Allows use of del.icio.us bookmarksfrom the commandline with minimum keystrokes
 require_paths: 
 - lib
@@ -31,9 +31,10 @@ authors:
 files: 
 - bin/delish
 - bin/import_delicious
+- bin/update_delicious
 - lib/delish_bookmark_search.rb
+- lib/import_delish.rb
 - test/tests
-- test/test_db
 - README
 test_files: 
 - test/tests
@@ -48,6 +49,7 @@ extra_rdoc_files:
 executables: 
 - delish
 - import_delicious
+- update_delicious
 extensions: []
 
 requirements: []