dolly 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea68df6004ba83c19215952ce9a3ce9e19169ec3
+  data.tar.gz: 835ecc53373d834ff7a8c05173200911490d7e4e
+SHA512:
+  metadata.gz: 40468de07bee1d6412e8dcae7b96f06d85ab9a7c8e1c7a41158a648f922cbb08b0b9c7ac3e54b30bf98a23647597f30d1c603dafabe784db61997323f5e12a9c
+  data.tar.gz: 30ddf8c41e68c48645f899d145aa439f6c4bde64218f82e048ba3af8aa85dc614fe7c18eeda6973faee88345cea4932c1ad07b4d4671c068d71c5416a4aa7f18

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/dolly.rb

@@ -0,0 +1,51 @@
+require "dolly/version"
+require "dolly/document"
+require "dolly/property"
+
+module Dolly
+
+  class Base
+    include Dolly::Document
+    attr_accessor :rows, :doc, :key
+
+    def rows= col
+      col.each{ |r| @doc = r['doc'] }
+      _properties.each do |p|
+        self.send "#{p.name}=", doc[p.name]
+      end
+      @rows = col
+    end
+
+    def self.property *ary
+      options       = ary.pop if ary.last.kind_of? Hash
+      options     ||= {}
+      @properties ||= []
+
+      @properties += ary.map do |name|
+        options.merge!({name: name})
+        property = Property.new(options)
+
+        define_method(name) do
+          property.value = @doc[name.to_s]
+          property.value
+        end
+
+        define_method("#{name}=") do |val|
+          @doc ||={}
+          @doc[name.to_s] = val
+        end
+
+        define_method(:"#{name}?") { send name } if property.boolean?
+        define_method("[]") {|n| send n.to_sym}
+
+        property
+      end
+    end
+
+    private
+    def _properties
+      self.class.properties
+    end
+  end
+
+end

data/lib/dolly/collection.rb

@@ -0,0 +1,57 @@
+require 'dolly/representations/collection_representation'
+
+module Dolly
+  class Collection
+    extend Forwardable
+    attr_accessor :rows
+    attr_writer :json, :docs_class
+
+    def_delegators :@set, :clear, :empty?, :length, :+, :-
+
+    def initialize str, docs_class
+      @set = Set.new
+      @docs_class = docs_class
+      @json = str
+    end
+
+    def map &block
+      load if empty?
+      @set.collect &block
+    end
+
+    def each &block
+      load if empty?
+      @set.each &block
+      #TODO: returning nil to avoid extra time serializing set.
+      nil
+    end
+
+    def to_a
+      load if empty?
+      @set.to_a
+    end
+
+    def count
+      load if empty?
+      length
+    end
+
+    def load
+      @set = self.extend(representation).from_json(json).rows
+    end
+
+    private
+    def representation
+      Representations::CollectionRepresentation.config(docs_class)
+    end
+
+    def docs_class
+      @docs_class
+    end
+
+    def json
+      @json
+    end
+
+  end
+end

data/lib/dolly/connection.rb

@@ -0,0 +1,15 @@
+require "dolly/request"
+
+module Dolly
+  module Connection
+
+    def database
+      @database ||= Request.new(database_name: @@database_name)
+    end
+
+    def database_name value
+       @@database_name ||= value
+    end
+
+  end
+end

data/lib/dolly/document.rb

