careo-makura 0.1

data/lib/makura/design.rb

@@ -0,0 +1,37 @@
+module Makura
+  class Design
+    attr_accessor :database, :name, :language
+    attr_reader :layouts
+
+    def initialize(name, database = nil)
+      @name, @database = name, database
+      @language = 'javascript'
+      @layouts = {}
+    end
+
+    def save
+      hash = to_hash
+      doc = @database[hash['_id']]
+      doc['views'] = hash['views']
+      @database.save(doc)
+    rescue Makura::Error::ResourceNotFound
+      @database.save(to_hash)
+    end
+
+    def [](layout_name)
+      @layouts[layout_name.to_s]
+    end
+
+    def []=(layout_name, layout)
+      @layouts[layout_name.to_s] = layout
+    end
+
+    def to_hash
+      views = {}
+      @layouts.each{|name, layout| views[name] = layout.to_hash }
+      views.delete_if{|k,v| !(v[:map] || v['map']) }
+
+      {'language' => @language, '_id' => "_design/#{@name}", 'views' => views}
+    end
+  end
+end

data/lib/makura/error.rb

@@ -0,0 +1,14 @@
+module Makura
+  # Mother and namespace of all exceptions
+  class Error < ::RuntimeError
+    class ConnectionRefused < Error; end
+    class RequestFailed < Error; end
+    class ResourceNotFound < RequestFailed; end
+    class Conflict < RequestFailed; end
+    class MissingRevision < RequestFailed; end
+    class BadRequest < RequestFailed; end
+    class Authorization < RequestFailed; end
+    class NotFound < RequestFailed; end
+    class FileExists < RequestFailed; end
+  end
+end

data/lib/makura/http_methods.rb

@@ -0,0 +1,19 @@
+module Makura
+  module HTTPMethods
+    def delete(path, params = {})
+      request(:delete, path, params)
+    end
+
+    def get(path, params = {})
+      request(:get, path, params)
+    end
+
+    def post(path, params = {})
+      request(:post, path, params)
+    end
+
+    def put(path, params = {})
+      request(:put, path, params)
+    end
+  end
+end

data/lib/makura/layout.rb

@@ -0,0 +1,62 @@
+module Makura
+  class Layout
+    attr_accessor :design, :name, :map, :reduce
+
+    PATH = [
+      './couch',
+      File.join(Makura::ROOT, '../couch')
+    ]
+
+    def initialize(name, design = nil)
+      @name, @design = name, design
+      @design[name] = self
+      @map = @reduce = nil
+      @options = {}
+    end
+
+    def load_proto_map(file_or_function, replace = {})
+      return unless common_load(:proto_map, file_or_function)
+      replace.each{|from, to| @proto_map.gsub!(/"\{\{#{from}\}\}"/, to) }
+      @map = @proto_map
+    end
+
+    def load_proto_reduce(file_or_function, replace = {})
+      return unless common_load(:proto_reduce, file_or_function)
+      replace.each{|from, to| @proto_reduce.gsub!(/"\{\{#{from}\}\}"/, to) }
+      @reduce = @proto_reduce
+    end
+
+    def load_map(file_or_function)
+      common_load(:map, file_or_function)
+    end
+
+    def load_reduce(file_or_function)
+      common_load(:reduce, file_or_function)
+    end
+
+    def common_load(root, file_or_function)
+      return unless file_or_function
+
+      if file_or_function =~ /function\(.*\)/
+        function = file_or_function
+      else
+        filename = "#{root}/#{file_or_function}.js"
+
+        if pathname = PATH.find{|pa| File.file?(File.join(pa, filename)) }
+          function = File.read(File.join(pathname, filename))
+        end
+      end
+
+      instance_variable_set("@#{root}", function) if function
+    end
+
+    def save
+      @design[@name] = self.to_hash
+      @design.save
+    end
+
+    def to_hash
+      {:map => @map, :reduce => @reduce, :makura_options => @options}
+    end
+  end
+end

data/lib/makura/model.rb

