nobrainer 0.22.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c53755e5f9ec902612c417fcf053404cf114ca0b
-  data.tar.gz: 529fe4b627d366ba4813fd6ff750192caf0df316
+  metadata.gz: f77c9211fbf5a8c8fb7a695542b862cfd693ed82
+  data.tar.gz: 72bd41593dfbb997eb1dd72a70c00c08f75f4124
 SHA512:
-  metadata.gz: 920d6b1c7bec9acd28b4a0e7f54a9967d068a01d31174396ca961eaf8cbfec31e3b8397ab2242ac87c73b9ca3789e80b47c8ca4b809d7a71b5fa80aeedb81f4b
-  data.tar.gz: 92144b91eb03ac14d2a01ea5244480b215286228691e5406a9f7bcf218499853ecfb0d1313f1380f62d509d97dc2bb1dac65ae8e97c0c2c3cc2b7b4c3835e1c2
+  metadata.gz: fd5ca8440015b18adfc34f61bb7862e15bc445a459cf1c2310843c3c7194862f1d1abecd72c4ce14a7501a6345704fea20f49b332331b227d8ee0309494a36bb
+  data.tar.gz: cd4d1d5b1e8cb9ee69eed9b6a0956626e407fd3e1c1bf9e60bedd502def6c0adbe8684826afde573dde490ae6db0842cb602eb03b2025166780574bb17c474a5

data/lib/no_brainer/criteria/enumerable.rb

@@ -21,4 +21,6 @@ module NoBrainer::Criteria::Enumerable
     return super unless [].respond_to?(name)
     to_a.__send__(name, *args, &block)
   end
+
+  delegate :as_json, :to => :each
 end

data/lib/no_brainer/criteria/where.rb

@@ -401,7 +401,8 @@ module NoBrainer::Criteria::Where
         options[:right_bound] = {:lt => :open, :le => :closed}[right_bound.op] if right_bound
 
         return IndexStrategy.new(self, ast, [left_bound, right_bound].compact, index, :between,
-                                 [left_bound.try(:value), right_bound.try(:value)], options)
+                                 [left_bound  ? left_bound.try(:value)  : RethinkDB::RQL.new.minval,
+                                  right_bound ? right_bound.try(:value) : RethinkDB::RQL.new.maxval], options)
       end
       return nil
     end

data/lib/no_brainer/document/association/belongs_to.rb

@@ -7,17 +7,14 @@ class NoBrainer::Document::Association::BelongsTo
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
-      # TODO test :foreign_key
       options[:foreign_key].try(:to_sym) || :"#{target_name}_#{primary_key}"
     end
 
     def primary_key
-      # TODO test :primary_key
       options[:primary_key].try(:to_sym) || target_model.pk_name
     end
 
     def target_model
-      # TODO test :class_name
       (options[:class_name] || target_name.to_s.camelize).constantize
     end
 
@@ -27,15 +24,30 @@ class NoBrainer::Document::Association::BelongsTo
 
     def hook
       super
+      # XXX We are loading the target_model unless the primary_key is not
+      # specified. This may eager load a part of the application.
+      # Oh well.
 
-      # TODO It would be good to set the type we want to work with, but because
-      # the target class is eager loaded, we are not doing it.
-      # This would have the effect of loading all the models because they
-      # are likely to be related to each other. So we don't know the type
-      # of the primary key of the target.
+      # TODO if the primary key of the target_model changes, we need to revisit
+      # our default foreign_key/primary_key value
+
+      # TODO set the type of the foreign key to be the same as the target's primary key
       owner_model.field(foreign_key, :store_as => options[:foreign_key_store_as], :index => options[:index])
-      owner_model.validates(target_name, :presence => options[:required]) if options[:required]
-      owner_model.validates(target_name, options[:validates]) if options[:validates]
+
+      unless options[:validates] == false
+        owner_model.validates(target_name, options[:validates]) if options[:validates]
+
+        if options[:required]
+          owner_model.validates(target_name, :presence => options[:required])
+        else
+          # Always validate the validity of the foreign_key if not nil.
+          owner_model.validates_each(foreign_key) do |doc, attr, value|
+            if !value.nil? && doc.read_attribute_for_validation(target_name).nil?
+              doc.errors.add(attr, :invalid_foreign_key, :target_model => target_model, :primary_key => primary_key)
+            end
+          end
+        end
+      end
 
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
       delegate("#{target_name}_changed?", "#{foreign_key}_changed?", :to => :self)
@@ -64,7 +76,7 @@ class NoBrainer::Document::Association::BelongsTo
 
   def write(target)
     assert_target_type(target)
-    owner.write_attribute(foreign_key, target.try(:pk_value))
+    owner.write_attribute(foreign_key, target.try(primary_key))
     preload(target)
   end
 

data/lib/no_brainer/document/association/has_many.rb

