baza 0.0.19 → 0.0.20

data/lib/baza/model.rb

@@ -1,4 +1,4 @@
-#This class helps create models in a framework with Baza::Db and Baza::ModelHandler.
+# This class helps create models in a framework with Baza::Db and Baza::ModelHandler.
 #===Examples
 #  db = Baza::Db.new(type: :sqlite3, path: "somepath.sqlite3")
 #  ob = Baza::ModelHandler.new(db: db, datarow: true, path: "path_of_model_class_files")
@@ -6,97 +6,101 @@
 class Baza::Model
   @@refs = {}
 
-  #Returns the Baza::ModelHandler which handels this model.
+  # Returns the Baza::ModelHandler which handels this model.
   def ob
-    return self.class.ob
+    self.class.ob
   end
 
-  #Returns the Baza::Db which handels this model.
+  # Returns the Baza::Db which handels this model.
   def db
-    return self.class.db
+    self.class.db
   end
 
-  #Returns the 'Baza::ModelHandler'-object that handels this class.
-  def self.ob
-    return @ob
+  # Returns the 'Baza::ModelHandler'-object that handels this class.
+  class << self
+    attr_reader :ob
   end
 
-  #Returns the 'Baza::Db'-object that handels this class.
-  def self.db
-    return @db
+  # Returns the 'Baza::Db'-object that handels this class.
+  class << self
+    attr_reader :db
   end
 
-  #This is used by 'Baza::ModelHandler' to find out what data is required for this class. Returns the array that tells about required data.
+  # This is used by 'Baza::ModelHandler' to find out what data is required for this class. Returns the array that tells about required data.
   #===Examples
-  #When adding a new user, this can fail if the ':group_id' is not given, or the ':group_id' doesnt refer to a valid group-row in the db.
+  # When adding a new user, this can fail if the ':group_id' is not given, or the ':group_id' doesnt refer to a valid group-row in the db.
   #  class Models::User < Baza::Datarow
   #    has_one [
-  #      {:class => :Group, :col => :group_id, :method => :group, :required => true}
+  #      {class: :Group, col: :group_id, method: :group, required: true}
   #    ]
   #  end
   def self.required_data
-    @required_data = [] if !@required_data
-    return @required_data
+    @required_data = [] unless @required_data
+    @required_data
   end
 
-  #This is used by 'Baza::ModelHandler' to find out what other objects this class depends on. Returns the array that tells about depending data.
+  # This is used by 'Baza::ModelHandler' to find out what other objects this class depends on. Returns the array that tells about depending data.
   #===Examples
-  #This will tell Baza::ModelHandler that files depends on users. It can prevent the user from being deleted, if any files depend on it.
+  # This will tell Baza::ModelHandler that files depends on users. It can prevent the user from being deleted, if any files depend on it.
   #  class Models::User < Baza::Datarow
   #    has_many [
-  #      {:class => :File, :col => :user_id, :method => :files, :depends => true}
+  #      {class: :File, col: :user_id, method: :files, depends: true}
   #    ]
   #  end
-  def self.depending_data
-    return @depending_data
+  class << self
+    attr_reader :depending_data
   end
 
-  #Returns true if this class has been initialized.
+  # Returns true if this class has been initialized.
   def self.initialized?
-    return false if !@columns_sqlhelper_args
-    return true
+    false unless @columns_sqlhelper_args
+    true
   end
 
-  #This is used by 'Baza::ModelHandler' to find out which other objects should be deleted when an object of this class is deleted automatically. Returns the array that tells about autodelete data.
+  # This is used by 'Baza::ModelHandler' to find out which other objects should be deleted when an object of this class is deleted automatically. Returns the array that tells about autodelete data.
   #===Examples
-  #This will trigger Baza::ModelHandler to automatically delete all the users pictures, when deleting the current user.
+  # This will trigger Baza::ModelHandler to automatically delete all the users pictures, when deleting the current user.
   #  class Models::User < Baza::Datarow
   #    has_many [
-  #      {:class => :Picture, :col => :user_id, :method => :pictures, :autodelete => true}
+  #      {class: :Picture, col: :user_id, method: :pictures, autodelete: true}
   #    ]
   #  end
-  def self.autodelete_data
-    return @autodelete_data
+  class << self
+    attr_reader :autodelete_data
   end
 
-  #Returns the autozero-data (if any).
-  def self.autozero_data
-    return @autozero_data
+  # Returns the autozero-data (if any).
+  class << self
+    attr_reader :autozero_data
   end
 
-  #This helps various parts of the framework determine if this is a datarow class without requiring it.
+  class << self
+    attr_accessor :classname
+  end
+
+  # This helps various parts of the framework determine if this is a datarow class without requiring it.
   #===Examples
   #  print "This is a knj-object." if obj.respond_to?("is_knj?")
-  def is_knj?
-    return true
+  def knj?
+    true
   end
 
-  #This tests if a certain string is a date-null-stamp.
+  # This tests if a certain string is a date-null-stamp.
   #===Examples
   #  time_str = dbrow[:date]
   #  print "No valid date on the row." if Baza::Datarow.is_nullstamp?(time_str)