@@ -0,0 +1,114 @@
+require "active_model/naming"
+require "dolly/connection"
+require "dolly/collection"
+require "dolly/representations/document_representation"
+require "dolly/representations/collection_representation"
+require "exceptions/dolly"
+
+module Dolly
+  module Document
+
+    def id
+      doc['_id']
+    end
+
+    def rev
+      doc['_rev']
+    end
+
+    def save
+      response = database.put(id_as_resource, self.doc.to_json)
+      obj = JSON::parse response.parsed_response
+      doc['_rev'] = obj['rev'] if obj['rev']
+      obj['ok']
+    end
+
+    def save!
+      #TODO: decide how to handle validations...
+      save
+    end
+
+    def from_json string
+      self.class.new.extend(representation).from_json( string )
+    end
+
+    def database
+      self.class.database
+    end
+
+    def id_as_resource
+      CGI::escape id
+    end
+
+    def representation
+      Representations::DocumentRepresentation.config(self.class.properties)
+    end
+
+    module ClassMethods
+      include ActiveModel::Naming
+      include Dolly::Connection
+      attr_accessor :properties
+
+      DESIGN_DOC = "dolly"
+
+      def find *ids
+        response = default_view(keys: ids.map{|id| namespace(id)}).parsed_response
+        ids.count > 1 ? Collection.new(response, name.constantize) : self.new.from_json(response)
+      rescue NoMethodError => err
+        if err.message == "undefined method `[]' for nil:NilClass"
+          raise Dolly::ResourceNotFound
+        else
+          raise
+        end
+      end
+
+      def all
+        Collection.new default_view.parsed_response, name.constantize
+      end
+
+      def default_view options = {}
+        view default_doc, options
+      end
+
+      def view doc, options = {}
+        options.merge! include_docs: true
+        database.get doc, options
+      end
+
+      def default_doc
+        "#{design_doc}/_view/#{name_paramitized}"
+      end
+
+      def design_doc
+        "_design/#{@@design_doc || DESIGN_DOC}"
+      end
+
+      def set_design_doc value
+        @@design_doc = value
+      end
+
+      def name_paramitized
+        model_name.param_key
+      end
+
+      def namespace id
+        return id if id =~ /^#{name_paramitized}/
+        "#{name_paramitized}/#{id}"
+      end
+
+      def timestamps!
+        %i/created_at updated_at/.each do |method|
+          define_method(method){ @doc[method.to_s] ||= DateTime.now }
+          define_method(:"[]"){|m| self.send(m.to_sym) }
+          define_method(:"[]="){|m, v| self.send(:"#{m}=", v) }
+          define_method(:"#{method}="){|val| @doc[method.to_s] = val }
+        end
+      end
+
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/dolly/property.rb

@@ -0,0 +1,67 @@
+module Dolly
+  class Property
+    attr_writer :value
+    attr_accessor :name
+
+    def initialize opts = {}
+      @class_name = opts.delete(:class_name) if opts.present?
+      @name = opts.delete(:name).to_s
+      @default = opts.delete(:default)
+      warn 'There are some unprocesed options' if opts.present?
+    end
+
+    def value
+      return @default if @value.nil?
+      return @value unless self_klass
+
+      klass_sym = :"#{self_klass.name.underscore}_#{__method__}"
+
+      return self_klass.new @value unless self.respond_to?(klass_sym)
+
+      self.send klass_sym
+    end
+
+    def array_value
+      @value.to_a
+    end
+
+    def hash_value
+      @value.to_h
+    end
+
+    def string_value
+      @value.to_s
+    end
+
+    def integer_value
+      @value.to_i
+    end
+
+    def float_value
+      @value.to_f
+    end
+
+    def true_class_value
+      truthy_value?
+    end
+
+    def false_class_value
+      truthy_value?
+    end
+
+    def boolean?
+      self_klass == TrueClass || self_klass == FalseClass
+    end
+
+    private
+    def truthy_value?
+      @value =~ /true/ || @value === true
+    end
+
+    def self_klass
+      return unless @class_name
+      @class_name.is_a?(Class)? @class_name : @class_name.constantize
+    end
+
+  end
+end

data/lib/dolly/representations/collection_representation.rb

@@ -0,0 +1,15 @@
+require 'representable/json'
+
+module Dolly
+  module Representations
+    module CollectionRepresentation
+      include Representable::JSON
+
+      def self.config docs_class
+        self.collection :rows, extend: DocumentRepresentation, class: docs_class
+        self
+      end
+    end
+  end
+end
+

