rebel 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea69d0d0787dec584bc554cb9fa7223937d55562
-  data.tar.gz: c0d0f09f74a15f6079ac9496eb807981d3250edd
+  metadata.gz: aa3b3e1d946d65b40349085c1f02503587f2f3fd
+  data.tar.gz: e7923044d3c6f76a81eda0001941bb978adf85f5
 SHA512:
-  metadata.gz: 01672fe5ec3f73beeca1e66465e70d19f47ed765c23f07c47f7dca4fbdbb617900568c7643a694accb47660955b886539bc576e991573fa497a12c96883def84
-  data.tar.gz: 6c7457efbe296284d8acb777b3c39df51dd53ed3b94d439f885dacde8dc0638411a465ff7d72d97b556ca72aaafa028234a8c14b189a5bf3e04ea58ae656990e
+  metadata.gz: 5992df606d5eba47645c9301729488d4114f1d4278542d7476521675aaed788427d7a6f4e9673a32bd88f1238a06ee3bfa7ea9f14d6136d7a49805846cae8516
+  data.tar.gz: d44f06d4f085bee06d81b3db9a609a34dfdba2e6d191c003e316eca27bc154c8c7ffaa57c962f28b6e1ed46177ad04344fc5aa5cf72c5e6f2620849c7fc193b4

data/lib/rebel/sql.rb

@@ -6,49 +6,53 @@ module Rebel::SQL
   end
 
   def create_table(table_name, desc)
-    exec(SQL.create_table(table_name, desc))
+    exec(Rebel::SQL.create_table(table_name, desc))
+  end
+
+  def drop_table(table_name)
+    exec(Rebel::SQL.drop_table(table_name))
   end
 
   def select(*fields, from: nil, where: nil, inner: nil, left: nil, right: nil)
-    exec(SQL.select(*fields,
-                    from: from,
-                    where: where,
-                    inner: inner,
-                    left: left,
-                    right: right))
+    exec(Rebel::SQL.select(*fields,
+                           from: from,
+                           where: where,
+                           inner: inner,
+                           left: left,
+                           right: right))
   end
 
   def insert_into(table_name, *rows)
-    exec(SQL.insert_into(table_name, *rows))
+    exec(Rebel::SQL.insert_into(table_name, *rows))
   end
 
   def update(table_name, set: nil, where: nil, inner: nil, left: nil, right: nil)
-    exec(SQL.update(table_name, set: set, where: where, inner: inner, left: left, right: right))
+    exec(Rebel::SQL.update(table_name, set: set, where: where, inner: inner, left: left, right: right))
   end
 
   def delete_from(table_name, where: nil, inner: nil, left: nil, right: nil)
-    exec(SQL.delete_from(table_name, where: where, inner: inner, left: left, right: right))
+    exec(Rebel::SQL.delete_from(table_name, where: where, inner: inner, left: left, right: right))
   end
 
   def truncate(table_name)
-    exec(SQL.truncate(table_name))
+    exec(Rebel::SQL.truncate(table_name))
   end
 
   def count(*n)
-    SQL.count(*n)
+    Rebel::SQL.count(*n)
   end
 
   def join(table, on: nil)
-    SQL.join(table, on: on)
+    Rebel::SQL.join(table, on: on)
   end
 
   def outer_join(table, on: nil)
-    SQL.outer_join(table, on: on)
+    Rebel::SQL.outer_join(table, on: on)
   end
 
   class Raw < String
     def as(n)
-      Raw.new(self + " AS #{SQL.name(n)}")
+      Raw.new(self + " AS #{Rebel::SQL.name(n)}")
     end
 
     def as?(n)
@@ -56,7 +60,7 @@ module Rebel::SQL
     end
 
     def on(clause)
-      Raw.new(self + " ON #{SQL.and_clause(clause)}")
+      Raw.new(self + " ON #{Rebel::SQL.and_clause(clause)}")
     end
 
     def on?(clause)
@@ -71,55 +75,61 @@ module Rebel::SQL
 
     def create_table(table_name, desc)
       <<-SQL
-      CREATE TABLE #{SQL.name(table_name)} (
-        #{SQL.list(desc.map { |k, v| "#{SQL.name(k)} #{v}" })}
+      CREATE TABLE #{Rebel::SQL.name(table_name)} (
+        #{Rebel::SQL.list(desc.map { |k, v| "#{Rebel::SQL.name(k)} #{v}" })}
       );
       SQL
     end
 
