hayabusa 0.0.25 → 0.0.30

data/lib/hayabusa_revision.rb

@@ -0,0 +1,347 @@
+#This class takes a database-schema from a hash and runs it against the database. It then checks that the database matches the given schema.
+#
+#===Examples
+# db = Knj::Db.new(:type => "sqlite3", :path => "test_db.sqlite3")
+# schema = {
+#   "tables" => {
+#     "User" => {
+#       columns: [
+#         {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
+#         {"name" => "name", "type" => "varchar"},
+#         {"name" => "lastname", "type" => "varchar"}
+#       ],
+#       "indexes" => [
+#         "name",
+#         {"name" => "lastname", columns: ["lastname"]}
+#       ],
+#       "on_create_after" => proc{|d|
+#         d["db"].insert("User", {"name" => "John", "lastname" => "Doe"})
+#       }
+#     }
+#   }
+# }
+#
+# rev = Knj::Db::Revision.new
+# rev.init_db("db" => db, "schema" => schema)
+class Hayabusa::Revision
+  def initialize(args = {})
+    @args = args
+  end
+
+  #This initializes a database-structure and content based on a schema-hash.
+  #===Examples
+  # dbrev = Knj::Db::Revision.new
+  # dbrev.init_db("db" => db_obj, "schema" => schema_hash)
+  def init_db(args)
+    schema = args["schema"]
+    db = args["db"]
+
+    #Check for normal bugs and raise apropiate error.
+    raise "'schema' argument was not a Hash: '#{schema.class.name}'." if !schema.is_a?(Hash)
+    raise "':return_keys' is not 'symbols' - Knjdbrevision will not work without it." if db.opts[:return_keys] != "symbols"
+    raise "No tables given." if !schema.has_key?("tables")
+
+    #Cache tables to avoid constant reloading.
+    if !args.key?("tables_cache") or args["tables_cache"]
+      print "Caching tables-list.\n" if args["debug"]
+      tables = db.tables.list
+    else
+      print "Skipping tables-cache.\n" if args["debug"]
+    end
+
+    schema["tables"].each do |table_name, table_data|
+      begin
+        begin
+          table_obj = db.tables[table_name]
+
+          #Cache indexes- and column-objects to avoid constant reloading.
+          cols = table_obj.columns
+          indexes = table_obj.indexes
+
+          if table_data[:columns]
+            first_col = true
+            table_data[:columns].each do |col_data|
+              begin
+                col_obj = table_obj.column(col_data["name"])
+                col_str = "#{table_name}.#{col_obj.name}"
+                type = col_data["type"].to_s
+                dochange = false
+
+                if !first_col and !col_data["after"]
+                  #Try to find out the previous column - if so we can set "after" which makes the column being created in the right order as defined.
+                  if !col_data.has_key?("after")
+                    prev_no = table_data[:columns].index(col_data)
+                    if prev_no != nil and prev_no != 0
+                      prev_no = prev_no - 1
+                      prev_col_data = table_data[:columns][prev_no]
+                      col_data["after"] = prev_col_data["name"]
+                    end
+                  end
+
+                  actual_after = nil
+                  set_next = false
+                  cols.each do |col_name, col_iter|
+                    if col_iter.name == col_obj.name
+                      break
+                    else
+                      actual_after = col_iter.name
+                    end
+                  end
+
+                  if actual_after != col_data["after"]
+                    print "Changing '#{col_str}' after from '#{actual_after}' to '#{col_data["after"]}'.\n" if args["debug"]
+                    dochange = true
+                  end
+                end
+
+                #BUGFIX: When using SQLite3 the primary-column or a autoincr-column may never change type from int... This will break it!
+                if db.opts[:type] == "sqlite3" and col_obj.type.to_s == "int" and (col_data["primarykey"] or col_data["autoincr"]) and db.int_types.index(col_data["type"].to_s)
+                  type = "int"
+                end
+
+                if type and col_obj.type.to_s != type
+                  print "Type mismatch on #{col_str}: #{col_data["type"]}, #{col_obj.type}\n" if args["debug"]
+                  dochange = true
+                end
+
+                if col_data.has_key?("primarykey") and col_obj.primarykey? != col_data["primarykey"]
+                  print "Primary-key mismatch for #{col_str}: #{col_data["primarykey"]}, #{col_obj.primarykey?}\n" if args["debug"]
+                  dochange = true
+                end
+
+                if col_data.has_key?("autoincr") and col_obj.autoincr? != col_data["autoincr"]
+                  print "Auto-increment mismatch for #{col_str}: #{col_data["autoincr"]}, #{col_obj.autoincr?}\n" if args["debug"]
+                  dochange = true
+                end
+
+                if col_data.has_key?("maxlength") and col_obj.maxlength.to_s != col_data["maxlength"].to_s
+                  print "Maxlength mismatch on #{col_str}: #{col_data["maxlength"]}, #{col_obj.maxlength}\n" if args["debug"]
+                  dochange = true
+                end
+
+                if col_data.has_key?("null") and col_obj.null?.to_s != col_data["null"].to_s
+                  print "Null mismatch on #{col_str}: #{col_data["null"]}, #{col_obj.null?}\n" if args["debug"]
+                  dochange = true
+                end
+
+                if col_data.has_key?("default") and col_obj.default.to_s != col_data["default"].to_s
+                  print "Default mismatch on #{col_str}: #{col_data["default"]}, #{col_obj.default}\n" if args["debug"]
+                  dochange = true
+                end
+
+                if col_data.has_key?("comment") and col_obj.respond_to?(:comment) and col_obj.comment.to_s != col_data["comment"].to_s
+                  print "Comment mismatch on #{col_str}: #{col_data["comment"]}, #{col_obj.comment}\n" if args["debug"]
+                  dochange = true
+                end
+
+                if col_data.is_a?(Hash) and col_data["on_before_alter"]
+                  callback_data = col_data["on_before_alter"].call("db" => db, "table" => table_obj, "col" => col_obj, "col_data" => col_data)
+                  if callback_data and callback_data["action"]
+                    if callback_data["action"] == "retry"
+                      raise Knj::Errors::Retry
+                    end
+                  end
+                end
+
+                if dochange
+                  col_obj.change(col_data)
+
+                  #Change has been made - update cache.
+                  cols = table_obj.columns
+                end
+
+                first_col = false
+              rescue Errno::ENOENT => e
+                print "Column not found: #{table_obj.name}.#{col_data["name"]}.\n" if args["debug"]
+
+                if col_data.has_key?("renames")
+                  raise "'renames' was not an array for column '#{table_obj.name}.#{col_data["name"]}'." if !col_data["renames"].is_a?(Array)
+
+                  rename_found = false
+                  col_data["renames"].each do |col_name|
+                    begin
+                      col_rename = table_obj.column(col_name)
+                    rescue Errno::ENOENT => e
+                      next
+                    end
+
+                    print "Rename #{table_obj.name}.#{col_name} to #{table_obj.name}.#{col_data["name"]}\n" if args["debug"]
+                    if col_data.is_a?(Hash) and col_data["on_before_rename"]
+                      col_data["on_before_rename"].call("db" => db, "table" => table_obj, "col" => col_rename, "col_data" => col_data)
+                    end
+
+                    col_rename.change(col_data)
+
+                    #Change has been made - update cache.
+                    cols = table_obj.columns
+
+                    if col_data.is_a?(Hash) and col_data["on_after_rename"]
+                      col_data["on_after_rename"].call("db" => db, "table" => table_obj, "col" => col_rename, "col_data" => col_data)
+                    end
+
+                    rename_found = true
+                    break
+                  end
+
+                  retry if rename_found
+                end
+
+                oncreated = col_data[:on_created]
+                col_data.delete(:on_created) if col_data[:oncreated]
+                col_obj = table_obj.create_columns([col_data])
+
+                #Change has been made - update cache.
+                cols = table_obj.columns
+
+                oncreated.call("db" => db, "table" => table_obj) if oncreated
+              end
+            end
+          end
+
+          if table_data["columns_remove"]
+            table_data["columns_remove"].each do |column_name, column_data|
+              begin
+                col_obj = table_obj.column(column_name)
+              rescue Errno::ENOENT => e
+                next
+              end
+
+              column_data["callback"].call if column_data.is_a?(Hash) and column_data["callback"]
+              col_obj.drop
+            end
+          end
+
+          if table_data[:indexes]
+            table_data[:indexes].each do |index_data|
+              if index_data.is_a?(String)
+                index_data = {name: index_data, columns: [index_data]}
+              end
+
+              begin
+                index_obj = table_obj.index(index_data[:name])
+
+                rewrite_index = false
+                rewrite_index = true if index_data.key?(:unique) and index_data[:unique] != index_obj.unique?
+
+                if rewrite_index
+                  index_obj.drop
+                  table_obj.create_indexes([index_data])
+                end
+              rescue Errno::ENOENT => e
+                table_obj.create_indexes([index_data])
+              end
+            end
+          end
+
+          if table_data["indexes_remove"]
+            table_data["indexes_remove"].each do |index_name, index_data|
+              begin
+                index_obj = table_obj.index(index_name)
+              rescue Errno::ENOENT => e
+                next
+              end
+
+              if index_data.is_a?(Hash) and index_data["callback"]
+                index_data["callback"].call if index_data["callback"]
+              end
+
+              index_obj.drop
+            end
+          end
+
+          rows_init("db" => db, "table" => table_obj, "rows" => table_data["rows"]) if table_data and table_data["rows"]
+        rescue Baza::Errors::TableNotFound => e
+          if table_data.key?("renames")
+            table_data["renames"].each do |table_name_rename|
+              begin
+                table_rename = db.tables[table_name_rename.to_sym]
+                table_rename.rename(table_name)
+                raise Knj::Errors::Retry
+              rescue Errno::ENOENT
+                next
+              end
+            end
+          end
+
+          if !table_data.key?(:columns)
+            print "Notice: Skipping creation of '#{table_name}' because no columns were given in hash.\n"
+            next
+          end
+
+          if table_data["on_create"]
+            table_data["on_create"].call("db" => db, "table_name" => table_name, "table_data" => table_data)
+          end
+
+          table_data[:columns].each do |column|
+            column.delete(:comment) if column.key?(:comment)
+            column.delete(:on_created) if column.key?(:on_created)
+          end
+
+          db.tables.create(table_name, table_data)
+          table_obj = db.tables[table_name.to_sym]
+
+          if table_data["on_create_after"]
+            table_data["on_create_after"].call("db" => db, "table_name" => table_name, "table_data" => table_data)
+          end
+
+          rows_init("db" => db, "table" => table_obj, "rows" => table_data["rows"]) if table_data["rows"]
+        end
+      rescue Knj::Errors::Retry
+        retry
+      end
+    end
+
+    if schema["tables_remove"]
+      schema["tables_remove"].each do |table_name, table_data|
+        begin
+          table_obj = db.tables[table_name.to_sym]
+          table_data["callback"].call("db" => db, "table" => table_obj) if table_data.is_a?(Hash) and table_data["callback"]
+          table_obj.drop
+        rescue Errno::ENOENT => e
+          next
+        end
+      end
+    end
+
+
+    #Free cache.
+    tables.clear if tables
+    tables = nil
+  end
+
+  private
+
+  #This method checks if certain rows are present in a table based on a hash.
+  def rows_init(args)
+    db = args["db"]
+    table = args["table"]
+
+    raise "No db given." if !db
+    raise "No table given." if !table
+
+    args["rows"].each do |row_data|
+      if row_data["find_by"]
+        find_by = row_data["find_by"]
+      elsif row_data["data"]
+        find_by = row_data["data"]
+      else
+        raise "Could not figure out the find-by."
+      end
+
+      rows_found = 0
+      args["db"].select(table.name, find_by) do |d_rows|
+        rows_found += 1
+
+        if Knj::ArrayExt.hash_diff?(Knj::ArrayExt.hash_sym(row_data["data"]), Knj::ArrayExt.hash_sym(d_rows), {"h2_to_h1" => false})
+          print "Data was not right - updating row: #{JSON.generate(row_data["data"])}\n" if args["debug"]
+          args["db"].update(table.name, row_data["data"], d_rows)
+        end
+      end
+
+      if rows_found == 0
+        print "Inserting row: #{JSON.generate(row_data["data"])}\n" if args["debug"]
+        table.insert(row_data["data"])
+      end
+    end
+  end
+end

