dolly 1.1.7 → 3.1.1

data/lib/dolly/mango_index.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'dolly/document'
+
+module Dolly
+  class MangoIndex
+    class << self
+      extend Forwardable
+
+      ALL_DOCS = '_all_docs'
+      DESIGN = '_index'
+      ROWS_KEY = :rows
+      DESIGN_PREFIX = '_design/'
+
+      def_delegators :connection, :get, :post
+
+      def all
+        get(DESIGN)[:indexes]
+      end
+
+      def create(name, fields, type = 'json')
+        post(DESIGN, build_index_structure(name, fields, type))
+      end
+
+      def create_in_database(database, name, fields, type = 'json')
+        connection_for_database(database).post(DESIGN, build_index_structure(name, fields, type))
+      end
+
+      def find_by_fields(fields)
+        rows = get(ALL_DOCS, key: key_from_fields(fields))[ROWS_KEY]
+        (rows && rows.any?)
+      end
+
+      def delete_all
+        all.each do |index_doc|
+          next if index_doc[:ddoc].nil?
+          delete(index_doc)
+        end
+      end
+
+      def delete(index_doc)
+        resource = "#{DESIGN}/#{index_doc[:ddoc]}/json/#{index_doc[:name]}"
+        connection.delete(resource, escape: false)
+      end
+
+      private
+
+      def connection_for_database(database)
+        Dolly::Connection.new(database.to_sym, Rails.env || :development)
+      end
+
+      def connection
+        @connection ||= Dolly::Document.connection
+      end
+
+      def build_index_structure(name, fields, type)
+        {
+          ddoc: key_from_fields(fields).gsub(DESIGN_PREFIX, ''),
+          index: {
+            fields: fields
+          },
+          name: name,
+          type: type
+        }
+      end
+
+      def key_from_fields(fields)
+        "#{DESIGN_PREFIX}index_#{fields.join('_')}"
+      end
+    end
+  end
+end

data/lib/dolly/properties.rb

@@ -0,0 +1,36 @@
+require 'dolly/property_set'
+require  'dolly/property'
+
+module Dolly
+  module Properties
+    SPECIAL_KEYS = %i[_id _rev]
+
+    def property *opts, class_name: nil, default: nil
+      opts.each do |opt|
+
+        properties << (prop = Property.new(opt, class_name, default))
+        send(:attr_reader, opt)
+
+        define_method(:"#{opt}=") { |value| write_attribute(opt, value) }
+        define_method(:"#{opt}?") { send(opt) } if prop.boolean?
+        define_method(:"[]") {|name| send(name) }
+      end
+    end
+
+    def properties
+      @properties ||= PropertySet.new
+    end
+
+    def all_property_keys
+      properties.map(&:key) + SPECIAL_KEYS
+    end
+
+    def property_keys
+      all_property_keys - SPECIAL_KEYS
+    end
+
+    def property_clean_doc(doc)
+      doc.reject { |key, _value| property_keys.exclude?(key.to_sym) }
+    end
+  end
+end

data/lib/dolly/property.rb

@@ -1,85 +1,115 @@
+require 'refinements/string_refinements'
+
 module Dolly
   class Property
-    attr_writer :value
-    attr_accessor :name
-    attr_reader :class_name, :default
+    attr_reader :key, :class_name, :default
+    CANT_CLONE = [NilClass, TrueClass, FalseClass, Integer]
 
-    CANT_CLONE = [NilClass, TrueClass, FalseClass, Fixnum].freeze
+    using StringRefinements
 
-    def initialize opts = {}
-      @class_name = opts.delete(:class_name) if opts.present?
-      @name = opts.delete(:name).to_s
-      @default = opts.delete(:default)
-      @default = @default.clone if @default && CANT_CLONE.none? { |klass| @default.is_a? klass }
-      @value = @default if @default
-      warn 'There are some unprocessed options!' if opts.present?
+    def initialize(key, class_name, default = nil)
+      @key = key
+      @default = default
+      @class_name = class_name
     end
 
