throne 0.0.2 → 0.0.3

data/Rakefile

@@ -13,7 +13,7 @@ begin
     gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.add_dependency "rest-client", ">= 0"
     gem.add_dependency "hashie", ">= 0"
-    gem.add_dependency "json", ">= 0"
+    gem.add_dependency "yajl-ruby", ">= 0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/TODO

@@ -19,3 +19,28 @@
 
 * Attachments
   * Just a put to url/attchment with data attached. Data in as a #read object?
+
+* Design Documents
+  * Would be great to have a way to include functions into designs. Either via Couch, or embed
+
+* Niceities
+  * pretty format the JSON dump?
+
+* Model stuff 2
+  * By default, return a Mash. Good enough for most cases
+  * Have a mixin, that can be called inside something that subclasses Dash.
+  * when the method is called to set the database on the Dash, look for a design
+      document with the same name
+    * If it exists, map methods on the _class_ for .viewname that invoke the view,
+        and .listname.viewname that invoke the view from the list. these take a
+        params hash, and pass these in as URL params.
+    * when these view methods are called, iterate the result tree, and if they have a
+        couchdoc class and that class exists, instantiate it with the contents.
+    * when calling the get method on the class, do the object matching as well
+  * the tree setting for sub items is up to the object to do in its' constructor
+    * provide a convenience 'cast' method to help with this?
+
+* The get method should return an array by default, but if a :limit=1 param set, 
+    return a single object.
+
+* Check that the mash constructor uses the passed in object, rather than copying.

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/throne.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'yajl/json_gem'
 require 'rest_client'
 require 'hashie'
 

data/lib/throne/database.rb

@@ -40,7 +40,7 @@ class Throne::Database
   def get(docid, rev=nil)
     begin
       revurl = rev ? "?rev=#{rev}" : ""
-      JSON.parse(c.get(@url + '/' + docid + revurl))
+      Hashie::Mash.new(JSON.parse(c.get(@url + '/' + docid + revurl)))
     rescue RestClient::ResourceNotFound
       nil
     end
@@ -82,7 +82,7 @@ class Throne::Database
       end
       nil
     else
-      res
+      Hashie::Mash.new(res)
     end
   end
 
@@ -91,7 +91,8 @@ class Throne::Database
   def paramify_url url, params = {}
     if params && !params.empty?
       query = params.collect do |k,v|
-        v = v.to_json if %w{key startkey endkey}.include?(k.to_s)
+        v = v.to_json if %w{key startkey endkey}.include?(k.to_s) && 
+          (v.kind_of?(Array) || v.kind_of?(Hash))
         "#{k}=#{CGI.escape(v.to_s)}"
       end.join("&")
       url = "#{url}?#{query}"

data/lib/throne/tasks.rb

@@ -1,96 +1,125 @@
-# Defines rake tasks for managing databases and views.
+require 'yaml'
+
+# Defines tasks for managing databases and views.
+#
+# To reference a file in lib/ from your design doc, use a commend like this
+# // !code library.js
+#
+# This will include the contents at this locate.
+#
+# These tasks require an environment variable of SERVER_URL to be set.
+#
+# The documents should be stored using the following structure - all items in the 
+# root of base path will be included in all databases, items with a database will be
+# included into that database only.
+#
+# base_path/
+# |-- lib
+# |    `-- library.js
+# |-- data
+# |   `-- .json and .yml folders with seed data
+# |-- design
+# |   `-- <design doc name>
+# |       |-- lists
+# |       |   `-- listname.js
+# |       |-- shows
+# |       |   `-- showname.js
+# |       |-- validate_doc_update.sh
+# |       `-- views
+# |           `-- statuses
+# |               |-- map.js
+# |               `-- reduce.js 
+# |-- <db name>
+#     |-- lib
+#     |    `-- library.js
+#     |-- data
+#     |   `-- .json and .yml folders with seed data
+#     `-- design
+#          `-- <design doc name>
+#              |-- lists
+#              |   `-- listname.js
+#              |-- shows
+#              |   `-- showname.js
+#              |-- validate_doc_update.sh 
+#              `-- views
+#                  `-- statuses
+#                      |-- map.js
+#                      `-- reduce.js 
 #
-# Requires either a SERVER_URL or DB_URL defined as an environment variable.
-# If SERVER_URL is set the database path is inferred from the directory the files
-# are stored in, if DB_URL is set that database is explicitly used, 
-# overriding the name of the folder/task. 
 class Throne::Tasks
