ddl_parser 0.0.3 → 0.0.4

data/spec/ddl_parser/parser_spec.rb

@@ -1,65 +1,65 @@
-require "spec_helper"
+require_relative '../../spec/spec_helper'
 
 describe 'DDLParser::Parser' do
   
   it "knows if it's valid" do
-    sql = "CREATE TABLE TEST (ID INT)"
+    sql = 'CREATE TABLE TEST (ID INT)'
     parser = DDLParser::Parser.new(sql)
     parser.valid?.should == true
   end
 
   it "knows if it's invalid" do
-    sql = "CREATE TABLE TEST ()"
+    sql = 'CREATE TABLE TEST ()'
     parser = DDLParser::Parser.new(sql)
     parser.valid?.should == false
   end
 
-  it "can report errors" do
-    sql = "CREATE TABLE TEST ()"
+  it 'can report errors' do
+    sql = 'CREATE TABLE TEST ()'
     parser = DDLParser::Parser.new(sql)
-    parser.errors.should include("CREATE_TABLE_STATEMENT")
+    parser.errors.should include('CREATE_TABLE_STATEMENT')
   end
 
-  it "statement_type" do
-    sql = "CREATE TABLE TEST (ID INT, FOO INT)"
+  it 'statement_type' do
+    sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
     parser = DDLParser::Parser.new(sql)
     parser.statement_type.should == :create_table
   end
 
-  it "returns the parse tree" do
-    sql = "CREATE TABLE TEST (ID INT, FOO INT)"
+  it 'returns the parse tree' do
+    sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
     parser = DDLParser::Parser.new(sql)
-    parser.parse_tree.should == {:operation=>"CREATE TABLE", :table_name=>"TEST", :elements=>[
-        {:column=>{:field=>"ID", :data_type=>"INT", :options=>""}},
-        {:column=>{:field=>"FOO", :data_type=>"INT", :options=>""}}]}
+    parser.parse_tree.should == {:operation=> 'create table', :table_name=> 'test', :elements=>[
+        {:column=>{:field=> 'id', :data_type=> 'int', :options=> ''}},
+        {:column=>{:field=> 'foo', :data_type=> 'int', :options=> ''}}]}
   end
 
-  context "create table translate" do
-    it "translate table_name" do
-      sql = "CREATE TABLE TEST (ID INT, FOO INT)"
+  context 'create table translate' do
+    it 'translate table_name' do
+      sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
       parser = DDLParser::Parser.new(sql)
-      parser.translate.table_name.should == "TEST"
+      parser.translate.table_name.should == 'test'
     end
 
 
-    it "translate columns" do
-      sql = "CREATE TABLE TEST (ID INT, FOO INT)"
+    it 'translate columns' do
+      sql = 'CREATE TABLE TEST (ID INT, FOO INT)'
       parser = DDLParser::Parser.new(sql)
-      parser.translate.columns.should == [{:field=>"ID", :data_type=>"INT", :options=>""}, {:field=>"FOO", :data_type=>"INT", :options=>""}]
+      parser.translate.columns.should == [{:field=> 'id', :data_type=> 'int', :options=> ''}, {:field=> 'foo', :data_type=> 'int', :options=> ''}]
 
-      sql = "CREATE TABLE TEST (ID INT)"
+      sql = 'CREATE TABLE TEST (ID INT)'
       parser = DDLParser::Parser.new(sql)
-      parser.translate.columns.should == [{:field=>"ID", :data_type=>"INT", :options=>""}]
+      parser.translate.columns.should == [{:field=> 'id', :data_type=> 'int', :options=> ''}]
     end
 
-    it "translate primary key" do
-      sql = "CREATE TABLE TEST (ID   INT, PRIMARY KEY (ID))"
+    it 'translate primary key' do
+      sql = 'CREATE TABLE TEST (ID   INT, PRIMARY KEY (ID))'
       parser = DDLParser::Parser.new(sql)
-      parser.translate.primary_key.should == "ID"
+      parser.translate.primary_key.should == 'id'
     end
   end
 
-  context "alter table translate" do
+  context 'alter table translate' do
     let(:sql) {
       sql = <<EOF
             ALTER TABLE BUDGET
@@ -69,27 +69,27 @@ EOF
       sql
     }
 