data/lib/models/log.rb

@@ -1,15 +1,15 @@
-class Hayabusa::Models::Log < Knj::Datarow
+class Hayabusa::Models::Log < Hayabusa::Datarow
   has_many [
     {:class => :Log_link, :col => :log_id, :method => :links, :depends => true, :autodelete => true}
   ]
-  
+
   def self.list(d, &block)
     sql = "SELECT #{table}.* FROM #{table}"
-    
+
     if d.args["object_lookup"]
       data_val = d.ob.get_by(:Log_data_value, {"value" => d.args["object_lookup"].class.name})
       return [] if !data_val #if this data-value cannot be found, nothing has been logged for the object. So just return empty array here and skip the rest.
-      
+
       sql << "
         LEFT JOIN Log_link ON
           Log_link.log_id = #{table}.id AND
@@ -17,14 +17,14 @@ class Hayabusa::Models::Log < Knj::Datarow
           Log_link.object_id = '#{d.db.esc(d.args["object_lookup"].id)}'
       "
     end
-    
+
     q_args = nil
     return_sql = false
     ret = self.list_helper(d)
-    
+
     sql << ret[:sql_joins]
     sql << " WHERE 1=1"
-    
+
     d.args.each do |key, val|
       case key
         when "object_lookup"
@@ -44,87 +44,87 @@ class Hayabusa::Models::Log < Knj::Datarow
           raise "Invalid key: #{key}."
         end
     end
