baza_models 0.0.0 → 0.0.1

data/lib/baza_models/errors.rb

@@ -1,5 +1,6 @@
 class BazaModels::Errors
   class InvalidRecord < RuntimeError; end
+  class RecordNotFound < RuntimeError; end
 
   def initialize
     @errors = {}
@@ -14,10 +15,19 @@ class BazaModels::Errors
     messages = []
 
     @errors.each do |attribute_name, errors|
-      messages += errors
+      errors.each do |error|
+        message = ""
+
+        unless attribute_name == :base
+          message << "#{StringCases.snake_to_camel(attribute_name)} "
+        end
+
+        message << error
+        messages << message
+      end
     end
 
-    return messages
+    messages
   end
 
   def empty?
@@ -27,4 +37,16 @@ class BazaModels::Errors
   def any?
     full_messages.any?
   end
+
+  def to_s
+    "#<BazaModels::Errors full_messages=\"#{full_messages}\">"
+  end
+
+  def inspect
+    to_s
+  end
+
+  def [](key)
+    @errors[key] || []
+  end
 end

data/lib/baza_models/model.rb

@@ -1,21 +1,51 @@
 require "string-cases"
 
 class BazaModels::Model
-  attr_accessor :db
+  path = "#{File.dirname(__FILE__)}/model"
+
+  autoload :BelongsToRelations, "#{path}/belongs_to_relations"
+  autoload :CustomValidations, "#{path}/custom_validations"
+  autoload :Delegation, "#{path}/delegation"
+  autoload :HasManyRelations, "#{path}/has_many_relations"
+  autoload :HasOneRelations, "#{path}/has_one_relations"
+  autoload :Manipulation, "#{path}/manipulation"
+  autoload :Queries, "#{path}/queries"
+  autoload :Scopes, "#{path}/scopes"
+  autoload :TranslationFunctionality, "#{path}/translation_functionality"
+  autoload :Validations, "#{path}/validations"
+
+  include BelongsToRelations
+  include Delegation
+  include CustomValidations
+  include HasManyRelations
+  include HasOneRelations
+  include Manipulation
+  include Queries
+  include Scopes
+  include TranslationFunctionality
+  include Validations
+
+  attr_accessor :data, :db
   attr_reader :changes, :errors
 
   # Define all callback methods.
-  CALLBACK_TYPES = [:before_create, :after_create, :before_save, :after_save, :before_destroy, :after_destroy,
+  CALLBACK_TYPES = [
+    :before_create, :after_create, :before_save, :after_save, :before_destroy, :after_destroy,
     :before_validation, :after_validation, :before_validation_on_create, :after_validation_on_create,
-    :before_validation_on_update, :after_validation_on_update]
+    :before_validation_on_update, :after_validation_on_update
+  ]
 
   CALLBACK_TYPES.each do |callback_type|
+    # rubocop:disable Style/ClassVars
     @@callbacks ||= {}
-    @@callbacks[callback_type] = []
+    # rubocop:enable Style/ClassVars
+
+    @@callbacks[callback_type] = {}
     callbacks = @@callbacks
 