@@ -0,0 +1,372 @@
+module Makura
+  module Model
+    KEY = 'makura_type'
+
+    class << self
+      attr_reader :server, :database
+
+      def database=(name)
+        @database = server.database(name)
+      end
+
+      def server=(obj)
+        case obj
+        when Makura::Server
+          @server = obj
+        when String, URI
+          @server = Makura::Server.new(obj)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def server
+        return @server if @server
+        self.server = Makura::Server.new
+      end
+
+      def included(into)
+        into.extend(SingletonMethods)
+        into.send(:include, InstanceMethods)
+        into.makura_relation = {:belongs_to => {}, :has_many => {}}
+        into.property_type = {}
+        into.defaults = {'type' => into.name}
+        into.properties(:_id, :_rev, :type)
+      end
+    end
+
+    module InstanceMethods
+      def initialize(hash = {})
+        @_hash = self.class.defaults.dup
+        merge!(hash)
+      end
+
+      def merge!(hash)
+        case hash
+        when Makura::Model
+          merge!(hash.to_hash)
+        when Hash
+          hash.each{|key, value|
+            meth = "#{key}="
+
+            if respond_to?(meth)
+              self.send("#{key}=", value)
+            else
+              self[key.to_s] = value
+            end
+          }
+        else
+          raise ArgumentError, "This is neither relation data nor an Hash"
+        end
+      end
+
+      def [](key)
+        @_hash[key.to_s]
+      end
+
+      def []=(key, value)
+        @_hash[key.to_s] = value
+      end
+
+      def to_hash
+        @_hash.dup
+      end
+
+      def to_json
+        @_hash.to_json
+      end
+
+      def inspect
+        "#<#{self.class} #{@_hash.inspect}>"
+      end
+
+      def pretty_print(o)
+        ["#<#{self.class} ", @_hash, ">"].each{|e| e.pretty_print(o) }
+      end
+
+      def saved?
+        self['_rev']
+      end
+
+      def save
+        return if not valid? if respond_to?(:valid)
+        return if saved?
+        save!
+      end
+
+      def save!
+        hash = self.to_hash
+
+        self.class.makura_relation.each do |kind, relation_hash|
+          relation_hash.each do |key, value|
+            hash[key.to_s] = hash[key.to_s] #._id
+          end
+        end
+
+        response = self.class.database.save(hash)
+        self._rev = response['rev']
+        self._id = response['id']
+
+        return self
+      end
+
+      # path, file, args = {})
+      def attach(*args)
+        self.class.database.put_attachment(self, *args)
+      end
+
+      # delete attachment by name.
+      # we make sure the parameter is given and a nonempty string to avoid
+      # destroying the document itself
+      def detach(name)
+        name.strip!
+        return if name.empty?
+        self.class.database.request(:delete, "#{_id}/#{name}", :rev => _rev)
+      rescue Makura::Error::Conflict
+        self['_rev'] = self.class[self._id]['_rev']
+        retry
+      end
+
+      def destroy
+        self.class.database.delete(_id, :rev => _rev)
+      end
+
+      def ==(obj)
+        self.class == obj.class and self._id == obj._id
+      end
+
+      def hash
+        @_hash.hash
+      end
+
+      def eql?(other)
+        other == self && other.hash == self.hash
+      end
+
+      def clone
+        hash = @_hash.dup
+        hash.delete('_id')
+        hash.delete('_rev')
+        self.class.new(hash)
+      end
+    end
+
+    module SingletonMethods
+      attr_accessor :defaults, :makura_relation, :property_type
+
+      def plugin(name)
+        require "makura/plugin/#{name}".downcase
+
+        name = name.to_s.capitalize
+        mod = Makura::Plugin.const_get(name)
+
+        include(mod::InstanceMethods) if defined?(mod::InstanceMethods)
+        extend(mod::SingletonMethods) if defined?(mod::SingletonMethods)
+      end
+
+      def database=(name)
+        @database = Makura::Model.server.database(name)
+      end
+
+      def database
+        @database || Makura::Model.database
+      end
+
+      def properties(*names)
+        names.each{|name| property(name) }
+      end
+
+      def property(name, opts = {})
+        name = name.to_s
+        defaults[name] = default = opts.delete(:default) if opts[:default]
+        property_type[name] = type = opts.delete(:type) if opts[:type]
+
+        if type == Time
+          code = "
+            def #{name}()
+              Time.at(@_hash[#{name.dump}].to_i)
+            end
+            def #{name}=(obj)
+              @_hash[#{name.dump}] = obj.to_i
+            end"
+          class_eval(code)
+        else
+          code = "
+            def #{name}() @_hash[#{name.dump}] end
+            def #{name}=(obj) @_hash[#{name.dump}] = obj end"
+        end
+
+        class_eval(code)
+      end
+
+      def id(name)
+        @id = name
+        class_eval("
+          alias #{name} _id
+          alias #{name}= _id=")
+      end
+
+      def belongs_to(name, model = nil)
+        name = name.to_s
+        klass = (model || name.capitalize).to_s
+        @makura_relation[:belongs_to][name] = klass
+
+        class_eval("
+          def #{name}()
+            @#{name} ||= #{klass}[self[#{name.dump}]]
+          end
+          def #{name}=(obj)
+            if obj.respond_to?(:_id)
+              @_hash[#{name.dump}] = obj._id
+            else
+              @_hash[#{name.dump}] = obj
+            end
+          end")
+      end
+
+      def has_many(name, model = nil)
+        name = name.to_s
+        klass = (model || name.capitalize).to_s
+        @makura_relation[:has_many][name] = klass
+
+        class_eval("
+          def #{name}()
+            @#{name} ||= #{klass}[self[#{name.dump}]]
+          end
+          def #{name}=(obj)
+            return unless obj
+            raise RuntimeError, 'You many not assign here'
+          end")
+      end
+
+      def [](id, rev = nil)
+        new(database[id, rev])
+      rescue Error::ResourceNotFound
+        nil
+      end
+
+      def design
+        @design ||= Design.new(name.to_s, database)
+      end
+
+      def layout(name, opts = {})
+        design[name] = layout = Layout.new(name, design)
+
+        map_name    = opts[:map]    || "#{self.name}_#{name}".downcase
+        reduce_name = opts[:reduce] || "#{self.name}_#{name}".downcase
+
+        layout.load_map(map_name)
+        layout.load_reduce(reduce_name)
+
+        return layout
+      end
+
+      def proto_layout(common, name, opts = {})
+        design[name] = layout = Layout.new(name, design)
+
+        map_name    = opts.delete(:map)    || "#{self.name}_#{common}".downcase
+        reduce_name = opts.delete(:reduce) || "#{self.name}_#{common}".downcase
+
+        layout.load_proto_map(map_name, opts)
+        layout.load_proto_reduce(reduce_name, opts)
+
+        return layout
+      end
+
+      def save
+        design.save
+      end
+
+      # +opts+ must include a :keys or 'keys' key with something that responds
+      # to #to_a as value
+      #
+      # Usage given a map named `Post/by_tags' that does something like:
+      #
+      #     for(t in doc.tags){ emit([doc.tags[t]], null); }
+      #
+      # You can use this like:
+      #
+      #     keys = ['ruby', 'couchdb']
+      #     Post.multi_fetch(:by_tags, :keys => keys)
+      #
+      # And it will return all docs with the tags 'ruby' OR 'couchdb'
+      # This can be extended to match even more complex things
+      #
+      #   for(t in doc.tags){ emit([doc.author, doc.tags[t]], null); }
+      #
+      # Now we do
+      #
+      #     keys = [['manveru', 'ruby'], ['mika', 'couchdb']]
+      #     Post.multi_fetch(:by_tags, :keys => keys)
+      #
+      # This will return all docs match following:
+      #     ((author == 'manveru' && tags.include?('ruby')) ||
+      #      (author == 'mika' && tags.include?('couchdb')))
+      #
+      # Of course you can add as many keys as you like:
+      #
+      #     keys = [['manveru', 'ruby'],
+      #             ['manveru', 'couchdb'],
+      #             ['mika', 'design']]
+      #             ['mika', 'couchdb']]
+      #     Post.multi_fetch(:by_tags, :keys => keys)
+      #
+      #
+      # From http://wiki.apache.org/couchdb/HTTP_view_API
+      #   A JSON structure of {"keys": ["key1", "key2", ...]} can be posted to
+      #   any user defined view or _all_docs to retrieve just the view rows
+      #   matching that set of keys. Rows are returned in the order of the keys
+      #   specified. Combining this feature with include_docs=true results in
+      #   the so-called multi-document-fetch feature.
+
+      def multi_fetch(name, opts = {})
+        keys = opts.delete(:keys) || opts.delete('keys')
+        opts.merge!(:payload => {'keys' => keys.to_a})
+        hash = database.post("_view/#{self}/#{name}", opts)
+        convert_raw(hash['rows'])
+      end
+
+      def multi_fetch_with_docs(name, opts = {})
+        opts.merge!(:include_docs => true, :reduce => false)
+        multi_fetch(name, opts)
+      end
+      alias multi_document_fetch multi_fetch_with_docs
+
+      # It is generally recommended not to include the doc in the emit of the
+      # map function but to use include_docs=true.
+      # To make using this approach more convenient use this method.
+
+      def view_with_docs(name, opts = {})
+        opts.merge!(:include_docs => true, :reduce => false)
+        view(name, opts)
+      end
+
+      alias view_docs view_with_docs
+
+      def view(name, opts = {})
+        flat = opts.delete(:flat)
+        hash = database.view("#{self}/#{name}", opts)
+
+        convert_raw(hash['rows'], flat)
+      end
+
+      def convert_raw(rows, flat = false)
+        rows.map do |row|
+          value = row['doc'] || row['value']
+
+          if value.respond_to?(:to_hash)
+            if type = value['type'] and not flat
+              const_get(type).new(value)
+            else
+              row
+            end
+          elsif not row['key']
+            value
+          else
+            row
+          end
+        end
+      end
+    end
+  end
+end