Release 0.7.2

Update gem homepage
Release 0.7.1
2025-12-06 10:04:39 +01:00 · 2018-09-14 09:53:46 +02:00 · 2018-09-14 09:52:55 +02:00 · 2017-11-23 16:33:26 +01:00 · 2017-11-23 16:33:01 +01:00 · 2017-11-23 10:40:12 +01:00
3 changed files with 81 additions and 75 deletions
--- a/lib/rebel/sql.rb
+++ b/lib/rebel/sql.rb
@ -183,67 +183,59 @@ module Rebel
    end

    def create_table(table_name, desc)
-      raw <<-SQL
-      CREATE TABLE #{name(table_name)} (
-        #{list(desc.map { |k, v| "#{name(k)} #{v}" })}
-      )
-      SQL
+      raw %[CREATE TABLE #{name(table_name)} (#{list(desc.map { |k, v| "#{name(k)} #{v}" })})]
    end

    def drop_table(table_name)
-      raw <<-SQL
-      DROP TABLE #{name(table_name)}
-      SQL
+      raw "DROP TABLE #{name(table_name)}"
    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
-      SELECT #{distinct ? "DISTINCT #{names(*distinct)}" : names(*fields)}
-      #{from?(from)}
-      #{inner?(inner)}
-      #{left?(left)}
-      #{right?(right)}
-      #{where?(where)}
-      #{group?(group)}
-      #{order?(order)}
-      #{limit?(limit, offset)}
-      SQL
+      raw [
+        "SELECT #{distinct ? "DISTINCT #{names(*distinct)}" : names(*fields)}",
+        from?(from),
+        inner?(inner),
+        left?(left),
+        right?(right),
+        where?(where),
+        group?(group),
+        order?(order),
+        limit?(limit, offset),
+      ].compact.join(' ')
    end

    def insert_into(table_name, *rows)
-      raw <<-SQL
-      INSERT INTO #{name(table_name)} (#{names(*rows.first.keys)})
-      VALUES #{list(rows.map { |r| "(#{values(*r.values)})" })}
-      SQL
+      raw [
+        "INSERT INTO #{name(table_name)} (#{names(*rows.first.keys)})",
+        "VALUES #{list(rows.map { |r| "(#{values(*r.values)})" })}",
+      ].join(' ')
    end

    def update(table_name, set: nil, where: nil, inner: nil, left: nil, right: nil)
      raise ArgumentError if set.nil?

-      raw <<-SQL
-      UPDATE #{name(table_name)}
-      SET #{assign_clause(set)}
-      #{inner?(inner)}
-      #{left?(left)}
-      #{right?(right)}
-      #{where?(where)}
-      SQL
+      raw [
+        "UPDATE #{name(table_name)}",
+        "SET #{assign_clause(set)}",
+        inner?(inner),
+        left?(left),
+        right?(right),
+        where?(where),
+      ].compact.join(' ')
    end

    def delete_from(table_name, where: nil, inner: nil, left: nil, right: nil)
-      raw <<-SQL
-      DELETE FROM #{name(table_name)}
-      #{inner?(inner)}
-      #{left?(left)}
-      #{right?(right)}
-      #{where?(where)}
-      SQL
+      raw [
+        "DELETE FROM #{name(table_name)}",
+        inner?(inner),
+        left?(left),
+        right?(right),
+        where?(where),
+      ].join(' ')
    end

    def truncate(table_name)
-      raw <<-SQL
-      TRUNCATE #{name(table_name)}
-      SQL
+      raw "TRUNCATE #{name(table_name)}"
    end

    ## Functions
@ -300,7 +292,10 @@ module Rebel
    end

    def escape_str(str)
-      str.gsub(@string_quote, @escaped_string_quote)
+      str.dup.tap do |s|
+        s.gsub!('\\') { @escaped_string_backslash } if @escaped_string_backslash
+        s.gsub!(@string_quote) { @escaped_string_quote }
+      end
    end

    def value(v)
@ -398,6 +393,7 @@ module Rebel
      @identifier_quote = options[:identifier_quote] || '"'
      @string_quote = options[:string_quote] || "'"
      @escaped_string_quote = options[:escaped_string_quote] || "''"
+      @escaped_string_backslash = options[:escaped_string_backslash]
      @true_literal = options[:true_literal] || 'TRUE'
      @false_literal = options[:false_literal] || 'FALSE'

--- a/rebel.gemspec
+++ b/rebel.gemspec
@ -1,11 +1,11 @@
 Gem::Specification.new do |s|
  s.name        = 'rebel'
-  s.version     = '0.7.0'
+  s.version     = '0.7.2'
  s.licenses    = ['MIT']
  s.summary     = 'Fight against the Object tyranny'
  s.description = 'SQL-flavoured Ruby, or is it the other way around?'
  s.authors     = ['Loic Nageleisen']
  s.email       = 'loic.nageleisen@gmail.com'
  s.files       = Dir['lib/**/*.rb']
-  s.homepage    = 'https://github.com/lloeki/rebel.git'
+  s.homepage    = 'https://gitlab.com/lloeki/rebel.git'
 end
--- a/test/test_raw.rb
+++ b/test/test_raw.rb
@ -8,7 +8,7 @@ class TestRaw < Minitest::Test
  end

  def assert_mysql(expected, &actual)
-    assert_equal(expected.to_s, Rebel::SQL(identifier_quote: '`', string_quote: '"', escaped_string_quote: '""', &actual).to_s)
+    assert_equal(expected.to_s, Rebel::SQL(identifier_quote: '`', escaped_string_quote: "\\'", escaped_string_backslash: '\\', &actual).to_s)
  end

  def assert_sqlite(expected, &actual)
@ -137,33 +137,43 @@ class TestRaw < Minitest::Test

  def test_string
    assert_sql("'FOO'") { value('FOO') }
-    assert_mysql('"FOO"') { value('FOO') }
+    assert_mysql("'FOO'") { value('FOO') }
    assert_postgresql("'FOO'") { value('FOO') }
    assert_sqlite("'FOO'") { value('FOO') }
  end

  def test_escaped_string
-    assert_sql("'FOO''BAR'") { value("FOO'BAR") }
-    assert_mysql('"FOO\'BAR"') { value("FOO'BAR") }
-    assert_postgresql("'FOO''BAR'") { value("FOO'BAR") }
-    assert_sqlite("'FOO''BAR'") { value("FOO'BAR") }
+    assert_sql        (%q('FOO''BAR'))   { value(%q(FOO'BAR))  }
+    assert_postgresql (%q('FOO''BAR'))   { value(%q(FOO'BAR))  }
+    assert_sqlite     (%q('FOO''BAR'))   { value(%q(FOO'BAR))  }
+    assert_mysql      (%q('FOO\'BAR'))   { value(%q(FOO'BAR))  }

-    assert_sql("'FOO\"BAR'") { value('FOO"BAR') }
-    assert_mysql('"FOO""BAR"') { value('FOO"BAR') }
-    assert_postgresql("'FOO\"BAR'") { value('FOO"BAR') }
-    assert_sqlite("'FOO\"BAR'") { value('FOO"BAR') }
+    assert_sql        (%q('FOO"BAR'))    { value(%q(FOO"BAR))  }
+    assert_postgresql (%q('FOO"BAR'))    { value(%q(FOO"BAR))  }
+    assert_sqlite     (%q('FOO"BAR'))    { value(%q(FOO"BAR))  }
+    assert_mysql      (%q('FOO"BAR'))    { value(%q(FOO"BAR))  }
+
+    assert_sql        (%q('FOO\BAR'))    { value(%q(FOO\BAR))  }
+    assert_postgresql (%q('FOO\BAR'))    { value(%q(FOO\BAR))  }
+    assert_sqlite     (%q('FOO\BAR'))    { value(%q(FOO\BAR))  }
+    assert_mysql      (%q('FOO\\BAR'))   { value(%q(FOO\BAR))  }
+
+    assert_sql        (%q('FOO\\''BAR')) { value(%q(FOO\'BAR)) }
+    assert_postgresql (%q('FOO\\''BAR')) { value(%q(FOO\'BAR)) }
+    assert_sqlite     (%q('FOO\\''BAR')) { value(%q(FOO\'BAR)) }
+    assert_mysql      (%q('FOO\\\'BAR')) { value(%q(FOO\'BAR)) }
  end

  def test_boolean_literal
-    assert_sql("TRUE") { value(true) }
-    assert_mysql("TRUE") { value(true) }
-    assert_postgresql("TRUE") { value(true) }
-    assert_sqlite("1") { value(true) }
+    assert_sql('TRUE') { value(true) }
+    assert_mysql('TRUE') { value(true) }
+    assert_postgresql('TRUE') { value(true) }
+    assert_sqlite('1') { value(true) }

-    assert_sql("FALSE") { value(false) }
-    assert_mysql("FALSE") { value(false) }
-    assert_postgresql("FALSE") { value(false) }
-    assert_sqlite("0") { value(false) }
+    assert_sql('FALSE') { value(false) }
+    assert_mysql('FALSE') { value(false) }
+    assert_postgresql('FALSE') { value(false) }
+    assert_sqlite('0') { value(false) }
  end

  def test_value
@ -179,7 +189,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 +197,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
Author	SHA1	Message	Date
Loic Nageleisen	0e82d96755	Release 0.7.2	2018-09-14 09:53:46 +02:00
Loic Nageleisen	95ecac4946	Update gem homepage	2018-09-14 09:52:55 +02:00
Loic Nageleisen	071932e4be	Release 0.7.1	2017-11-23 16:33:26 +01:00
Loic Nageleisen	86ce2b65ff	Properly handle backslash escaping	2017-11-23 16:33:01 +01:00
Loic Nageleisen	a0f1153407	Adjust quote style	2017-11-23 10:40:12 +01:00
Loic Nageleisen	3bb41b81f0	Generate less whitespace	2017-11-23 10:39:59 +01:00