-    it "translate table_name" do
+    it 'translate table_name' do
       parser = DDLParser::Parser.new(sql)
-      parser.translate.table_name.should == "BUDGET"
+      parser.translate.table_name.should == 'budget'
     end
 
 
-    it "translate columns" do
+    it 'translate columns' do
       parser = DDLParser::Parser.new(sql)
-      parser.translate.add_columns.should == [{:field=>"BUDGET_AMOUNT_IN_CO",
-                                               :data_type=>{:decimal=>{:precision=>{:total=>{:integer=>"15"}, :scale=>{:integer=>"2"}}}},
-                                               :options=>[{:column_option=>"NOT NULL"},
-                                                          {:default_clause=>[{:integer=>"0"}]}]},
-                                              {:field=>"BUDGET_AMOUNT_CURR",
-                                               :data_type=>{:char=>{:length=>{:integer=>"4"}}},
-                                               :options=>""}]
+      parser.translate.add_columns.should == [{:field=> 'budget_amount_in_co',
+                                               :data_type=>{:decimal=>{:precision=>{:total=>{:integer=> '15'}, :scale=>{:integer=> '2'}}}},
+                                               :options=>[{:column_option=> 'not null'},
+                                                          {:default_clause=>[{:integer=> '0'}]}]},
+                                              {:field=> 'budget_amount_curr',
+                                               :data_type=>{:char=>{:length=>{:integer=> '4'}}},
+                                               :options=> ''}]
     end
 
-    it "translate primary key" do
-      sql = "CREATE TABLE TEST (ID   INT, PRIMARY KEY (ID))"
+    it 'translate primary key' do
+      sql = 'CREATE TABLE TEST (ID   INT, PRIMARY KEY (ID))'
       parser = DDLParser::Parser.new(sql)
-      parser.translate.primary_key.should == "ID"
+      parser.translate.primary_key.should == 'id'
     end
   end
 

data/spec/ddl_parser/shared_rules/constants_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require_relative '../../../spec/spec_helper'
 
 class DummyParser < Parslet::Parser
   include DDLParser::SharedRules::Constants
@@ -7,120 +7,120 @@ end
 describe DDLParser::SharedRules::Constants do
   let(:parser) { DummyParser.new }
 
-  it "digits" do
+  it 'digits' do
     (0..9).each do |digit|
       expect(parser.digit).to     parse(digit.to_s)
     end
-    ("a".."z").each do |non_digit|
+    ('a'..'z').each do |non_digit|
       expect(parser.digit).not_to     parse(non_digit.to_s)
     end
   end
 
-  it "integer" do
-    expect(parser.integer).to     parse("1")
-    expect(parser.integer).to     parse("123456789")
-    expect(parser.integer).to     parse("-123456789")
-    expect(parser.integer).to     parse("0123")
-    expect(parser.integer).not_to parse("1.2")
+  it 'integer' do
+    expect(parser.integer).to     parse('1')
+    expect(parser.integer).to     parse('123456789')
+    expect(parser.integer).to     parse('-123456789')
+    expect(parser.integer).to     parse('0123')
+    expect(parser.integer).not_to parse('1.2')
   end
 
-  it "float" do
-    expect(parser.float).to     parse("-1.1")
-    expect(parser.float).to     parse("1.1")
-    expect(parser.float).to     parse("123456.789")
-    expect(parser.float).to     parse("-123456.789")
-    expect(parser.float).not_to parse("12")
+  it 'float' do
+    expect(parser.float).to     parse('-1.1')
+    expect(parser.float).to     parse('1.1')
+    expect(parser.float).to     parse('123456.789')
+    expect(parser.float).to     parse('-123456.789')
+    expect(parser.float).not_to parse('12')
   end
 
-  it "space" do
-    expect(parser.space).to     parse(" ")
-    expect(parser.space).to     parse("  ")
+  it 'space' do
+    expect(parser.space).to     parse(' ')
+    expect(parser.space).to     parse('  ')
     expect(parser.space).to     parse("\t")
-    expect(parser.space).not_to parse("")
-    expect(parser.space).not_to parse("1")
+    expect(parser.space).not_to parse('')
+    expect(parser.space).not_to parse('1')
   end
 
