makura 2009.05.27

data/lib/makura/plugin/pager.rb

@@ -0,0 +1,56 @@
+module Makura
+  module Plugin
+    module Pager
+      module SingletonMethods
+        def pager(page, limit)
+          Makura::Plugin::Pager::Pagination.new(self, :pager, page, limit)
+        end
+      end
+
+      class Pagination
+        def initialize(model, view, page, limit)
+          @model, @view, @page, @limit = model, view, page, limit
+        end
+
+        # /pager/_all_docs?count=10&group=true
+        # /pager/_all_docs?startkey=%224f9dca1c66121f9320a69553546db07a%22&startkey_docid=4f9dca1c66121f9320a69553546db07a&skip=1&descending=false&count=10&group=true
+        # /pager/_all_docs?startkey=%22_design%2FUser%22&startkey_docid=_design%2FUser&skip=1&descending=false&count=10&group=true
+        # /pager/_all_docs?startkey=%22d850f0801686b85035680bb6f38d5c5c%22&startkey_docid=d850f0801686b85035680bb6f38d5c5c&skip=1&descending=false&count=10&group=true
+
+        # NOTE:
+        #   * descending should be true if you page backwards
+
+        include Enumerable
+
+        def each(start_id = nil, descending = false, &block)
+          opts = {
+            :count => @limit,
+            :group => true,
+            :descending => descending,
+            # :include_docs => true,
+          }
+
+          if start_id
+            opts[:skip] = 1
+            opts[:startkey_docid] = start_id
+            opts[:startkey] = start_id
+          end
+
+          @model.view(@view, opts).each(&block)
+        end
+
+        def count
+        end
+
+        def first_page?
+        end
+
+        def last_page?
+        end
+
+        def empty?
+        end
+      end
+    end
+  end
+end

data/lib/makura/server.rb

