dolly 1.1.4 → 3.0.1

data/lib/dolly/property_set.rb

@@ -0,0 +1,23 @@
+module Dolly
+  class PropertySet < Set
+    def include? key
+      keys.include?(key)
+    end
+
+    def <<(property)
+      return if include?(property.key)
+      super(property)
+    end
+
+    def [](key)
+      return detect {|property| property.key == key } if key.is_a?(Symbol)
+      super
+    end
+
+    private
+
+    def keys
+      map(&:key)
+    end
+  end
+end

data/lib/dolly/query.rb

@@ -1,85 +1,55 @@
-require "dolly/connection"
-require "dolly/collection"
-require "dolly/name_space"
-require "exceptions/dolly"
+require 'dolly/collection'
+require 'dolly/query_arguments'
+require 'dolly/document_type'
+require 'refinements/string_refinements'
 
 module Dolly
   module Query
-    module ClassMethods
-      include Dolly::NameSpace
-      include Dolly::Connection
-      attr_accessor :properties
+    include QueryArguments
+    include DocumentType
 
-      DESIGN_DOC = "dolly"
+    using StringRefinements
 
-      def find *keys
-        query_hash = { keys: keys.map{|key| namespace key} }
+    def find *keys
+      query_hash = { keys: namespace_keys(keys).map { |k| k.cgi_escape } }
 
-        if keys.count > 1
-          build_collection( query_hash )
-        else
-          self.new.from_json( database.all_docs(query_hash).parsed_response )
-        end
-      rescue NoMethodError => err
-        if err.message == "undefined method `[]' for nil:NilClass"
-          raise Dolly::ResourceNotFound
-        else
-          raise
-        end
-      end
-
-      def default_query_args
-        {startkey: "#{name_paramitized}/", endkey: "#{name_paramitized}/\ufff0"}
-      end
-
-      def all
-        build_collection default_query_args
-      end
-
-      def first limit = 1
-        res = build_collection default_query_args.merge( limit: 1)
-        limit == 1 ? res.first : res
-      end
-
-      def last limit = 1
-        res = build_collection({startkey: default_query_args[:endkey], endkey: default_query_args[:startkey], limit: limit, descending: true})
-        limit == 1 ? res.first : res
-      end
+      build_collection(query_hash).first_or_all&.itself ||
+        raise(Dolly::ResourceNotFound)
+    end
 
-      def build_collection q
-        res = database.all_docs(q)
-        Collection.new res.parsed_response, name_for_class
-      end
+    def safe_find *keys
+      find *keys
+    rescue Dolly::ResourceNotFound
+      nil
+    end
 
-      def find_with doc, view_name, opts = {}
-        res = view "_design/#{doc}/_view/#{view_name}", opts
-        Collection.new res.parsed_response, name_for_class
-      end
+    def all
+      build_collection(default_query_args)
+    end
 
-      #TODO: new implementation for collection returning
-      # multiple types is failling when the class has a namespace
-      # as the namespace does not exists on the doc id
-      # we need to reimplement this through a references class method.
-      def name_for_class
-        if name.include? '::'
-          name.constantize
-        end
-      end
+    def first limit = 1
+      query_hash = default_query_args.merge(limit: limit)
+      build_collection(query_hash).first_or_all(limit > 1)
+    end
 
-      def view doc, options = {}
-        options.merge! include_docs: true
-        database.get doc, options
-      end
+    def last limit = 1
+      query_hash = descending_query_args.merge(limit: limit)
+      build_collection(query_hash).first_or_all(limit > 1)
+    end
 
-      def raw_view doc, view, opts = {}
-        JSON.parse database.get "_design/#{doc}/_view/#{view}", opts
-      end
+    def find_with doc, view_name, opts = {}
+      opts          = opts.each_with_object({}) { |(k, v), h| h[k] = escape_value(v) }
+      query_results = raw_view(doc, view_name, opts)
 
+      Collection.new({ rows: query_results, options: {} }).first_or_all
     end
 
-    def self.included(base)
-      base.extend ClassMethods
+    def build_collection(query)
+      Collection.new({ rows: connection.get('_all_docs', query.merge(include_docs: true)), options: { doc_type: self.class_name }})
     end
 
+    def bulk_document
+      BulkDocument.new(connection)
+    end
   end
 end