-  it "space?" do
-    expect(parser.space?).to     parse("")
-    expect(parser.space?).to     parse(" ")
-    expect(parser.space?).to     parse("  ")
-    expect(parser.space?).not_to parse("1")
+  it 'space?' do
+    expect(parser.space?).to     parse('')
+    expect(parser.space?).to     parse(' ')
+    expect(parser.space?).to     parse('  ')
+    expect(parser.space?).not_to parse('1')
   end
 
-  it "newline" do
+  it 'newline' do
     expect(parser.newline).to     parse("\n")
-    expect(parser.newline).not_to parse(" ")
+    expect(parser.newline).not_to parse(' ')
     expect(parser.newline).not_to parse("\t")
   end
 
-  it "spaces" do
+  it 'spaces' do
     expect(parser.spaces).to     parse("\n")
     expect(parser.spaces).to     parse(" \n \n")
     expect(parser.spaces).to     parse("\t ")
   end
 
-  it "comment?" do
-    expect(parser.comment?).to     parse("-- foobar")
+  it 'comment?' do
+    expect(parser.comment?).to     parse('-- foobar')
     expect(parser.comment?).not_to parse("--\nfoobar")
   end
 
-  it "comma" do
-    expect(parser.comma).to     parse(",")
-    expect(parser.comma).to     parse(", ")
-    expect(parser.comma).not_to parse(" , ")
+  it 'comma' do
+    expect(parser.comma).to     parse(',')
+    expect(parser.comma).to     parse(', ')
+    expect(parser.comma).not_to parse(' , ')
   end
 
-  it "lparen" do
-    expect(parser.lparen).to     parse("(")
-    expect(parser.lparen).to     parse("( ")
-    expect(parser.lparen).not_to parse(" (")
+  it 'lparen' do
+    expect(parser.lparen).to     parse('(')
+    expect(parser.lparen).to     parse('( ')
+    expect(parser.lparen).not_to parse(' (')
   end
 
-  it "rparen" do
-    expect(parser.rparen).to     parse(")")
-    expect(parser.rparen).to     parse(") ")
-    expect(parser.rparen).not_to parse(" )")
+  it 'rparen' do
+    expect(parser.rparen).to     parse(')')
+    expect(parser.rparen).to     parse(') ')
+    expect(parser.rparen).not_to parse(' )')
   end
 
-  it "boolean" do
-    expect(parser.boolean).to     parse("true")
-    expect(parser.boolean).to     parse("false")
-    expect(parser.boolean).not_to parse("false ")
+  it 'boolean' do
+    expect(parser.boolean).to     parse('true')
+    expect(parser.boolean).to     parse('false')
+    expect(parser.boolean).not_to parse('false ')
   end
 
-  it "datetime" do
-    expect(parser.datetime).to    parse("2014-02-28T12:01:02Z")
+  it 'datetime' do
+    expect(parser.datetime).to    parse('2014-02-28T12:01:02Z')
   end
 
-  it "string" do
+  it 'string' do
     expect(parser.string).to      parse("'foobar'")
     expect(parser.string).to      parse("'foo bar'")
     expect(parser.string).not_to  parse("'foo bar")
     expect(parser.string).not_to  parse('"foobar"')
   end
 
-  it "const" do
+  it 'const' do
     expect(parser.const).to      parse("'foobar'")
-    expect(parser.const).to      parse("1")
-    expect(parser.const).to      parse("1.1")
-    expect(parser.const).to      parse("true")
-    expect(parser.const).to      parse("2014-02-28T12:01:02Z")
-    expect(parser.const).not_to  parse("(")
+    expect(parser.const).to      parse('1')
+    expect(parser.const).to      parse('1.1')
+    expect(parser.const).to      parse('true')
+    expect(parser.const).to      parse('2014-02-28T12:01:02Z')
+    expect(parser.const).not_to  parse('(')
     expect(parser.const).not_to  parse(',')
   end
 