-    
+
     sql << ret[:sql_where]
     sql << ret[:sql_order]
     sql << ret[:sql_limit]
-    
+
     return sql if return_sql
-    
+
     return d.ob.list_bysql(:Log, sql, q_args, &block)
   end
-  
+
   def self.add(d)
     d.data[:date_saved] = Time.now if !d.data.key?(:date_saved)
   end
-  
+
   def text
     return ob.get(:Log_data_value, self[:text_value_id])[:value]
   end
-  
+
   def comment
     return "" if self[:comment_data_id].to_i == 0
     log_data = ob.get(:Log_data_value, self[:comment_data_id])
     return "" if !log_data
     return log_data[:value]
   end
-  
+
   def tag
     return "" if self[:tag_data_id].to_i == 0
     log_data = ob.get(:Log_data_value, self[:tag_data_id])
     return "" if !log_data
     return log_data[:value]
   end
-  
+
   def get
     ob.args[:hayabusa].log_data_hash(self[:get_keys_data_id], self[:get_values_data_id])
   end
-  
+
   def post
     ob.args[:hayabusa].log_data_hash(self[:post_keys_data_id], self[:post_values_data_id])
   end
-  
+
   def cookie
     ob.args[:hayabusa].log_data_hash(self[:cookie_keys_data_id], self[:cookie_values_data_id])
   end