@@ -0,0 +1,203 @@
+module Makura
+  class Server
+    include HTTPMethods
+    attr_accessor :uri, :cache_ttl, :cache_tries
+
+    COUCHDB_URI = 'http://localhost:5984'
+    CACHE_TTL = 5
+    CACHE_TRIES = 2
+
+    # Usage:
+    #   server = Makura::Server.new
+    #   #<URI::HTTP:0xb778ce38 URL:http://localhost:5984>
+    #   server.info
+    #   {"couchdb"=>"Welcome", "version"=>"0.9.0a718650-incubating"}
+
+    def initialize(uri = COUCHDB_URI, cache_ttl = CACHE_TTL, cache_tries = CACHE_TRIES)
+      @uri = URI(uri.to_s)
+      @cache_ttl = cache_ttl
+      @cache_tries = cache_tries
+      @uuids = UUIDCache.new(self)
+    end
+
+    def inspect
+      @uri.inspect
+    end
+
+    # General queries
+
+    # Answers with general couchdb info, looks like:
+    #
+    # Usage:
+    #   server.info
+    #   # {'couchdb' => 'Welcome', 'version' => '0.9.0a718650-incubating'}
+    def info
+      get('/')
+    end
+
+    # Answers with configuration info.
+    #
+    # Usage:
+    #   server.config
+    #
+    def config
+      get('/_config')
+    end
+
+    # Issue restart of the CouchDB daemon.
+    #
+    # Usage:
+    #   server.restart
+    #   # {'ok' => true}
+    def restart
+      post('/_restart')
+    end
+
+    # Array of names of databases on the server
+    #
+    # Usage:
+    #   server.databases
+    #   # ["another", "blog", "makura-spec"]
+    def databases
+      get('/_all_dbs')
+    end
+
+    # Return new database instance using this server instance.
+    #
+    # Usage:
+    #   foo = server.database('foo')
+    #   # #<Makura::Database 'http://localhost:5984/foo'>
+    #   server.databases
+    #   # ["another", "blog", "foo", "makura-spec"]
+
+    def database(name)
+      Database.new(self, name)
+    end
+
+    # Answers with an uuid from the UUIDCache.
+    #
+    # Usage:
+    #   server.next_uuid
+    #   # "55fdca746fa5a5b56f5270875477a2cc"
+
+    def next_uuid
+      @uuids.next
+    end
+
+    def start_cache(namespace = 'makura', *servers)
+      servers << 'localhost:11211' if servers.empty?
+      @cache = MemCache.new(servers, :namespace => namespace, :multithread => true)
+    end
+
+    def stop_cache
+      @cache = nil
+    end
+
+    def cached(request, ttl = cache_ttl, tries = cache_tries)
+      key = request[:url]
+
+      unless response = @cache.get(key)
+        response = execute(request)
+        @cache.add(key, response, ttl)
+      end
+
+      return response
+    rescue MemCache::MemCacheError => error
+      servers = @cache.servers.map{|s| "#{s.host}:#{s.port}"}
+      start_cache(@cache.namespace, *servers)
+      tries -= 1
+      retry if tries > 0
+      warn "[makura caching disabled] #{error.message}"
+      @cache = nil
+      execute(request)
+    end
+
+    # Helpers
+
+    def request(method, path, params = {})
+      keep_raw = params.delete(:raw)
+      payload = params.delete(:payload)
+      payload = payload.to_json if payload and not keep_raw
+      headers = {}
+
+      if content_type = params.delete('Content-Type')
+        headers['Content-Type'] = content_type
+      end
+
+      params.delete_if{|k,v| v.nil? }
+      uri = uri(path, params).to_s
+
+      request = {
+        :method => method,
+        :url => uri,
+        :payload => payload,
+        :headers => headers}
+
+      if @cache and request[:method] == :get
+        raw = cached(request)
+      else
+        raw = execute(request)
+      end
+
+      return raw if keep_raw
+      json = JSON.parse(raw)
+    rescue JSON::ParserError
+      return raw
+    rescue RestClient::RequestFailed => ex
+      raise appropriate_error(ex)
+    rescue RestClient::ResourceNotFound => ex
+      raise Error::ResourceNotFound, request[:url], ex.backtrace
+    rescue Errno::ECONNREFUSED
+      raise Error::ConnectionRefused, "Is CouchDB running at #{@uri}?"
+    end
+
+    def execute(request)
+      RestClient::Request.execute(request)
+    end
+
+    def appropriate_error(exception)
+      body = exception.response.body if exception.respond_to?(:response)
+      backtrace = exception.backtrace
+
+      raise(Error::RequestFailed, exception.message, backtrace) unless body
+      raise(Error::RequestFailed, exception.message, backtrace) if body.empty?
+
+      json = JSON.parse(body)
+      error, reason = json['error'], json['reason']
+
+      case error
+      when 'bad_request'
+        raise(Error::BadRequest, reason, backtrace)
+      when 'authorization'
+        raise(Error::Authorization, reason, backtrace)
+      when 'not_found'
+        raise(Error::NotFound, reason, backtrace)
+      when 'file_exists'
+        raise(Error::FileExists, reason, backtrace)
+      when 'missing_rev'
+        raise(Error::MissingRevision, reason, backtrace)
+      when 'conflict'
+        raise(Error::Conflict, reason, backtrace)
+      else
+        raise(Error::RequestFailed, json.inspect, backtrace)
+      end
+    end
+
+    JSON_PARAMS = %w[key startkey endkey]
+
+    def paramify(hash)
+      hash.map{|k,v|
+        k = k.to_s
+        v = v.to_json if JSON_PARAMS.include?(k)
+        "#{Makura.escape(k)}=#{Makura.escape(v)}"
+      }.join('&')
+    end
+
+    def uri(path = '/', params = {})
+      uri = @uri.dup
+      uri.path = (path[0,1] == '/' ? path : "/#{path}").squeeze('/')
+      uri.query = paramify(params) unless params.empty?
+      uri
+    end
+  end
+end

data/lib/makura/uuid_cache.rb