-  it "identifier" do
-    expect(parser.identifier).to      parse("foobar")
-    expect(parser.identifier).not_to  parse("foo bar")
-    expect(parser.identifier).to     parse("a")
-    expect(parser.identifier).to     parse("aB")
-    expect(parser.identifier).to     parse("A1")
-    expect(parser.identifier).to     parse("A1_2")
-    expect(parser.identifier).not_to parse("A B")
+  it 'identifier' do
+    expect(parser.identifier).to      parse('foobar')
+    expect(parser.identifier).not_to  parse('foo bar')
+    expect(parser.identifier).to     parse('a')
+    expect(parser.identifier).to     parse('aB')
+    expect(parser.identifier).to     parse('A1')
+    expect(parser.identifier).to     parse('A1_2')
+    expect(parser.identifier).not_to parse('A B')
   end
 
-  it "current_timestamp" do
-    expect(parser.current_timestamp).to      parse("current timestamp")
+  it 'current_timestamp' do
+    expect(parser.current_timestamp).to      parse('current timestamp')
   end
 
 end

data/spec/ddl_parser/shared_rules/data_types_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require_relative '../../../spec/spec_helper'
 
 class DummyParser < Parslet::Parser
   include DDLParser::SharedRules::DataTypes
@@ -7,19 +7,19 @@ end
 describe DDLParser::SharedRules::DataTypes do
   let(:parser) { DummyParser.new }
 
-  it "parses data types" do
-    parser.data_type.parse("smallint").should       == {:data_type=>"smallint"}
-    parser.data_type.parse("int").should            == {:data_type=>"int"}
-    parser.data_type.parse("decimal(1,2)").should   == {:data_type=>{:decimal=>{:precision => {:total=>{:integer=>"1"}, :scale=>{:integer=>"2"}}}}}
-    parser.data_type.parse("float(1)").should       == {:data_type=>{:float=>{:precision=>{:integer=>"1"}}}}
-    parser.data_type.parse("real").should           == {:data_type=>"real"}
-    parser.data_type.parse("double").should         == {:data_type=>"double"}
-    parser.data_type.parse("char(1)").should        == {:data_type=>{:char=>{:length=>{:integer=>"1"}}}}
-    parser.data_type.parse("varchar(1)").should     == {:data_type=>{:varchar=>{:length=>{:integer=>"1"}}}}
-    parser.data_type.parse("clob(50000)").should     == {:data_type=>{:clob=>{:length=>{:integer=>"50000"}}}}
-    parser.data_type.parse("date").should           == {:data_type=>"date"}
-    parser.data_type.parse("time").should           == {:data_type=>"time"}
-    parser.data_type.parse("timestamp").should      == {:data_type=>"timestamp"}
+  it 'parses data types' do
+    parser.data_type.parse('smallint').should       == {:data_type=> 'smallint'}
+    parser.data_type.parse('int').should            == {:data_type=> 'int'}
+    parser.data_type.parse('decimal(1,2)').should   == {:data_type=>{:decimal=>{:precision => {:total=>{:integer=> '1'}, :scale=>{:integer=> '2'}}}}}
+    parser.data_type.parse('float(1)').should       == {:data_type=>{:float=>{:precision=>{:integer=> '1'}}}}
+    parser.data_type.parse('real').should           == {:data_type=> 'real'}
+    parser.data_type.parse('double').should         == {:data_type=> 'double'}
+    parser.data_type.parse('char(1)').should        == {:data_type=>{:char=>{:length=>{:integer=> '1'}}}}
+    parser.data_type.parse('varchar(1)').should     == {:data_type=>{:varchar=>{:length=>{:integer=> '1'}}}}
+    parser.data_type.parse('clob(50000)').should     == {:data_type=>{:clob=>{:length=>{:integer=> '50000'}}}}
+    parser.data_type.parse('date').should           == {:data_type=> 'date'}
+    parser.data_type.parse('time').should           == {:data_type=> 'time'}
+    parser.data_type.parse('timestamp').should      == {:data_type=> 'timestamp'}
   end
 
 

data/spec/ddl_parser/sql/db2/select_parser_spec.rb

@@ -1,38 +1,38 @@
-require "spec_helper"
+require_relative '../../../../spec/spec_helper'
 
 describe DDLParser::SQL::DB2::SelectParser do
   let(:parser) { DDLParser::SQL::DB2::SelectParser.new }
 