@@ -7,17 +7,14 @@ class NoBrainer::Document::Association::HasMany
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
-      # TODO test :foreign_key
-      options[:foreign_key].try(:to_sym) || :"#{owner_model.name.underscore}_#{owner_model.pk_name}"
+      options[:foreign_key].try(:to_sym) || :"#{owner_model.name.underscore}_#{primary_key}"
     end
 
     def primary_key
-      # TODO test :primary_key
-      options[:primary_key].try(:to_sym) || target_model.pk_name
+      options[:primary_key].try(:to_sym) || owner_model.pk_name
     end
 
     def target_model
-      # TODO test :class_name
       (options[:class_name] || target_name.to_s.singularize.camelize).constantize
     end
 
@@ -60,7 +57,7 @@ class NoBrainer::Document::Association::HasMany
   end
 
   def target_criteria
-    @target_criteria ||= base_criteria.where(foreign_key => owner.pk_value)
+    @target_criteria ||= base_criteria.where(foreign_key => owner.__send__(primary_key))
                                       .after_find(set_inverse_proc)
   end
 

data/lib/no_brainer/document/dirty.rb

@@ -17,7 +17,9 @@ module NoBrainer::Document::Dirty
   def clear_dirtiness(options={})
     if options[:keep_ivars] && options[:missing_attributes].try(:[], :pluck)
       attrs = options[:missing_attributes][:pluck].keys
-      @_old_attributes = @_old_attributes.reject { |k,v| attrs.include?(k) } else @_old_attributes = {}.with_indifferent_access
+      @_old_attributes = @_old_attributes.reject { |k,v| attrs.include?(k) }
+    else
+      @_old_attributes = {}.with_indifferent_access
     end
 
     @_old_attributes_keys = @_attributes.keys # to track undefined -> nil changes

data/lib/no_brainer/locale/en.yml

@@ -4,3 +4,4 @@ en:
       taken: "is already taken"
       invalid_type: "should be a %{type}"
       undefined: "must be defined"
+      invalid_foreign_key: "is an invalid foreign key: %{target_model}(%{primary_key}: %{value}) is not found"

data/lib/no_brainer/{query_runner/logger.rb → logger.rb}

@@ -1,16 +1,9 @@
-class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
-  def call(env)
-    start_time = Time.now
-    @runner.call(env).tap { log_query(env, start_time) }
-  rescue Exception => e
-    log_query(env, start_time, e)
-    raise e
-  end
-
-  private
-
-  def log_query(env, start_time, exception=nil)
-    return if handle_on_demand_exception?(env, exception)
+class NoBrainer::Logger
+  def on_query(env)
+    # env[:end_time] = Time.now
+    # env[:duration] = env[:end_time] - env[:start_time]
+    # env[:exception] = exception
+    # env[:query_type] = NoBrainer::RQL.type_of(env[:query])
 
     not_indexed = env[:criteria] && env[:criteria].where_present? &&
                     !env[:criteria].where_indexed? &&
@@ -20,8 +13,6 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
              not_indexed ? Logger::INFO : Logger::DEBUG
     return if NoBrainer.logger.nil? || NoBrainer.logger.level > level
 
-    duration = Time.now - start_time
-
     msg_duration = (duration * 1000.0).round(1).to_s
     msg_duration = " " * [0, 6 - msg_duration.size].max + msg_duration
     msg_duration = "[#{msg_duration}ms] "
@@ -52,10 +43,4 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
     msg = [msg_duration, msg_db, msg_query, msg_exception, msg_last].join
     NoBrainer.logger.add(level, msg)
   end
-
-  def handle_on_demand_exception?(env, e)
-    # pretty gross I must say.
-    e && (NoBrainer::QueryRunner::DatabaseOnDemand.new(nil).handle_database_on_demand_exception?(env, e) ||
-          NoBrainer::QueryRunner::TableOnDemand.new(nil).handle_table_on_demand_exception?(env, e))
-  end
 end

data/lib/no_brainer/profiler.rb

@@ -0,0 +1,11 @@
+module NoBrainer::Profiler
+  class << self
+    attr_accessor :registered_profilers
+
+    def register(profiler)
+      self.registered_profilers << profiler
+    end
+  end
+
+  self.registered_profilers = []
+end

data/lib/no_brainer/profiler/controller_runtime.rb

