juozasg-couchrest 0.10.1 → 0.10.13

data/lib/couchrest/helper/file_manager.rb

@@ -1,317 +0,0 @@
-require 'digest/md5'
-
-module CouchRest
-  class FileManager
-    attr_reader :db
-    attr_accessor :loud
-    
-    LANGS = {"rb" => "ruby", "js" => "javascript"}
-    MIMES = {
-      "html"  => "text/html",
-      "htm"   => "text/html",
-      "png"   => "image/png",
-      "gif"   => "image/gif",
-      "css"   => "text/css",
-      "js"    => "test/javascript"
-    }    
-    def initialize(dbname, host="http://localhost:5984")
-      @db = CouchRest.new(host).database(dbname)
-    end
-    
-    def push_directory(push_dir, docid=nil)
-      docid ||= push_dir.split('/').reverse.find{|part|!part.empty?}
-
-      pushfiles = Dir["#{push_dir}/**/*.*"].collect do |f|
-        {f.split("#{push_dir}/").last => open(f).read}
-      end
-
-      return if pushfiles.empty?
-
-      @attachments = {}
-      @signatures = {}
-      pushfiles.each do |file|
-        name = file.keys.first
-        value = file.values.first
-        @signatures[name] = md5(value)
-
-        @attachments[name] = {
-          "data" => value,
-          "content_type" => MIMES[name.split('.').last]
-        }
-      end
-
-      doc = @db.get(docid) rescue nil
-
-      unless doc
-        say "creating #{docid}"
-        @db.save({"_id" => docid, "_attachments" => @attachments, "signatures" => @signatures})
-        return
-      end
-
-      doc["signatures"] ||= {}
-      doc["_attachments"] ||= {}
-      # remove deleted docs
-      to_be_removed = doc["signatures"].keys.select do |d| 
-        !pushfiles.collect{|p| p.keys.first}.include?(d) 
-      end 
-
-      to_be_removed.each do |p|
-        say "deleting #{p}"
-        doc["signatures"].delete(p)
-        doc["_attachments"].delete(p)
-      end
-
-      # update existing docs:
-      doc["signatures"].each do |path, sig|
-        if (@signatures[path] == sig)
-          say "no change to #{path}. skipping..."
-        else
-          say "replacing #{path}"
-          doc["signatures"][path] = md5(@attachments[path]["data"])
-          doc["_attachments"][path].delete("stub")
-          doc["_attachments"][path].delete("length")    
-          doc["_attachments"][path]["data"] = @attachments[path]["data"]
-          doc["_attachments"][path].merge!({"data" => @attachments[path]["data"]} )
-        end
-      end
-
-      # add in new files
-      new_files = pushfiles.select{|d| !doc["signatures"].keys.include?( d.keys.first) } 
-
-      new_files.each do |f|
-        say "creating #{f}"
-        path = f.keys.first
-        content = f.values.first
-        doc["signatures"][path] = md5(content)
-
-        doc["_attachments"][path] = {
-          "data" => content,
-          "content_type" => MIMES[path.split('.').last]
-        }
-      end
-
-      begin
-        @db.save(doc)
-      rescue Exception => e
-        say e.message
-      end
-    end
-    
-    def push_views(view_dir)
-      designs = {}
-
-      Dir["#{view_dir}/**/*.*"].each do |design_doc|
-        design_doc_parts = design_doc.split('/')
-        next if /^lib\..*$/.match design_doc_parts.last
-        pre_normalized_view_name = design_doc_parts.last.split("-")
-        view_name = pre_normalized_view_name[0..pre_normalized_view_name.length-2].join("-")
-
-        folder = design_doc_parts[-2]
-
-        designs[folder] ||= {}
-        designs[folder]["views"] ||= {}
-        design_lang = design_doc_parts.last.split(".").last
-        designs[folder]["language"] ||= LANGS[design_lang]
-
-        libs = ""
-        Dir["#{view_dir}/lib.#{design_lang}"].collect do |global_lib|
-          libs << open(global_lib).read
-          libs << "\n"
-        end
-        Dir["#{view_dir}/#{folder}/lib.#{design_lang}"].collect do |global_lib|
-          libs << open(global_lib).read
-          libs << "\n"
-        end
-        if design_doc_parts.last =~ /-map/
-          designs[folder]["views"]["#{view_name}-map"] ||= {}
-
-          designs[folder]["views"]["#{view_name}-map"]["map"] = read(design_doc, libs)
-
-          designs[folder]["views"]["#{view_name}-reduce"] ||= {}
-          designs[folder]["views"]["#{view_name}-reduce"]["map"] = read(design_doc, libs)
-        end
-
-        if design_doc_parts.last =~ /-reduce/
-          designs[folder]["views"]["#{view_name}-reduce"] ||= {}
-
-          designs[folder]["views"]["#{view_name}-reduce"]["reduce"] = read(design_doc, libs)
-        end
-      end
-
-      # cleanup empty maps and reduces
-      designs.each do |name, props|
-        props["views"].each do |view, funcs|
-          next unless view.include?("reduce")
-          props["views"].delete(view) unless funcs.keys.include?("reduce")
-        end
-      end
-      
-      designs.each do |k,v|
-        create_or_update("_design/#{k}", v)
-      end
-      
-      designs
-    end
-    
-    def pull_views(view_dir)
-      prefix = "_design"
-      ds = db.documents(:startkey => '#{prefix}/', :endkey => '#{prefix}/ZZZZZZZZZ')
-      ds['rows'].collect{|r|r['id']}.each do |id|
-        puts directory = id.split('/').last
-        FileUtils.mkdir_p(File.join(view_dir,directory))
-        views = db.get(id)['views']
-
-        vgroups = views.keys.group_by{|k|k.sub(/\-(map|reduce)$/,'')}
-        vgroups.each do|g,vs|
-          mapname = vs.find {|v|views[v]["map"]}
-          if mapname
-            # save map
-            mapfunc = views[mapname]["map"]
-            mapfile = File.join(view_dir, directory, "#{g}-map.js") # todo support non-js views
-            File.open(mapfile,'w') do |f|
-              f.write mapfunc
-            end
-          end
-
-          reducename = vs.find {|v|views[v]["reduce"]}
-          if reducename
-            # save reduce
-            reducefunc = views[reducename]["reduce"]
-            reducefile = File.join(view_dir, directory, "#{g}-reduce.js") # todo support non-js views
-            File.open(reducefile,'w') do |f|
-              f.write reducefunc
-            end
-          end
-        end
-      end  
-      
-    end
-    
-    def push_app(appdir, appname)
-      libs = []
-      viewdir = File.join(appdir,"views")
-      attachdir = File.join(appdir,"_attachments")
-      views, lang = read_design_views(viewdir)
-
-      docid = "_design/#{appname}"
-      design = @db.get(docid) rescue {}
-      design['_id'] = docid
-      design['views'] = views
-      design['language'] = lang if lang
-      @db.save(design)
-      push_directory(attachdir, docid)
-      
-      push_fields(appdir, docid)
-    end
-    
-    def push_fields(appdir, docid)
-      fields = {}
-      (Dir["#{appdir}/**/*.*"] - 
-        Dir["#{appdir}/views/**/*.*"] - 
-        Dir["#{appdir}/doc.json"] -         
-        Dir["#{appdir}/_attachments/**/*.*"]).each do |file|
-        farray = file.sub(appdir, '').sub(/^\//,'').split('/')
-        myfield = fields
-        while farray.length > 1
-          front = farray.shift
-          myfield[front] ||= {}
-          myfield = myfield[front]
-        end
-        fname, fext = farray.shift.split('.')
-        fguts = File.open(file).read
-        if fext == 'json'
-          myfield[fname] = JSON.parse(fguts)
-        else
-          myfield[fname] = fguts
-        end
-      end
-      if File.exists?("#{appdir}/doc.json")
-        default_json = JSON.parse(File.open("#{appdir}/doc.json").read)
-      end
-      design = @db.get(docid) rescue {}
-      design.merge!(fields)
-      design.merge!(default_json) if default_json
-      @db.save(design)
-    end
-    
-    # Generate an application in the given directory.
-    # This is a class method because it doesn't depend on 
-    # specifying a database.
-    def self.generate_app(app_dir)      
-      FileUtils.mkdir_p(app_dir)
-      FileUtils.mkdir_p(File.join(app_dir,"_attachments"))      
-      FileUtils.mkdir_p(File.join(app_dir,"views"))
-      FileUtils.mkdir_p(File.join(app_dir,"foo"))
-      
-      {
-        "index.html" => "_attachments",
-        'example-map.js' => "views",
-        'example-reduce.js' => "views",
-        'bar.txt' => "foo",
-      }.each do |filename, targetdir|
-        template = File.join(File.expand_path(File.dirname(__FILE__)), 'templates',filename)
-        dest = File.join(app_dir,targetdir,filename)
-        FileUtils.cp(template, dest)
-      end
-    end
-    
-    private
-    
-    def read_design_views(viewdir)
-      libs = []
-      language = nil
-      views = {}
-      Dir["#{viewdir}/*.*"].each do |viewfile|
-        view_parts = viewfile.split('/')
-        viewfile_name = view_parts.last
-        # example-map.js
-        viewfile_name_parts = viewfile_name.split('.')
-        viewfile_ext = viewfile_name_parts.last
-        view_name_parts = viewfile_name_parts.first.split('-')
-        func_type = view_name_parts.pop
-        view_name = view_name_parts.join('-')
-        contents = File.open(viewfile).read
-        if /^lib\..*$/.match viewfile_name
-          libs.push(contents)
-        else
-          views[view_name] ||= {}
-          language = LANGS[viewfile_ext]
-          views[view_name][func_type] = contents.sub(/(\/\/|#)include-lib/,libs.join("\n"))
-        end
-      end
-      [views, language]
-    end
-    
-    def say words
-      puts words if @loud
-    end
-    
-    def md5 string
-      Digest::MD5.hexdigest(string)
-    end
-    
-    def read(file, libs=nil)
-      st = open(file).read
-      st.sub!(/(\/\/|#)include-lib/,libs) if libs
-      st
-    end
-    
-    def create_or_update(id, fields)
-      existing = @db.get(id) rescue nil
-
-      if existing
-        updated = existing.merge(fields)
-        if existing != updated
-          say "replacing #{id}"
-          db.save(updated)
-        else
-          say "skipping #{id}"
-        end
-      else
-        say "creating #{id}"
-        db.save(fields.merge({"_id" => id}))
-      end
-
-    end
-  end
-end

data/lib/couchrest/helper/pager.rb

@@ -1,103 +0,0 @@
-module CouchRest
-  class Pager
-    attr_accessor :db
-    def initialize db
-      @db = db
-    end
-    
-    def all_docs(count=100, &block)
-      startkey = nil
-      oldend = nil
-      
-      while docrows = request_all_docs(count+1, startkey)        
-        startkey = docrows.last['key']
-        docrows.pop if docrows.length > count
-        if oldend == startkey
-          break
-        end
-        yield(docrows)
-        oldend = startkey
-      end
-    end
-    
-    def key_reduce(view, count=2000, firstkey = nil, lastkey = nil, &block)
-      # start with no keys
-      startkey = firstkey
-      # lastprocessedkey = nil
-      keepgoing = true
-      
-      while keepgoing && viewrows = request_view(view, count, startkey)
-        startkey = viewrows.first['key']
-        endkey = viewrows.last['key']
-
-        if (startkey == endkey)
-          # we need to rerequest to get a bigger page
-          # so we know we have all the rows for that key
-          viewrows = @db.view(view, :key => startkey)['rows']
-          # we need to do an offset thing to find the next startkey
-          # otherwise we just get stuck
-          lastdocid = viewrows.last['id']
-          fornextloop = @db.view(view, :startkey => startkey, :startkey_docid => lastdocid, :count => 2)['rows']
-
-          newendkey = fornextloop.last['key']
-          if (newendkey == endkey)
-            keepgoing = false
-          else
-            startkey = newendkey
-          end
-          rows = viewrows
-        else
-          rows = []
-          for r in viewrows
-            if (lastkey && r['key'] == lastkey)
-              keepgoing = false
-              break
-            end
-            break if (r['key'] == endkey)
-            rows << r
-          end   
-          startkey = endkey
-        end
-        
-        key = :begin
-        values = []
-
-        rows.each do |r|
-          if key != r['key']
-            # we're on a new key, yield the old first and then reset
-            yield(key, values) if key != :begin
-            key = r['key']
-            values = []
-          end
-          # keep accumulating
-          values << r['value']
-        end
-        yield(key, values)
-
-      end
-    end
-
-    private
-    
-    def request_all_docs count, startkey = nil
-      opts = {}
-      opts[:count] = count if count
-      opts[:startkey] = startkey if startkey      
-      results = @db.documents(opts)
-      rows = results['rows']
-      rows unless rows.length == 0
-    end
-
-    def request_view view, count = nil, startkey = nil, endkey = nil
-      opts = {}
-      opts[:count] = count if count
-      opts[:startkey] = startkey if startkey
-      opts[:endkey] = endkey if endkey
-      
-      results = @db.view(view, opts)
-      rows = results['rows']
-      rows unless rows.length == 0
-    end
-
-  end
-end

data/lib/couchrest/helper/streamer.rb

@@ -1,44 +0,0 @@
-module CouchRest
-  class Streamer
-    attr_accessor :db
-    def initialize db
-      @db = db
-    end
-    
-    # Stream a view, yielding one row at a time. Shells out to <tt>curl</tt> to keep RAM usage low when you have millions of rows.
-    def view name, params = nil, &block
-      urlst = /^_/.match(name) ? "#{@db.root}/#{name}" : "#{@db.root}/_view/#{name}"
-      url = CouchRest.paramify_url urlst, params
-      # puts "stream #{url}"
-      first = nil
-      IO.popen("curl --silent #{url}") do |view|
-        first = view.gets # discard header
-        while line = view.gets 
-          row = parse_line(line)
-          block.call row
-        end
-      end
-      parse_first(first)
-    end
-    
-    private
-    
-    def parse_line line
-      return nil unless line
-      if /(\{.*\}),?/.match(line.chomp)
-        JSON.parse($1)
-      end
-    end
-
-    def parse_first first
-      return nil unless first
-      parts = first.split(',')
-      parts.pop
-      line = parts.join(',')
-      JSON.parse("#{line}}")
-    rescue
-      nil
-    end
-    
-  end
-end

data/lib/couchrest/helper/templates/bar.txt

@@ -1,11 +0,0 @@
-Couchapp will create a field on your document corresponding to any directories you make within the application directory, with the text of any files found as key/value pairs.
-
-Also, any files that end in .json will be treated as json rather than text, and put in the corresponding field. Also note that file.json, file.js, or file.txt will be stored under the "file" key, so don't make collisions in the filesystem unless you want unpredictable results.
-
-Of course you know that the views directory will be treated specially and -map and -reduce files will be mapped to the map and reduce functions. And the _attachments directory will be treated strangely as well.
-
-doc.json is a special case, it is treated as json and its keys are applied to the document root; eg it does not result in a "doc" field on your design document. If you need a doc field on the design document, you'll have to define it with a doc.json like so: {"doc":"value for doc field"}
-
-ps: each design document only has one language key: it will be set based on the file extensions in the views directory. CouchDB defaults to Javascript, so that's what you'll get if you don't define any views. You can override it with the doc.json file, but don't say we didn't warn you.
-
-Oh yeah it's recommended that you delete this file.

data/lib/couchrest/helper/templates/example-map.js

@@ -1,8 +0,0 @@
-// an example map function, emits the doc id 
-// and the list of keys it contains
-
-function(doc) {
-  var k, keys = []
-  for (k in doc) keys.push(k);
-  emit(doc._id, keys);
-};

data/lib/couchrest/helper/templates/example-reduce.js

@@ -1,10 +0,0 @@
-// example reduce function to count the
-// number of rows in a given key range.
-
-function(keys, values, rereduce) {
-  if (rereduce) {
-    return sum(values);
-  } else {
-    return values.length;
-  }
-};

data/lib/couchrest/helper/templates/index.html

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Generated CouchApp</title>
-    <link rel="stylesheet" href="screen.css" type="text/css">
-  </head>
-  <body>
-    <h1>Generated CouchApp</h1>
-    <ul id="view"></ul>
-  </body>
-  <script src="/_utils/script/json2.js"></script>
-  <script src="/_utils/script/jquery.js?1.2.6"></script>
-  <script src="/_utils/script/jquery.couch.js?0.8.0"></script>
-  <script type="text/javascript" charset="utf-8">
-    $(function() {
-      var dbname = document.location.href.split('/')[3];
-      var design = unescape(document.location.href).split('/')[5];
-      var DB = $.couch.db(dbname);
-      DB.view(design+"/example",{success: function(json) {
-        $("#view").html(json.rows.map(function(row) {
-          return '<li>'+row.key+'</li>';
-        }).join(''));
-      }});
-    });
-  </script>
-</html>

data/lib/couchrest/monkeypatches.rb

@@ -1,24 +0,0 @@
-# This file must be loaded after the JSON gem and any other library that beats up the Time class.
-class Time
-  # This date format sorts lexicographically
-  # and is compatible with Javascript's <tt>new Date(time_string)</tt> constructor.
-  # Note this this format stores all dates in UTC so that collation 
-  # order is preserved. (There's no longer a need to set <tt>ENV['TZ'] = 'UTC'</tt>
-  # in your application.)
-
-  def to_json(options = nil)
-    u = self.utc
-    %("#{u.strftime("%Y/%m/%d %H:%M:%S +0000")}")
-  end
-
-  # Decodes the JSON time format to a UTC time.
-  # Based on Time.parse from ActiveSupport. ActiveSupport's version
-  # is more complete, returning a time in your current timezone, 
-  # rather than keeping the time in UTC. YMMV.
-  # def self.parse string, fallback=nil
-  #   d = DateTime.parse(string).new_offset
-  #   self.utc(d.year, d.month, d.day, d.hour, d.min, d.sec)
-  # rescue
-  #   fallback
-  # end
-end

data/lib/couchrest.rb

@@ -1,125 +0,0 @@
-# Copyright 2008 J. Chris Anderson
-# 
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-# 
-#        http://www.apache.org/licenses/LICENSE-2.0
-# 
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-require "rubygems"
-require 'json'
-require 'rest_client'
-# require 'extlib'
-
-$:.unshift File.dirname(__FILE__) unless
-  $:.include?(File.dirname(__FILE__)) ||
-  $:.include?(File.expand_path(File.dirname(__FILE__)))
-  
-  
-require 'couchrest/monkeypatches'
-
-# = CouchDB, close to the metal
-module CouchRest
-  autoload :Server,       'couchrest/core/server'
-  autoload :Database,     'couchrest/core/database'
-  autoload :Document,     'couchrest/core/document'
-  autoload :Design,     'couchrest/core/design'
-  autoload :View,         'couchrest/core/view'
-  autoload :Model,        'couchrest/core/model'
-  autoload :Pager,        'couchrest/helper/pager'
-  autoload :FileManager,  'couchrest/helper/file_manager'
-  autoload :Streamer,     'couchrest/helper/streamer'
-  
-  # The CouchRest module methods handle the basic JSON serialization 
-  # and deserialization, as well as query parameters. The module also includes
-  # some helpers for tasks like instantiating a new Database or Server instance.
-  class << self
-
-    # todo, make this parse the url and instantiate a Server or Database instance
-    # depending on the specificity.
-    def new(*opts)
-      Server.new(*opts)
-    end
-    
-    def parse url
-      case url
-      when /^http:\/\/(.*)\/(.*)\/(.*)/
-        host = $1
-        db = $2
-        docid = $3
-      when /^http:\/\/(.*)\/(.*)/
-        host = $1
-        db = $2
-      when /^http:\/\/(.*)/
-        host = $1
-      when /(.*)\/(.*)\/(.*)/
-        host = $1
-        db = $2
-        docid = $3
-      when /(.*)\/(.*)/
-        host = $1
-        db = $2
-      else
-        db = url
-      end
-
-      db = nil if db && db.empty?
-
-      {
-        :host => host || "localhost:5984",
-        :database => db,
-        :doc => docid
-      }
-    end
-
-    # ensure that a database exists
-    # creates it if it isn't already there
-    # returns it after it's been created
-    def database! url
-      parsed = parse url
-      cr = CouchRest.new(parsed[:host])
-      cr.database!(parsed[:database])
-    end
-  
-    def database url
-      parsed = parse url
-      cr = CouchRest.new(parsed[:host])
-      cr.database(parsed[:database])
-    end
-    
-    def put uri, doc = nil
-      payload = doc.to_json if doc
-      JSON.parse(RestClient.put(uri, payload))
-    end
-
-    def get uri
-      JSON.parse(RestClient.get(uri), :max_nesting => false)
-    end
-  
-    def post uri, doc = nil
-      payload = doc.to_json if doc
-      JSON.parse(RestClient.post(uri, payload))
-    end
-  
-    def delete uri
-      JSON.parse(RestClient.delete(uri))
-    end
-  
-    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)
-          "#{k}=#{CGI.escape(v.to_s)}"
-        end.join("&")
-        url = "#{url}?#{query}"
-      end
-      url
-    end
-  end # class << self
-end