-  
+
   def meta
     ob.args[:hayabusa].log_data_hash(self[:meta_keys_data_id], self[:meta_values_data_id])
   end
-  
+
   def session
     ob.args[:hayabusa].log_data_hash(self[:session_keys_data_id], self[:session_values_data_id])
   end
-  
+
   def ip
     meta_d = self.meta
-    
+
     return meta_d[:HTTP_X_FORWARDED_FOR].split(/\s*,\s*/).first if meta_d.has_key?(:HTTP_X_FORWARDED_FOR)
     return meta_d[:REMOTE_ADDR] if meta_d.has_key?(:REMOTE_ADDR)
     return "[no ip logged]"
   end
-  
+
   def first_line
     lines = self.text.to_s.split("\n").first.to_s
   end
-  
+
   def objects_html(ob_use)
     html = ""
     first = true
-    
+
     self.links.each do |link|
       obj = link.object(ob_use)
-      
+
       html << ", " if !first
       first = false if first
-      
+
       if obj.respond_to?(:html)
         html << obj.html
       else
         html << "#{obj.class.name}{#{obj.id}}"
       end
     end
-    
+
     return html
   end
 end

data/lib/models/log_access.rb

@@ -1,88 +1,88 @@
-class Hayabusa::Models::Log_access < Knj::Datarow
+class Hayabusa::Models::Log_access < Hayabusa::Datarow
   def get
     return data_hash("get")
   end
-  
+
   def post
     return data_hash("post")
   end
-  
+
   def meta
     return data_hash("meta")
   end
