baza 0.0.19 → 0.0.20

data/spec/info_mysql_shippable.rb

@@ -11,7 +11,7 @@ class Baza::InfoMysql
   end
 
   def before
-    @db.tables.list.each do |name, table|
+    @db.tables.list do |table|
       table.drop
     end
   end

data/spec/info_sqlite3.rb

@@ -6,18 +6,19 @@ class Baza::InfoSqlite3
     require "tmpdir"
 
     @path = "#{Dir.tmpdir}/baza_sqlite3_test_#{Time.now.to_f.to_s.hash}_#{Random.rand}.sqlite3"
-    File.unlink(path) if File.exists?(@path)
+    File.unlink(path) if File.exist?(@path)
 
     @db = Baza::Db.new({
       type: :sqlite3,
       path: @path,
       index_append_table_name: true,
-      sql_to_error: true
+      sql_to_error: true,
+      debug: false
     }.merge(args))
   end
 
   def before
-    @db.tables.list.each do |name, table|
+    @db.tables.list do |table|
       table.drop
     end
   end

data/spec/model_handler_spec.rb

@@ -6,7 +6,7 @@ describe "Objects" do
     require "sqlite3" unless RUBY_ENGINE == "jruby"
     require "tmpdir"
 
-    File.unlink(db_path) if File.exists?(db_path)
+    File.unlink(db_path) if File.exist?(db_path)
     db = Baza::Db.new(type: :sqlite3, path: db_path, debug: false)
 
     schema = {
@@ -79,8 +79,8 @@ describe "Objects" do
     ob
   end
 
-  let(:task) { ob.add(:Task, name: 'Test task', person_id: person.id) }
-  let(:person) { ob.add(:Person, name: 'Kasper') }
+  let(:task) { ob.add(:Task, name: "Test task", person_id: person.id) }
+  let(:person) { ob.add(:Person, name: "Kasper") }
   let(:project) { ob.add(:Project) }
 
   before(:all) do
@@ -107,7 +107,7 @@ describe "Objects" do
       ]
 
       def html
-        return self[:name]
+        self[:name]
       end
     end
 
@@ -118,7 +118,7 @@ describe "Objects" do
     expect(ob.ids_cache[:User].length).to eq 5
 
     user = ob.get(:User, 4)
-    raise "No user returned." if !user
+    raise "No user returned." unless user
     ob.delete(user)
 
     expect(ob.ids_cache[:User].length).to eq 4
@@ -141,26 +141,34 @@ describe "Objects" do
     ob.adds(:User, userd)
     users = ob.list(:User).to_a
 
-    #Stress it to test threadsafety...
+    # Stress it to test threadsafety...
     threads = []
     0.upto(5) do |tc|
       threads << Thread.new do
         0.upto(5) do |ic|
-          user = ob.add(:User, {:username => "User #{tc}-#{ic}"})
-          raise "No user returned." if !user
+          user = ob.add(:User, username: "User #{tc}-#{ic}")
+          raise "No user returned." unless user
           ob.delete(user)
 
-          user1 = ob.add(:User, {:username => "User #{tc}-#{ic}-1"})
-          user2 = ob.add(:User, {:username => "User #{tc}-#{ic}-2"})
-          user3 = ob.add(:User, {:username => "User #{tc}-#{ic}-3"})
+          user1 = ob.add(:User, username: "User #{tc}-#{ic}-1")
+          user2 = ob.add(:User, username: "User #{tc}-#{ic}-2")
+          user3 = ob.add(:User, username: "User #{tc}-#{ic}-3")
+
+          expect(user1).to_not eq nil
+          expect(user1.deleted?).to eq false
+
+          expect(user2).to_not eq nil
+          expect(user2.deleted?).to eq false
+
+          expect(user3).to_not eq nil
+          expect(user3.deleted?).to eq false
 
-          raise "Missing user?" if !user1 or !user2 or !user3 or user1.deleted? or user2.deleted? or user3.deleted?
           ob.deletes([user1, user2, user3])
 
           count = 0