-    def value
-      #TODO: tets if this actually sets `doc[ "name" ]`
-      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)
+    def cast_value(value)
+      return set_default if value.nil?
+      return value unless class_name
+      return custom_class(value) unless respond_to?(klass_sym)
+      send(klass_sym, value)
+    end
 
-      self.send klass_sym
+    def custom_class(value)
+      value = value.is_a?(Hash) ? value.symbolize_keys : value
+      self_klass.new(value)
     end
 
-    def array_value
-      @value.to_a
+    def boolean?
+      [TrueClass, FalseClass].include?(class_name)
     end
 
-    def hash_value
-      @value.to_h
+    def string_value(value)
+      value.to_s
     end
 
-    def string_value
-      @value.to_s
+    def hash_value(value)
+      value.to_h
     end
 
-    def integer_value
-      @value.to_i
+    def hash_with_indifferent_access_value(value)
+      if defined?(Rails)
+        value.to_h.with_indifferent_access
+      else
+        value.to_h
+      end
     end
 
-    def float_value
-      @value.to_f
+    def integer_value(value)
+      value.to_i
     end
 
-    def date_value
-      @value.to_date
+    def float_value(value)
+      value.to_f
     end
 
-    def time_value
-      @value.to_time
+    def date_value(value)
+      return value.to_date if value.respond_to?(:to_date)
+      Date.parse(value)
     end
 
-    def date_time_value
-      @value.to_datetime
+    def time_value(value)
+      return value.to_time if value.respond_to?(:to_time)
+      DateTime.parse(value).to_time
     end
 
-    def true_class_value
-      truthy_value?
+    def date_time_value(value)
+      return value.to_datetime if value.respond_to?(:to_datetime)
+      DateTime.parse(value)
     end
 
-    def false_class_value
-      truthy_value?
+    def true_class_value(value)
+      truthy_value?(value)
     end
 
-    def boolean?
-      self_klass == TrueClass || self_klass == FalseClass
+    def false_class_value(value)
+      truthy_value?(value)
     end
 
     private
-    def truthy_value?
-      @value =~ /true/ || @value === true
+
+    def truthy_value?(value)
+      value =~ /true/ || value === true
+    end
+
+    def klass_sym
+      klass_name = self_klass.
+                   name.
+                   split('::').
+                   last.
+                   underscore
+
+      :"#{klass_name}_value"
     end
 
     def self_klass
-      return unless @class_name
-      @class_name.is_a?(Class)? @class_name : @class_name.constantize
+      return unless class_name
+      return class_name if class_name.is_a?(Class)
+      Object.const_get class_name
+    end
+
+    def set_default
+      return unless default_present?
+      return default unless cant_clone_default?
+      default.clone
     end
 
+    def cant_clone_default?
+      CANT_CLONE.none? { |klass| default.is_a? klass }
+    end
+
+    def default_present?
+      !default.nil?
+    end
   end
 end

data/lib/dolly/property_manager.rb

@@ -0,0 +1,53 @@
+module Dolly
+  module PropertyManager
+    def build_property(attributes)
+      assign_identity_properties(attributes)
+      assign_rev_properties(attributes)
+
+      lambda do |property|
+        name = property.key
+        next unless doc[name].nil?
+        write_attribute(name, attributes[name])
+      end
+    end
+
+    def update_attribute
+      lambda do |key, value|
+        raise InvalidProperty unless valid_property?(key)
+        write_attribute(key, value)
+      end
+    end
+
+    def write_attribute(key, value)
+      casted_value = set_property_value(key, value)
+      instance_variable_set(:"@#{key}", casted_value)
+      update_doc(key, casted_value)
+    end
+
+    def valid_property?(name)
+      properties.include?(name)
+    end
+
+    def update_doc(key, value)
+      doc[key] = value
+    end
+
+    def properties
+      self.class.properties
+    end
+
+    def set_property_value(key, value)
+      properties[key].cast_value(value)
+    end
+
+    def assign_identity_properties(opts = {})
+      id_presence = opts[:id] || opts[:_id] || opts['id'] || opts['_id']
+      self.id = id_presence if id_presence
+    end
+
+    def assign_rev_properties(opts = {})
+      rev_presence = opts[:rev] || opts [:_rev] || opts['rev'] || opts['_rev']
+      self.rev = rev_presence if rev_presence
+    end
+  end
+end

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,73 @@
-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
-
-      DESIGN_DOC = "dolly"
-
-      def find *keys
-        query_hash = { keys: keys.map{|key| namespace key} }
-
-        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
-
-      def build_collection q
-        res = database.all_docs(q)
-        Collection.new res.parsed_response, name_for_class
-      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
-
-      #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 view doc, options = {}
-        options.merge! include_docs: true
-        database.get doc, options
-      end
-
-      def raw_view doc, view, opts = {}
-        JSON.parse database.get "_design/#{doc}/_view/#{view}", opts
-      end
+    include QueryArguments
+    include DocumentType
 
