baza_models 0.0.0 → 0.0.1

data/lib/baza_models/model/belongs_to_relations.rb

@@ -0,0 +1,49 @@
+module BazaModels::Model::BelongsToRelations
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def belongs_to(relation_name, args = {})
+      relation = {
+        type: :belongs_to,
+        relation_name: relation_name,
+        table_name: args[:table_name] || StringCases.pluralize(relation_name),
+        foreign_key: :"#{relation_name}_id"
+      }
+
+      if args[:class_name]
+        relation[:class_name] = args.fetch(:class_name)
+      else
+        relation[:class_name] = StringCases.snake_to_camel(relation_name)
+      end
+
+      @belongs_to_relations ||= []
+      @belongs_to_relations << relation
+
+      @relationships ||= {}
+      @relationships[relation_name] = relation
+
+      define_method(relation_name) do
+        if (model = @changes[relation_name])
+          model
+        elsif (model = autoloads[relation_name])
+          model
+        else
+          if relation[:class_name]
+            class_name = relation.fetch(:class_name)
+          else
+            class_name = StringCases.snake_to_camel(relation_name)
+          end
+
+          Object.const_get(class_name).find(@data.fetch(relation.fetch(:foreign_key)))
+        end
+      end
+
+      define_method("#{relation_name}=") do |new_model|
+        @changes[relation.fetch(:foreign_key)] = new_model.id
+        autoloads.delete(relation_name)
+      end
+    end
+  end
+end

data/lib/baza_models/model/custom_validations.rb

@@ -0,0 +1,24 @@
+module BazaModels::Model::CustomValidations
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    attr_reader :custom_validations
+
+    def validate(method_name)
+      @custom_validations ||= []
+      @custom_validations << method_name
+    end
+  end
+
+private
+
+  def execute_custom_validations
+    return unless self.class.custom_validations
+
+    self.class.custom_validations.each do |method_name|
+      __send__(method_name)
+    end
+  end
+end

data/lib/baza_models/model/delegation.rb

@@ -0,0 +1,21 @@
+module BazaModels::Model::Delegation
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def delegate(*methods, args)
+      methods.each do |method|
+        if args[:prefix]
+          method_name = "#{args.fetch(:to)}_#{method}"
+        else
+          method_name = method
+        end
+
+        define_method(method_name) do |*method_args, &method_blk|
+          __send__(args[:to]).__send__(method, *method_args, &method_blk)
+        end
+      end
+    end
+  end
+end

data/lib/baza_models/model/has_many_relations.rb

@@ -0,0 +1,85 @@
+module BazaModels::Model::HasManyRelations
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    # rubocop:disable Style/PredicateName
+    def has_many(relation_name, *all_args)
+      # rubocop:enable Style/PredicateName
+
+      args = all_args.pop
+
+      relation = {
+        type: :has_many,
+        relation_name: relation_name,
+        table_name: args[:table_name] || relation_name,
+        args: args,
+        all_args: all_args
+      }
+
+      if args[:foreign_key]
+        relation[:foreign_key] = args.fetch(:foreign_key)
+      else
+        relation[:foreign_key] = :"#{StringCases.camel_to_snake(name)}_id"
+      end
+
+      relation[:dependent] = args.fetch(:dependent) if args[:dependent]
+
+      if args && args[:class_name]
+        relation[:class_name] = args.fetch(:class_name)
+      else
+        relation[:class_name] = StringCases.snake_to_camel(relation_name.to_s.gsub(/s$/, ""))
+      end
+
+      @has_many_relations ||= []
+      @has_many_relations << relation
+
+      @relationships ||= {}
+      @relationships[relation_name] = relation
+
+      define_method(relation_name) do
+        class_instance = Object.const_get(relation.fetch(:class_name))
+        query = class_instance.where(relation.fetch(:foreign_key) => id)
+        query._previous_model = self
+        query._relation = relation
+
+        all_args.each do |arg|
+          query = query.instance_exec(&arg) if arg.is_a?(Proc)
+        end
+
+        return query
+      end
+    end
+  end
+
+private
+
+  def restrict_has_many_relations
+    self.class.relationships.each do |relation_name, relation|
+      next if relation.fetch(:type) != :has_many || relation[:dependent] != :restrict_with_error
+
+      if __send__(relation_name).any?
+        errors.add(:base, "can't be destroyed because it contains #{relation_name}")
+        return false
+      end
+    end
+
+    true
+  end
+
+  def destroy_has_many_relations
+    self.class.relationships.each do |relation_name, relation|
+      next if relation.fetch(:type) != :has_many || relation[:dependent] != :destroy
+
+      __send__(relation_name).each do |model|
+        unless model.destroy
+          errors.add(:base, model.errors.full_messages.join(". "))
+          return false
+        end
+      end
+    end
+
+    true
+  end
+end

data/lib/baza_models/model/has_one_relations.rb