-          users.each do |user|
+          users.each do |user_i|
             count += 1
-            user[:username] = "#{user[:username]}." unless user.deleted?
+            user_i[:username] = "#{user_i[:username]}." unless user_i.deleted?
           end
 
           expect(count).to eq 21
@@ -175,9 +183,9 @@ describe "Objects" do
     class Group < Baza::Model; end
 
     ob2 = Baza::ModelHandler.new(
-      :db => db,
-      :datarow => true,
-      :require => false
+      db: db,
+      datarow: true,
+      require: false
     )
 
     threads = []
@@ -186,82 +194,82 @@ describe "Objects" do
         Thread.current.abort_on_exception = true
 
         0.upto(5) do
-          ret = ob2.add(:Group, {groupname: "User 1"}, {skip_ret: true})
+          ret = ob2.add(:Group, {groupname: "User 1"}, skip_ret: true)
           raise "Expected empty return but got something: #{ret}" if ret
         end
       end
     end
 
-    threads.each do |thread|
-      thread.join
-    end
+    threads.each(&:join)
   end
 
   it "should delete the temporary database." do
-    File.unlink(db_path) if File.exists?(db_path)
+    File.unlink(db_path) if File.exist?(db_path)
   end
 
-  #Moved from "knjrbfw_spec.rb"
+  # Moved from "knjrbfw_spec.rb"
   it "should be able to generate a sample SQLite database and add a sample table, with sample columns and with a sample index to it" do
-    require 'tmpdir'
+    require "tmpdir"
 
     db_path = "#{Dir.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
     db = Baza::Db.new(
-      :type => :sqlite3,
-      :path => db_path,
-      :index_append_table_name => true
+      type: :sqlite3,
+      path: db_path,
+      index_append_table_name: true
     )
 