+    using StringRefinements
+
+    def find *keys
+      query_hash = { keys: namespace_keys(keys) }
+
+      build_collection(query_hash).first_or_all&.itself ||
+        raise(Dolly::ResourceNotFound)
+    end
+
+    def bulk_find(*keys_to_find)
+      data = {
+        query: { include_docs: true },
+        keys: keys_to_find.map { |key| namespace_key(key) }
+      }
+
+      res = connection.post('_all_docs', data)
+      Collection.new(rows: res, options: { doc_type: self.class_name })
+    end
+
+    def find_all(*keys)
+      query_hash = { keys: namespace_keys(keys) }
+      return [] if query_hash[:keys].none?
+
+      keys_to_find_counter = query_hash[:keys].length
+      build_collection(query_hash).first_or_all(true)&.itself
+    end
+
+    def safe_find *keys
+      find *keys
+    rescue Dolly::ResourceNotFound
+      nil
     end
 
-    def self.included(base)
-      base.extend ClassMethods
+    def all
+      build_collection(default_query_args)
     end
 
+    def first limit = 1
+      query_hash = default_query_args.merge(limit: limit)
+      build_collection(query_hash).first_or_all(limit > 1)
+    end
+
+    def last limit = 1
+      query_hash = descending_query_args.merge(limit: limit)
+      build_collection(query_hash).first_or_all(limit > 1)
+    end
+
+    def find_with doc, view_name, opts = {}
+      opts          = opts.each_with_object({}) { |(k, v), h| h[k] = v }
+      query_results = raw_view(doc, view_name, opts)
+
+      Collection.new({ rows: query_results, options: {} }).first_or_all
+    end
+
+    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
+      "\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,119 +1,24 @@
-require "httparty"
-require "dolly/bulk_document"
-
 module Dolly
-
-  class Request
-    include HTTParty
-    REQUIRED_KEYS = %w/host port name/.freeze
-
-    attr_accessor :database_name, :host, :port, :bulk_document
-
-    def initialize options = {}
-      REQUIRED_KEYS.each do |key|
-        raise Dolly::MissingRequestConfigSettings.new(key) unless options[key]
-      end
-
-      @host          = options["host"]
-      @port          = options["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
-    end
-
-    def stats
-      request :get, "/#{database_name}"
-    end
-
-    def put resource, data
-      request :put, full_path(resource), {body: data}
-    end
-
-    def post resource, data
-      request :post, full_path(resource), {body: data}
-    end
-
-    def delete resource
-      request :delete, full_path(resource), {}
+  module Request
+    def set_namespace name
+      @namespace = name
     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}
+    def set_app_env env
+      @app_env = env
     end
 
-    def protocol
-      @protocol ||= 'http'
+    def connection
+      @connection ||= Connection.new(namespace, app_env)
     end
 
-    def uuids opts = {}
-      tools("_uuids", opts)["uuids"]
+    def namespace
+      @namespace ||= :default
     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)
-      log_request(resource, response.code) if Dolly.log_requests?
-      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}"
-    end
-
-    def log_request resource, response_code
-      log_value = ->(resource, response_code) { "Query: #{resource}, Response Code: #{response_code}" }
-      case response_code
-      when 200..399
-        Dolly.logger.info log_value[resource, response_code]
-      when 400..600
-        Dolly.logger.warn log_value[resource, response_code]
-      end
+    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, :present?, :merge!
+
+    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