-  context "value parsing" do
+  context 'value parsing' do
 
-    it "parses integers" do
-      expect(parser.const).to     parse("1")
-      expect(parser.const).to     parse("-123")
-      expect(parser.const).to     parse("120381")
-      expect(parser.const).to     parse("181")
-      expect(parser.const).to     parse("0181")
+    it 'parses integers' do
+      expect(parser.const).to     parse('1')
+      expect(parser.const).to     parse('-123')
+      expect(parser.const).to     parse('120381')
+      expect(parser.const).to     parse('181')
+      expect(parser.const).to     parse('0181')
     end
 
-    it "parses floats" do
-      expect(parser.const).to     parse("0.1")
-      expect(parser.const).to     parse("3.14159")
-      expect(parser.const).to     parse("-0.00001")
-      expect(parser.const).to_not parse(".1")
+    it 'parses floats' do
+      expect(parser.const).to     parse('0.1')
+      expect(parser.const).to     parse('3.14159')
+      expect(parser.const).to     parse('-0.00001')
+      expect(parser.const).to_not parse('.1')
     end
 
-    it "parses booleans" do
-      expect(parser.const).to     parse("true")
-      expect(parser.const).to     parse("false")
-      expect(parser.const).to_not parse("truefalse")
+    it 'parses booleans' do
+      expect(parser.const).to     parse('true')
+      expect(parser.const).to     parse('false')
+      expect(parser.const).to_not parse('truefalse')
     end
 
-    it "parses datetimes" do
-      expect(parser.const).to     parse("1979-05-27T07:32:00Z")
-      expect(parser.const).to     parse("2013-02-24T17:26:21Z")
-      expect(parser.const).to_not parse("1979l05-27 07:32:00")
+    it 'parses datetimes' do
+      expect(parser.const).to     parse('1979-05-27T07:32:00Z')
+      expect(parser.const).to     parse('2013-02-24T17:26:21Z')
+      expect(parser.const).to_not parse('1979l05-27 07:32:00')
     end
 
-    it "parses strings" do
+    it 'parses strings' do
       expect(parser.const).to     parse("''")
       expect(parser.const).to     parse("'hello world'")
       expect(parser.const).to     parse("'120.0, ~!@#$\%^&*+_\}{ asdfasf'")
@@ -41,74 +41,74 @@ describe DDLParser::SQL::DB2::SelectParser do
 
   end
 
-  context "namelist parsing" do
-    it "simple" do
+  context 'namelist parsing' do
+    it 'simple' do
       expect(parser.namelist).to     parse('a,b,c')
       expect(parser.namelist).to     parse('a, b, C')
     end
 
-    it "not parse invalid" do
+    it 'not parse invalid' do
       expect(parser.namelist).not_to     parse('a b')
       expect(parser.namelist).not_to     parse('a: b')
-      expect(parser.namelist).not_to     parse("a; b" )
+      expect(parser.namelist).not_to     parse('a; b')
       expect(parser.namelist).not_to     parse("a, b, 'foo'" )
-      expect(parser.namelist).not_to     parse("a, b, max(c)" )
+      expect(parser.namelist).not_to     parse('a, b, max(c)')
     end
 
   end
 
-  context "arglist parsing" do
-    it "simple" do
+  context 'arglist parsing' do
+    it 'simple' do
       expect(parser.arglist).to     parse('a,b,c')
       expect(parser.arglist).to     parse('a, b, c')
       expect(parser.arglist).to     parse("a, b, 'foo'" )
-      expect(parser.arglist).to     parse("a, b, max(c)" )
+      expect(parser.arglist).to     parse('a, b, max(c)')
     end
 
-    it "not parse invalid" do
+    it 'not parse invalid' do
       expect(parser.arglist).not_to     parse('a b')
       expect(parser.arglist).not_to     parse('a: b')
-      expect(parser.arglist).not_to     parse("a; b" )
+      expect(parser.arglist).not_to     parse('a; b')
     end
 
   end
 