-    db.tables.create("Project", {
-      :columns => [
-        {:name => :id, :type => :int, :autoincr => true, :primarykey => true},
-        {:name => :category_id, :type => :int},
-        {:name => :name, :type => :varchar}
+    db.tables.create(
+      "Project",
+      columns: [
+        {name: :id, type: :int, autoincr: true, primarykey: true},
+        {name: :category_id, type: :int},
+        {name: :name, type: :varchar}
       ],
-      :indexes => [
-        {:name => :category_id, :columns => [:category_id]}
+      indexes: [
+        {name: :category_id, columns: [:category_id]}
       ]
-    })
-
-    db.tables.create("Task", {
-      :columns => [
-        {:name => :id, :type => :int, :autoincr => true, :primarykey => true},
-        {:name => :project_id, :type => :int},
-        {:name => :person_id, :type => :int},
-        {:name => :name, :type => :varchar}
+    )
+
+    db.tables.create(
+      "Task",
+      columns: [
+        {name: :id, type: :int, autoincr: true, primarykey: true},
+        {name: :project_id, type: :int},
+        {name: :person_id, type: :int},
+        {name: :name, type: :varchar}
       ],
-      :indexes => [
-        {:name => :project_id, :columns => [:project_id]}
+      indexes: [
+        {name: :project_id, columns: [:project_id]}
       ]
-    })
+    )
 
-    db.tables.create("Person", {
-      :columns => [
-        {:name => :id, :type => :int, :autoincr => true, :primarykey => true},
-        {:name => :name, :type => :varchar}
+    db.tables.create(
+      "Person",
+      columns: [
+        {name: :id, type: :int, autoincr: true, primarykey: true},
+        {name: :name, type: :varchar}
       ]
-    })
+    )
 
-    db.tables.create("Timelog", {
-      :columns => [
-        {:name => :id, :type => :int, :autoincr => true, :primarykey => true},
-        {:name => :person_id, :type => :int}
+    db.tables.create(
+      "Timelog",
+      columns: [
+        {name: :id, type: :int, autoincr: true, primarykey: true},
+        {name: :person_id, type: :int}
       ],
-      :indexes => [
+      indexes: [
         :person_id
       ]
-    })
+    )
 
     table = db.tables[:Project]
 
     indexes = table.indexes
-    raise "Could not find the sample-index 'category_id' that should have been created." unless indexes[:Project__category_id]
+    raise "Could not find the sample-index 'category_id' that should have been created." unless indexes.any? { |index| index.name == "Project__category_id" }
 
 
-    #If we insert a row the ID should increase and the name should be the same as inserted (or something is very very wrong)...
-    db.insert("Project", {
-      "name" => "Test project"
-    })
+    # If we insert a row the ID should increase and the name should be the same as inserted (or something is very very wrong)...
+    db.insert("Project", name: "Test project")
 
     count = 0
     db.q("SELECT * FROM Project") do |d|
@@ -274,37 +282,31 @@ describe "Objects" do
   end
 
   it "should be able to automatic generate methods on datarow-classes (has_many, has_one)." do
-    ob = Baza::ModelHandler.new(:db => db, :datarow => true, :require => false)
+    ob = Baza::ModelHandler.new(db: db, datarow: true, require: false)
 
-    ob.add(:Person, {
-      :name => "Kasper"
-    })
-    ob.add(:Task, {
-      :name => "Test task",
-      :person_id => person.id,
-      :project_id => project.id
-    })
+    ob.add(:Person, name: "Kasper")
+    ob.add(:Task, name: "Test task", person_id: person.id, project_id: project.id)
 
     begin
-      obb.add(:Task, {:name => "Test task"})
+      obb.add(:Task, name: "Test task")
       raise "Method should fail but didnt."
     rescue
-      #ignore.
+      # Ignore.
     end
 
 
-    #Test 'list_invalid_required'.
-    db.insert(:Task, :name => "Invalid require")
+    # Test 'list_invalid_required'.
+    db.insert(:Task, name: "Invalid require")
     id = db.last_id
     found = false
 
-    ob.list_invalid_required(:class => :Task) do |d|
+    ob.list_invalid_required(class: :Task) do |d|
       raise "Expected object ID to be #{id} but it wasnt: #{d[:obj].id}" if d[:obj].id.to_i != id.to_i
       ob.delete(d[:obj])
       found = true
     end
 
-    raise "Expected to find a task but didnt." if !found
+    raise "Expected to find a task but didnt." unless found
 
 
     ret_proc = []
@@ -324,22 +326,22 @@ describe "Objects" do
       ret_proc << task
     end
 
-    raise "When given a block the return should be nil so it doesnt hold weak-ref-objects in memory but it didnt return nil." if ret_test != nil
+    raise "When given a block the return should be nil so it doesnt hold weak-ref-objects in memory but it didnt return nil." unless ret_test == nil
     raise "list for project with proc should return one task but didnt (#{ret_proc.length})." if ret_proc.length != 1
 
     person = tasks.first.person
     project_second = tasks.first.project
 
-    raise "Returned object was not a person on task." if !person.is_a?(Person)
-    raise "Returned object was not a project on task." if !project_second.is_a?(Project)
+    raise "Returned object was not a person on task." unless person.is_a?(Person)
+    raise "Returned object was not a project on task." unless project_second.is_a?(Project)
 
 
-    #Check that has_many-depending is actually working.
+    # Check that has_many-depending is actually working.
     begin
       ob.delete(project)
       raise "It was possible to delete project 1 even though task 1 depended on it!"
     rescue
-      #this should happen - it should not possible to delete project 1 because task 1 depends on it."
+      # This should happen - it should not possible to delete project 1 because task 1 depends on it."
     end
   end
 
@@ -347,24 +349,24 @@ describe "Objects" do
     task
     list = ob.list_optshash(:Task)
     list.length.should eq 1
-    list[1].should eq 'Test task'
+    list[1].should eq "Test task"
   end
 
   it "should be able to connect to objects 'no-html' callback and test it." do
     task
-    ob.events.connect(:no_html) do |event, classname|
+    ob.events.connect(:no_html) do |_event, classname|
       "[no #{classname.to_s.downcase}]"
     end
 
     expect(task.person_html).to eq "Kasper"
-    task.update(:person_id => 0)
+    task.update(person_id: 0)
     expect(task.person_html).to eq "[no person]"
   end
 
   it "should be able to to multiple additions and delete objects through a buffer" do
     objs = []
     0.upto(500) do
-      objs << {:name => :Kasper}
+      objs << {name: :Kasper}
     end
 
     ob.adds(:Person, objs)
@@ -374,7 +376,7 @@ describe "Objects" do
     db.q_buffer do |buffer|
       ob.list(:Person) do |person|
         count += 1
-        ob.delete(person, :db_buffer => buffer)
+        ob.delete(person, db_buffer: buffer)
       end
 
       buffer.flush
@@ -383,23 +385,15 @@ describe "Objects" do
     raise "Expected count to be #{pers_length} but it wasnt: #{count}" if count != pers_length
 
     persons = ob.list(:Person).to_a
-    raise "Expected persons count to be 0 but it wasnt: #{persons.map{|e| e.data} }" if persons.length > 0
+    raise "Expected persons count to be 0 but it wasnt: #{persons.map(&:data)}" if persons.length > 0
   end
 
   it "should do autozero when deleting objects" do
-    person1 = ob.add(:Person, {
-      :name => "Kasper"
-    })
-    person2 = ob.add(:Person, {
-      :name => "Charlotte"
-    })
-
-    timelog1 = ob.add(:Timelog, {
-      :person_id => person1.id
-    })
-    timelog2 = ob.add(:Timelog, {
-      :person_id => person2.id
-    })
+    person1 = ob.add(:Person, name: "Kasper")
+    person2 = ob.add(:Person, name: "Charlotte")
+
+    timelog1 = ob.add(:Timelog, person_id: person1.id)
+    timelog2 = ob.add(:Timelog, person_id: person2.id)
 
     ob.delete(person1)
 
@@ -409,36 +403,29 @@ describe "Objects" do
 
   it "should be able to do multiple deletes from ids" do
     ids = []
-    1.upto(10) do |count|
+    1.upto(10) do |_count|
       ids << ob.add(:Person).id
     end
 
-    ob.delete_ids(:class => :Person, :ids => ids)
+    ob.delete_ids(class: :Person, ids: ids)
   end
 
   it "get_or_add" do
-    person1 = ob.add(:Person, {
-      :name => "get_or_add"
-    })
-
-    person2 = ob.get_or_add(:Person, {
-      :name => "get_or_add"
-    })
+    person1 = ob.add(:Person, name: "get_or_add")
+    person2 = ob.get_or_add(:Person, name: "get_or_add")
 
     person2.id.should eql(person1.id)
     person2[:name].should eql("get_or_add")
 
-    person3 = ob.get_or_add(:Person, {
-      :name => "get_or_add3"
-    })
+    person3 = ob.get_or_add(:Person, name: "get_or_add3")
 
     raise "Failure ID was the same" if person3.id == person2.id
     person3[:name].should eql("get_or_add3")
   end
 
   it "should delete the temp database again." do
-    require 'tmpdir'
+    require "tmpdir"
     db_path = "#{Dir.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
-    File.unlink(db_path) if File.exists?(db_path)
+    File.unlink(db_path) if File.exist?(db_path)
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,17 +1,17 @@
 require "codeclimate-test-reporter"
 CodeClimate::TestReporter.start
 
-require 'baza'
+require "baza"
 
-if RUBY_PLATFORM == 'java'
-  require 'jdbc/mysql'
+if RUBY_PLATFORM == "java"
+  require "jdbc/mysql"
   ::Jdbc::MySQL.load_driver
 
-  require 'jdbc/sqlite3'
+  require "jdbc/sqlite3"
   ::Jdbc::SQLite3.load_driver
 end
 
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
   config.expect_with :rspec do |c|