data/lib/dolly/representations/document_representation.rb

@@ -0,0 +1,19 @@
+require 'representable/json'
+
+module Dolly
+  module Representations
+    module DocumentRepresentation
+      include Representable::JSON
+
+      property :rows
+      property :doc
+
+      def self.config properties
+        properties.each do |p|
+          self.property p.name
+        end
+        self
+      end
+    end
+  end
+end

data/lib/dolly/request.rb

@@ -0,0 +1,58 @@
+require "httparty"
+
+module Dolly
+
+  class Request
+    include HTTParty
+    DEFAULT_HOST = 'localhost'
+    DEFAULT_PORT = '5984'
+
+    attr_accessor :database_name, :host, :port
+
+    def initialize options = {}
+      @host = options[:host] || DEFAULT_HOST
+      @port = options[:port] || DEFAULT_PORT
+      @database_name = options[:database_name]
+
+      self.class.base_uri "#{protocol}://#{host}:#{port}"
+    end
+
+    def get resource, data
+      request :get, resource, {query: values_to_json(data)}
+    end
+
+    def put resource, data
+      request :put, resource, {body: data}
+    end
+
+    def delete resource
+      request :delete, resource, {}
+    end
+
+    def protocol
+      @protocol || 'http'
+    end
+
+    private
+    def values_to_json hash
+      hash.reduce({}){|h, v| h[v.first] = v.last.to_json; h}
+    end
+
+    def full_path resource
+      "/#{database_name}/#{resource}"
+    end
+
+    def request method, resource, data = nil
+      headers = { 'Content-Type' => 'application/json' }
+      response = self.class.send method, full_path(resource), data.merge(headers: headers)
+      if response.code == 404
+        raise Dolly::ResourceNotFound
+      elsif (500..600).include? response.code
+        raise Dolly::ServerError
+      else
+        response
+      end
+    end
+  end
+
+end

data/lib/dolly/version.rb

@@ -0,0 +1,3 @@
+module Dolly
+  VERSION = "0.0.1"
+end

data/lib/exceptions/dolly.rb

@@ -0,0 +1,12 @@
+module Dolly
+  class ResourceNotFound < RuntimeError
+    def to_s
+      'The document was not found.'
+    end
+  end
+  class ServerError < RuntimeError
+    def to_s
+      'There has been an error on the couchdb server. Please review your couch logs.'
+    end
+  end
+end

data/test/dolly_test.rb

