dolly 1.1.5 → 3.1.0

data/lib/dolly/document_type.rb

@@ -0,0 +1,47 @@
+require 'refinements/string_refinements'
+
+module Dolly
+  module DocumentType
+    using StringRefinements
+
+    def namespace_keys(keys)
+      keys.map { |key| namespace_key key }
+    end
+
+    def namespace_key(key)
+      return key if key =~ %r{^#{name_paramitized}/}
+      "#{name_paramitized}/#{key}"
+    end
+
+    def base_id
+      self.id.sub(%r{^#{name_paramitized}/}, '')
+    end
+
+    def name_paramitized
+      class_name.split("::").last.underscore
+    end
+
+    def class_name
+      is_a?(Class) ? name : self.class.name
+    end
+
+    def typed?
+      respond_to?(:type)
+    end
+
+    def set_type
+      return unless typed?
+      write_attribute(:type, name_paramitized)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def typed_model
+        property :type, class_name: String
+      end
+    end
+  end
+end

data/lib/dolly/exceptions.rb

@@ -0,0 +1,32 @@
+module Dolly
+  class ResourceNotFound < RuntimeError
+    def to_s
+      'The document was not found.'
+    end
+  end
+
+  class ServerError < RuntimeError
+    def initialize msg
+      @msg = msg
+    end
+
+    def to_s
+      "There has been an error on the couchdb server: #{@msg.inspect}"
+    end
+  end
+
+  class InvalidMangoOperatorError < RuntimeError
+    def initialize msg
+      @msg = msg
+    end
+
+    def to_s
+      "Invalid Mango operator: #{@msg.inspect}"
+    end
+  end
+
+  class IndexNotFoundError < RuntimeError; end
+  class InvalidConfigFileError < RuntimeError; end
+  class InvalidProperty < RuntimeError; end
+  class DocumentInvalidError < RuntimeError; end
+end

data/lib/dolly/identity_properties.rb

@@ -0,0 +1,29 @@
+require 'dolly/document_type'
+require 'dolly/class_methods_delegation'
+
+module Dolly
+  module IdentityProperties
+    include DocumentType
+    include ClassMethodsDelegation
+
+    def id
+      doc[:_id] ||= namespace_key(connection.uuids.last)
+    end
+
+    def id= value
+      doc[:_id] = namespace_key(value)
+    end
+
+    def rev
+      doc[:_rev]
+    end
+
+    def rev= value
+      doc[:_rev] = value
+    end
+
+    def id_as_resource
+      CGI.escape(id)
+    end
+  end
+end

data/lib/dolly/mango.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'refinements/hash_refinements'
+
+module Dolly
+  module Mango
+    using HashRefinements
+
+    SELECTOR_SYMBOL = '$'
+
+    COMBINATION_OPERATORS = %I[
+      and
+      or
+      not
+      nor
+      all
+      elemMatch
+      allMath
+    ].freeze
+
+    CONDITION_OPERATORS = %I[
+      lt
+      lte
+      eq
+      ne
+      gte
+      gt
+      exists
+      in
+      nin
+      size
+      mod
+      regex
+    ].freeze
+
+    TYPE_OPERATOR = %I[
+      type
+      $type
+    ]
+
+    ALL_OPERATORS = COMBINATION_OPERATORS + CONDITION_OPERATORS
+
+    DESIGN = '_find'
+
+    def find_by(query, opts = {})
+      build_model_from_doc(find_doc_by(query, opts))
+    end
+
+    def find_doc_by(query, opts = {})
+      opts.merge!(limit: 1)
+      response = perform_query(build_query(query, opts))
+      print_index_warning(query) if response.fetch(:warning, nil)
+      response[:docs].first
+    end
+
+    def where(query, opts = {})
+      docs_where(query, opts).map do |doc|
+        build_model_from_doc(doc)
+      end
+    end
+
+    def docs_where(query, opts = {})
+      response = perform_query(build_query(query, opts))
+      print_index_warning(query) if response.fetch(:warning, nil)
+      response[:docs]
+    end
+
+    def find_bare(id, fields, options = {})
+      q = { _id: id }
+      opts = { fields: fields }.merge(options)
+      query = build_query(q, opts)
+      response = perform_query(query)
+      response[:docs]
+    end
+
+    def where_bare(selector, fields, options = {})
+      opts = { fields: fields }.merge(options)
+      query = build_query(selector, opts)
+      response = perform_query(query)
+      response[:docs]
+    end
+
+    def find_with_metadata(query, options = {})
+      opts = options.merge!(limit: 1)
+      perform_query(build_query(query, opts))
+    end
+
+    def where_with_metadata(query, options = {})
+      perform_query(build_query(query, options))
+    end
+
+    def perform_query(structured_query)
+      connection.post(DESIGN, structured_query)
+    end
+
+    private
+
+    def print_index_warning(query)
+      message = "Index not found for #{query.inspect}"
+      if (defined?(Rails.logger) && Rails&.env&.development?)
+        Rails.logger.info(message)
+      else
+        puts message
+      end
+    end
+
+    def build_model_from_doc(doc)
+      return nil if doc.nil?
+      new(doc.slice(*all_property_keys)).tap { |d| d.rev = doc[:_rev] }
+    end
+
+    def build_query(query, opts)
+      { 'selector' => build_selectors(query) }.merge(opts)
+    end
+
+    def build_selectors(query)
+      query.deep_transform_keys do |key|
+        next build_key(key) if is_operator?(key)
+        next key if is_type_operator?(key)
+        raise Dolly::InvalidMangoOperatorError.new(key) unless has_property?(key)
+        key
+      end
+    end
+
+    def build_key(key)
+      return key if key.to_s.starts_with?(SELECTOR_SYMBOL)
+      "#{SELECTOR_SYMBOL}#{key}"
+    end
+
+    def is_operator?(key)
+      ALL_OPERATORS.include?(key) || key.to_s.starts_with?(SELECTOR_SYMBOL)
+    end
+
+    def fetch_fields(query)
+      deep_keys(query).reject do |key|
+        is_operator?(key) || is_type_operator?(key)
+      end
+    end
+
+    def has_property?(key)
+      self.all_property_keys.include?(key)
+    end
+
+    def is_type_operator?(key)
+      TYPE_OPERATOR.include?(key.to_sym)
+    end
+
+    def deep_keys(obj)
+      case obj
+      when Hash then obj.keys + obj.values.flat_map { |v| deep_keys(v) }
+      when Array then obj.flat_map { |i| deep_keys(i) }
+      else []
+      end
+    end
+  end
+end

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.include?(key) }
+    end
+  end
+end

data/lib/dolly/property.rb

@@ -1,85 +1,96 @@
+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__}"
+    def cast_value(value)
+      return set_default if value.nil?
+      return value unless class_name
+      return self_klass.new(value) unless respond_to?(klass_sym)
+      send(klass_sym, value)
+    end
 
-      return self_klass.new @value unless self.respond_to?(klass_sym)
+    def boolean?
+      [TrueClass, FalseClass].include?(class_name)
+    end
 
-      self.send klass_sym
+    def string_value(value)
+      value.to_s
     end
 
-    def array_value
-      @value.to_a
+    def hash_value(value)
+      value.to_h
     end
 
-    def hash_value
-      @value.to_h
+    def integer_value(value)
+      value.to_i
     end
 
-    def string_value
-      @value.to_s
+    def float_value(value)
+      value.to_f
     end
 
-    def integer_value
-      @value.to_i
+    def date_value(value)
+      return value.to_date if value.respond_to?(:to_date)
+      Date.parse(value)
     end
 
-    def float_value
-      @value.to_f
+    def time_value(value)
+      return value.to_time if value.respond_to?(:to_time)
+      DateTime.parse(value).to_time
     end
 
-    def date_value
-      @value.to_date
+    def date_time_value(value)
+      return value.to_datetime if value.respond_to?(:to_datetime)
+      DateTime.parse(value)
     end
 
-    def time_value
-      @value.to_time
+    def true_class_value(value)
+      truthy_value?(value)
     end
 
-    def date_time_value
-      @value.to_datetime
+    def false_class_value(value)
+      truthy_value?(value)
     end
 
-    def true_class_value
-      truthy_value?
+    private
+
+    def truthy_value?(value)
+      value =~ /true/ || value === true
     end
 
-    def false_class_value
-      truthy_value?
+    def klass_sym
+      :"#{self_klass.name.underscore}_value"
     end
 
-    def boolean?
-      self_klass == TrueClass || self_klass == FalseClass
+    def self_klass
+      return unless class_name
+      return class_name if class_name.is_a?(Class)
+      Object.const_get class_name
     end
 
-    private
-    def truthy_value?
-      @value =~ /true/ || @value === true
+    def set_default
+      return unless default_present?
+      return default unless cant_clone_default?
+      default.clone
     end
 
-    def self_klass
-      return unless @class_name
-      @class_name.is_a?(Class)? @class_name : @class_name.constantize
+    def cant_clone_default?
+      CANT_CLONE.none? { |klass| default.is_a? klass }
     end
 
+    def default_present?
+      !default.nil?
+    end
   end
 end