rebel 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa3b3e1d946d65b40349085c1f02503587f2f3fd
-  data.tar.gz: e7923044d3c6f76a81eda0001941bb978adf85f5
+  metadata.gz: 10809e6c0a432430cd14bff789a33f4e931d8d19
+  data.tar.gz: f09ec1c343f3202fdec996cbea89cc8b5c88eccc
 SHA512:
-  metadata.gz: 5992df606d5eba47645c9301729488d4114f1d4278542d7476521675aaed788427d7a6f4e9673a32bd88f1238a06ee3bfa7ea9f14d6136d7a49805846cae8516
-  data.tar.gz: d44f06d4f085bee06d81b3db9a609a34dfdba2e6d191c003e316eca27bc154c8c7ffaa57c962f28b6e1ed46177ad04344fc5aa5cf72c5e6f2620849c7fc193b4
+  metadata.gz: bb6c20a31bac4c52a5b2dba793608c53544b5abe713540b733e614009747a4f7e216e6bf998aee9b56985d4becc7c3b9552f35f93241c9cd50b462696a2a8c5a
+  data.tar.gz: dac1d09cbbc44bc324441295848757be87f77b48e362eda69417d15c770e8ceb8dd9a359bead9072c2d2173cc0a7d45320da7cbc4cc9888c43013c7c0acebeef

data/lib/rebel/sql.rb

@@ -51,6 +51,24 @@ module Rebel::SQL
   end
 
   class Raw < String
+    def wants_parens!
+      @wants_parens = true
+      self
+    end
+
+    def wants_parens?
+      @wants_parens = false unless instance_variable_defined?(:@wants_parens)
+      @wants_parens
+    end
+
+    def parens
+      Raw.new("(#{self})")
+    end
+
+    def parens?
+      wants_parens? ? parens : self
+    end
+
     def as(n)
       Raw.new(self + " AS #{Rebel::SQL.name(n)}")
     end
@@ -59,48 +77,117 @@ module Rebel::SQL
       n ? as(n) : self
     end
 
-    def on(clause)
-      Raw.new(self + " ON #{Rebel::SQL.and_clause(clause)}")
+    def on(*clause)
+      Raw.new(self + " ON #{Rebel::SQL.and_clause(*clause)}")
+    end
+
+    def on?(*clause)
+      clause.any? ? on(clause) : self
+    end
+
+    def and(*clause)
+      Raw.new("#{self.parens?} AND #{Rebel::SQL.and_clause(*clause)}")
     end
 
-    def on?(clause)
-      clause ? on(clause) : self
+    def or(*clause)
+      Raw.new("#{self} OR #{Rebel::SQL.and_clause(*clause)}").wants_parens!
+    end
+
+    def eq(n)
+      case n
+      when nil
+        Raw.new("#{self} IS NULL")
+      else
+        Raw.new("#{self} = #{Rebel::SQL.name_or_value(n)}")
+      end
+    end
+    alias == eq
+    alias is eq
+
+    def ne(n)
+      case n
+      when nil
+        Raw.new("#{self} IS NOT NULL")
+      else
+        Raw.new("#{self} != #{Rebel::SQL.name_or_value(n)}")
+      end
+    end
+    alias != ne
+
+    def lt(n)
+      Raw.new("#{self} < #{Rebel::SQL.name_or_value(n)}")
+    end
+    alias < lt
+
+    def gt(n)
+      Raw.new("#{self} > #{Rebel::SQL.name_or_value(n)}")
+    end
+    alias > gt
+
+    def le(n)
+      Raw.new("#{self} <= #{Rebel::SQL.name_or_value(n)}")
+    end
+    alias <= le
+
+    def ge(n)
+      Raw.new("#{self} >= #{Rebel::SQL.name_or_value(n)}")
+    end
+    alias >= ge
+
+    def in(*v)
+      Raw.new("#{self} IN (#{Rebel::SQL.values(*v)})")
     end
   end
 
+  @identifier_quote = '"'
+  @string_quote = "'"
+  @escaped_string_quote = "''"
+
   class << self
+    def identifier_quote=(str)
+      @identifier_quote = str
+    end
+
+    def string_quote=(str)
+      @string_quote = str
+    end
+
+    def escaped_string_quote=(str)
+      @escaped_string_quote = str
+    end
+
     def raw(str)
       Raw.new(str)
     end
 
     def create_table(table_name, desc)
       <<-SQL
-      CREATE TABLE #{Rebel::SQL.name(table_name)} (
-        #{Rebel::SQL.list(desc.map { |k, v| "#{Rebel::SQL.name(k)} #{v}" })}
+      CREATE TABLE #{name(table_name)} (
+        #{list(desc.map { |k, v| "#{name(k)} #{v}" })}
       );
       SQL
     end
 
     def drop_table(table_name)
       <<-SQL
-      DROP TABLE #{Rebel::SQL.name(table_name)};
+      DROP TABLE #{name(table_name)};
       SQL
     end
 
     def select(*fields, from: nil, where: nil, inner: nil, left: nil, right: nil)
       <<-SQL
       SELECT #{names(*fields)} FROM #{name(from)}