-  
+
   def cookie
     return data_hash("cookie")
   end
-  
+
   def ips
     return data_array(self[:ip_data_id])
   end
-  
+
   def data_array(data_id)
     sql = "
       SELECT
         value_value.value AS value
-      
+
       FROM
         Log_data_link AS value_links,
         Log_data_value AS value_value
-      
+
       WHERE
         value_links.data_id = '#{data_id}' AND
         value_value.id = value_links.value_id
-      
+
       ORDER BY
         key_links.no
     "
-    
+
     arr = []
     q_array = db.query(sql)
     while d_array = q_array.fetch
       arr << d_array[:value]
     end
-    
+
     return arr
   end
-  
+
   def data_hash(type)
     col_keys_id = "#{type}_keys_data_id".to_sym
     col_values_id = "#{type}_values_data_id".to_sym
-    
+
     keys_id = self[col_keys_id]
     values_id = self[col_values_id]
-    
+
     keys_data_obj = ob.get(:Log_data, keys_id)
     values_data_obj = ob.get(:Log_data, values_id)
-    
+
     sql = "
       SELECT
         key_value.value AS `key`,
         value_value.value AS value
-      
+
       FROM
         Log_data_link AS key_links,
         Log_data_link AS value_links,
         Log_data_value AS key_value,
         Log_data_value AS value_value
-      
+
       WHERE
         key_links.data_id = '#{keys_id}' AND
         value_links.data_id = '#{values_id}' AND
         key_links.no = value_links.no AND
         key_value.id = key_links.value_id AND
         value_value.id = value_links.value_id
-      
+
       ORDER BY
         key_links.no
     "
-    
+
     hash = {}
     q_hash = db.query(sql)
     while d_hash = q_hash.fetch
       hash[d_hash[:key].to_s] = d_hash[:value]
     end
-    
+
     return hash
   end
 end

data/lib/models/log_data.rb

@@ -1,26 +1,26 @@
-class Hayabusa::Models::Log_data < Knj::Datarow
+class Hayabusa::Models::Log_data < Hayabusa::Datarow
   def self.force(d, id_hash)
     data_obj = d.ob.get_by(:Log_data, {"id_hash" => id_hash})
-    
+
     if !data_obj
       data_obj = d.ob.add(:Log_data, {"id_hash" => id_hash})
     end
-    
+
     return data_obj
   end
-  
+
   def self.force_id(d, id_hash)
     data = d.db.query("SELECT * FROM Log_data WHERE id_hash = '#{d.db.esc(id_hash)}' LIMIT 1").fetch
     return data[:id].to_i if data
     return d.db.insert(:Log_data, {:id_hash => id_hash}, {:return_id => true}).to_i
   end
-  
+
   def self.by_id_hash(d, id_hash)
     data = d.db.query("SELECT * FROM Log_data WHERE id_hash = '#{d.db.esc(id_hash)}' LIMIT 1").fetch
     return data[:id].to_i if data
     return false
   end
-  
+
   def links(args = {})
     return ob.list(:Log_data_link, {"data" => self}.merge(args))
   end

data/lib/models/log_data_link.rb

@@ -1,3 +1,3 @@
-class Hayabusa::Models::Log_data_link < Knj::Datarow
-  
+class Hayabusa::Models::Log_data_link < Hayabusa::Datarow
+
 end

data/lib/models/log_data_value.rb

@@ -1,21 +1,21 @@
-class Hayabusa::Models::Log_data_value < Knj::Datarow
+class Hayabusa::Models::Log_data_value < Hayabusa::Datarow
   def self.force(d, value)
     value_obj = d.ob.get_by(:Log_data_value, {
       "value" => value.to_s
     })
-    
+
     if !value_obj
       value_obj = d.ob.add(:Log_data_value, {"value" => value})
     end
-    
+
     return value_obj
   end
-  
+
   def self.force_id(d, value)
     d.db.select(:Log_data_value, {"value" => value}) do |d_val|
       return d_val[:id].to_i if d_val[:value].to_s == value.to_s #MySQL doesnt take upper/lower-case into consideration because value is a text-column... lame! - knj
     end
-    
+
     return d.db.insert(:Log_data_value, {:value => value}, {:return_id => true}).to_i
   end
 end