-  # Injects rake tasks for loading and dumping data from databases.
+  # This will inject Rake tasks for managing the database data. The base path should
+  # be where all the items are stored.
+  #
   # @param [String] base_path the path where design docs are stored
-  def self.inject_data_tasks(base_path)
+  def self.inject_tasks(base_path)
     namespace :throne do
-      namespace :load_data do
-        dirs_in_path(base_path).each do |dir, fulldir|
-          desc "Loads data for database #{dir}"
-          task dir.to_sym do
-            load_data_for_database(url(dir), fulldir)
+      namespace :documents do
+        namespace :load do
+          databases_in_path(base_path).each do |dbname, fulldir|
+            desc "Loads data for database #{dbname}, optionally into db"
+            task dbname.to_sym, :db do |t, args|
+              load_data_for_database(url(dbname, args), base_path, dbname)
+            end
           end
-        end
 
-        desc "load all dbs"
-        task :all => dirs_in_path(base_path)
-      end
-      namespace :dump_data do
-        desc "Dump data for a database into a YAML file"
-        task :yml, :db do |t, args|
-          dump_docs_from_db(args.db, base_path, :yml)
+          desc "load all dbs"
+          task :all => databases_in_path(base_path)
         end
+        namespace :dump do
+          desc "Dump data for a database into a YAML file"
+          task :yml, :db do |t, args|
+            dump_docs_from_db(args.db, base_path, :yml)
+          end
 
-        desc "Dump data for a database into a JSON file"
-        task :json, :db do |t, args|
-          dump_docs_from_db(args.db, base_path, :json)
+          desc "Dump data for a database into a JSON file"
+          task :json, :db do |t, args|
+            dump_docs_from_db(args.db, base_path, :json)
+          end
         end
       end
-    end
-  end
 
-  # This will inject Rake tasks for loading design docs into the DB
-  # The docs should be layed out in the following format:
-  # base_path/
-  # |-- <db name>
-  #      `-- <design doc name>
-  #          |-- lists
-  #          |   `-- statuses
-  #          |       `-- list.js
-  #          `-- views
-  #              `-- statuses
-  #                  |-- map.js
-  #                  `-- reduce.js 
-  #
-  # @param [String] base_path the path where design docs are stored
-  def self.inject_design_doc_tasks(base_path)
-    namespace :throne do
-      namespace :push_design do
-        dirs_in_path(base_path).each do |dir, fulldir|
-          desc "pushes designs for database #{dir}"
-          task dir.to_sym do
-            load_design_documents(url(dir), fulldir)
+      #design tasks
+      namespace :design do
+        namespace :push do
+          databases_in_path(base_path).each do |dbname, fulldir|
+            desc "pushes designs for database #{dbname}, optionally into db"
+            task dbname.to_sym, :db do |t, args|
+              load_design_documents(url(dbname, args), base_path, dbname)
+            end
           end
-        end
 
-        desc "push all designs"
-        task :all => dirs_in_path(base_path)
+          desc "push all designs"
+          task :all => databases_in_path(base_path)
+        end
       end
-    end
-  end
 
-  # Injects tasks to create and delete databases
-  def self.inject_database_tasks(base_path)
-    namespace :throne do
-      desc "Creates a database if it doesn't exist"
-      task :createdb, :db do |t, args|
-        get_db(args).create_database
-        puts "Database at #{url(args.db)}"
-      end
+      # Db Tasks
+      namespace :database do
+        desc "Creates a database if it doesn't exist"
+        task :createdb, :db do |t, args|
+          get_db(args).create_database
+          puts "Database at #{url(args.db)}"
+        end
 
-      desc "Deletes a database"
-      task :deletedb, :db do |t, args|
-        get_db(args).delete_database
-        puts "Database at #{url(args.db)}"
-      end
+        desc "Deletes a database"
+        task :deletedb, :db do |t, args|
+          get_db(args).delete_database
+          puts "Database at #{url(args.db)}"
+        end
 
-      desc "Deletes, creates and re-loads a database"
-      task :rebuilddb, :db do |t, args|
-        db = get_db(args)
-        raise "you must specify the database name (task[db])" unless args.db
-        db.delete_database
-        # re-getting the object will create the DB
-        db = get_db(args)
-        # load design docs
-        load_design_documents(db.url, File.join(base_path, 'design', args.db))
-        # load data
-        load_data_for_database(db.url, File.join(base_path, 'data', args.db))
-        puts "Done."
+        desc "Deletes, creates and re-loads a database"
+        task :rebuilddb, :db do |t, args|
+          db = get_db(args)
+          raise "you must specify the database name (task[db])" unless args.db
+          db.delete_database
+          # re-getting the object will create the DB
+          db = get_db(args)
+          # load design docs
+          load_design_documents(db.url, File.join(base_path, 'design', args.db))
+          # load data
+          load_data_for_database(db.url, File.join(base_path, 'data', args.db))
+          puts "Done."
+        end
       end
 
 