@@ -0,0 +1,147 @@
+require 'test_helper'
+
+class FooBar < Dolly::Base
+  database_name 'test'
+  set_design_doc 'test'
+
+  property :foo, :bar
+  property :with_default, default: 1
+  property :boolean, class_name: TrueClass, default: true
+
+  timestamps!
+end
+
+class DollyTest < ActiveSupport::TestCase
+
+  def setup
+    data     = {foo: 'Foo', bar: 'Bar', type: 'foo_bar'}
+    all_docs = [ {foo: 'Foo B', bar: 'Bar B', type: 'foo_bar'},  {foo: 'Foo A', bar: 'Bar A', type: 'foo_bar'}]
+
+    view_resp   = build_view_response [data]
+    empty_resp  =  build_view_response []
+    @multi_resp = build_view_response all_docs
+
+    build_request ["foo_bar/1"], view_resp
+    build_request ["foo_bar/2"], empty_resp
+    build_request ["foo_bar/1","foo_bar/2"], @multi_resp
+    build_request [], @multi_resp
+  end
+
+  test 'with timestamps!' do
+    later = DateTime.new 1963, 1, 1
+    now = DateTime.now
+    DateTime.stubs(:now).returns(now)
+    foo = FooBar.find "1"
+    assert_equal now, foo.created_at
+    assert_equal now, foo['created_at']
+    assert_equal now, foo.updated_at
+    assert foo.updated_at = later
+    assert_equal later, foo.updated_at
+    assert foo['created_at'] = later
+    assert_equal later, foo['created_at']
+    assert_equal foo['created_at'], foo.created_at
+  end
+
+  test 'empty find should raise error' do
+    assert_raise Dolly::ResourceNotFound do
+      FakeWeb.register_uri :get, "http://localhost:5984/test/_design/test/_view/foo_bar?keys=%5B%5D&include_docs=true", :status => ["404", "Not Found"]
+      foo = FooBar.find
+    end
+  end
+
+  test 'error on server raises Dolly::ServerError' do
+    assert_raise Dolly::ServerError do
+      FakeWeb.register_uri :get, "http://localhost:5984/test/_design/test/_view/foo_bar?keys=%5B%5D&include_docs=true", :status => ["500", "Error"]
+      foo = FooBar.find
+    end
+  end
+
+  test 'will have object with boolean? method' do
+    foo = FooBar.find "1"
+    assert_equal true, foo.boolean?
+    foo.boolean = false
+    assert_equal false, foo['boolean']
+    assert_equal false, foo.boolean?
+  end
+
+  test 'find will get a FooBar document' do
+    foo = FooBar.find "1"
+    assert_equal true, foo.kind_of?(FooBar)
+  end
+
+  test 'will have key properties' do
+    foo = FooBar.find "1"
+    assert_equal 'Foo', foo['foo']
+    assert_equal 'Bar', foo['bar']
+  end
+
+  test 'will have only set properties' do
+    foo = FooBar.find "1"
+    assert_equal 'Foo', foo.foo
+    assert_equal 'Bar', foo.bar
+    assert_equal false, foo.respond_to?(:type)
+  end
+
+  test 'with default will return default value on nil' do
+    foo = FooBar.find "1"
+    assert_equal 1, foo.with_default
+  end
+
+  test 'default will be avoerwriten' do
+    foo = FooBar.find "1"
+    assert_equal 1, foo.with_default
+    assert foo.with_default = 30
+    assert_equal 30, foo.with_default
+  end
+
+  test 'getting not found document' do
+    assert_raise Dolly::ResourceNotFound do
+      missing = FooBar.find "2"
+    end
+  end
+
+  test 'find with multiple ids will return Collection' do
+    many = FooBar.find "1", "2"
+    assert_equal true, many.kind_of?(Dolly::Collection)
+  end
+
+  test 'all will get 2 docs' do
+    all = FooBar.all
+    assert_equal 2, all.count
+  end
+
+  test 'all will get FooBar documents' do
+     all = FooBar.all
+     all.each{ |d| assert_equal true, d.kind_of?(FooBar) }
+  end
+
+  test 'multi response with right data' do
+    all = FooBar.all
+    ids = @multi_resp[:rows].map{|d| d[:id]}
+    foos = @multi_resp[:rows].map{|d| d[:doc][:foo]}
+    bars = @multi_resp[:rows].map{|d| d[:doc][:bar]}
+    all.each do |d|
+      assert foos.include?(d.foo)
+    end
+  end
+
+  private
+  def build_view_response properties
+    rows = properties.map.with_index do |v, i|
+      {
+        id: "foo_bar/#{i}",
+        key: "foo_bar",
+        value: 1,
+        doc: {_id: "foo_bar/#{i}", _rev: SecureRandom.hex}.merge!(v)
+      }
+    end
+    {total_rows: properties.count, offset:0, rows: rows}
+  end
+
+  def build_request keys, body, view_name = 'foo_bar'
+    base_url = "http://localhost:5984/test/_design/test/_view/foo_bar"
+    query = "keys=#{CGI::escape keys.to_s.gsub(' ','')}&" unless keys.blank?
+    FakeWeb.register_uri :get, "#{base_url}?#{query.to_s}include_docs=true", body: body.to_json
+  end
+
+end