-  def self.is_nullstamp?(stamp)
-    return true if !stamp or stamp == "0000-00-00 00:00:00" or stamp == "0000-00-00"
-    return false
+  def self.nullstamp?(stamp)
+    return true if !stamp || stamp == "0000-00-00 00:00:00" || stamp == "0000-00-00"
+    false
   end
 
-  #This is used to define datarows that this object can have a lot of.
+  # This is used to define datarows that this object can have a lot of.
   #===Examples
-  #This will define the method "pictures" on 'Models::User' that will return all pictures for the users and take possible Objects-sql-arguments. It will also enabling joining pictures when doing Objects-sql-lookups.
+  # This will define the method "pictures" on 'Models::User' that will return all pictures for the users and take possible Objects-sql-arguments. It will also enabling joining pictures when doing Objects-sql-lookups.
   #  class Models::User < Baza::Datarow
   #    has_many [
   #      [:Picture, :user_id, :pictures],
-  #      {:class => :File, :col => :user_id, :method => :files}
+  #      {class: :File, col: :user_id, method: :files}
   #    ]
   #  end
   def self.has_many(arr)
@@ -104,75 +108,77 @@ class Baza::Model
       if val.is_a?(Array)
         classname, colname, methodname = *val
       elsif val.is_a?(Hash)
-        classname, colname, methodname = nil, nil, nil
+        classname = nil
+        colname = nil
+        methodname = nil
 
         val.each do |hkey, hval|
           case hkey
-            when :class
-              classname = hval
-            when :col
-              colname = hval
-            when :method
-              methodname = hval
-            when :depends, :autodelete, :autozero, :where
-              #ignore
-            else
-              raise "Invalid key for 'has_many': '#{hkey}'."
+          when :class
+            classname = hval
+          when :col
+            colname = hval
+          when :method
+            methodname = hval
+          when :depends, :autodelete, :autozero, :where
+            # Ignore
+          else
+            raise "Invalid key for 'has_many': '#{hkey}'."
           end
         end
 
-        colname = "#{self.name.to_s.split("::").last.to_s.downcase}_id".to_sym if colname.to_s.empty?
+        colname = "#{name.to_s.split("::").last.to_s.downcase}_id" if colname.to_s.empty?
 
         if val[:depends]
-          @depending_data = [] if !@depending_data
+          @depending_data = [] unless @depending_data
           @depending_data << {
-            :colname => colname,
-            :classname => classname
+            colname: colname,
+            classname: classname
           }
         end
 
         if val[:autodelete]
-          @autodelete_data = [] if !@autodelete_data
+          @autodelete_data = [] unless @autodelete_data
           @autodelete_data << {
-            :colname => colname,
-            :classname => classname
+            colname: colname,
+            classname: classname
           }
         end
 
         if val[:autozero]
-          @autozero_data = [] if !@autozero_data
+          @autozero_data = [] unless @autozero_data
           @autozero_data << {
-            :colname => colname,
-            :classname => classname
+            colname: colname,
+            classname: classname
           }
         end
       else
         raise "Unknown argument: '#{val.class.name}'."
       end
 
-      raise "No classname given." if !classname
-      methodname = "#{StringCases.camel_to_snake(classname)}s".to_sym if !methodname
-      raise "No column was given for '#{self.name}' regarding has-many-class: '#{classname}'." if !colname
+      raise "No classname given." unless classname
+      methodname = "#{StringCases.camel_to_snake(classname)}s" unless methodname
+      raise "No column was given for '#{name}' regarding has-many-class: '#{classname}'." unless colname
 
-      if val.is_a?(Hash) and val.key?(:where)
+      if val.is_a?(Hash) && val.key?(:where)
         where_args = val[:where]
       else
         where_args = nil
       end
 
-      self.define_many_methods(classname, methodname, colname, where_args)
+      define_many_methods(classname, methodname, colname, where_args)
 
