ardb 0.28.1 → 0.29.2

data/lib/ardb/db_tests.rb

@@ -1,8 +1,9 @@
-require 'active_record'
-require 'assert'
+# frozen_string_literal: true
 
-module Ardb
+require "active_record"
+require "assert"
 
+module Ardb
   class DbTests < Assert::Context
     around do |block|
       ActiveRecord::Base.transaction do
@@ -11,5 +12,4 @@ module Ardb
       end
     end
   end
-
 end

data/lib/ardb/default_order_by.rb

@@ -1,59 +1,51 @@
-require 'much-plugin'
+# frozen_string_literal: true
 
-module Ardb
+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
-      extend ClassMethods
-      include InstanceMethods
-
+    mixin_included do
       @ardb_default_order_by_config = {}
-
     end
 
-    module ClassMethods
-
+    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
         @ardb_default_order_by_config
       end
-
     end
 
-    module InstanceMethods
-
+    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
-
   end
 end

data/lib/ardb/migration.rb

@@ -1,8 +1,10 @@
-require 'fileutils'
+# frozen_string_literal: true
 
-module Ardb
+require "fileutils"
 
+module Ardb
   class Migration
+    NoIdentifierError = Class.new(ArgumentError)
 
     attr_reader :migrations_path, :identifier
     attr_reader :class_name, :file_name, :file_path, :source
@@ -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")
-
-      @source = "require 'ardb/migration_helpers'\n\n" \
-                "class #{@class_name} < ActiveRecord::Migration\n" \
-                "  include Ardb::MigrationHelpers\n\n" \
-                "  def change\n" \
-                "  end\n\n" \
-                "end\n"
+      @file_path  = File.join(migrations_path, "#{@file_name}.rb")
+
+      migration_version = ActiveRecord::Migration.current_version
+      @source =
+        "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
 
@@ -36,9 +39,5 @@ module Ardb
     def get_file_name(identifier)
       "#{Time.now.strftime("%Y%m%d%H%M%S")}_#{identifier.underscore}"
     end
-
-    NoIdentifierError = Class.new(ArgumentError)
-
   end
-
 end

data/lib/ardb/record_spy.rb

@@ -1,26 +1,23 @@
-require 'arel'
-require 'much-plugin'
-require 'ardb/relation_spy'
+# frozen_string_literal: true
 
-module Ardb
+require "arel"
+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
     end
 
-    plugin_included do
-      extend ClassMethods
-      include InstanceMethods
-    end
-
-    module ClassMethods
+    CallbackType = Struct.new(:name, :options)
 
+    mixin_class_methods do
       attr_accessor :table_name
 
       # Associations
@@ -29,19 +26,18 @@ module Ardb
         @associations ||= []
       end
 
-      [ :belongs_to, :has_one, :has_many ].each do |method_name|
-
+      [: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
 
       # Validations
@@ -50,7 +46,8 @@ module Ardb
         @validations ||= []
       end
 
-      [ :validates_acceptance_of,
+      [
+        :validates_acceptance_of,
         :validates_confirmation_of,
         :validates_exclusion_of,
         :validates_format_of,
@@ -59,30 +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
@@ -91,7 +87,8 @@ module Ardb
 
       # Callbacks
 
-      [ :before_validation,
+      [
+        :before_validation,
         :after_validation,
         :before_create,
         :around_create,
@@ -108,13 +105,11 @@ 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
 
       def custom_callback_types
@@ -122,23 +117,21 @@ 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
       end
 
-      CallbackType = Struct.new(:name, :options)
-
       # Scopes
 
       attr_writer :relation_spy
@@ -147,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,
@@ -168,23 +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
 
-    module InstanceMethods
-
+    mixin_instance_methods do
       attr_accessor :id
 
       def update_column(col, value)
-        self.send("#{col}=", value)
+        send("#{col}=", value)
       end
 
       def manually_run_callbacks
@@ -192,10 +182,9 @@ 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
 
     class Association
@@ -212,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
@@ -221,21 +210,17 @@ 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
-
 end

data/lib/ardb/relation_spy.rb

@@ -1,7 +1,7 @@
-module Ardb
+# frozen_string_literal: true
 
+module Ardb
   class RelationSpy
-
     attr_reader :applied
     attr_accessor :limit_value, :offset_value
     attr_accessor :pluck_values, :maximum_values, :minimum_values
@@ -23,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
@@ -39,52 +39,50 @@ 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
       end
-
     end
 
     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)
@@ -93,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)
@@ -108,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
@@ -147,12 +145,10 @@ module Ardb
 
     class AppliedExpression < Struct.new(:type, :args)
       def to_sql
-        "#{self.type}: #{self.args.inspect}"
+        "#{type}: #{args.inspect}"
       end
     end
 
     NotFoundError = Class.new(RuntimeError)
-
   end
-
 end