@@ -0,0 +1,76 @@
+# Rails specific. TODO Test
+module NoBrainer::Profiler::ControllerRuntime
+  extend ActiveSupport::Concern
+
+  class Profiler
+    attr_accessor :write_duration, :read_duration, :other_duration
+    def initialize
+      @write_duration = @read_duration = @other_duration = 0.0
+    end
+
+    def total_duration
+      read_duration + write_duration + other_duration
+    end
+
+    def add_query(env)
+      case env[:query_type]
+      when :write      then @write_duration += env[:duration]
+      when :read       then @read_duration  += env[:duration]
+      else                  @other_duration += env[:duration]
+      end
+    end
+
+    def self.spawn_controller_profiler
+      Thread.current[:nobrainer_controller_profiler] = new
+    end
+
+    def self.cleanup_controller_profiler
+      Thread.current[:nobrainer_controller_profiler] = nil
+    end
+
+    def self.current
+      Thread.current[:nobrainer_controller_profiler]
+    end
+
+    def self.on_query(env)
+      current.try(:add_query, env)
+    end
+
+    NoBrainer::Profiler.register(self)
+  end
+
+  def process_action(action, *args)
+    Profiler.spawn_controller_profiler
+    super
+  ensure
+    Profiler.cleanup_controller_profiler
+  end
+
+  def cleanup_view_runtime
+    time_spent_in_db_before_views = Profiler.current.total_duration
+    runtime = super
+    time_spent_in_db_after_views = Profiler.current.total_duration
+
+    time_spent_in_db_during_views = (time_spent_in_db_after_views - time_spent_in_db_before_views) * 1000
+    runtime - time_spent_in_db_during_views
+  end
+
+  def append_info_to_payload(payload)
+    super
+    payload[:nobrainer_profiler] = Profiler.current
+  end
+
+  module ClassMethods # :nodoc:
+    def log_process_action(payload)
+      messages, profiler = super, payload[:nobrainer_profiler]
+      if profiler && !profiler.total_duration.zero?
+        msg = []
+        msg << "%.1fms (write)" % (profiler.write_duration * 1000) unless profiler.write_duration.zero?
+        msg << "%.1fms (read)"  % (profiler.read_duration  * 1000) unless profiler.read_duration.zero?
+        msg << "%.1fms (other)" % (profiler.other_duration * 1000) unless profiler.other_duration.zero?
+        messages << "NoBrainer: #{msg.join(", ")}"
+      end
+      messages
+    end
+  end
+end

data/lib/no_brainer/profiler/logger.rb

@@ -0,0 +1,46 @@
+class NoBrainer::Profiler::Logger
+  def on_query(env)
+    not_indexed = env[:criteria] && env[:criteria].where_present? &&
+                    !env[:criteria].where_indexed? &&
+                    !env[:criteria].model.try(:perf_warnings_disabled)
+
+    level = env[:exception] ? Logger::ERROR :
+             not_indexed ? Logger::INFO : Logger::DEBUG
+    return if NoBrainer.logger.nil? || NoBrainer.logger.level > level
+
+    msg_duration = (env[:duration] * 1000.0).round(1).to_s
+    msg_duration = " " * [0, 6 - msg_duration.size].max + msg_duration
+    msg_duration = "[#{msg_duration}ms] "
+
+    env[:query_type] = NoBrainer::RQL.type_of(env[:query])
+    env[:custom_db_name] = env[:db_name] if env[:db_name].to_s != NoBrainer.connection.parsed_uri[:db]
+
+    msg_db = "[#{env[:custom_db_name]}] " if env[:custom_db_name]
+    msg_query = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
+
+    msg_exception = "#{env[:exception].class} #{env[:exception].message.split("\n").first}" if env[:exception]
+    msg_exception ||= "perf: filtering without using an index" if not_indexed
+
+    msg_last = nil
+
+    if NoBrainer::Config.colorize_logger
+      query_color = case env[:query_type]
+                    when :write      then "\e[1;31m" # red
+                    when :read       then "\e[1;32m" # green
+                    when :management then "\e[1;33m" # yellow
+                    end
+      msg_duration = [query_color, msg_duration].join
+      msg_db = ["\e[0;34m", msg_db, query_color].join if msg_db
+      if msg_exception
+        exception_color = "\e[0;31m" if level == Logger::ERROR
+        msg_exception = ["\e[0;39m", " -- ", exception_color, msg_exception].compact.join
+      end
+      msg_last = "\e[0m"
+    end
+
+    msg = [msg_duration, msg_db, msg_query, msg_exception, msg_last].join
+    NoBrainer.logger.add(level, msg)
+  end
+
+  NoBrainer::Profiler.register(self.new)
+end

data/lib/no_brainer/query_runner.rb

@@ -11,7 +11,7 @@ module NoBrainer::QueryRunner
   end
 
   autoload :Driver, :DatabaseOnDemand, :TableOnDemand, :WriteError,
-           :Reconnect, :Selection, :RunOptions, :Logger, :MissingIndex,
+           :Reconnect, :Selection, :RunOptions, :Profiler, :MissingIndex,
            :ConnectionLock
 
   class << self
@@ -28,11 +28,11 @@ module NoBrainer::QueryRunner
   # thread-safe, since require() is ran with a mutex.
   self.stack = ::Middleware::Builder.new do
     use RunOptions