-      #{Rebel::SQL.inner?(inner)}
-      #{Rebel::SQL.left?(left)}
-      #{Rebel::SQL.right?(right)}
-      #{Rebel::SQL.where?(where)};
+      #{inner?(inner)}
+      #{left?(left)}
+      #{right?(right)}
+      #{where?(where)};
       SQL
     end
 
     def insert_into(table_name, *rows)
       <<-SQL
-      INSERT INTO #{Rebel::SQL.name(table_name)} (#{Rebel::SQL.names(*rows.first.keys)})
-      VALUES #{Rebel::SQL.list(rows.map { |r| "(#{Rebel::SQL.values(*r.values)})" })};
+      INSERT INTO #{name(table_name)} (#{names(*rows.first.keys)})
+      VALUES #{list(rows.map { |r| "(#{values(*r.values)})" })};
       SQL
     end
 
@@ -108,33 +195,38 @@ module Rebel::SQL
       raise ArgumentError if set.nil?
 
       <<-SQL
-      UPDATE #{Rebel::SQL.name(table_name)}
-      SET #{Rebel::SQL.assign_clause(set)}
-      #{Rebel::SQL.inner?(inner)}
-      #{Rebel::SQL.left?(left)}
-      #{Rebel::SQL.right?(right)}
-      #{Rebel::SQL.where?(where)};
+      UPDATE #{name(table_name)}
+      SET #{assign_clause(set)}
+      #{inner?(inner)}
+      #{left?(left)}
+      #{right?(right)}
+      #{where?(where)};
       SQL
     end
 
     def delete_from(table_name, where: nil, inner: nil, left: nil, right: nil)
       <<-SQL
-      DELETE FROM #{Rebel::SQL.name(table_name)}
-      #{Rebel::SQL.inner?(inner)}
-      #{Rebel::SQL.left?(left)}
-      #{Rebel::SQL.right?(right)}
-      #{Rebel::SQL.where?(where)};
+      DELETE FROM #{name(table_name)}
+      #{inner?(inner)}
+      #{left?(left)}
+      #{right?(right)}
+      #{where?(where)};
       SQL
     end
 
     def truncate(table_name)
       <<-SQL
-      TRUNCATE #{Rebel::SQL.name(table_name)};
+      TRUNCATE #{name(table_name)};
       SQL
     end
 
     ## Functions
 
+    def function(name, *args)
+      raw("#{name}(#{names_or_values(*args)})")
+    end
+    alias fn function
+
     def count(*n)
       raw("COUNT(#{names(*n)})")
     end
@@ -165,7 +257,7 @@ module Rebel::SQL
       return name if name.is_a?(Raw)
       return raw('*') if name == '*'
 
-      name.to_s.split('.').map { |e| "\"#{e}\"" }.join('.')
+      raw(name.to_s.split('.').map { |e| "#{@identifier_quote}#{e}#{@identifier_quote}" }.join('.'))
     end
 
     def names(*names)
@@ -176,11 +268,17 @@ module Rebel::SQL
       items.join(', ')
     end
 
+    def escape_str(str)
+      str.tr(@string_quote, @escaped_string_quote)
+    end
+
     def value(v)
       case v
       when Raw then v
-      when String then raw "'#{v.tr("'", "''")}'"
+      when String then raw "'#{escape_str(v)}'"
       when Integer then raw v.to_s
+      when TrueClass, FalseClass then raw(v ? 'TRUE' : 'FALSE')
+      when Date, Time, DateTime then value(v.iso8601)
       when nil then raw 'NULL'
       else raise NotImplementedError, v.inspect
       end
@@ -194,6 +292,10 @@ module Rebel::SQL
       item.is_a?(Symbol) ? name(item) : value(item)
     end
 
+    def names_or_values(*items)
+      list(items.map { |v| name_or_value(v) })
+    end
+
     def equal(l, r)
       "#{name_or_value(l)} = #{name_or_value(r)}"
     end
@@ -205,28 +307,26 @@ module Rebel::SQL
     def clause_term(left, right)
       case right
       when Array
-        "#{name(left)} IN (#{values(*right)})"
+        name(left).in(*right)
       else
-        "#{name(left)} = #{name_or_value(right)}"
+        name(left).eq(name_or_value(right))
       end
     end
 
-    def and_clause(clause)
-      return clause if clause.is_a?(Raw) || clause.is_a?(String)
-
+    def and_clause(*clause)
       clause.map do |e|
         case e
+        when Hash then and_clause(*e.to_a)
         when Array then clause_term(e[0], e[1])
-        when Raw, String then e
+        when Raw then e.parens?
+        when String then e
         else raise NotImplementedError, e.class
         end
       end.join(' AND ')
     end
 
-    def where?(clause)
-      return "WHERE #{clause}" if clause.is_a?(Raw) || clause.is_a?(String)
-
-      clause && clause.any? ? "WHERE #{Rebel::SQL.and_clause(clause)}" : nil
+    def where?(*clause)
+      clause.any? ? "WHERE #{and_clause(*clause)}" : nil
     end
 
     def inner?(join)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rebel
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Loic Nageleisen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-01 00:00:00.000000000 Z
+date: 2017-03-06 00:00:00.000000000 Z
 dependencies: []
 description: SQL-flavoured Ruby, or is it the other way around?
 email: loic.nageleisen@gmail.com
@@ -38,7 +38,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Fight against the Object tyranny