-    (class << self; self; end).send(:define_method, callback_type) do |method_name, *args, &blk|
-      callbacks[callback_type] << {
+    (class << self; self; end).__send__(:define_method, callback_type) do |method_name = nil, *args, &blk|
+      callbacks[callback_type][name] ||= []
+      callbacks[callback_type][name] << {
         block: blk,
         method_name: method_name,
         args: args
@@ -23,13 +53,29 @@ class BazaModels::Model
     end
   end
 
-  def initialize(data = {})
+
+  QUERY_METHODS = [
+    :all, :any?, :empty?, :none?, :count, :first, :find_first, :last, :length, :select, :includes,
+    :joins, :group, :where, :order, :limit, :to_a, :accessible_by
+  ]
+  QUERY_METHODS.each do |query_method|
+    (class << self; self; end).__send__(:define_method, query_method) do |*args, &blk|
+      BazaModels::Query.new(model: self).__send__(query_method, *args, &blk)
+    end
+  end
+
+  def initialize(data = {}, args = {})
     self.class.init_model unless self.class.model_initialized?
 
-    @data = data
+    reset_errors
     @changes = {}
 
-    reset_errors
+    if args[:init]
+      @data = self.class.__blank_attributes.merge(real_attributes(data))
+    else
+      @data = self.class.__blank_attributes.clone
+      @changes.merge!(real_attributes(data))
+    end
 
     if @data[:id]
       @new_record = false
@@ -38,18 +84,45 @@ class BazaModels::Model
     end
   end
 
+  # rubocop:disable Style/TrivialAccessors
   def new_record?
-    return @new_record
+    # rubocop:enable Style/TrivialAccessors
+
+    @new_record
+  end
+
+  def persisted?
+    !new_record?
   end
 
   def db
     return @db if @db
-    return self.class.db
+    @db ||= self.class.db
   end
 
+  attr_writer :db
+
   def self.db
+    @db = nil if @db && @db.closed?
     return @db if @db
-    return BazaModels.primary_db
+    @db ||= BazaModels.primary_db
+    raise "No Baza database has been configured" unless @db
+    @db
+  end
+
+  def self.to_adapter
+    BazaModels::BazaOrmAdapter.new(class: self)
+  end
+
+  class << self
+    attr_writer :db, :table_name
+  end
+
+  attr_writer :table_name
+
+  def autoloads
+    @autoloads ||= {}
+    @autoloads
   end
 
   def table_name
@@ -57,172 +130,220 @@ class BazaModels::Model
   end
 
   def self.table_name
-    @table_name ||= "#{StringCases.camel_to_snake(name)}s"
+    @table_name ||= "#{StringCases.camel_to_snake(name.gsub("::", ""))}s"
   end
 
-  def self.init_model
-    @table = db.tables[table_name]
-    @table.columns.each do |column_name, column|
-      init_attribute_from_column(column)
-    end
+  def self.relationships
+    @relationships ||= {}
+  end
 
-    @model_initialized = true
+  def to_model
+    self
   end
 
-  def self.init_attribute_from_column(column)
-    column_name = column.name.to_sym
+  def self.init_model
+    @table = db.tables[table_name]
 
-    define_method(column_name) do
-      return @changes.fetch(column_name) if @changes.key?(column_name)
-      return @data.fetch(column_name)
-    end
+    @__blank_attributes ||= {}
 
-    define_method("#{column_name}_was") do
-      return @data.fetch(column_name)
+    @table.columns do |column|
+      init_attribute_from_column(column)
+      @__blank_attributes[column.name.to_sym] = nil
     end
 
-    define_method("#{column_name}=") do |new_value|
-      @changes[column_name] = new_value
-    end
+    @model_initialized = true
   end
 
-  def self.model_initialized?
-    return @model_initialized
+  def id
+    @data.fetch(:id)
   end
 
-  def self.validates(attribute_name, args)
-    args.each do |validator_name, validator_args|
-      validator_camel_name = StringCases.snake_to_camel(validator_name)
-      class_name = "#{validator_camel_name}Validator"
+  def to_param
+    id.to_s if id
+  end
 
-      @@validators ||= {}
-      @@validators[attribute_name] ||= []
-      @@validators[attribute_name] << BazaModels::Validators.const_get(class_name).new(attribute_name, args)
+  def to_key
+    if new_record?
+      nil
+    else
+      [id]
     end
   end
 
-  def id
-    return @data[:id]
+  def reload
+    @data = db.single(table_name, {id: id}, limit: 1)
+    raise BazaModels::Errors::RecordNotFound unless @data
+    @changes = {}
+    self
   end
 
-  def save
-    if valid?
-      new_record = new_record?
-      fire_callbacks(:before_save)
+  def to_s
+    if new_record?
+      "#<#{self.class.name} new!>"
+    else
+      "#<#{self.class.name} id=#{id}>"
+    end
+  end
 
-      if new_record
-        fire_callbacks(:before_create)
-        @data[:id] = db.insert(table_name, @data.merge(@changes), return_id: true)
+  def inspect
+    data_str = ""
+    @data.each do |key, value|
+      if @changes.key?(key)
+        value_to_use = @changes.fetch(key)
       else
-        db.update(table_name, @changes, id: id)
+        value_to_use = value
       end
 
-      @changes = {}
-      @new_record = false
-      reload
+      data_str << " " unless data_str.empty?
+      data_str << "#{key}=\"#{value_to_use}\""
+    end
+
+    "#<#{self.class.name} #{data_str}>"
+  end
 
-      fire_callbacks(:after_save)
-      fire_callbacks(:after_create) if new_record
+  def ==(other)
+    return false unless self.class == other.class
 
-      return true
+    if new_record? && other.new_record?
+      return merged_data == other.__send__(:merged_data)
     else
-      return false
+      return id == other.id
     end
   end
 
-  def save!
-    if save
-      return true
-    else
-      raise BazaModels::Errors::InvalidRecord
-    end
+  # rubocop:disable Style/PredicateName
+  def has_attribute?(name)
+    # rubocop:enable Style/PredicateName
+    self.class.column_names.include?(name.to_s)
   end
 
-  def reload
-    @data = db.select(table_name, {id: id}, limit: 1).fetch
-    @changes = {}
-    return self
+  def self.column_names
+    @column_names ||= __blank_attributes.keys.map(&:to_s)
   end
 
-  def destroy
-    if new_record?
-      errors.add(:base, "cannot destroy new record")
-      return false
-    else
-      fire_callbacks(:before_destroy)
-      db.delete(table_name, id: id)
-      fire_callbacks(:after_destroy)
-      return true
-    end
+  def self.ransack(params)
+    BazaModels::Ransacker.new(class: self, params: params)
   end
 
-  def destroy!
-    raise BazaModels::Errors::InvalidRecord, @errors.full_messages.join(". ") unless destroy
+  def [](key)
+    read_attribute(key)
   end
 
-  def assign_attributes(attributes)
-    @changes.merge!(attributes)
+  def []=(key, value)
+    write_attribute(key, value)
   end
 
-  def update_attributes(attributes)
-    assign_attributes(attributes)
-    return save
+  def read_attribute(attribute_name)
+    return @changes.fetch(attribute_name) if @changes.key?(attribute_name)
+    @data.fetch(attribute_name)
   end
 
-  def update_attributes!(attributes)
-    unless update_attributes(attributes)
-      raise BazaModels::Errors::InvalidRecord, @errors.full_messages.join(". ")
+  def write_attribute(attribute_name, value)
+    @changes[attribute_name] = value
+  end
+
+  def changed?
+    changed = false
+    @changes.each do |key, value|
+      next if @data.fetch(key) == value
+      changed = true
+      break
     end
+
+    changed
   end
 
-  def valid?
-    fire_callbacks(:before_validation)
+protected
 
-    if new_record?
-      fire_callbacks(:before_validation_on_create)
-    else
-      fire_callbacks(:before_validation_on_update)
-    end
+  class << self
+    attr_reader :__blank_attributes
+  end
 
-    reset_errors
+  # rubocop:disable Style/TrivialAccessors
+  def self.model_initialized?
+    # rubocop:enable Style/TrivialAccessors
+    @model_initialized
+  end
 
-    merged_data = @data.merge(@changes)
-    merged_data.each do |attribute_name, attribute_value|
-      next unless @@validators.key?(attribute_name)
+  def self.init_attribute_from_column(column)
+    column_name = column.name.to_sym
 
-      @@validators[attribute_name].each do |validator|
-        validator.validate(self, attribute_value)
-      end
+    define_method(column_name) do
+      read_attribute(column_name)
+    end
+
+    define_method("#{column_name}_was") do
+      return @data.fetch(column_name)
     end
 
-    fire_callbacks(:after_validation)
+    define_method("#{column_name}=") do |new_value|
+      write_attribute(column_name, new_value)
+    end
 
-    if new_record?
-      fire_callbacks(:after_validation_on_create)
-    else
-      fire_callbacks(:after_validation_on_update)
+    define_method("#{column_name}?") do
+      !@data.fetch(column_name).to_s.strip.empty?
     end
 
-    return @errors.empty?
+    define_method("#{column_name}_changed?") do
+      if @changes.key?(column_name) && @changes.fetch(column_name) != @data.fetch(column_name)
+        true
+      else
+        false
+      end
+    end
   end
 
-protected
-
   def reset_errors
     @errors = BazaModels::Errors.new
   end
 
   def fire_callbacks(name)
-    if @@callbacks[name]
-      @@callbacks[name].each do |callback_data|
-        if callback_data[:block]
-          callback_data[:block].call(*callback_data[:args])
-        elsif callback_data[:method_name]
-          __send__(callback_data[:method_name], *callback_data[:args])
+    return if !@@callbacks[name] || !@@callbacks[name][self.class.name]
+
+    @@callbacks[name][self.class.name].each do |callback_data|
+      if callback_data[:block]
+        instance_eval(&callback_data.fetch(:block))
+      elsif callback_data[:method_name]
+        __send__(callback_data[:method_name], *callback_data.fetch(:args))
+      else
+        raise "Didn't know how to perform callbacks for #{name}"
+      end
+    end
+  end
+
+  def merged_data
+    @data.merge(@changes)
+  end
+
+  # Converts attributes like "user" to "user_id" and so on.
+  def real_attributes(attributes)
+    new_attributes = {}
+    attributes.each do |attribute_name, attribute_value|
+      belongs_to_relations = self.class.instance_variable_get(:@belongs_to_relations)
+
+      if belongs_to_relations
+        belongs_to_relations.each do |relation|
+          if attribute_name.to_s == relation[:relation_name].to_s
+            attribute_name = :"#{attribute_name}_id"
+            attribute_value = attribute_value.id
+          end
+        end
+      end
+
+      unless has_attribute?(attribute_name)
+        set_method_name = "#{attribute_name}="
+
+        if respond_to?(set_method_name)
+          __send__(set_method_name, attribute_value)
+          next
         else
-          raise "Didn't know how to perform callbacks for #{name}"
+          raise "Unknown attribute: #{attribute_name}"
         end
       end
+
+      new_attributes[attribute_name.to_sym] = attribute_value
     end
+
+    new_attributes
   end
 end