-  context "between parsing" do
-    it "should parse between" do
-      expect(parser.single_cond).to   parse("a between 1 and 2")
-      expect(parser.single_cond).to   parse("a between 1 and 2")
-      expect(parser.single_cond.parse("a between 1 and 2")).to eq(:lhs=>"a", :op=>"between", :rhs=>{:btw_from=>{:integer=>"1"}, :btw_to=>{:integer=>"2"}})
+  context 'between parsing' do
+    it 'should parse between' do
+      expect(parser.single_cond).to   parse('a between 1 and 2')
+      expect(parser.single_cond).to   parse('a between 1 and 2')
+      expect(parser.single_cond.parse('a between 1 and 2')).to eq(:lhs=> 'a', :op=> 'between', :rhs=>{:btw_from=>{:integer=> '1'}, :btw_to=>{:integer=> '2'}})
     end
   end
 
-  context "like parsing" do
-    it "should parse" do
+  context 'like parsing' do
+    it 'should parse' do
       expect(parser.single_cond).to   parse("a like '%foo%bar'")
     end
 
   end
 
-  context "condition parsing" do
-    it "should parse single" do
-      expect(parser.condition).to   parse("a = a")
-      expect(parser.condition).to   parse("a=a")
-      expect(parser.condition).to   parse("a > a")
-      expect(parser.condition).to   parse("a < a")
-      expect(parser.condition).to   parse("a between 1 and 2")
+  context 'condition parsing' do
+    it 'should parse single' do
+      expect(parser.condition).to   parse('a = a')
+      expect(parser.condition).to   parse('a=a')
+      expect(parser.condition).to   parse('a > a')
+      expect(parser.condition).to   parse('a < a')
+      expect(parser.condition).to   parse('a between 1 and 2')
       expect(parser.condition).to   parse("a like '%foo%bar'")
     end
 
-    it "should parse multible" do
-      expect(parser.condition).to   parse("a = a or b = b")
-      expect(parser.condition).to   parse("a = a and b = b")
+    it 'should parse multible' do
+      expect(parser.condition).to   parse('a = a or b = b')
+      expect(parser.condition).to   parse('a = a and b = b')
       expect(parser.condition).to   parse("a > a and a between 'foo' and 'bar'")
       expect(parser.condition).to   parse("a < a and a like '%foo%bar'")
     end
 
   end
 
-  context "select statements" do
-    it "parse simple statements" do
+  context 'select statements' do
+    it 'parse simple statements' do
       [
           'select a from b',
           'select a, b from comme',
@@ -121,7 +121,7 @@ describe DDLParser::SQL::DB2::SelectParser do
       end
     end
 
-    it "parse statements with where" do
+    it 'parse statements with where' do
       [
           'select a from b where a > 20',
           'select a,b from c where a = 20',
@@ -134,7 +134,7 @@ describe DDLParser::SQL::DB2::SelectParser do
       end
     end
 
-    it "parse statements with group by" do
+    it 'parse statements with group by' do
       [
           'select a from b group by c',
           'select a from b where a > 345 group by c',
@@ -144,7 +144,7 @@ describe DDLParser::SQL::DB2::SelectParser do
       end
     end
 
-    it "not to parse bad selects" do
+    it 'not to parse bad selects' do
       [
         'select',
         'select a, b from c where a = "120.0, ~!@#$%^&*+_\}{\" asdfa"sf"',
@@ -155,10 +155,10 @@ describe DDLParser::SQL::DB2::SelectParser do
 
   end
 
-  context "extract" do
-    it "should fetch select" do
-      result = parser.parse("select a from b where a = b")
-      #result[:select].should
+  context 'extract' do
+    it 'should fetch select' do
+      result = parser.parse('select a from b where a = b')
+      result[:select].should == {:item=> 'a'}
     end
   end
 

data/spec/spec_helper.rb

@@ -3,9 +3,9 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 
-  #config.expect_with :rspec do |c|
-  #  c.syntax = :expect
-  #end
+  config.expect_with :rspec do |c|
+    c.syntax = [:expect, :should]
+  end
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
@@ -14,9 +14,9 @@ RSpec.configure do |config|
   config.order = 'random'
 end
 
-require "parslet/rig/rspec"
-require "ddl_parser"
-require "yaml"
+require 'parslet/rig/rspec'
+require 'ddl_parser'
+require 'yaml'
 
 def fixture(filename)
   File.read("spec/fixtures/#{filename}")