data/lib/dolly/query_arguments.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Dolly
+  module QueryArguments
+    def last_item_in_range
+      URI.escape("\ufff0")
+    end
+
+    def default_query_args
+      {
+        startkey: "#{name_paramitized}/",
+        endkey: "#{name_paramitized}/#{last_item_in_range}"
+      }
+    end
+
+    def descending_query_args
+      {
+        startkey: default_query_args[:endkey],
+        endkey: default_query_args[:startkey],
+        descending: true
+      }
+    end
+
+    def escape_value(value)
+      return value                if value.is_a? Numeric
+      return escape_values(value) if value.is_a? Array
+      return CGI.escape(value)    if value.is_a? String
+      value
+    end
+
+    def escape_values *values
+      values.flatten.map { |value| escape_value(value) }
+    end
+  end
+end

data/lib/dolly/request.rb

@@ -1,106 +1,24 @@
-require "httparty"
-require "dolly/bulk_document"
-
 module Dolly
-
-  class Request
-    include HTTParty
-    DEFAULT_HOST = 'localhost'
-    DEFAULT_PORT = '5984'
-
-    attr_accessor :database_name, :host, :port, :bulk_document
-
-    def initialize options = {}
-      @host = options["host"] || DEFAULT_HOST
-      @port = options["port"] || DEFAULT_PORT
-
-      @database_name = options["name"]
-      @username      = options["username"]
-      @password      = options["password"]
-      @protocol      = options["protocol"]
-
-      @bulk_document = Dolly::BulkDocument.new []
-      self.class.base_uri "#{protocol}://#{host}:#{port}"
-    end
-
-    def get resource, data = nil
-      q = {query: values_to_json(data)} if data
-      request :get, full_path(resource), q
+  module Request
+    def set_namespace name
+      @namespace = name
     end
 
-    def stats
-      request :get, "/#{database_name}"
+    def set_app_env env
+      @app_env = env
     end
 
-    def put resource, data
-      request :put, full_path(resource), {body: data}
+    def connection
+      @connection ||= Connection.new(namespace, app_env)
     end
 
-    def post resource, data
-      request :post, full_path(resource), {body: data}
+    def namespace
+      @namespace ||= :default
     end
 
-    def delete resource
-      request :delete, full_path(resource), {}
-    end
-
-    def attach resource, attachment_name, data, headers = {}
-      data = StringIO.new(data) if data.is_a?(String)
-      request :put, attachment_path(resource, attachment_name), {body: data, headers: headers}
-    end
-
-    def protocol
-      @protocol || 'http'
-    end
-
-    def uuids opts = {}
-      tools("_uuids", opts)["uuids"]
-    end
-
-    def all_docs data = {}
-      data =  values_to_json data.merge( include_docs: true )
-      request :get, full_path('_all_docs'), {query: data}
-    end
-
-    def request method, resource, data = nil
-      data ||= {}
-      data.merge!(basic_auth: auth_info) if auth_info.present?
-      headers = { 'Content-Type' => 'application/json' }
-      headers.merge! data[:headers] if data[:headers]
-      response = self.class.send method, resource, data.merge(headers: headers)
-      if response.code == 404
-        raise Dolly::ResourceNotFound
-      elsif (400..600).include? response.code
-        raise Dolly::ServerError.new( response )
-      else
-        response
-      end
-    end
-
-    private
-    def tools path, opts = nil
-      data = {}
-      q = "?#{CGI.unescape(opts.to_query)}" unless opts.blank?
-      data.merge!(basic_auth: auth_info) if auth_info.present?
-      JSON::parse self.class.get("/#{path}#{q}", data)
-    end
-
-    def auth_info
-      return nil unless @username.present?
-      {username: @username, password: @password}
-    end
-
-    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 attachment_path resource, attachment_name
-      "#{full_path(resource)}/#{attachment_name}"
+    def app_env
+      return Rails.env if defined? Rails.env
+      @app_env ||= :development
     end
   end
-
 end

data/lib/dolly/request_header.rb

@@ -0,0 +1,26 @@
+require 'forwardable'
+
+module Dolly
+  class HeaderRequest
+    extend Forwardable
+
+    CONTENT_TYPE_KEY = 'Content-Type'
+    JSON_CONTENT = 'application/json'
+
+    def_delegators :@collection, :[], :[]=, :keys, :each
+
+    def initialize hash = nil
+      @collection = hash || default_value
+    end
+
+    def json?
+      @collection[CONTENT_TYPE_KEY] == JSON_CONTENT
+    end
+
+    private
+
+    def default_value
+      { CONTENT_TYPE_KEY => JSON_CONTENT }
+    end
+  end
+end