@@ -104,55 +133,57 @@ class Throne::Tasks
     end
   end
 
-  # Injects all tasks. Related data files will be stores in base_path/data, and 
-  # design docs in base_path/design
-  #
-  # @param [String] base_path path for db related files.
-  def self.inject_all_tasks(base_path)
-    inject_data_tasks(File.join(base_path, 'data'))
-    inject_design_doc_tasks(File.join(base_path, 'design'))
-    inject_database_tasks(base_path)
-  end
-
   # Loads design documents into the database url, extracted from the source path
   # The docs should be layed out in the following format:
-  # base_path/
-  # |-- <db name>
-  #      `-- <design doc name>
-  #          |-- lists
-  #          |   `-- statuses
-  #          |       `-- list.js
-  #          `-- views
-  #              `-- statuses
-  #                  |-- map.js
-  #                  `-- reduce.js 
+  #  `-- <design doc name>
+  #      |-- lists
+  #      |   `-- statuses
+  #      |       `-- list.js
+  #      `-- views
+  #          `-- statuses
+  #              |-- map.js
+  #              `-- reduce.js 
   # @param [String] db_url the url of the database to load the data in to
   # @param [String] source_path the path to search for .yml and .json files
-  def self.load_design_documents(db_url, source_path)
+  def self.load_design_documents(db_url, base_path, database)
     # for each folder in base path, create a new design doc key
     # create a lists key
     # for each path in lists, add a key with the folder name
     # inside this, there is a key called list, with the contents of the list function
     # views is the same, except with a map and reduce function
-    Dir.glob(File.join(source_path, '*')).each do |doc_path|
+    paths_for_item(base_path, database, 'design/*').each do |doc_path|
       doc_name = File.basename(doc_path)
-      doc = {'lists' => {}, 'views' => {}}
-      Dir.glob(File.join(doc_path, 'lists', '*')) do |list_path|
-        list_name = File.basename(list_path)
+      doc = {'lists' => {}, 'views' => {}, 'shows' => {}}
+
+      Dir.glob(File.join(doc_path, 'lists', '*.js')) do |list_path|
+        list_name = File.basename(list_path).split('.').first
         doc['lists'][list_name] = {}
-        listfn = File.join(list_path, 'list.js')
         doc['lists'][list_name] = 
-            File.read(listfn) if File.exists?(listfn)
+            inject_code_includes(base_path, database, list_path) 
+      end
+
+      Dir.glob(File.join(doc_path, 'shows', '*.js')) do |show_path|
+        show_name = File.basename(show_path).split('.').first
+        doc['shows'][show_name] = {}
+        doc['shows'][show_name] = 
+            inject_code_includes(base_path, database, show_path) 
+      end
+      
+      if File.exists?(vfn = File.join(doc_path, 'validate_doc_update.js'))
+        doc['validate_doc_update'] =
+            inject_code_includes(base_path, database, vfn)
       end
+
       Dir.glob(File.join(doc_path, 'views', '*')) do |view_path|
         view_name = File.basename(view_path)
         doc['views'][view_name] = {}
         mapfn = File.join(view_path, 'map.js')
         reducefn = File.join(view_path, 'reduce.js')
         doc['views'][view_name]['map'] =
-            File.read(mapfn) if File.exists?(mapfn)
+            inject_code_includes(base_path, database, mapfn) if File.exists?(mapfn)
         doc['views'][view_name]['reduce'] =
-            File.read(reducefn) if File.exists?(reducefn)
+            inject_code_includes(base_path, database, reducefn) if 
+                File.exists?(reducefn)
       end
       # try to get the existing doc
       doc_id = "_design/#{doc_name}"
@@ -165,7 +196,7 @@ class Throne::Tasks
       end
       doc['language'] = 'javascript'
       db.save(doc)
-      puts "Design documents from #{source_path} loaded"
+      puts "Design documents from #{doc_path} loaded"
     end
     
     # try and get a document with the design name
@@ -178,16 +209,16 @@ class Throne::Tasks
   # Loads data into the database url from the source path. Picks up .yml and .json
   # @param [String] db_url the url of the database to load the data in to
   # @param [String] source_path the path to search for .yml and .json files
