ardb 0.29.1 → 0.29.2

data/lib/ardb/db_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record"
 require "assert"
 

data/lib/ardb/default_order_by.rb

@@ -1,26 +1,28 @@
-require "much-plugin"
+# frozen_string_literal: true
+
+require "much-mixin"
 
 module Ardb
   module DefaultOrderBy
-    include MuchPlugin
+    include MuchMixin
 
     DEFAULT_ATTRIBUTE  = :order_by
     DEFAULT_SCOPE_PROC = proc{ self.class.scoped }
 
-    plugin_included do
+    mixin_included do
       @ardb_default_order_by_config = {}
     end
 
-    plugin_class_methods do
+    mixin_class_methods do
       def default_order_by(options = nil)
         options ||= {}
 
         @ardb_default_order_by_config.merge!({
-          :attribute  => options[:attribute] || DEFAULT_ATTRIBUTE,
-          :scope_proc => options[:scope]     || DEFAULT_SCOPE_PROC
+          attribute: options[:attribute] || DEFAULT_ATTRIBUTE,
+          scope_proc: options[:scope] || DEFAULT_SCOPE_PROC,
         })
 
-        before_validation :ardb_default_order_by, :on => :create
+        before_validation :ardb_default_order_by, on: :create
       end
 
       def ardb_default_order_by_config
@@ -28,20 +30,20 @@ module Ardb
       end
     end
 
-    plugin_instance_methods do
+    mixin_instance_methods do
       private
 
       def reset_order_by
         attr_name  = self.class.ardb_default_order_by_config[:attribute]
         scope_proc = self.class.ardb_default_order_by_config[:scope_proc]
 
-        current_max = self.instance_eval(&scope_proc).maximum(attr_name) || 0
-        self.send("#{attr_name}=", current_max + 1)
+        current_max = instance_eval(&scope_proc).maximum(attr_name) || 0
+        send("#{attr_name}=", current_max + 1)
       end
 
       def ardb_default_order_by
         attr_name = self.class.ardb_default_order_by_config[:attribute]
-        reset_order_by if self.send(attr_name).to_s.empty?
+        reset_order_by if send(attr_name).to_s.empty?
         true
       end
     end

data/lib/ardb/migration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "fileutils"
 
 module Ardb
@@ -15,19 +17,20 @@ module Ardb
 
       @class_name = @identifier.classify.pluralize
       @file_name  = get_file_name(@identifier)
-      @file_path  = File.join(self.migrations_path, "#{@file_name}.rb")
+      @file_path  = File.join(migrations_path, "#{@file_name}.rb")
 
       migration_version = ActiveRecord::Migration.current_version
       @source =
-        "class #{@class_name} < ActiveRecord::Migration[#{migration_version}]\n"\
+        "class #{@class_name} "\
+        "< ActiveRecord::Migration[#{migration_version}]\n"\
         "  def change\n"\
         "  end\n"\
         "end\n"
     end
 
     def save!
-      FileUtils.mkdir_p self.migrations_path
-      File.open(self.file_path, "w"){ |f| f.write(self.source) }
+      FileUtils.mkdir_p migrations_path
+      File.open(file_path, "w"){ |f| f.write(source) }
       self
     end
 

data/lib/ardb/record_spy.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require "arel"
-require "much-plugin"
+require "much-mixin"
 require "ardb/relation_spy"
 
 module Ardb
   module RecordSpy
-    include MuchPlugin
+    include MuchMixin
 
     def self.new(&block)
-      block ||= proc{ }
+      block ||= proc{}
       record_spy = Class.new{ include Ardb::RecordSpy }
       record_spy.class_eval(&block)
       record_spy
@@ -15,7 +17,7 @@ module Ardb
 
     CallbackType = Struct.new(:name, :options)
 
-    plugin_class_methods do
+    mixin_class_methods do
       attr_accessor :table_name
 
       # Associations
@@ -27,13 +29,14 @@ module Ardb
       [:belongs_to, :has_one, :has_many].each do |method_name|
         define_method(method_name) do |assoc_name, *args|
           define_method(assoc_name) do
-            instance_variable_get("@#{assoc_name}") || (method_name == :has_many ? [] : nil)
+            instance_variable_get("@#{assoc_name}") ||
+            (method_name == :has_many ? [] : nil)
           end
           define_method("#{assoc_name}=") do |value|
             instance_variable_set("@#{assoc_name}", value)
           end
 
