i_dig_sql 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a72cee2c11ff760fcb5227b539fa976a39dfb56
-  data.tar.gz: a418aba79878b9361f980f137c7be1b108e3ee74
+  metadata.gz: 31d1e3efcf21763358024010c06ded12c96db386
+  data.tar.gz: 406fb62530629737bc65194b61f971d30d817963
 SHA512:
-  metadata.gz: 1e7ef6053d12c991ab562da0c882bc510babae4c315e108e7bb34c67855e998106ea51ccc1f5c4384a88d9f5c0fdbaf8b2f183539d1c3a40b208b4be73431de5
-  data.tar.gz: 43c7bca10bbb494ab492e7ad1852ecbd992ba80b96832056bf6760b7f8c2a533023faeb8df91ab595bf30e04c38081d927367ad522f269245b1f6b5c8f113aae
+  metadata.gz: a0d7425d98fd9de91ad8a03169215bfeb34c895d54fb8fd3bcca9e58746e7dd819f96928ed091934b60058ed2e4529eccb73105766fb0475ca08a3e3cca38e8c
+  data.tar.gz: 0d429c6906c64c71beaf531b34a88a51313ad5ce559db376bc6e79dc28890db099c9221d4ca575e71ffcaae500434f822e48eccf3a6f661397bfeaa83cb48e90

data/README.md

@@ -24,24 +24,40 @@ Please note that none of this is ready yet.
   require 'i_dig_sql'
 
   sql = I_Dig_Sql.new
-  sql[:HEROES]   = "SELECT id FROM hero    WHERE id = :PERSON_ID"
-  sql[:VILLIANS] = "SELECT id FROM villian WHERE id = :PERSON_ID"
-  sql << %^
+  sql.sql :HEROES,   "SELECT id FROM hero    WHERE id = :PERSON_ID"
+  sql.sql :VILLIANS, "SELECT id FROM villian WHERE id = :PERSON_ID"
+
+  sql.sql(:SIDE_KICKS) {
+
+    FROM :HEROES, :good_guys do
+      SELECT :nick_name, :name
+    end
+
+    INNER :PEOPLE, :others do
+      ON '_.heroe_id == __.id'
+      SELECT :nick_name, :name
+    end
+
+    SELECT 'field' => 'a_field'
+
+    GROUP_BY 'id DESC', 'created_at ASC'
+
+  }
+
+  sql.sql :SQL, %^
     SELECT *
     FROM people
     WHERE
-      id IN ( << HEROES >> AND status = :ALIVE)
-      OR
       id IN (SELECT ID FROM {{ HEROES }} AND status = :ALIVE)
       OR
-      id IN ( << * HEROES >> )
+      id IN ( {{ HEROES * }} )
       OR
-      id IN ( << patron_id VILLIANS >> )
+      id IN ( {{ VILLIANS patron_id }} )
       OR
-      id IN ( << VILLIANS >> )
+      id IN ( {{ VILLIANS * }} )
   ^
 