-  def self.load_data_for_database(db_url, source_path)
+  def self.load_data_for_database(db_url, base_path, database)
     @db = Throne::Database.new(db_url)
     items = []
     doccount = 0
     # grab and parse all YML files
-    Dir.glob(source_path + '/**/*.yml').each do |yml|
+    paths_for_item(base_path, database, 'data/**/*.yml').each do |yml|
       items << YAML::load(File.open(yml))
     end
     # and json
-    Dir.glob(source_path + '/**/*.json').each do |json|
+    paths_for_item(base_path, database, 'data/**/*.json').each do |json|
       items << JSON.parse(File.open(json).read)
     end
     # load em up
@@ -221,14 +252,14 @@ class Throne::Tasks
       else
         puts "There is something funky with the data for #{source_path}"
       end
-      puts "#{doccount} document(s) loaded into database at #{@db.url}"
     end
+    puts "#{doccount} document(s) loaded into database at #{@db.url}"
   end
 
   def self.dump_docs_from_db(db, base_path, format)
     raise "You must specify a DB name to dump task[dbname]" unless db
-    outdir = File.join(base_path, db)
-    Dir.mkdir(outdir) unless File.exists?(outdir)
+    outdir = File.join(base_path, db, "data")
+    FileUtils.mkdir_p(outdir) unless File.exists?(outdir)
     @db = Throne::Database.new(url(db))
     docs = []
 
@@ -239,7 +270,7 @@ class Throne::Tasks
     outfn = format == :json ? 'dump.json' : 'dump.yml'
     File.open(File.join(outdir, outfn), 'w') do |f| 
       if format == :json
-        f.puts docs.to_json
+        f.puts JSON.pretty_generate(docs)
       elsif format == :yml
         f.puts docs.to_yaml
       else
@@ -251,22 +282,50 @@ class Throne::Tasks
 
   private
 
-  def self.dirs_in_path(path)
+  def self.inject_code_includes(base_path, database, file)
+    res = ''
+    File.open(file).each do |line|
+      if line =~ /(\/\/|#)\ ?!code (.*)/
+        if File.exists?(inc = File.join(base_path, database, 'lib', $2))
+          res += File.read(inc)
+        elsif File.exists?(inc = File.join(base_path, 'lib', $2))
+          res += File.read(inc)
+        else  
+          raise "Include file #{$2} does not exist in lib/ or #{database}/lib"
+        end
+      else
+        res += line
+      end
+    end
+    res
+  end
+  
+  # For the gives path, returns a list of database names and their full path.
+  # exludes lib and our other dirs.
+  def self.databases_in_path(path)
     res = {}
     Dir.glob(path + '/*').each do |fn|
+      next if %w(lib data design).any? {|i| File.basename(fn) == i}
       res[File.basename(fn)] = fn if File.directory?(fn) 
     end
     res
   end
 
-  def self.url(dbname)
-    if dburl = ENV['DB_URL']
-      return dburl
-    elsif svrurl = ENV['SERVER_URL']
+  def self.url(dbname, args=nil)
+    if svrurl = ENV['SERVER_URL']
+      return svrurl + '/' + args.db if args && args.db
       return svrurl + '/' + dbname
     else
-      raise("You must provide a SERVER_URL or DB_URL")
+      raise("You must provide a SERVER_URL")
     end
   end
 
+  # Given the base dir, the DB name and the item path we are after, get a list
+  # of items. This includes global and DB spec.
+  # e.g for item - data , designs, lib.
+  def self.paths_for_item(base, database, item_glob)
+    items = Dir.glob(File.join(base, item_glob))
+    items.concat(Dir.glob(File.join(base, database, item_glob)))
+  end
+
 end

data/spec/database_spec.rb

@@ -83,15 +83,13 @@ describe Throne::Database do
       id = @db.save(:testfield => 'true')
       doc = @db.get(id)
       @db.delete(doc)
-      lambda {@db.get(id)}.
-        should raise_error(RestClient::ResourceNotFound)
+      @db.get(id).should be_nil
     end
 
     it "should be able to delete a document when given a document id" do
       id = @db.save(:testfield => 'true')
       @db.delete(id)
-      lambda {@db.get(id)}.
-        should raise_error(RestClient::ResourceNotFound)
+      @db.get(id).should be_nil
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: throne
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Lincoln Stoll
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-14 00:00:00 +11:00
+date: 2009-12-16 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,7 +43,7 @@ dependencies:
         version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: json
+  name: yajl-ruby
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement