Generate less whitespace

lib/rebel/sql.rb

@@ -183,67 +183,59 @@ module Rebel
     end
 
     def create_table(table_name, desc)
-      raw <<-SQL
+      raw %[CREATE TABLE #{name(table_name)} (#{list(desc.map { |k, v| "#{name(k)} #{v}" })})]
-      CREATE TABLE #{name(table_name)} (
-        #{list(desc.map { |k, v| "#{name(k)} #{v}" })}
-      )
-      SQL
     end
 
     def drop_table(table_name)
-      raw <<-SQL
+      raw "DROP TABLE #{name(table_name)}"
-      DROP TABLE #{name(table_name)}
-      SQL
     end
 
     def select(*fields, distinct: nil, from: nil, where: nil, inner: nil, left: nil, right: nil, group: nil, order: nil, limit: nil, offset: nil)
-      raw <<-SQL
+      raw [
-      SELECT #{distinct ? "DISTINCT #{names(*distinct)}" : names(*fields)}
+        "SELECT #{distinct ? "DISTINCT #{names(*distinct)}" : names(*fields)}",
-      #{from?(from)}
+        from?(from),
-      #{inner?(inner)}
+        inner?(inner),
-      #{left?(left)}
+        left?(left),
-      #{right?(right)}
+        right?(right),
-      #{where?(where)}
+        where?(where),
-      #{group?(group)}
+        group?(group),
-      #{order?(order)}
+        order?(order),
-      #{limit?(limit, offset)}
+        limit?(limit, offset),
-      SQL
+      ].compact.join(' ')
     end
 
     def insert_into(table_name, *rows)
-      raw <<-SQL
+      raw [
-      INSERT INTO #{name(table_name)} (#{names(*rows.first.keys)})
+        "INSERT INTO #{name(table_name)} (#{names(*rows.first.keys)})",
-      VALUES #{list(rows.map { |r| "(#{values(*r.values)})" })}
+        "VALUES #{list(rows.map { |r| "(#{values(*r.values)})" })}",
-      SQL
+      ].join(' ')
     end
 
     def update(table_name, set: nil, where: nil, inner: nil, left: nil, right: nil)
       raise ArgumentError if set.nil?
 
-      raw <<-SQL
+      raw [
-      UPDATE #{name(table_name)}
+        "UPDATE #{name(table_name)}",
-      SET #{assign_clause(set)}
+        "SET #{assign_clause(set)}",
-      #{inner?(inner)}
+        inner?(inner),
-      #{left?(left)}
+        left?(left),
-      #{right?(right)}
+        right?(right),
-      #{where?(where)}
+        where?(where),
-      SQL
+      ].compact.join(' ')
     end
 
     def delete_from(table_name, where: nil, inner: nil, left: nil, right: nil)
-      raw <<-SQL
+      raw [
-      DELETE FROM #{name(table_name)}
+        "DELETE FROM #{name(table_name)}",
-      #{inner?(inner)}
+        inner?(inner),
-      #{left?(left)}
+        left?(left),
-      #{right?(right)}
+        right?(right),
-      #{where?(where)}
+        where?(where),
-      SQL
+      ].join(' ')
     end
 
     def truncate(table_name)
-      raw <<-SQL
+      raw "TRUNCATE #{name(table_name)}"
-      TRUNCATE #{name(table_name)}
-      SQL
     end
 
     ## Functions

test/test_raw.rb

@@ -179,7 +179,7 @@ class TestRaw < Minitest::Test
   end
 
   def test_select
-    assert_sql('SELECT * FROM "foo"') { select(raw('*'), from: name(:foo)).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT * FROM "foo"') { select(raw('*'), from: name(:foo)) }
   end
 
   def test_select_without_from
@@ -187,50 +187,50 @@ class TestRaw < Minitest::Test
   end
 
   def test_select_distinct
-    assert_sql('SELECT DISTINCT "bar" FROM "foo"') { select(distinct: :bar, from: :foo).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT DISTINCT "bar" FROM "foo"') { select(distinct: :bar, from: :foo) }
   end
 
   def test_select_distinct_multiple
-    assert_sql('SELECT DISTINCT "bar", "baz" FROM "foo"') { select(distinct: [:bar, :baz], from: :foo).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT DISTINCT "bar", "baz" FROM "foo"') { select(distinct: [:bar, :baz], from: :foo) }
   end
 
   def test_select_group_by
-    assert_sql('SELECT "bar" FROM "foo" GROUP BY "baz"') { select(:bar, from: :foo, group: by(:baz)).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT "bar" FROM "foo" GROUP BY "baz"') { select(:bar, from: :foo, group: by(:baz)) }
   end
 
   def test_select_group_by_having
-    assert_sql('SELECT "bar" FROM "foo" GROUP BY "baz" HAVING COUNT("qux") > 5') { select(:bar, from: :foo, group: by(:baz).having(count(:qux).gt(5))).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT "bar" FROM "foo" GROUP BY "baz" HAVING COUNT("qux") > 5') { select(:bar, from: :foo, group: by(:baz).having(count(:qux).gt(5))) }
   end
 
   def test_select_order_by
-    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz"') { select(:bar, from: :foo, order: by(:baz)).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz"') { select(:bar, from: :foo, order: by(:baz)) }
   end
 
   def test_select_order_by_asc
-    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz" ASC') { select(:bar, from: :foo, order: by(:baz).asc).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz" ASC') { select(:bar, from: :foo, order: by(:baz).asc) }
   end
 
   def test_select_order_by_desc
-    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz" DESC') { select(:bar, from: :foo, order: by(:baz).desc).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz" DESC') { select(:bar, from: :foo, order: by(:baz).desc) }
   end
 
   def test_select_multiple_order_by
-    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz", "qux"') { select(:bar, from: :foo, order: by(:baz, :qux)).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz", "qux"') { select(:bar, from: :foo, order: by(:baz, :qux)) }
   end
 
   def test_select_multiple_order_by_opposing
-    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz" ASC, "qux" DESC') { select(:bar, from: :foo, order: by(name(:baz).asc, name(:qux).desc)).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT "bar" FROM "foo" ORDER BY "baz" ASC, "qux" DESC') { select(:bar, from: :foo, order: by(name(:baz).asc, name(:qux).desc)) }
   end
 
   def test_select_limit
-    assert_sql('SELECT "bar" FROM "foo" LIMIT 10') { select(:bar, from: :foo, limit: 10).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT "bar" FROM "foo" LIMIT 10') { select(:bar, from: :foo, limit: 10) }
   end
 
   def test_select_offset
-    assert_sql('SELECT "bar" FROM "foo" LIMIT 10 OFFSET 20') { select(:bar, from: :foo, limit: 10, offset: 20).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT "bar" FROM "foo" LIMIT 10 OFFSET 20') { select(:bar, from: :foo, limit: 10, offset: 20) }
   end
 
   def test_nested_select
-    assert_sql('SELECT * FROM "foo" WHERE "bar" IN ( SELECT "bar" FROM "foo" )') { select(raw('*'), from: name(:foo), where: name(:bar).in(select(name(:bar), from: name(:foo)))).gsub(/\s+/, ' ').strip }
+    assert_sql('SELECT * FROM "foo" WHERE "bar" IN (SELECT "bar" FROM "foo")') { select(raw('*'), from: name(:foo), where: name(:bar).in(select(name(:bar), from: name(:foo)))) }
   end
 end