@@ -0,0 +1,93 @@
+module BazaModels::Model::HasOneRelations
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    # rubocop:disable Style/PredicateName
+    def has_one(relation_name, *all_args)
+      # rubocop:enable Style/PredicateName
+
+      args = all_args.pop
+
+      relation = {
+        type: :has_one,
+        relation_name: relation_name,
+        table_name: args[:table_name] || StringCases.pluralize(relation_name),
+        args: args,
+        all_args: all_args
+      }
+
+      if args[:foreign_key]
+        relation[:foreign_key] = args.fetch(:foreign_key)
+      else
+        relation[:foreign_key] = :"#{StringCases.camel_to_snake(name)}_id"
+      end
+
+      relation[:dependent] = args.fetch(:dependent) if args[:dependent]
+
+      if args && args[:class_name]
+        relation[:class_name] = args.fetch(:class_name)
+      else
+        relation[:class_name] = StringCases.snake_to_camel(relation_name)
+      end
+
+      @has_one_relations ||= []
+      @has_one_relations << relation
+
+      relationships[relation_name] = relation
+
+      define_method(relation_name) do
+        if (model = autoloads[relation_name])
+          model
+        else
+          if relation[:args][:through]
+            __send__(relation[:args][:through]).__send__(relation_name)
+          else
+            class_instance = Object.const_get(relation.fetch(:class_name))
+
+            query = class_instance.where(relation.fetch(:foreign_key) => id)
+            query._previous_model = self
+            query._relation = relation
+
+            all_args.each do |arg|
+              query = query.instance_exec(&arg) if arg.is_a?(Proc)
+            end
+
+            query.first
+          end
+        end
+      end
+    end
+  end
+
+private
+
+  def restrict_has_one_relations
+    self.class.relationships.each do |relation_name, relation|
+      next if relation.fetch(:type) != :has_one || relation[:dependent] != :restrict_with_error
+
+      if __send__(relation_name)
+        errors.add(:base, "can't be destroyed because it contains #{relation_name}")
+        return false
+      end
+    end
+
+    true
+  end
+
+  def destroy_has_one_relations
+    self.class.relationships.each do |relation_name, relation|
+      next if relation.fetch(:type) != :has_one || relation[:dependent] != :destroy
+
+      model = __send__(relation_name)
+
+      if model && !model.destroy
+        errors.add(:base, model.errors.full_messages.join(". "))
+        return false
+      end
+    end
+
+    true
+  end
+end

data/lib/baza_models/model/manipulation.rb

@@ -0,0 +1,123 @@
+module BazaModels::Model::Manipulation
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def save(args = {})
+    if args[:validate] == false || valid?
+      new_record = new_record?
+      fire_callbacks(:before_save)
+      self.updated_at = Time.now if has_attribute?(:updated_at)
+
+      if new_record
+        status = create
+      else
+        db.update(table_name, @changes, id: id)
+        status = true
+      end
+
+      return false unless status
+
+      @changes = {}
+      @new_record = false
+      reload
+
+      fire_callbacks(:after_save)
+      fire_callbacks(:after_create) if new_record
+
+      return true
+    else
+      return false
+    end
+  end
+
+  def create
+    unless new_record?
+      errors.add(:base, "cannot create unless new record")
+      return false
+    end
+
+    fire_callbacks(:before_create)
+    self.created_at = Time.now if has_attribute?(:created_at) && !created_at?
+
+    @data[:id] = db.insert(table_name, @changes, return_id: true)
+
+    if @autoloads
+      @autoloads.each do |relation_name, collection|
+        relation = self.class.relationships.fetch(relation_name)
+
+        collection.each do |model|
+          model.assign_attributes(relation.fetch(:foreign_key) => id)
+          model.create! if model.new_record?
+        end
+      end
+    end
+
+    true
+  end
+
+  def create!
+    if create
+      return true
+    else
+      raise BazaModels::Errors::InvalidRecord, errors.full_messages.join(". ")
+    end
+  end
+
+  def save!(args = {})
+    if save(args)
+      return true
+    else
+      raise BazaModels::Errors::InvalidRecord, errors.full_messages.join(". ")
+    end
+  end
+
+  def update_attributes(attributes)
+    assign_attributes(attributes)
+    save
+  end
+
+  def update_attributes!(attributes)
+    raise BazaModels::Errors::InvalidRecord, @errors.full_messages.join(". ") unless update_attributes(attributes)
+  end
+
+  def assign_attributes(attributes)
+    @changes.merge!(real_attributes(attributes))
+  end
+
+  def destroy
+    if new_record?
+      errors.add(:base, "cannot destroy new record")
+      return false
+    else
+      fire_callbacks(:before_destroy)
+
+      return false unless restrict_has_one_relations
+      return false unless restrict_has_many_relations
+      return false unless destroy_has_one_relations
+      return false unless destroy_has_many_relations
+
+      db.delete(table_name, id: id)
+      fire_callbacks(:after_destroy)
+      return true
+    end
+  end
+
+  def destroy!
+    raise BazaModels::Errors::InvalidRecord, @errors.full_messages.join(". ") unless destroy
+  end
+
+  module ClassMethods
+    def create(data = {})
+      model = new(data)
+      model.save
+      model
+    end
+
+    def create!(data = {})
+      model = new(data)
+      model.save!
+      model
+    end
+  end
+end

data/lib/baza_models/model/queries.rb

@@ -0,0 +1,45 @@
+module BazaModels::Model::Queries
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def find(id)
+      row = db.select(table_name, {id: id}, limit: 1).fetch
+      raise BazaModels::Errors::RecordNotFound, "Record not found by ID: #{id}" unless row
+      new(row, init: true)
+    end
+
+    def find_by(where_hash)
+      row = db.select(table_name, where_hash, limit: 1).fetch
+      return new(row, init: true) if row
+      false
+    end
+
+    def find_by!(where_hash)
+      model = find_by(where_hash)
+      return model if model
+      raise BazaModels::Errors::RecordNotFound, "Record not found by arguments: #{where_hash}" unless model
+    end
+
+    def find_or_initialize_by(data)
+      model = find_by(data)
+      return model if model
+      new(data)
+    end
+
+    def find_or_create_by(data)
+      model = find_or_initialize_by(data)
+      model.save if model.new_record?
+      yield model if block_given?
+      model
+    end
+
+    def find_or_create_by!(data)
+      model = find_or_initialize_by(data)
+      model.save! if model.new_record?
+      yield model if block_given?
+      model
+    end
+  end
+end