+    def drop_table(table_name)
+      <<-SQL
+      DROP TABLE #{Rebel::SQL.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)}
-      #{SQL.inner?(inner)}
-      #{SQL.left?(left)}
-      #{SQL.right?(right)}
-      #{SQL.where?(where)};
+      #{Rebel::SQL.inner?(inner)}
+      #{Rebel::SQL.left?(left)}
+      #{Rebel::SQL.right?(right)}
+      #{Rebel::SQL.where?(where)};
       SQL
     end
 
     def insert_into(table_name, *rows)
       <<-SQL
-      INSERT INTO #{SQL.name(table_name)} (#{SQL.names(*rows.first.keys)})
-      VALUES #{SQL.list(rows.map { |r| "(#{SQL.values(*r.values)})" })};
+      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)})" })};
       SQL
     end
 
     def update(table_name, set: nil, where: nil, inner: nil, left: nil, right: nil)
-      fail ArgumentError if set.nil?
+      raise ArgumentError if set.nil?
 
       <<-SQL
-      UPDATE #{SQL.name(table_name)}
-      SET #{SQL.assign_clause(set)}
-      #{SQL.inner?(inner)}
-      #{SQL.left?(left)}
-      #{SQL.right?(right)}
-      #{SQL.where?(where)};
+      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)};
       SQL
     end
 
     def delete_from(table_name, where: nil, inner: nil, left: nil, right: nil)
       <<-SQL
-      DELETE FROM #{SQL.name(table_name)}
-      #{SQL.inner?(inner)}
-      #{SQL.left?(left)}
-      #{SQL.right?(right)}
-      #{SQL.where?(where)};
+      DELETE FROM #{Rebel::SQL.name(table_name)}
+      #{Rebel::SQL.inner?(inner)}
+      #{Rebel::SQL.left?(left)}
+      #{Rebel::SQL.right?(right)}
+      #{Rebel::SQL.where?(where)};
       SQL
     end
 
     def truncate(table_name)
       <<-SQL
-      TRUNCATE #{SQL.name(table_name)};
+      TRUNCATE #{Rebel::SQL.name(table_name)};
       SQL
     end
 
@@ -137,6 +147,18 @@ module Rebel::SQL
       raw("OUTER JOIN #{name(table)}").on?(on)
     end
 
+    def inner_join(table, on: nil)
+      raw(inner? join(table, on: on))
+    end
+
+    def left_outer_join(table, on: nil)
+      raw(left? outer_join(table, on: on))
+    end
+
+    def right_outer_join(table, on: nil)
+      raw(right? outer_join(table, on: on))
+    end
+
     ## Support
 
     def name(name)
@@ -158,9 +180,9 @@ module Rebel::SQL
       case v
       when Raw then v
       when String then raw "'#{v.tr("'", "''")}'"
-      when Fixnum then raw v.to_s
+      when Integer then raw v.to_s
       when nil then raw 'NULL'
-      else fail NotImplementedError, v.inspect
+      else raise NotImplementedError, v.inspect
       end
     end
 
@@ -180,14 +202,23 @@ module Rebel::SQL
       list(clause.map { |k, v| equal(k, v) })
     end
 
+    def clause_term(left, right)
+      case right
+      when Array
+        "#{name(left)} IN (#{values(*right)})"
+      else
+        "#{name(left)} = #{name_or_value(right)}"
+      end
+    end
+
     def and_clause(clause)
       return clause if clause.is_a?(Raw) || clause.is_a?(String)
 
       clause.map do |e|
         case e
-        when Array then "#{name(e[0])} = #{name_or_value(e[1])}"
+        when Array then clause_term(e[0], e[1])
         when Raw, String then e
-        else fail NotImplementedError, e.class
+        else raise NotImplementedError, e.class
         end
       end.join(' AND ')
     end
@@ -195,7 +226,7 @@ module Rebel::SQL
     def where?(clause)
       return "WHERE #{clause}" if clause.is_a?(Raw) || clause.is_a?(String)
 
-      (clause && clause.any?) ? "WHERE #{SQL.and_clause(clause)}" : nil
+      clause && clause.any? ? "WHERE #{Rebel::SQL.and_clause(clause)}" : nil
     end
 
     def inner?(join)

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rebel
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Loic Nageleisen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-27 00:00:00.000000000 Z
+date: 2017-03-01 00:00:00.000000000 Z
 dependencies: []
-description: Write SQL queries in Ruby, or is it the other way around?
+description: SQL-flavoured Ruby, or is it the other way around?
 email: loic.nageleisen@gmail.com
 executables: []
 extensions: []