@@ -0,0 +1,23 @@
+module Makura
+  class UUIDCache
+    attr_accessor :min, :max, :server, :pretty
+
+    def initialize(server, min = 500, max = 1500, pretty = true)
+      @server, @min, @max, @pretty = server, min, max, pretty
+      @uuids = []
+    end
+
+    def next
+      fetch if @uuids.size < min
+      @uuids.shift
+    end
+
+    def fetch(count = 0)
+      todo = max - @uuids.size
+      count = [min, todo, max].sort[1]
+      uuids = @server.get('/_uuids', :count => count)['uuids']
+      uuids.map!{|u| Makura.pretty_from_md5(u) } if pretty
+      @uuids.concat(uuids)
+    end
+  end
+end

data/lib/makura/version.rb

@@ -0,0 +1,3 @@
+module Makura
+  VERSION = "2009.05.27"
+end

data/makura.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{makura}
+  s.version = "2009.05.27"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael 'manveru' Fellinger"]
+  s.date = %q{2009-05-27}
+  s.default_executable = %q{makura}
+  s.email = %q{m.fellinger@gmail.com}
+  s.executables = ["makura"]
+  s.files = ["CHANGELOG", "COPYING", "MANIFEST", "README.md", "Rakefile", "bin/makura", "example/blog.rb", "example/couch/map/author_all.js", "example/couch/map/author_posts.js", "example/couch/map/post_all.js", "example/couch/map/post_comments.js", "example/couch/reduce/sum_length.js", "lib/makura.rb", "lib/makura/database.rb", "lib/makura/design.rb", "lib/makura/error.rb", "lib/makura/http_methods.rb", "lib/makura/layout.rb", "lib/makura/model.rb", "lib/makura/plugin/localize.rb", "lib/makura/plugin/pager.rb", "lib/makura/server.rb", "lib/makura/uuid_cache.rb", "lib/makura/version.rb", "makura.gemspec", "tasks/authors.rake", "tasks/bacon.rake", "tasks/changelog.rake", "tasks/copyright.rake", "tasks/gem.rake", "tasks/gem_installer.rake", "tasks/git.rake", "tasks/grancher.rake", "tasks/manifest.rake", "tasks/metric_changes.rake", "tasks/rcov.rake", "tasks/release.rake", "tasks/reversion.rake", "tasks/todo.rake", "tasks/traits.rake", "tasks/yard.rake", "tasks/ycov.rake"]
+  s.homepage = %q{http://github.com/manveru/makura}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Ruby wrapper around the CouchDB REST API.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rest-client>, [">= 0.8.1"])
+    else
+      s.add_dependency(%q<rest-client>, [">= 0.8.1"])
+    end
+  else
+    s.add_dependency(%q<rest-client>, [">= 0.8.1"])
+  end
+end

data/tasks/authors.rake

@@ -0,0 +1,30 @@
+# Once git has a fix for the glibc in handling .mailmap and another fix for
+# allowing empty mail address to be mapped in .mailmap we won't have to handle
+# them manually.
+
+desc 'Update AUTHORS'
+task :authors do
+  authors = Hash.new(0)
+
+  `git shortlog -nse`.scan(/(\d+)\s(.+)\s<(.*)>$/) do |count, name, email|
+    case name
+    when "ahoward"
+      name, email = "Ara T. Howard", "ara.t.howard@gmail.com"
+    when "Martin Hilbig blueonyx@dev-area.net"
+      name, email = "Martin Hilbig", "blueonyx@dev-area.net"
+    when "Michael Fellinger m.fellinger@gmail.com"
+      name, email = "Michael Fellinger", "m.fellinger@gmail.com"
+    end
+
+    authors[[name, email]] += count.to_i
+  end
+
+  File.open('AUTHORS', 'w+') do |io|
+    io.puts "Following persons have contributed to #{GEMSPEC.name}."
+    io.puts '(Sorted by number of submitted patches, then alphabetically)'
+    io.puts ''
+    authors.sort_by{|(n,e),c| [-c, n.downcase] }.each do |(name, email), count|
+      io.puts("%6d %s <%s>" % [count, name, email])
+    end
+  end
+end

data/tasks/bacon.rake

@@ -0,0 +1,66 @@
+desc 'Run all bacon specs with pretty output'
+task :bacon => :install_dependencies do
+  require 'open3'
+  require 'scanf'
+  require 'matrix'
+
+  specs = PROJECT_SPECS
+
+  some_failed = false
+  specs_size = specs.size
+  len = specs.map{|s| s.size }.sort.last
+  total_tests = total_assertions = total_failures = total_errors = 0
+  totals = Vector[0, 0, 0, 0]
+
+  red, yellow, green = "\e[31m%s\e[0m", "\e[33m%s\e[0m", "\e[32m%s\e[0m"
+  left_format = "%4d/%d: %-#{len + 11}s"
+  spec_format = "%d specifications (%d requirements), %d failures, %d errors"
+
+  specs.each_with_index do |spec, idx|
+    print(left_format % [idx + 1, specs_size, spec])
+
+    Open3.popen3(RUBY, spec) do |sin, sout, serr|
+      out = sout.read.strip
+      err = serr.read.strip
+
+      # this is conventional, see spec/innate/state/fiber.rb for usage
+      if out =~ /^Bacon::Error: (needed .*)/
+        puts(yellow % ("%6s %s" % ['', $1]))
+      else
+        total = nil
+
+        out.each_line do |line|
+          scanned = line.scanf(spec_format)
+
+          next unless scanned.size == 4
+
+          total = Vector[*scanned]
+          break
+        end
+
+        if total
+          totals += total
+          tests, assertions, failures, errors = total_array = total.to_a
+
+          if tests > 0 && failures + errors == 0
+            puts((green % "%6d passed") % tests)
+          else
+            some_failed = true
+            puts(red % "       failed")
+            puts out unless out.empty?
+            puts err unless err.empty?
+          end
+        else
+          some_failed = true
+          puts(red % "       failed")
+          puts out unless out.empty?
+          puts err unless err.empty?
+        end
+      end
+    end
+  end
+
+  total_color = some_failed ? red : green
+  puts(total_color % (spec_format % totals.to_a))
+  exit 1 if some_failed
+end

data/tasks/changelog.rake

@@ -0,0 +1,18 @@
+desc 'update changelog'
+task :changelog do
+  File.open('CHANGELOG', 'w+') do |changelog|
+    `git log -z --abbrev-commit`.split("\0").each do |commit|
+      next if commit =~ /^Merge: \d*/
+      ref, author, time, _, title, _, message = commit.split("\n", 7)
+      ref    = ref[/commit ([0-9a-f]+)/, 1]
+      author = author[/Author: (.*)/, 1].strip
+      time   = Time.parse(time[/Date: (.*)/, 1]).utc
+      title.strip!
+
+      changelog.puts "[#{ref} | #{time}] #{author}"
+      changelog.puts '', "  * #{title}"
+      changelog.puts '', message.rstrip if message
+      changelog.puts
+    end
+  end
+end

data/tasks/copyright.rake

@@ -0,0 +1,21 @@
+desc "add copyright to all .rb files in the distribution"
+task :copyright do
+  ignore = File.readlines('doc/LEGAL').
+    select{|line| line.strip!; File.exist?(line)}.
+    map{|file| File.expand_path(file)}
+
+  puts "adding copyright to files that don't have it currently"
+  puts PROJECT_COPYRIGHT
+  puts
+
+  Dir['{lib,test}/**/*{.rb}'].each do |file|
+    file = File.expand_path(file)
+    next if ignore.include? file
+    lines = File.readlines(file).map{|l| l.chomp}
+    unless lines.first(PROJECT_COPYRIGHT.size) == PROJECT_COPYRIGHT
+      puts "#{file} seems to need attention, first 4 lines:"
+      puts lines[0..3]
+      puts
+    end
+  end
+end