-  sql.to_sql
+  puts sql.pair
 
 ```
 

data/VERSION

@@ -1 +1 @@
-3.0.0
+4.0.0

data/bin/i_dig_sql

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# -*- bash -*-
+#
+#
+
+action="$1"
+shift
+
+if [[ -z "$action" ]]; then
+  action="test"
+fi
+# ===============================================================
+
+set -u -e -o pipefail
+
+case "$action" in
+
+  "help")
+    echo " ====================================================="
+    echo ""
+    echo " $  i_dig_sql   watch"
+    echo ""
+    echo " $  i_dig_sql   test"
+    echo " $  i_dig_sql   test   name"
+    echo ""
+    echo " ====================================================="
+    echo ""
+    exit 0
+    ;;  # === start
+
+  "watch")
+    echo ""
+    echo "=== Watching: $@"
+
+    echo -e "\n=== Running test:"
+    bin/i_dig_sql test "$@" || echo ""
+
+    inotifywait -q -m -e close_write,close --exclude .git/ -r .  | while read CHANGE
+    do
+
+      dir=$(echo "$CHANGE" | cut -d' ' -f 1)
+      op=$(echo "$CHANGE" | cut -d' ' -f 2)
+      file=$(echo "$CHANGE" | cut -d' ' -f 3)
+      path="${dir}$file"
+
+      if [[ "$op" == *CLOSE_WRITE* && ( $file == *.rb* || $file == *.md* ) ]]; then
+        echo -e "\n=== Running test:"
+        bin/i_dig_sql test "$@" || echo ""
+      fi
+
+    done # === do
+
+    echo ""
+    exit 0
+    ;;
+
+
+  "test")
+    files="$(echo specs/*-$@.rb)"
+    if [[ -f "$files" ]]; then
+      shift
+    else
+      files="$(echo specs/*-*.rb)"
+    fi
+
+    bundle exec bacon -rpry -ri_dig_sql specs/helpers.rb $files "$@"
+    ;; # === test
+
+
+  *)
+    echo "=== Unknown action: $action" 1>&2
+    exit 1
+    ;;
+
+esac # =========================================================
+

data/i_dig_sql.gemspec

@@ -21,12 +21,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "boxomojo" , "> 1.0.1"
+
   spec.add_development_dependency "bundler"            , "> 1.5"
   spec.add_development_dependency "bacon"              , '> 1.0'
   spec.add_development_dependency "Bacon_Colored"      , '> 0'
   spec.add_development_dependency "pry"                , '> 0'
   spec.add_development_dependency "awesome_print"      , '> 0'
-  spec.add_development_dependency "anbt-sql-formatter" , '> 0'
   spec.add_development_dependency "rouge" , '> 0.0.0'
   spec.add_development_dependency "unindent" , '> 0.0.0'
 end

data/lib/i_dig_sql.rb

@@ -1,448 +1,193 @@
 
-require "i_dig_sql/H"
 
-class I_Dig_Sql
-
-  include Enumerable
+require 'i_dig_sql/H'
+require 'boxomojo'
 
-  HAS_VAR = /(\{\{|\<\<)[^\}\>]+(\}\}|\>\>)/
-  SELECT_FROM_REG = /SELECT.+FROM.+/
+class I_Dig_Sql
 
+  Box = Boxomojo.new(
+    :SELECT,
+    :FROM, :LEFT, :RIGHT, :INNER,
+    :AS, :ON,
+    :GROUP_BY, :ORDER_BY
+  )
 
+  HAS_VAR          = /(\{\{)[^\}\>]+(\}\})/
+  SELECT_FROM_REG  = /SELECT.+FROM.+/
+  COMMAS_OR_COLONS = /(\,|\:)+/
   ALL_UNDERSCORE   = /\A[_]+\Z/
-  COMBO_LEFT_RIGHT = [:left, :left, :right, :right]
-  COMBO_OUT_IN     = [:out, :in, :out, :in]
-
-  Duplicate = Class.new RuntimeError
+  NOTHING          = "".freeze
 
   class << self
-  end # === class self ===
 
-  attr_reader :digs, :WITHS, :data
-  def initialize *args
-    @WITH     = nil
-    @FRAGMENT = nil
-    @SQL      = nil
-    @WITHS    = []
+    def box_to_string arr
+      h = {:SELECT=>[], :FROM=>[], :GROUP_BY=>[], :ORDER_BY=>[]}
+      table_name_stack = []
+      arr.each { |raw|
+        name, args, blok = raw
+
+        case name
+        when :SELECT
+          h[:SELECT] << args.join(' AS ')
+
+        when :FROM, :LEFT, :RIGHT, :INNER
+          table_name_stack.push args.last
+          str = if name == :FROM
+                  args.join(' ')
+                else
+                  "#{name} JOIN #{args.join ' '}"
+                end
+
+          table_name = args.last
+
+          if blok
+            on = []
+            blok.each { |raw|
+              args = raw.dup
+              name = args.shift
+              blok = args.pop
+              case name
+              when :ON
+                on << args
+
+              when :SELECT
+                h[:SELECT] << "#{table_name}.#{args.join ' AS '}"
 
-    @digs  = []
-    @data  = H.new(:allow_update)
-    .merge!(
-      :name  => nil,
-      :raw   => nil,
-      :vars  => H.new,
-      :procs => H.new
-    )
-
-    args.each { |a|
+              else
+                fail ArgumentError, "Unknown name: #{name.inspect}"
+              end
+            }
 
-      case a
+            ( str << "\nON " << on.join(' AND ') ) unless on.empty?
+          end
 
-      when Symbol
-        @data[:name] = a
+          str.gsub!(/\b([_]+)(?=\.)/) { |match|
+            t_name = table_name_stack[match.size * -1]
+            fail ArgumentError, "Name not found for: #{match}" if !t_name
+            t_name
+          }
 
-      when I_Dig_Sql
-        @digs << a
+          h[:FROM] << str
 
-      when String
-        @data.merge!(:raw=>a)
+        when :GROUP_BY, :ORDER_BY
+          h[name].concat args
 
-      when Hash, H
-        if a.has_key?(:raw)
-          @data.merge! a
         else
-          @data[:vars].merge! a
+          fail ArgumentError, "Unknown: #{name.inspect}"
         end
+      }
 
-      else
-        fail ArgumentError, "Unknown arg: #{a.inspect}"
-
-      end  # === case
+      <<-EOF
+        SELECT
+          #{h[:SELECT].empty? ? '*' : h[:SELECT].join(",\n")}
+        FROM
+          #{h[:FROM].join "\n"}
+        #{ h[:GROUP_BY].empty? ? '' : 'GROUP BY ' + h[:GROUP_BY].join(', ')}
+        #{ h[:ORDER_BY].empty? ? '' : 'ORDER BY ' + h[:ORDER_BY].join(', ')}
+      EOF
+    end # === def box_to_string
+
+    #
+    #  Examples:
+    #    string( "...", dig)
+    #    string( dig ) { FROM ... }
+    #
+    def string *args, &blok
+      dig   = args.pop
+      str   = args.shift || box_to_string(Box.new &blok)
+      s     = str.dup
+      withs = []
+
+      while s[HAS_VAR]
+        s.gsub!(/\{\{\s?([^\}]+)\s?\}\}/) do |match|
+          pieces = $1.split
+          name   = pieces.shift
+          key    = name.to_sym
+          args   = pieces
+          withs << key
+          withs.concat(dig.sql(key)[:withs]) if dig.sqls.has_key?(key)
+          case args.size
+          when 0
+            name
+          else
+            "SELECT #{args.join ', '} FROM #{name}"
+          end # === case
+        end
+      end # === while s HAS_VAR
+
+      with = if withs.empty?
+               ""
+             else
+               maps  = []
+               done  = {}
+               withs.uniq!
+               withs.each { |name|
+                 next if done[name]
+                 fragment = dig.sql(name)[:base]
+                 (fragment = fragment.gsub(/^/, "    ")) if ENV['IS_DEV']
+                 maps << "#{name} AS (\n#{fragment}\n  )"
+                 done[name] = true
+               } # === each withs
+
+               %^WITH\n  #{maps.join ",\n  "}\n\n^
+             end
+
+      [with + s, s, withs]
+    end # === def extract_withs
 
-    }
+  end # === class self ===
 
+  attr_reader :vars, :sqls
+  def initialize
+    @stack = []
+    @sqls  = H.new
+    @vars  = H.new
   end # === def initialize
 
-  %w{name raw vars}.each { |k|
-    eval <<-EOF.strip, nil, __FILE__, __LINE__
-      def #{k}
-        @data[:#{k}]
-      end
-    EOF
-  }
-
-  def vars!
-    vars = H.new.merge!(@data[:vars])
-
-    @digs.reverse.inject(vars) { |memo, dig|
-      if dig != self
-        memo.merge! dig.vars
-      end
-      memo
-    }
-  end
-
-  def has_key? name
-    !!(search name)
-  end
-
-  def search name
-    fail ArgumentError, "No name specified: #{name.inspect}" if !name
-    return self if self.name == name
-    found = false
-    if @data[:procs].has_key?(name)
-      return @data[:procs][name]
-    end
-
-    @digs.reverse.detect { |d|
-      found = if d.name == name
-                d
-              elsif d.data[:procs].has_key?(name)
-                d.data[:procs][name]
-              else
-                d.digs.detect { |deep|
-                  found = deep if deep.name == name
-                  found = deep.data[:procs][name] if deep.data[:procs].has_key?(name)
-                  found
-                }
-              end
-    }
-    found
-  end
-
-  def [] name
-    found = search(name)
-    fail ArgumentError, "SQL not found for: #{name.inspect}" unless found
-    found
-  end
-
-  def []= name, val
-    fail ArgumentError, "Name already taken: #{name.inspect}" if has_key?(name)
-
-    case val
-    when String
-      @digs << I_Dig_Sql.new(self, name, val)
-
-    when Hash, H
-      case
-      when val[:name] == :DEFAULT
-        @digs << I_Dig_Sql.new(:DEFAULT, val)
-      when val[:raw]
-        @data.merge! val
-      else
-        @digs << I_Dig_Sql.new(self, name, val)
-      end
-
-    when I_Dig_Sql
-      @digs << val
-
-    when Proc
-      @data[:procs][name] = val
+  def var name, *args
+    case args.size
 
-    else
-      fail ArgumentError, "Unknown class: #{name.inspect} -> #{val.class}"
+    when 0
+      @vars[name]
 
-    end # === case
-  end
+    when 1
+      @vars[name] = args.first
 
-  def each
-    digs = @digs.reverse
-    digs.unshift self
-    if block_given?
-      digs.each { |d| yield d.name, d }
     else
-      digs.each
-    end
-  end
-
-
-  def << str
-    (@data[:raw] ||= "") << str
-  end
-
-  def has_raw?
-    !!(@data[:raw] && !@data[:raw].strip.empty?)
-  end
-
-  def to_pair
-    [to_sql, vars!]
-  end
-
-  def to_meta *args
-    compile *args
-  end
-
-  def to_sql *args
-    compile(*args)[:SQL]
-  end
-
-  %w{ FRAGMENT SQL }.each { |k|
-    eval <<-EOF.strip, nil, __FILE__, __LINE__ + 1
-      def #{k}
-        return @#{k} if @SQL
-        to_meta[:#{k}]
-      end
-    EOF
-  }
-
-  private # ==========================================
-
-  def prefix_raw sym
-    "raw_#{sym.to_s.split('_').first}".to_sym
-  end
-
-  def prefix sym
-    sym.to_s.split('_').first.to_sym
-  end
-
-  protected(
-    def table_name one, two = nil
-      if two
-        k = two
-        link_name = one
-      else
-        k = one
-        link_name = nil
-      end
-
-      case
-      when [:out_ftable, :in_ftable].include?(k)
-        "#{real_table}_#{ meta[prefix(k)] }_#{meta[k]}"
-
-      when link? && link_name && @data[link_name][:inner_join].include?(k)
-        "#{self.name}_#{@data[link_name][:name]}_#{k}"
-
-      else
-        fail ArgumentError, "Unknown key for table name: #{k.inspect}"
-      end
-    end
-  ) # === protected
-
-  #
-  # Examples:
-  #
-  #   field :in, :owner_id
-  #   field :screen_name, :screen_name
-  #   field :in
-  #   field :raw_in
-  #
-  protected(
-    def field *args
-
-      case args
-      when [:out], [:in]
-        "#{name}.#{data[args.last][:name]}"
-      when [:raw, :out], [:raw, :in]
-        "#{name}.#{self[:DEFAULT].data[args.last]}"
-      when [:owner_id], [:type_id]
-        "#{name}.#{args.first}"
-      else
-        fail ArgumentError, "Unknown args: #{args.inspect}"
-      end # === case
-
-    end # === def field
-  )
-
-  protected def compile target = nil
-    return(self[target].compile) if target && target != name
-
-    if !@SQL
-      compile_raw
-    end
-
-    {FRAGMENT: @FRAGMENT, SQL: @SQL, WITH: @WITH, VARS: vars!}
-  end # === def to_sql
-
-  def compile_raw
-    @data[:raw].freeze
-
-    s = @FRAGMENT = @data[:raw].dup
-
-    while s[HAS_VAR] 
-      s.gsub!(/\{\{\s?([a-zA-Z0-9\_]+)\s?\}\}/) do |match|
-        key = $1.to_sym
-        @WITHS << key
-        key
-      end
-
-      s.gsub!(/\<\<\s?([a-zA-Z0-9\_\-\ \*]+)\s?\>\>/) do |match|
-        tokens = $1.split
-
-        key = tokens.last.to_sym
+      fail ArgumentError, "Unknown args: #{args.inspect}"
 
-        if has_key?(key)
+    end # === case
+  end # === def var
 
-          tokens.pop
-          target = self[key]
+  # Example:
+  #   sql(:name)
+  #   sql(:name, 'string')
+  #   sql(:name) { FROM ... }
+  #
+  def sql name, *args, &blok
+    case
 
-          if target.is_a?(Proc)
-            target.call self, *tokens
-          else
-            field  = tokens.empty? ? nil : tokens.join(' ')
-
-            if field
-              @WITHS << key
-              tokens.pop
-              "SELECT #{field} FROM #{key}"
-            else
-              target.to_sql
-            end
-          end
+    when args.size == 0 && !block_given?
+      @sqls[name]
 
-        elsif has_key?(tokens.first.to_sym)
-          self[tokens.shift.to_sym].call self, *tokens
+    when (args.size == 0 && block_given?) || args.size == 1
+      @sqls[name] = H.new
+      @sqls[name][:complete], @sqls[name][:base], @sqls[name][:withs] = I_Dig_Sql.string(*(args), self, &blok)
 
-        else
-          fail ArgumentError, "Not found: #{$1}"
-
-        end # === if has_key?
-      end
-    end # === while s HAS_VAR
-
-    @WITH = if @WITHS.empty?
-              ""
-            else
-              %^WITH\n  #{WITH()}\n\n^
-            end
-
-    @SQL = (@WITH + @FRAGMENT).strip
-  end # === fragments_to_raw
-
-  def WITH
-    withs = @WITHS.dup
-    maps  = []
-    done  = {}
-    while name = withs.shift
-      next if done[name]
-      if name == :DEFAULT || !self.has_key?(name)
-        done[name] = true
-        next
-      end
-
-      fragment = self[name].FRAGMENT
-      fragment.gsub!(/^/, "    ") if ENV['IS_DEV']
-      maps << "#{name} AS (\n#{fragment}\n  )"
-      withs.concat self[name].WITHS
-      done[name] = true
-    end # === while name
-
-    maps.join ",\n  "
-  end
-
-  def WHERE
-    wheres = @data[:WHERE].dup
-
-    if link? && name != :block
-      wheres << "#{field :type_id} = :#{name.to_s.upcase}_TYPE_ID"
-
-      pattern = [ data[:out][:inner_join], data[:in][:inner_join] ]
-      left, mid = data[:out][:inner_join]
-      right, _  = *data[:in][:inner_join]
-
-
-      case
-      when [[:screen_name], [:screen_name]], [[:screen_name, :computer],[:screen_name]]
-        # do nothing
-      else
-        fail "Programmer Error: Permissions not implemented for: #{pattern.inspect}"
-      end # === case
-
-      if left == :screen_name && right == :screen_name
-        default = self[:DEFAULT]
-        block   = self[:block]
-        blocked = block.table_name(:out, :screen_name)
-        victim  = block.table_name(:in, :screen_name)
-        f_in    = table_name :in, :screen_name
-        f_out   = table_name :out, :screen_name
-
-        wheres << %^
-        NOT EXISTS (
-          SELECT 1
-          FROM #{block.real_table} AS block
-          WHERE
-            (
-              block.type_id = :BLOCK_SCREEN_TYPE_ID
-              AND (
-                (
-                  #{f_out}.owner_id = #{block.field :out}
-                  AND
-                  #{f_in}.owner_id = #{victim}.owner_id
-                )
-                OR
-                (
-                  #{field :raw, :in} = #{block.field :out}
-                  AND
-                  #{blocked}.owner_id = #{victim}.owner_id
-                )
-              )
-            )
-            OR
-            (
-              block.type_id = :BLOCK_OWNER_TYPE_ID
-              AND (
-                (
-                  #{f_out}.owner_id = #{blocked}.owner_id
-                  AND
-                  #{f_in}.owner_id = #{victim}.owner_id
-                )
-                OR
-                (
-                  #{f_in}.owner_id = #{blocked}.owner_id
-                  AND
-                  #{f_out}.owner_id = #{victim}.owner_id
-                )
-              ) -- AND
-            )
-        ) -- NOT EXISTS
-        ^
-      end # === if :screen_name, :screen_name
-
-      if mid == :computer
-        asql(wheres.last)
-        fail "COMPUTER not ready"
-      end
-
-    end # === if link?
-
-    if @data.has_key?(:OF)
-      table = self[@data[:FROM].first]
-      wheres << "#{table.field(:out)} = #{@data[:OF].first}"
-    end
-
-    if false && @data[:NOT_EXISTS]
-      block = self[meta[:not_exists]]
-      w = ""
-      w << %^  NOT EXISTS (\n^
-      w << %^    SELECT 1\n^
-      w << %^    FROM #{meta[:not_exists]}\n^
-      w << %^    WHERE\n^
-
-      conds = []
-      block[:where].each { |block_meta|
-        type_id = block_meta.first
-        c = ""
-        c << %^    (\n^
-        c << "      #{field meta, block_meta[1][1], block_meta[1][2]} = #{field block, block_meta[2][1], block_meta[2][2]}\n"
-        c << "      AND\n"
-        c << "      #{meta[:not_exists]}.type_id = :#{type_id}_TYPE_ID\n"
-        c << "      AND\n"
-        c << "      #{field meta, block_meta[3][1], block_meta[3][2]} = #{field block, block_meta[4][1], block_meta[4][2]}\n"
-        c << %^    )\n^
-        conds << c
-      }
+    else
+      fail ArgumentError, "Unknown args: #{args.inspect}"
 
-      w << conds.join("    OR\n")
-      sql[:WHERE] << w
-    end
+    end # === case
+  end # === def sql
 
+  def pair name = :SQL, vars = {}
+    @vars.freeze unless @vars.frozen?
+    [sql(name)[:complete], @vars.merge(vars)]
+  end # === def to_sql
 
-    return nil if wheres.empty?
-    wheres.join " AND "
-  end
+end # === class I_Dig_Sql ===
 
-  # === END: Rendering DSL ==========================================
 
-end # === class I_Dig_Sql ===
 
 
 

data/lib/i_dig_sql/string.rb

@@ -0,0 +1,10 @@
+
+class I_Dig_Sql
+
+  def initialize str
+    @meta = {
+      :origin => str
+    }
+  end
+
+end # === I_Dig_Sql

data/specs/0000-I_Dig_Sql.rb

@@ -2,39 +2,36 @@
 
 describe :I_Dig_Sql do
 
+  it "runs" do
+    dig = I_Dig_Sql.new
+    dig.sql :heroes do
+      FROM(:tbl, :heroes) {
+        SELECT(:nickname, :name)
+      }
+    end
+
+    sql(dig.sql(:heroes)).should == sql("SELECT heroes.nickname AS name FROM tbl heroes")
+  end # === it
+
   it "runs the code from README.md" do
     readme = File.read(File.expand_path(File.dirname(__FILE__) + '/../README.md'))
-    code   = readme[/```ruby([^`]+)```/] && $1
+    code   = (readme[/```ruby([^`]+)```/] && $1).split("\n").map { |l| l.sub('puts ', '') }.join("\n")
     line   = 0
     readme.split("\n").detect { |l| line = line + 1; l['```ruby'] }
-    result = eval(code, nil, 'README.md', line)
-    sql(result).should == sql(%^
-      WITH
-      HEROES AS ( SELECT id FROM hero WHERE id = :PERSON_ID ),
-      VILLIANS AS ( SELECT id FROM villian WHERE id = :PERSON_ID )
-      SELECT * FROM people
-      WHERE
-        id IN ( SELECT id FROM hero WHERE id = :PERSON_ID AND status = :ALIVE)
-        OR
-        id IN (SELECT ID FROM HEROES AND status = :ALIVE)
-        OR
-        id IN ( SELECT * FROM HEROES )
-        OR
-        id IN ( SELECT patron_id FROM VILLIANS )
-        OR
-        id IN ( SELECT id FROM villian WHERE id = :PERSON_ID )
-    ^)
+    should.not.raise {
+      eval(code, nil, 'README.md', line)
+    }
   end # === it
 
   it "adds WITH: {{MY_NAME}}" do
     sql = I_Dig_Sql.new
-    sql[:MY_HERO] = "SELECT * FROM hero"
-    sql[:MY_NAME] = "SELECT * FROM name"
-    sql << %^
+    sql.sql :MY_HERO, "SELECT * FROM hero"
+    sql.sql :MY_NAME, "SELECT * FROM name"
+    sql.sql :SQL, %^
       {{MY_HERO}}
       {{MY_NAME}}
     ^
-    sql(sql).should == sql(%^
+    sql(sql.sql :SQL).should == sql(%^
       WITH
       MY_HERO AS (
         SELECT * FROM hero
@@ -47,25 +44,16 @@ describe :I_Dig_Sql do
     ^)
   end
 
-  it "replaces text with content: << MY_NAME >>" do
-    sql = I_Dig_Sql.new
-    sql[:MY_HERO] = "SELECT * FROM hero"
-    sql << %^
-      << MY_HERO >>
-    ^
-    sql(sql).should == "SELECT * FROM hero"
-  end # === it
-
   %w{ * id }.each { |s|
-    it "adds WITH: << #{s} MY_NAME >>" do
+    it "adds WITH: {{ MY_NAME #{s} }}" do
       sql = I_Dig_Sql.new
-      sql[:MY_HERO] = "SELECT id, p_id FROM hero"
-      sql[:MY_NAME] = "SELECT id, n_id FROM name"
-      sql << %^
-        << #{s} MY_NAME >>
-        << #{s} MY_HERO >>
+      sql.sql :MY_HERO, "SELECT id, p_id FROM hero"
+      sql.sql :MY_NAME, "SELECT id, n_id FROM name"
+      sql.sql :SQL, %^
+        {{ MY_NAME #{s} }}
+        {{ MY_HERO #{s} }}
       ^
-      sql(sql).should == sql(%^
+      sql(sql.sql :SQL).should == sql(%^
         WITH
         MY_NAME AS (
           SELECT id, n_id FROM name
@@ -77,8 +65,105 @@ describe :I_Dig_Sql do
         SELECT #{s} FROM MY_HERO
       ^)
     end # === it
-  }
+
+    it "replaces text with content: {{ MY_NAME #{s} }}" do
+      sql = I_Dig_Sql.new
+      sql.sql :MY_HERO, "SELECT * FROM hero"
+      sql.sql :SQL,     " {{ MY_HERO #{s} }} "
+      sql(sql.sql :SQL).should == "WITH MY_HERO AS ( SELECT * FROM hero ) SELECT #{s} FROM MY_HERO"
+    end # === it
+  } # === %w{}
+
+  it "renders nested replacements"  do
+    i = I_Dig_Sql.new
+    i.sql :THIRD,  "SELECT id FROM phantom"
+    i.sql :SECOND, " {{ THIRD }}  "
+    i.sql :FIRST,  " {{ SECOND }} "
+    i.sql :SQL,    " {{ FIRST }}  "
+    sql(i.sql :SQL).should == sql(
+      <<-EOF
+        WITH
+        FIRST AS ( SECOND ),
+        SECOND AS ( THIRD ),
+        THIRD AS ( SELECT id FROM phantom )
+        FIRST
+      EOF
+    )
+  end # === it
+
+  it "prints CTE definitions once, if used multiple times" do
+    i = I_Dig_Sql.new
+    i.sql :my_cte, "SELECT * FROM my"
+    i.sql :SQL, <<-EOF
+      {{my_cte}}
+      {{my_cte}}
+    EOF
+    sql(i.sql :SQL).should == sql(%^
+      WITH
+      my_cte AS (
+        SELECT * FROM my
+      )
+      my_cte
+      my_cte
+    ^)
+  end # === it
 
 end # === describe :I_Dig_Sql
 
 
+describe ":pair" do
+
+  it "returns an array of: [string, hash]" do
+    s = "select * from THE_WORLD"
+    i = I_Dig_Sql.new
+    i.sql :SQL, s
+    i.pair(:SQL).should == [s, {}]
+  end # === it
+
+  it "merges the hash passed to it" do
+    s = "select * from THE_UNI"
+    i = I_Dig_Sql.new
+    i.sql :SQL, s
+    i.pair(:SQL, {:a=>:b}).should == [s, {:a=>:b}]
+  end # === it
+
+  it "does not save :vars passed to it" do
+    s = "select * from THE_UNI"
+    i = I_Dig_Sql.new
+    i.sql :SQL, s
+    i.pair(:SQL, {:a=>:b})
+    i.vars.should == {}
+  end # === it
+
+end # === describe pair
+
+
+describe ":box" do
+
+  it "turns a box into a String" do
+    sql = I_Dig_Sql.new
+    sql.sql :joins do
+
+      FROM(:n, :notes) {
+        SELECT(:long_name, :name)
+      }
+
+      LEFT(:f, :fails) {
+        ON('_.n = __.n')
+        SELECT(:long_name, :name)
+      }
+
+    end
+
+    sql(sql.sql :joins).should == sql(%^
+      SELECT
+        notes.long_name AS name,
+        fails.long_name AS name
+      FROM
+        n notes
+        LEFT JOIN f fails
+        ON fails.n = notes.n
+    ^)
+  end # === it
+
+end # === describe ":box"

data/specs/helpers.rb

@@ -41,11 +41,20 @@ module Kernel
 end # === module Kernel
 
 def sql o
-  if o.is_a? String
-    return o.split.join(" ")
+  case o
+  when String
+    o.split.join(" ")
+
+  when I_Dig_Sql::H
+    sql o[:complete]
+
+  when Array
+    sql o.first
+
   else
     sql(o.to_sql)
-  end
-end
+
+  end # === case
+end # === def sql
 
 

metadata

@@ -1,59 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: i_dig_sql
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - da99
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-12 00:00:00.000000000 Z
+date: 2015-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: boxomojo
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :development
+        version: 1.0.1
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: 1.0.1
 - !ruby/object:Gem::Dependency
-  name: bacon
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
-  name: Bacon_Colored
+  name: bacon
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: Bacon_Colored
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: awesome_print
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: anbt-sql-formatter
+  name: awesome_print
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
@@ -127,7 +127,8 @@ description: "\n  You probably want another gem: arel. Use that\n  to generate S
   \ "
 email:
 - i-hate-spam-1234567@mailinator.com
-executables: []
+executables:
+- i_dig_sql
 extensions: []
 extra_rdoc_files: []
 files:
@@ -137,17 +138,12 @@ files:
 - README.md
 - Rakefile
 - VERSION
-- bin/test
+- bin/i_dig_sql
 - i_dig_sql.gemspec
 - lib/i_dig_sql.rb
 - lib/i_dig_sql/H.rb
-- lib/i_dig_sql/String.rb
+- lib/i_dig_sql/string.rb
 - specs/0000-I_Dig_Sql.rb
-- specs/0001-new.rb
-- specs/0010-vars.rb
-- specs/0011-to_pair.rb
-- specs/0020-to_sql.rb
-- specs/0030-funcs.rb
 - specs/helpers.rb
 homepage: https://github.com/da99/i_dig_sql
 licenses:
@@ -169,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Yet another way of generating Postgresql 9.2+ in Ruby.

data/bin/test

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-# -*- bash -*-
-#
-#
-x="$1"
-set -u -e -o pipefail
-
-if [[ "$x" == "watch" ]]; then
-  shift
-
-  echo ""
-  echo "=== Watching: $@"
-
-  echo -e "\n=== Running test:"
-  bin/test "$@" || echo ""
-
-  inotifywait -q -m -e close_write,close --exclude .git/ -r .  | while read CHANGE
-  do
-
-    dir=$(echo "$CHANGE" | cut -d' ' -f 1)
-    op=$(echo "$CHANGE" | cut -d' ' -f 2)
-    file=$(echo "$CHANGE" | cut -d' ' -f 3)
-    path="${dir}$file"
-
-    if [[ "$op" == *CLOSE_WRITE* && $file == *.rb*  ]]; then
-      echo -e "\n=== Running test:"
-      bin/test "$@" || echo ""
-    fi
-
-  done # === do
-
-  echo ""
-  exit 0
-fi # === if watch
-
-files="$(echo specs/*-$x.rb)"
-if [[ -f "$files" ]]; then
-  shift
-else
-  files="$(echo specs/*-*.rb)"
-fi
-
-
-
-bundle exec bacon -rpry -ri_dig_sql specs/helpers.rb $files "$@"
-
-

data/lib/i_dig_sql/String.rb

@@ -1,8 +0,0 @@
-
-class String
-
-  def i_dig_sql
-    I_Dig_Sql.new self
-  end
-
-end # === class String ===

data/specs/0001-new.rb

@@ -1,20 +0,0 @@
-
-
-describe '.new' do
-
-  it "merges sql values: .new(i_dig_sql)" do
-    first = I_Dig_Sql.new
-    first[:hero] = "SELECT * FROM hero"
-    second = I_Dig_Sql.new(first)
-    second[:name] = "SELECT * FROM name"
-    second << %^
-      << hero >>
-      << name >>
-    ^
-    sql(second).should == sql(%^
-      SELECT * FROM hero
-      SELECT * FROM name
-    ^)
-  end # === it
-
-end # === describe '.new'

data/specs/0010-vars.rb

@@ -1,38 +0,0 @@
-
-describe :vars do
-
-  it "combines vars from other digs" do
-    one   = I_Dig_Sql.new
-    one.vars[:one] = 1
-
-    two   = I_Dig_Sql.new
-    one.vars[:two] = 2
-
-    three = I_Dig_Sql.new
-    one.vars[:three] = 3
-
-    dig = I_Dig_Sql.new one, two, three
-    dig.vars[:four] = 4
-
-    dig.vars!.should == {
-      four:  4,
-      three: 3,
-      two:   2,
-      one:   1
-    }
-  end # === it
-
-  it "fails w/Duplicate if other digs have the same var name" do
-    should.raise(ArgumentError) {
-      one = I_Dig_Sql.new
-      one.vars[:two] = 2
-
-      i = I_Dig_Sql.new one
-      i.vars[:two] = 3
-      i.vars!
-    }.message.should.match /Key already set: :two/
-  end # === it
-
-end # === describe :vars
-
-

data/specs/0011-to_pair.rb

@@ -1,15 +0,0 @@
-
-describe :to_pair do
-
-  it "returns an Array: [String, Hash]" do
-    i = I_Dig_Sql.new <<-EOF
-      SELECT * FROM new
-    EOF
-    i.vars[:one] = 2
-    sql, vars = i.to_pair
-    sql(sql).should == sql("SELECT * FROM new")
-    vars.should == {one: 2}
-  end # === it
-
-end # === describe :to_pair
-

data/specs/0020-to_sql.rb

@@ -1,31 +0,0 @@
-
-
-describe :to_sql do
-
-  it "renders nested replacements"  do
-    i = I_Dig_Sql.new <<-EOF
-      << FIRST >>
-    EOF
-    i[:FIRST] = " << SECOND >> "
-    i[:SECOND] = " << THIRD >> "
-    i[:THIRD] = "SELECT id FROM phantom"
-    sql(i).should == "SELECT id FROM phantom"
-  end # === it
-
-  it "prints CTE definitions once, if used multiple times" do
-    i = I_Dig_Sql.new <<-EOF
-      {{my_cte}}
-      {{my_cte}}
-    EOF
-    i[:my_cte] = "SELECT * FROM my"
-    sql(i).should == sql(%^
-      WITH
-      my_cte AS (
-        SELECT * FROM my
-      )
-      my_cte
-      my_cte
-    ^)
-  end # === it
-
-end # === describe :to_sql

data/specs/0030-funcs.rb

@@ -1,40 +0,0 @@
-
-describe :funcs do
-
-  it "let's you use a lambda in a SQL fragment" do
-    sql = I_Dig_Sql.new :q, <<-EOF
-      SELECT name
-      FROM screen_name
-      WHERE
-        << id >>
-    EOF
-
-    sql[:id] = lambda { |dig| "id = :id" }
-
-    sql(sql).should == sql(%^
-      SELECT name
-      FROM screen_name
-      WHERE
-        id = :id
-    ^)
-  end # === it
-
-  it "passes args to function" do
-    sql = I_Dig_Sql.new :q, <<-EOF
-      SELECT name
-      FROM screen_name
-      WHERE
-        << names Hans Hoppe >>
-    EOF
-
-    sql[:names] =  lambda { |dig, *args| "name IN [#{args.join ', '}]" }
-
-    sql(sql).should == sql(%^
-      SELECT name
-      FROM screen_name
-      WHERE
-        name IN [Hans, Hoppe]
-    ^)
-  end # === it
-
-end # === describe :funcs