data/lib/dolly/timestamp.rb

@@ -0,0 +1,24 @@
+module Dolly
+  module Timestamp
+    def write_timestamps(is_persisted)
+      return unless timestamped?
+      write_attribute(:created_at, Time.now) unless is_persisted
+      write_attribute(:updated_at, Time.now)
+    end
+
+    def timestamped?
+      respond_to?(:created_at) && respond_to?(:updated_at)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def timestamps!
+        property :created_at, :updated_at, class_name: Time
+      end
+    end
+  end
+end
+

data/lib/dolly/version.rb

@@ -1,3 +1,3 @@
 module Dolly
-  VERSION = "1.1.4"
+  VERSION = "3.0.1"
 end

data/lib/dolly/view_query.rb

@@ -0,0 +1,14 @@
+require 'dolly/class_methods_delegation'
+
+module Dolly
+  module ViewQuery
+    def raw_view(doc, view_name, opts = {})
+      design = "_design/#{doc}/_view/#{view_name}"
+      connection.view(design, opts)
+    end
+
+    def view_value(doc, view_name, opts = {})
+      raw_view(doc, view_name, opts)[:rows].flat_map { |result| result[:value] }
+    end
+  end
+end

data/lib/{dolly → railties}/railtie.rb

@@ -1,4 +1,4 @@
-require 'rails'
+require 'rails/railtie'
 
 module Dolly
   class Railtie < Rails::Railtie
@@ -10,3 +10,4 @@ module Dolly
   end
 end
 
+

data/lib/refinements/hash_refinements.rb

@@ -0,0 +1,27 @@
+module HashRefinements
+  refine Hash do
+    # File activesupport/lib/active_support/core_ext/hash/keys.rb, line 82
+    def deep_transform_keys(&block)
+      _deep_transform_keys_in_object(self, &block)
+    end
+
+    def slice(*keys)
+      keys.each_with_object(Hash.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+    end
+
+    private
+
+    def _deep_transform_keys_in_object(object, &block)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+        end
+      when Array
+        object.map { |e| _deep_transform_keys_in_object(e, &block) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/refinements/string_refinements.rb

@@ -0,0 +1,28 @@
+module StringRefinements
+  UNESCAPABLE_PATTERNS = [
+      %r{_design/.+/_view/.+}
+    ]
+
+  refine String do
+    #FROM ActiveModel::Name
+    def underscore
+      to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    def cgi_escape
+      return if nil?
+      return self unless escapable?
+      CGI.escape self
+    end
+
+    def escapable?
+      UNESCAPABLE_PATTERNS.none? do |pattern|
+        self =~ pattern
+      end
+    end
+  end
+end

data/lib/tasks/db.rake

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 namespace :db do
   desc "Will create if missing database and add default views"
   task setup: :environment do
-    Dolly::Document.database.put "", nil
+    Dolly::Document.connection.put '', {}
     puts "Database created"
   end
 
@@ -38,9 +40,9 @@ namespace :db do
       view_doc.merge!( '_id' => design_doc_name, 'language' => 'coffeescript')
 
       begin
-        hash_doc = JSON::parse Dolly::Document.database.get(view_doc["_id"]).parsed_response
+        hash_doc = Dolly::Document.connection.request(:get, view_doc["_id"])
 
-        rev = hash_doc.delete('_rev')
+        rev = hash_doc.delete(:_rev)
 
         if hash_doc == view_doc
           puts 'everything up to date'
@@ -55,8 +57,22 @@ namespace :db do
         will_save = true
       end
 
-      Dolly::Document.database.put design_doc_name, view_doc.to_json if will_save
+      Dolly::Document.connection.request :put, design_doc_name, view_doc if will_save
     end
   end
 
+  namespace :index do
+    desc 'Creates indexes for mango querys located in db/indexes/*.json'
+    task create: :environment do
+      indexes_dir = Rails.root.join('db', 'indexes')
+      files = Dir.glob File.join(indexes_dir, '**', '*.json')
+
+      files.each do |file|
+        index_data = JSON.parse(File.read(file))
+        puts "Creating index: #{index_data["name"]}"
+        puts Dolly::MangoIndex.create(index_data['name'], index_data['fields'])
+      end
+    end
+  end
 end
+