-          self.associations << Association.new(method_name, assoc_name, *args)
+          associations << Association.new(method_name, assoc_name, *args)
         end
       end
 
@@ -43,7 +46,8 @@ module Ardb
         @validations ||= []
       end
 
-      [ :validates_acceptance_of,
+      [
+        :validates_acceptance_of,
         :validates_confirmation_of,
         :validates_exclusion_of,
         :validates_format_of,
@@ -52,29 +56,29 @@ module Ardb
         :validates_numericality_of,
         :validates_presence_of,
         :validates_size_of,
-        :validates_uniqueness_of
+        :validates_uniqueness_of,
       ].each do |method_name|
         type = method_name.to_s.match(/\Avalidates_(.+)_of\Z/)[1]
 
         define_method(method_name) do |*args|
-          self.validations << Validation.new(type, *args)
+          validations << Validation.new(type, *args)
         end
       end
 
       def validates_associated(*args)
-        self.validations << Validation.new(:associated, *args)
+        validations << Validation.new(:associated, *args)
       end
 
       def validates_with(*args)
-        self.validations << Validation.new(:with, *args)
+        validations << Validation.new(:with, *args)
       end
 
       def validates_each(*args, &block)
-        self.validations << Validation.new(:each, *args, &block)
+        validations << Validation.new(:each, *args, &block)
       end
 
       def validate(method_name = nil, &block)
-        self.validations << Validation.new(:custom, method_name, &block)
+        validations << Validation.new(:custom, method_name, &block)
       end
 
       def callbacks
@@ -83,7 +87,8 @@ module Ardb
 
       # Callbacks
 
-      [ :before_validation,
+      [
+        :before_validation,
         :after_validation,
         :before_create,
         :around_create,
@@ -100,10 +105,10 @@ module Ardb
         :after_commit,
         :after_rollback,
         :after_initialize,
-        :after_find
+        :after_find,
       ].each do |method_name|
         define_method(method_name) do |*args, &block|
-          self.callbacks << Callback.new(method_name, *args, &block)
+          callbacks << Callback.new(method_name, *args, &block)
         end
       end
 
@@ -112,16 +117,16 @@ module Ardb
       end
 
       def define_model_callbacks(*args)
-        options   = args.last.kind_of?(Hash) ? args.pop : {}
+        options   = args.last.is_a?(Hash) ? args.pop : {}
         types     = options[:only] || [:before, :around, :after]
         metaclass = class << self; self; end
 
         args.each do |name|
-          self.custom_callback_types << CallbackType.new(name, options)
+          custom_callback_types << CallbackType.new(name, options)
           types.each do |type|
             method_name = "#{type}_#{name}"
             metaclass.send(:define_method, method_name) do |*args, &block|
-              self.callbacks << Callback.new(method_name, *args, &block)
+              callbacks << Callback.new(method_name, *args, &block)
             end
           end
         end
@@ -135,14 +140,15 @@ module Ardb
       end
 
       def arel_table
-        @arel_table ||= Arel::Table.new(self.table_name)
+        @arel_table ||= Arel::Table.new(table_name)
       end
 
       def scoped
-        self.relation_spy
+        relation_spy
       end
 
-      [ :select,
+      [
+        :select,
         :from,
         :includes,
         :joins,
@@ -156,19 +162,19 @@ module Ardb
         :offset,
         :merge,
         :except,
-        :only
+        :only,
       ].each do |method_name|
         define_method(method_name) do |*args|
-          self.relation_spy.send(method_name, *args)
+          relation_spy.send(method_name, *args)
         end
       end
     end
 
-    plugin_instance_methods do
+    mixin_instance_methods do
       attr_accessor :id
 
       def update_column(col, value)
-        self.send("#{col}=", value)
+        send("#{col}=", value)
       end
 
       def manually_run_callbacks
@@ -176,8 +182,8 @@ module Ardb
       end
 
       def run_callbacks(name, &block)
-        self.manually_run_callbacks << name
-        block.call if block
+        manually_run_callbacks << name
+        block&.call
       end
     end
 
@@ -195,8 +201,8 @@ module Ardb
       attr_reader :type, :args, :options, :block
 
       def initialize(type, *args, &block)
-        @type  = type.to_sym
-        @options = args.last.kind_of?(::Hash) ? args.pop : {}
+        @type = type.to_sym
+        @options = args.last.is_a?(::Hash) ? args.pop : {}
         @args  = args
         @block = block
       end
@@ -204,18 +210,16 @@ module Ardb
 
     class Validation
       attr_reader :type, :args, :options, :method_name, :block
-      alias :columns :args
-      alias :associations :args
-      alias :classes :args
+      alias_method :columns, :args
+      alias_method :associations, :args
+      alias_method :classes, :args
 
       def initialize(type, *args, &block)
-        @type  = type.to_sym
-        @options = args.last.kind_of?(::Hash) ? args.pop : {}
+        @type = type.to_sym
+        @options = args.last.is_a?(::Hash) ? args.pop : {}
         @args = args
         @block = block
-        if @type == :custom
-          @method_name = @args.first
-        end
+        @method_name = @args.first if @type == :custom
       end
     end
   end

data/lib/ardb/relation_spy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ardb
   class RelationSpy
     attr_reader :applied
@@ -21,7 +23,7 @@ module Ardb
     end
 
     def ==(other)
-      other.kind_of?(self.class) ? @applied == other.applied : super
+      other.is_a?(self.class) ? @applied == other.applied : super
     end
 
     def to_sql
@@ -37,17 +39,17 @@ module Ardb
 
     # ActiveRecord::QueryMethods
 
-    [ :select,
-      :from,
-      :includes,
-      :joins,
-      :where,
-      :group,
-      :having,
-      :order,
-      :reverse_order,
-      :readonly
-    ].each do |type|
+    [:select,
+     :from,
+     :includes,
+     :joins,
+     :where,
+     :group,
+     :having,
+     :order,
+     :reverse_order,
+     :readonly,
+].each do |type|
       define_method(type) do |*args|
         @applied << AppliedExpression.new(type, args)
         self
@@ -56,31 +58,31 @@ module Ardb
 
     def limit(value)
       @limit_value = value ? value.to_i : nil
-      @applied << AppliedExpression.new(:limit, [ value ])
+      @applied << AppliedExpression.new(:limit, [value])
       self
     end
 
     def offset(value)
       @offset_value = value ? value.to_i : nil
-      @applied << AppliedExpression.new(:offset, [ value ])
+      @applied << AppliedExpression.new(:offset, [value])
       self
     end
 
     # ActiveRecord::SpawnMethods
 
     def merge(other)
-      return self if self.equal?(other)
-      if other.kind_of?(self.class)
-        other.applied.each{ |a| self.send(a.type, *a.args) }
+      return self if equal?(other)
+      if other.is_a?(self.class)
+        other.applied.each{ |a| send(a.type, *a.args) }
       else
-        @applied << AppliedExpression.new(:merge, [ other ])
+        @applied << AppliedExpression.new(:merge, [other])
       end
       self
     end
 
     def except(*skips)
       skips = skips.map(&:to_sym)
-      self.dup.tap do |r|
+      dup.tap do |r|
         r.applied.reject!{ |a| skips.include?(a.type) }
         r.limit_value    = nil if skips.include?(:limit)
         r.offset_value   = nil if skips.include?(:offset)
@@ -89,7 +91,7 @@ module Ardb
 
     def only(*onlies)
       onlies = onlies.map(&:to_sym)
-      self.dup.tap do |r|
+      dup.tap do |r|
         r.applied.reject!{ |a| !onlies.include?(a.type) }
         r.limit_value    = nil unless onlies.include?(:limit)
         r.offset_value   = nil unless onlies.include?(:offset)
@@ -104,19 +106,19 @@ module Ardb
     end
 
     def first
-      self.all.first
+      all.first
     end
 
     def first!
-      self.first || raise(NotFoundError)
+      first || raise(NotFoundError)
     end
 
     def last
-      self.all.last
+      all.last
     end
 
     def last!
-      self.last || raise(NotFoundError)
+      last || raise(NotFoundError)
     end
 
     def all
@@ -143,7 +145,7 @@ module Ardb
 
     class AppliedExpression < Struct.new(:type, :args)
       def to_sql
-        "#{self.type}: #{self.args.inspect}"
+        "#{type}: #{args.inspect}"
       end
     end
 

data/lib/ardb/require_autoloaded_active_record_files.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # ActiveRecord makes use of autoload to load some of its components as-needed.
 # This doesn"t work well with threaded environments, and causes uninitialized
 # constants. To avoid this, this file manually requires the following files that
@@ -173,7 +175,7 @@ elsif ActiveRecord.version.segments[0] == 5
 else
   raise(
     "ActiveRecord #{ActiveRecord.version} isn't supported. "\
-    "Switch to 5.X or 6.X"
+    "Switch to 5.X or 6.X",
   )
 end