-      self.joined_tables(
+      joined_tables(
         classname => {
-          :where => {
-            colname.to_s => {:type => :col, :name => :id}
+          where: {
+            colname.to_s => {type: :col, name: :id}
           }
         }
       )
     end
   end
 
-  #This define is this object has one element of another datarow-class. It define various methods and joins based on that.
+  # This define is this object has one element of another datarow-class. It define various methods and joins based on that.
   #===Examples
   #  class Models::User < Baza::Datarow
   #    has_one [
@@ -180,7 +186,7 @@ class Baza::Model
   #      :Group,
   #
   #      #Defines the method 'type', which returns a 'Type'-object by the column 'type_id'.
-  #      {:class => :Type, :col => :type_id, :method => :type}
+  #      {class: :Type, col: :type_id, method: :type}
   #    ]
   #  end
   def self.has_one(arr)
@@ -198,49 +204,51 @@ class Baza::Model
       elsif val.is_a?(Array)
         classname, colname, methodname = *val
       elsif val.is_a?(Hash)
-        classname, colname, methodname = nil, nil, nil
+        classname = nil
+        colname = nil
+        methodname = nil
 
         val.each do |hkey, hval|
           case hkey
-            when :class
-              classname = hval
-            when :col
-              colname = hval
-            when :method
-              methodname = hval
-            when :required
-              #ignore
-            else
-              raise "Invalid key for class '#{self.name}' functionality 'has_many': '#{hkey}'."
+          when :class
+            classname = hval
+          when :col
+            colname = hval
+          when :method
+            methodname = hval
+          when :required
+            # Ignore
+          else
+            raise "Invalid key for class '#{name}' functionality 'has_many': '#{hkey}'."
           end
         end
 
         if val[:required]
-          colname = "#{classname.to_s.downcase}_id".to_sym if !colname
-          self.required_data << {
-            :col => colname,
-            :class => classname
+          colname = "#{classname.to_s.downcase}_id".to_sym unless colname
+          required_data << {
+            col: colname,
+            class: classname
           }
         end
       else
         raise "Unknown argument-type: '#{arr.class.name}'."
       end
 
-      methodname = StringCases.camel_to_snake(classname) if !methodname
-      colname = "#{classname.to_s.downcase}_id".to_sym if !colname
-      self.define_one_methods(classname, methodname, colname)
+      methodname = StringCases.camel_to_snake(classname) unless methodname
+      colname = "#{classname.to_s.downcase}_id".to_sym unless colname
+      define_one_methods(classname, methodname, colname)
 
-      self.joined_tables(
+      joined_tables(
         classname => {
-          :where => {
-            "id" => {:type => :col, :name => colname}
+          where: {
+            "id" => {type: :col, name: colname}
           }
         }
       )
     end
   end
 
-  #This method initializes joins, sets methods to update translations and makes the translations automatically be deleted when the object is deleted.
+  # This method initializes joins, sets methods to update translations and makes the translations automatically be deleted when the object is deleted.
   #===Examples
   #  class Models::Article < Baza::Datarow
   #    #Defines methods such as: 'title', 'title=', 'content', 'content='. When used with Knjappserver these methods will change what they return and set based on the current language of the session.
@@ -252,7 +260,7 @@ class Baza::Model
   #
   #  article.title = 'Title in english if the language is english'
   def self.has_translation(arr)
-    @translations = [] if !@translations
+    @translations = [] unless @translations
 
     arr.each do |val|
       @translations << val
@@ -263,10 +271,10 @@ class Baza::Model
       joined_tables(
         table_name => {
           where: {
-            "object_class" => self.name,
+            "object_class" => name,
             "object_id" => {type: :col, name: :id},
             "key" => val.to_s,
-            "locale" => proc{|d| _session[:locale]}
+            "locale" => proc { |_d| _session[:locale] }
           },
           parent_table: :Translation,
           datarow: Knj::Translations::Translation,
@@ -274,53 +282,53 @@ class Baza::Model
         }
       )
 
-      self.define_translation_methods(val: val, val_dc: val_dc)
+      define_translation_methods(val: val, val_dc: val_dc)
     end
   end
 
-  #This returns all translations for this datarow-class.
-  def self.translations
-    return @translations
+  # This returns all translations for this datarow-class.
+  class << self
+    attr_reader :translations
   end
 
-  #Returns data about joined tables for this class.
+  # Returns data about joined tables for this class.
   def self.joined_tables(hash)
-    @columns_joined_tables = {} if !@columns_joined_tables
+    @columns_joined_tables = {} unless @columns_joined_tables
     @columns_joined_tables.merge!(hash)
   end
 
-  #Returns various data for the objects-sql-helper. This can be used to view various informations about the columns and more.
+  # Returns various data for the objects-sql-helper. This can be used to view various informations about the columns and more.
   def self.columns_sqlhelper_args
-    raise "No SQLHelper arguments has been spawned yet." if !@columns_sqlhelper_args
-    return @columns_sqlhelper_args
+    raise "No SQLHelper arguments has been spawned yet." unless @columns_sqlhelper_args
+    @columns_sqlhelper_args
   end
 
-  #Called by Baza::ModelHandler to initialize the model and load column-data on-the-fly.
+  # Called by Baza::ModelHandler to initialize the model and load column-data on-the-fly.
   def self.load_columns(d)
     @ob = d.ob
     @db = d.db
 
-    @classname = self.name.split("::").last.to_sym if !@classname
-    @table = @classname if !@table
-    @mutex = Monitor.new if !@mutex
+    @classname = name.split("::").last.to_sym unless @classname
+    @table = @classname unless @table
+    @mutex = Monitor.new unless @mutex
 
-    #Cache these to avoid method-lookups.
+    # Cache these to avoid method-lookups.
     @sep_col = @db.sep_col
     @sep_table = @db.sep_table
-    @table_str = "#{@sep_table}#{@db.esc_table(@table)}#{@sep_table}"
+    @table_str = "#{@sep_table}#{@db.escape_table(@table)}#{@sep_table}"
 
     @mutex.synchronize do
-      inst_methods = self.instance_methods(false)
+      inst_methods = instance_methods(false)
 
       sqlhelper_args = {
-        :db => @db,
-        :table => @table,
-        :cols_bools => [],
-        :cols_date => [],
-        :cols_dbrows => [],
-        :cols_num => [],
-        :cols_str => [],
-        :cols => {}
+        db: @db,
+        table: @table,
+        cols_bools: [],
+        cols_date: [],
+        cols_dbrows: [],
+        cols_num: [],
+        cols_str: [],
+        cols: {}
       }
 
       sqlhelper_args[:table] = @table
@@ -329,44 +337,42 @@ class Baza::Model
         col_name = col_obj.name.to_s
         col_name_sym = col_name.to_sym
         col_type = col_obj.type
-        col_type = :int if col_type == :bigint or col_type == :tinyint or col_type == :mediumint or col_type == :smallint
+        col_type = :int if col_type == :bigint || col_type == :tinyint || col_type == :mediumint || col_type == :smallint
         sqlhelper_args[:cols][col_name] = true
 
-        self.define_bool_methods(inst_methods, col_name)
+        define_bool_methods(inst_methods, col_name)
 
-        if col_type == :enum and col_obj.maxlength == "'0','1'"
+        if col_type == :enum && col_obj.maxlength == "'0','1'"
           sqlhelper_args[:cols_bools] << col_name
-        elsif col_type == :int and col_name.slice(-3, 3) == "_id"
+        elsif col_type == :int && col_name.slice(-3, 3) == "_id"
           sqlhelper_args[:cols_dbrows] << col_name
-        elsif col_type == :int or col_type == :decimal
+        elsif col_type == :int || col_type == :decimal
           sqlhelper_args[:cols_num] << col_name
-        elsif col_type == :varchar or col_type == :text or col_type == :enum
+        elsif col_type == :varchar || col_type == :text || col_type == :enum
           sqlhelper_args[:cols_str] << col_name
-        elsif col_type == :date or col_type == :datetime
+        elsif col_type == :date || col_type == :datetime
           sqlhelper_args[:cols_date] << col_name
-          self.define_date_methods(inst_methods, col_name_sym)
+          define_date_methods(inst_methods, col_name_sym)
         end
 
-        if col_type == :int or col_type == :decimal
-          self.define_numeric_methods(inst_methods, col_name_sym)
+        if col_type == :int || col_type == :decimal
+          define_numeric_methods(inst_methods, col_name_sym)
         end
 
-        if col_type == :int or col_type == :varchar
-          self.define_text_methods(inst_methods, col_name_sym)
+        if col_type == :int || col_type == :varchar
+          define_text_methods(inst_methods, col_name_sym)
         end
 
-        if col_type == :time
-          self.define_time_methods(inst_methods, col_name_sym)
-        end
+        define_time_methods(inst_methods, col_name_sym) if col_type == :time
       end
 
       if @columns_joined_tables
         @columns_joined_tables.each do |table_name, table_data|
-          table_data[:where].each do |key, val|
-            val[:table] = @table if val.is_a?(Hash) and !val.key?(:table) and val[:type].to_sym == :col
+          table_data[:where].each do |_key, val|
+            val[:table] = @table if val.is_a?(Hash) && !val.key?(:table) && val[:type].to_sym == :col
           end
 
-          table_data[:datarow] = @ob.args[:module].const_get(table_name.to_sym) if !table_data.key?(:datarow)
+          table_data[:datarow] = @ob.args[:module].const_get(table_name.to_sym) unless table_data.key?(:datarow)
         end
 
         sqlhelper_args[:joined_tables] = @columns_joined_tables
@@ -375,10 +381,10 @@ class Baza::Model
       @columns_sqlhelper_args = sqlhelper_args
     end
 
-    self.init_class(d) if self.respond_to?(:init_class)
+    init_class(d) if self.respond_to?(:init_class)
   end
 
-  #This method helps returning objects and supports various arguments. It should be called by Object#list.
+  # This method helps returning objects and supports various arguments. It should be called by Object#list.
   #===Examples
   #  ob.list(:User, {"username_lower" => "john doe"}) do |user|
   #    print user.id
@@ -402,27 +408,27 @@ class Baza::Model
     end
 
     qargs = nil
-    ret = self.list_helper(d)
+    ret = list_helper(d)
 
     sql << " FROM #{@table_str}"
     sql << ret[:sql_joins]
     sql << " WHERE 1=1"
     sql << ret[:sql_where]
 
-    args.each do |key, val|
+    args.each_key do |key|
       case key
-        when "return_sql"
-          #ignore
-        when :cloned_ubuf
-          qargs = {:cloned_ubuf => true}
-        else
-          raise "Invalid key: '#{key}' for '#{self.name}'. Valid keys are: '#{@columns_sqlhelper_args[:cols].keys.sort}'. Date-keys: '#{@columns_sqlhelper_args[:cols_date]}'."
+      when "return_sql"
+        # Ignore
+      when :cloned_ubuf
+        qargs = {cloned_ubuf: true}
+      else
+        raise "Invalid key: '#{key}' for '#{name}'. Valid keys are: '#{@columns_sqlhelper_args[:cols].keys.sort}'. Date-keys: '#{@columns_sqlhelper_args[:cols_date]}'."
       end
     end
 
-    #The count will bug if there is a group-by-statement.
+    # The count will bug if there is a group-by-statement.
     grp_shown = false
-    if !count and !ret[:sql_groupby]
+    if !count && !ret[:sql_groupby]
       sql << " GROUP BY #{@table_str}.#{@sep_col}id#{@sep_col}"
       grp_shown = true
     end
@@ -463,36 +469,26 @@ class Baza::Model
       return 0
     end
 
-    return @ob.list_bysql(self.classname, sql, qargs, &block)
+    @ob.list_bysql(classname, sql, qargs, &block)
   end
 
-  #Helps call 'sqlhelper' on Baza::ModelHandler to generate SQL-strings.
+  # Helps call 'sqlhelper' on Baza::ModelHandler to generate SQL-strings.
   def self.list_helper(d)
-    self.load_columns(d) if !@columns_sqlhelper_args
+    load_columns(d) unless @columns_sqlhelper_args
     @columns_sqlhelper_args[:table] = @table
-    return @ob.sqlhelper(d.args, @columns_sqlhelper_args)
-  end
-
-  #Returns the classname of the object without any subclasses.
-  def self.classname
-    return @classname
+    @ob.sqlhelper(d.args, @columns_sqlhelper_args)
   end
 
-  #Sets the classname to something specific in order to hack the behaviour.
-  def self.classname=(newclassname)
-    @classname = newclassname
-  end
-
-  #Returns the table-name that should be used for this datarow.
+  # Returns the table-name that should be used for this datarow.
   #===Examples
   #  db.query("SELECT * FROM `#{Models::User.table}` WHERE username = 'John Doe'") do |data|
   #    print data[:id]
   #  end
-  def self.table
-    return @table
+  class << self
+    attr_reader :table
   end
 
-  #This can be used to manually set the table-name. Useful when meta-programming classes that extends the datarow-class.
+  # This can be used to manually set the table-name. Useful when meta-programming classes that extends the datarow-class.
   #===Examples
   #  Models::User.table = "prefix_User"
   def self.table=(newtable)
@@ -500,21 +496,21 @@ class Baza::Model
     @columns_sqlhelper_args[:table] = @table if @columns_sqlhelper_args.is_a?(Hash)
   end
 
-  #Returns the class-name but without having to call the class-table-method. To make code look shorter.
+  # Returns the class-name but without having to call the class-table-method. To make code look shorter.
   #===Examples
-  #  user = ob.get_by(:User, {:username => 'John Doe'})
+  #  user = ob.get_by(:User, {username: 'John Doe'})
   #  db.query("SELECT * FROM `#{user.table}` WHERE username = 'John Doe'") do |data|
   #    print data[:id]
   #  end
   def table
-    return self.class.table
+    self.class.table
   end
 
-  #Initializes the object. This should be called from 'Baza::ModelHandler' and not manually.
+  # Initializes the object. This should be called from 'Baza::ModelHandler' and not manually.
   #===Examples
   #  user = ob.get(:User, 3)
   def initialize(data, args = nil)
-    if data.is_a?(Hash) and data.key?(:id)
+    if data.is_a?(Hash) && data.key?(:id)
       @data = data
       @id = @data[:id].to_i
     elsif data
@@ -522,13 +518,13 @@ class Baza::Model
 
       classname = self.class.classname.to_sym
       if self.class.ob.ids_cache_should.key?(classname)
-        #ID caching is enabled for this model - dont reload until first use.
-        raise Errno::ENOENT, "ID was not found in cache: '#{id}'." if !self.class.ob.ids_cache[classname].key?(@id)
+        # ID caching is enabled for this model - dont reload until first use.
+        raise Errno::ENOENT, "ID was not found in cache: '#{id}'." unless self.class.ob.ids_cache[classname].key?(@id)
         @should_reload = true
       else
-        #ID caching is not enabled - reload now to check if row exists. Else set 'should_reload'-variable if 'skip_reload' is set.
-        if !args or !args[:skip_reload]
-          self.reload
+        # ID caching is not enabled - reload now to check if row exists. Else set 'should_reload'-variable if 'skip_reload' is set.
+        if !args || !args[:skip_reload]
+          reload
         else
           @should_reload = true
         end
@@ -537,24 +533,24 @@ class Baza::Model
       raise ArgumentError, "Could not figure out the data from '#{data.class.name}'."
     end
 
-    if @id.to_i <= 0
-      raise "Invalid ID: '#{@id}' from '#{@data}'." if @data
-      raise "Invalid ID: '#{@id}'."
-    end
+    return unless @id.to_i <= 0
+
+    raise "Invalid ID: '#{@id}' from '#{@data}'." if @data
+    raise "Invalid ID: '#{@id}'."
   end
 
-  #Reloads the data from the database.
+  # Reloads the data from the database.
   #===Examples
   #  old_username = user[:username]
   #  user.reload
   #  print "The username changed in the database!" if user[:username] != old_username
   def reload
-    @data = self.class.db.single(self.class.table, {:id => @id})
-    raise Errno::ENOENT, "Could not find any data for the object with ID: '#{@id}' in the table '#{self.class.table}'." if !@data
+    @data = self.class.db.single(self.class.table, id: @id)
+    raise Errno::ENOENT, "Could not find any data for the object with ID: '#{@id}' in the table '#{self.class.table}'." unless @data
     @should_reload = false
   end
 
-  #Tells the object that it should reloads its data because it has changed. It wont reload before it is required though, which may save you a couple of SQL-calls.
+  # Tells the object that it should reloads its data because it has changed. It wont reload before it is required though, which may save you a couple of SQL-calls.
   #===Examples
   #  obj = _ob.get(:User, 5)
   #  obj.should_reload
@@ -563,99 +559,99 @@ class Baza::Model
     @data = nil
   end
 
-  #Returns the data-hash that contains all the data from the database.
+  # Returns the data-hash that contains all the data from the database.
   def data
-    self.reload if @should_reload
-    return @data
+    reload if @should_reload
+    @data
   end
 
-  #Writes/updates new data for the object.
+  # Writes/updates new data for the object.
   #===Examples
-  #  user.update(:username => 'New username', :date_changed => Time.now)
+  #  user.update(username: 'New username', date_changed: Time.now)
   def update(newdata)
-    self.class.db.update(self.class.table, newdata, {:id => @id})
-    self.should_reload
+    self.class.db.update(self.class.table, newdata, id: @id)
+    should_reload
     self.class.ob.call("object" => self, "signal" => "update")
   end
 
-  #Forcefully destroys the object. This is done after deleting it and should not be called manually.
+  # Forcefully destroys the object. This is done after deleting it and should not be called manually.
   def destroy
     @id = nil
     @data = nil
     @should_reload = nil
   end
 
-  #Returns true if that key exists on the object.
+  # Returns true if that key exists on the object.
   #===Examples
   #  print "Looks like the user has a name." if user.key?(:name)
   def key?(key)
-    self.reload if @should_reload
-    return @data.key?(key.to_sym)
+    reload if @should_reload
+    @data.key?(key.to_sym)
   end
-  alias has_key? key?
+  alias_method :has_key?, :key?
 
-  #Returns true if the object has been deleted.
+  # Returns true if the object has been deleted.
   #===Examples
   #  print "That user is deleted." if user.deleted?
   def deleted?
-    return true if !@data and !@id
-    return false
+    return true if !@data && !@id
+    false
   end
 
-  #Returns true if the given object no longer exists in the database. Also destroys the data on the object and sets it to deleted-status, if it no longer exists.
+  # Returns true if the given object no longer exists in the database. Also destroys the data on the object and sets it to deleted-status, if it no longer exists.
   #===Examples
   # print "That user is deleted." if user.deleted_from_db?
   def deleted_from_db?
-    #Try to avoid db-query if object is already deleted.
+    # Try to avoid db-query if object is already deleted.
     return true if self.deleted?
 
-    #Try to reload data. Destroy object and return true if the row is gone from the database.
+    # Try to reload data. Destroy object and return true if the row is gone from the database.
     begin
-      self.reload
+      reload
       return false
     rescue Errno::ENOENT
-      self.destroy
+      destroy
       return true
     end
   end
 
-  #Returns a specific data from the object by key.
+  # Returns a specific data from the object by key.
   #  print "Username: #{user[:username]}\n"
   #  print "ID: #{user[:id]}\n"
   #  print "ID again: #{user.id}\n"
   def [](key)
-    raise "Key was not a symbol: '#{key.class.name}'." if !key.is_a?(Symbol)
-    return @id if !@data and key == :id and @id
-    self.reload if @should_reload
-    raise "No data was loaded on the object? Maybe you are trying to call a deleted object? (#{self.class.classname}(#{@id}), #{@should_reload})" if !@data
+    raise "Key was not a symbol: '#{key.class.name}'." unless key.is_a?(Symbol)
+    return @id if !@data && key == :id && @id
+    reload if @should_reload
+    raise "No data was loaded on the object? Maybe you are trying to call a deleted object? (#{self.class.classname}(#{@id}), #{@should_reload})" unless @data
     return @data[key] if @data.key?(key)
     raise "No such key: '#{key}' on '#{self.class.name}' (#{@data.keys.join(", ")}) (#{@should_reload})."
   end
 
-  #Writes/updates a keys value on the object.
+  # Writes/updates a keys value on the object.
   #  user = ob.get_by(:User, {"username" => "John Doe"})
   #  user[:username] = 'New username'
   def []=(key, value)
-    self.update(key.to_sym => value)
-    self.should_reload
+    update(key.to_sym => value)
+    should_reload
   end
 
-  #Returns the objects ID.
+  # Returns the objects ID.
   def id
-    raise Errno::ENOENT, "This object has been deleted." if self.deleted?
-    raise "No ID on object." if !@id
-    return @id
+    raise Errno::ENOENT, "This object has been deleted." if deleted?
+    raise "No ID on object." unless @id
+    @id
   end
 
-  #This enable Wref to not return the wrong object.
+  # This enable Wref to not return the wrong object.
   def __object_unique_id__
     return 0 if self.deleted?
-    return self.id
+    id
   end
 
-  #Tries to figure out, and returns, the possible name or title for the object.
+  # Tries to figure out, and returns, the possible name or title for the object.
   def name
-    self.reload if @should_reload
+    reload if @should_reload
 
     if @data.key?(:title)
       return @data[:title]
@@ -665,74 +661,70 @@ class Baza::Model
 
     obj_methods = self.class.instance_methods(false)
     [:name, :title].each do |method_name|
-      return self.method(method_name).call if obj_methods.index(method_name)
+      return method(method_name).call if obj_methods.index(method_name)
     end
 
     raise "Couldnt figure out the title/name of the object on class #{self.class.name}."
   end
 
-  #Calls the name-method and returns a HTML-escaped value. Also "[no name]" if the name is empty.
+  # Calls the name-method and returns a HTML-escaped value. Also "[no name]" if the name is empty.
   def name_html
     name_str = name.to_s
     name_str = "[no name]" if name_str.empty?
-    return name_str
+    name_str
   end
 
-  alias title name
+  alias_method :title, :name
 
-  #Loops through the data on the object.
+  # Loops through the data on the object.
   #===Examples
   #  user = ob.get(:User, 1)
   #  user.each do |key, val|
   #    print "#{key}: #{val}\n" #=> username: John Doe
   #  end
   def each(*args, &block)
-    self.reload if @should_reload
-    return @data.each(*args, &block)
+    reload if @should_reload
+    @data.each(*args, &block)
   end
 
-  #Hash-compatible.
+  # Hash-compatible.
   def to_hash
-    self.reload if @should_reload
-    return @data.clone
+    reload if @should_reload
+    @data.clone
   end
 
-  #Returns a default-URL to show the object.
+  # Returns a default-URL to show the object.
   def url
     cname = self.class.classname.to_s.downcase
-    return "?show=#{cname}_show&#{cname}_id=#{self.id}"
+    "?show=#{cname}_show&#{cname}_id=#{id}"
   end
 
-  #Returns the URL for editting the object.
+  # Returns the URL for editting the object.
   def url_edit
     cname = self.class.classname.to_s.downcase
-    return "?show=#{cname}_edit&#{cname}_id=#{self.id}"
+    "?show=#{cname}_edit&#{cname}_id=#{id}"
   end
 
-  #Returns the HTML for making a link to the object.
+  # Returns the HTML for making a link to the object.
   def html(args = nil)
-    if args and args[:edit]
-      url = self.url_edit
+    if args && args[:edit]
+      url = url_edit
     else
       url = self.url
     end
 
-    return "<a href=\"#{Knj::Web.ahref_parse(url)}\">#{self.name_html}</a>"
+    "<a href=\"#{Knj::Web.ahref_parse(url)}\">#{name_html}</a>"
   end
 
-  private
+private
 
-  #Various methods to define methods based on the columns for the datarow.
+  # Various methods to define methods based on the columns for the datarow.
   def self.define_translation_methods(args)
     define_method("#{args[:val_dc]}=") do |newtransval|
       begin
-        _hb.trans_set(self, {
-          args[:val] => newtransval
-        })
+        _hb.trans_set(self, args[:val] => newtransval)
       rescue NameError
-        _kas.trans_set(self, {
-          args[:val] => newtransval
-        })
+        _kas.trans_set(self, args[:val] => newtransval)
       end
     end
 
@@ -751,135 +743,133 @@ class Baza::Model
         str = _kas.trans(self, args[:val])
       end
 
-      if str.to_s.strip.empty?
-        return "[no translation for #{args[:val]}]"
-      end
+      return "[no translation for #{args[:val]}]" if str.to_s.strip.empty?
 
       return str
     end
   end
 
-  #Defines the boolean-methods based on enum-columns.
+  # Defines the boolean-methods based on enum-columns.
   def self.define_bool_methods(inst_methods, col_name)
-    #Spawns a method on the class which returns true if the data is 1.
-    if !inst_methods.include?("#{col_name}?".to_sym)
-      define_method("#{col_name}?") do
-        return true if self[col_name.to_sym].to_s == "1"
-        return false
-      end
+    # Spawns a method on the class which returns true if the data is 1.
+    return if inst_methods.include?("#{col_name}?".to_sym)
+
+    define_method("#{col_name}?") do
+      return true if self[col_name.to_sym].to_s == "1"
+      return false
     end
   end
 
-  #Defines date- and time-columns based on datetime- and date-columns.
+  # Defines date- and time-columns based on datetime- and date-columns.
   def self.define_date_methods(inst_methods, col_name)
-    if !inst_methods.include?("#{col_name}_str".to_sym)
-      define_method("#{col_name}_str") do |*method_args|
-        if Datet.is_nullstamp?(self[col_name])
-          return self.class.ob.events.call(:no_date, self.class.name)
-        end
+    return if inst_methods.include?("#{col_name}_str".to_sym)
 
-        return Datet.in(self[col_name]).out(*method_args)
+    define_method("#{col_name}_str") do |*method_args|
+      if Datet.is_nullstamp?(self[col_name])
+        return self.class.ob.events.call(:no_date, self.class.name)
       end
+
+      return Datet.in(self[col_name]).out(*method_args)
     end
 
-    if !inst_methods.include?(col_name)
-      define_method(col_name) do |*method_args|
-        return false if Datet.is_nullstamp?(self[col_name])
-        return Datet.in(self[col_name])
-      end
+    return if inst_methods.include?(col_name)
+
+    define_method(col_name) do |*_method_args|
+      return false if Datet.is_nullstamp?(self[col_name])
+      return Datet.in(self[col_name])
     end
   end
 
-  #Define various methods based on integer-columns.
+  # Define various methods based on integer-columns.
   def self.define_numeric_methods(inst_methods, col_name)
-    if !inst_methods.include?("#{col_name}_format".to_sym)
-      define_method("#{col_name}_format") do |*method_args|
-        return Knj::Locales.number_out(self[col_name], *method_args)
-      end
+    return if inst_methods.include?("#{col_name}_format".to_sym)
+
+    define_method("#{col_name}_format") do |*method_args|
+      return Knj::Locales.number_out(self[col_name], *method_args)
     end
   end
 
-  #Define methods to look up objects directly.
+  # Define methods to look up objects directly.
   #===Examples
   #  user = Models::User.by_username('John Doe')
   #  print user.id
   def self.define_text_methods(inst_methods, col_name)
-    if !inst_methods.include?("by_#{col_name}".to_sym) and RUBY_VERSION.to_s.slice(0, 3) != "1.8"
-      define_singleton_method("by_#{col_name}") do |arg|
-        return self.class.ob.get_by(self.class.table, {col_name.to_s => arg})
-      end
+    return if inst_methods.include?("by_#{col_name}".to_sym) && RUBY_VERSION.to_s.slice(0, 3) != "1.8"
+
+    define_singleton_method("by_#{col_name}") do |arg|
+      return self.class.ob.get_by(self.class.table, col_name.to_s => arg)
     end
   end
 
-  #Defines dbtime-methods based on time-columns.
+  # Defines dbtime-methods based on time-columns.
   def self.define_time_methods(inst_methods, col_name)
-    if !inst_methods.include?("#{col_name}_dbt".to_sym)
-      define_method("#{col_name}_dbt") do
-        return Baza::Db::Dbtime.new(self[col_name.to_sym])
-      end
+    return if inst_methods.include?("#{col_name}_dbt".to_sym)
+
+    define_method("#{col_name}_dbt") do
+      return Baza::Db::Dbtime.new(self[col_name.to_sym])
     end
   end
 
-  #Memory friendly helper method that defines methods for 'has_many'.
+  # Memory friendly helper method that defines methods for 'has_many'.
   def self.define_many_methods(classname, methodname, colname, where_args)
     define_method(methodname) do |*args, &block|
-      if args and args[0]
+      if args && args[0]
         list_args = args[0]
       else
         list_args = {}
       end
 
       list_args.merge!(where_args) if where_args
-      list_args[colname.to_s] = self.id
+      list_args[colname.to_s] = id
 
-      return self.class.ob.list(classname, list_args, &block)
+      self.class.ob.list(classname, list_args, &block)
     end
 
     define_method("#{methodname}_count".to_sym) do |*args|
-      list_args = args[0] if args and args[0]
-      list_args = {} if !list_args
-      list_args[colname.to_s] = self.id
+      list_args = args[0] if args && args[0]
+      list_args = {} unless list_args
+      list_args[colname.to_s] = id
       list_args["count"] = true
 
-      return self.class.ob.list(classname, list_args)
+      self.class.ob.list(classname, list_args)
     end
 
     define_method("#{methodname}_last".to_sym) do |args|
-      args = {} if !args
-      return self.class.ob.list(classname, {"orderby" => [["id", "desc"]], "limit" => 1}.merge(args))
+      args = {} unless args
+      self.class.ob.list(classname, {"orderby" => [["id", "desc"]], "limit" => 1}.merge(args))
     end
   end
 
-  #Memory friendly helper method that defines methods for 'has_one'.
+  # Memory friendly helper method that defines methods for 'has_one'.
   def self.define_one_methods(classname, methodname, colname)
     define_method(methodname) do
-      return self.class.ob.get_try(self, colname, classname)
+      self.class.ob.get_try(self, colname, classname)
     end
 
     methodname_html = "#{methodname}_html".to_sym
     define_method(methodname_html) do |*args|
-      obj = self.__send__(methodname)
-      return self.class.ob.events.call(:no_html, classname) if !obj
+      obj = __send__(methodname)
+      return self.class.ob.events.call(:no_html, classname) unless obj
 
-      raise "Class '#{classname}' does not have a 'html'-method." if !obj.respond_to?(:html)
-      return obj.html(*args)
+      raise "Class '#{classname}' does not have a 'html'-method." unless obj.respond_to?(:html)
+      obj.html(*args)
     end
 
     methodname_name = "#{methodname}_name".to_sym
     define_method(methodname_name) do |*args|
-      obj = self.__send__(methodname)
-      return self.class.ob.events.call(:no_name, classname) if !obj
-      return obj.name(*args)
+      obj = __send__(methodname)
+      return self.class.ob.events.call(:no_name, classname) unless obj
+      obj.name(*args)
     end
   end
 
-  #Returns a hash reflection the current ActiveRecord model and its current values (not like .attributes which reflects the old values).
+  # Returns a hash reflection the current ActiveRecord model and its current values (not like .attributes which reflects the old values).
   def self.activerecord_to_hash(model)
     attrs = {}
     model.attribute_names.each do |name|
       attrs[name] = model.__send__(name)
     end
 
-    return attrs
+    attrs
   end
-end
+end