-    use WriteError
     use MissingIndex
     use DatabaseOnDemand
     use TableOnDemand
-    use Logger
+    use Profiler
+    use WriteError
     use ConnectionLock
     use Reconnect
     use Driver

data/lib/no_brainer/query_runner/profiler.rb

@@ -0,0 +1,42 @@
+class NoBrainer::QueryRunner::Profiler < NoBrainer::QueryRunner::Middleware
+  def call(env)
+    profiler_start(env)
+    @runner.call(env).tap { profiler_end(env) }
+  rescue Exception => e
+    profiler_end(env, e)
+    raise e
+  end
+
+  private
+
+  def profiler_start(env)
+    env[:start_time] = Time.now
+  end
+
+  def profiler_end(env, exception=nil)
+    return if handle_on_demand_exception?(env, exception)
+
+    env[:end_time] = Time.now
+    env[:duration] = env[:end_time] - env[:start_time]
+    env[:exception] = exception
+
+    env[:model] = env[:criteria] && env[:criteria].model
+    env[:query_type] = NoBrainer::RQL.type_of(env[:query])
+    env[:custom_db_name] = env[:db_name] if env[:db_name] && env[:db_name].to_s != NoBrainer.connection.parsed_uri[:db]
+
+    NoBrainer::Profiler.registered_profilers.each do |profiler|
+      begin
+        profiler.on_query(env)
+      rescue Exception => e
+        STDERR.puts "[NoBrainer] Profiling error: #{e.class} #{e.message}"
+      end
+    end
+  end
+
+  def handle_on_demand_exception?(env, e)
+    # pretty gross I must say.
+    e && (NoBrainer::QueryRunner::DatabaseOnDemand.new(nil).handle_database_on_demand_exception?(env, e) ||
+          NoBrainer::QueryRunner::TableOnDemand.new(nil).handle_table_on_demand_exception?(env, e))
+  end
+end
+

data/lib/no_brainer/railtie.rb

@@ -42,4 +42,9 @@ class NoBrainer::Railtie < Rails::Railtie
       NoBrainer::Loader.cleanup
     end
   end
+
+  ActiveSupport.on_load(:action_controller) do
+    require 'no_brainer/profiler/controller_runtime'
+    include NoBrainer::Profiler::ControllerRuntime
+  end
 end

data/lib/no_brainer/rql.rb

@@ -8,7 +8,9 @@ module NoBrainer::RQL
 
   def rql_proc_as_json(block)
     reset_lambda_var_counter
-    RethinkDB::RQL.new.new_func(&block).as_json
+    RethinkDB::Shim.load_json(
+      RethinkDB::Shim.dump_json(
+        RethinkDB::RQL.new.new_func(&block)))
   end
 
   def is_write_query?(rql_query)

data/lib/nobrainer.rb

@@ -13,7 +13,7 @@ module NoBrainer
 
   # We eager load things that could be loaded when handling the first web request.
   # Code that is loaded through the DSL of NoBrainer should not be eager loaded.
-  autoload :Document, :IndexManager, :Loader, :Fork, :Geo, :Lock
+  autoload :Document, :IndexManager, :Loader, :Fork, :Geo, :Lock, :Profiler
   eager_autoload :Config, :Connection, :ConnectionManager,  :Error,
                  :QueryRunner, :Criteria, :RQL
 
@@ -41,4 +41,5 @@ ActiveSupport.on_load(:i18n) do
   I18n.load_path << File.dirname(__FILE__) + '/no_brainer/locale/en.yml'
 end
 
+require 'no_brainer/profiler/logger'
 require 'no_brainer/railtie' if defined?(Rails)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.23.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-07 00:00:00.000000000 Z
+date: 2015-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.15.0.0
+        version: 2.0.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.15.0.0
+        version: 2.0.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -171,12 +171,16 @@ files:
 - lib/no_brainer/loader.rb
 - lib/no_brainer/locale/en.yml
 - lib/no_brainer/lock.rb
+- lib/no_brainer/logger.rb
+- lib/no_brainer/profiler.rb
+- lib/no_brainer/profiler/controller_runtime.rb
+- lib/no_brainer/profiler/logger.rb
 - lib/no_brainer/query_runner.rb
 - lib/no_brainer/query_runner/connection_lock.rb
 - lib/no_brainer/query_runner/database_on_demand.rb
 - lib/no_brainer/query_runner/driver.rb
-- lib/no_brainer/query_runner/logger.rb
 - lib/no_brainer/query_runner/missing_index.rb
+- lib/no_brainer/query_runner/profiler.rb
 - lib/no_brainer/query_runner/reconnect.rb
 - lib/no_brainer/query_runner/run_options.rb
 - lib/no_brainer/query_runner/table_on_demand.rb
@@ -208,7 +212,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.4
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: ORM for RethinkDB