abstract-sql 0.0.1 → 0.0.2

data/abstract-sql.gemspec

@@ -7,10 +7,12 @@ Gem::Specification.new do |s|
   s.version     = Abstract::Sql::VERSION
   s.authors     = ["Hallelujah"]
   s.email       = ["hery@rails-royce.org"]
-  s.homepage    = "https://github.com/hallelujah/sql-abstract"
+  s.homepage    = "https://github.com/hallelujah/abstract-sql"
   s.summary     = %q{Transform a SQL statement to Perl SQL::Abstract JSON format}
   s.description = %q{It reverse an SQL statement to a Perl SQL::Abstract JSON format.}
 
+  s.rubyforge_project = "abstract-sql"
+
 
   s.add_dependency 'parslet'
   s.add_development_dependency 'test-unit', '>= 2.1.0'

data/lib/abstract-sql/parser/statement.rb

@@ -9,6 +9,8 @@ module SQL
       rule(:spaces?){ spaces.maybe}
       rule(:digit) { match('[0-9]') }
       rule(:int){ digit.repeat(1).as(:int) }
+      rule(:bool_not) { spaces >> (str('not') | str('NOT')).as(:not) >> spaces}
+
       rule(:float) do
         (str('-').maybe >> (
                 str('0') | (match('[1-9]') >> digit.repeat)
@@ -46,7 +48,7 @@ module SQL
       end
 
       rule(:entity) do
-       (value.as(:lvalue) >> operator >> value.as(:rvalue))
+        bool_not.maybe >> (value.as(:lvalue) >> operator >> value.as(:rvalue))
       end
 
       rule(:statement) do

data/lib/abstract-sql/transform/statement.rb

@@ -7,32 +7,57 @@ module SQL
       rule(:val =>{:int => simple(:x)}){ String(x).to_i }
       rule(:val =>{:string => simple(:x)}){ String(x) }
       # rule(:boolean_operator => simple(:x)){{ :boolean_operator =>  String(x).downcase.to_sym }}
-      rule(:lvalue => {:column => simple(:x) }, :operator => simple(:op), :rvalue => {:column => simple(:z)}){ {operator(op) => { String(x).to_sym => String(z).to_sym } } }
-      rule(:lvalue => {:column => simple(:x) }, :operator => simple(:op), :rvalue => simple(:z) ){ {operator(op) => { String(x).to_sym => z } } }
-      rule(:lvalue => simple(:x) , :operator => simple(:op), :rvalue => {:column => simple(:z)}){ {operator(op) => { String(z).to_sym => x } } }
+      
+      rule(:lvalue => {:column => simple(:x) }, :operator => simple(:op), :rvalue => {:column => simple(:z)}) do 
+        { String(x).to_sym => { operator(op) => String(z).to_sym } } 
+      end
+
+      rule(:lvalue => {:column => simple(:x) }, :operator => simple(:op), :rvalue => simple(:z) ) do
+        {String(x).to_sym => { operator(op)  => z } } 
+      end
+      
+      rule(:lvalue => simple(:x) , :operator => simple(:op), :rvalue => {:column => simple(:z)}) do
+        { String(z).to_sym => { operator(op) => x } } 
+      end
 
       # Statement right or left without right leaf
-      rule(:lstatement => { :lstatement => subtree(:y) }){ {:lstatement => y }}
-      rule(:rstatement => { :lstatement => subtree(:y) }){ {:rstatement => y}}
+      rule(:lstatement => { :lstatement => subtree(:y) })do
+        {:lstatement => y } 
+      end
+
+      rule(:rstatement => { :lstatement => subtree(:y) })do
+        {:rstatement => y} 
+      end
 
-      rule({:lstatement=>{:lstatement=> subtree(:l)},
-           :boolean_operator => simple(:op),
-           :rstatement=>{:lstatement => subtree(:r)}}) do {:lstatement => l, :boolean_operator => op, :rstatement => r} end
+      rule({:lstatement=>{:lstatement=> subtree(:l)}, :boolean_operator => simple(:op), :rstatement=>{:lstatement => subtree(:r)}}) do 
+        {:lstatement => l, :boolean_operator => op, :rstatement => r} 
+      end
 
       # Statement right or left without right leaf and a boolean operator
-      rule(:lstatement => { :lstatement => subtree(:y) }){ {:lstatement => y }}
-      rule(:rstatement => { :lstatement => subtree(:y) }){ {:rstatement => y}}
+      rule(:lstatement => { :lstatement => subtree(:y) }) do
+        {:lstatement => y } 
+      end
+
+      rule(:rstatement => { :lstatement => subtree(:y) }) do
+        {:rstatement => y} 
+      end
+
+      rule({:lstatement => subtree(:l), :boolean_operator=> simple(:op), :rstatement=>{:lstatement=>subtree(:r)}}) do 
+        {:lstatement => l, :boolean_operator => operator(op), :rstatement => r} 
+      end
 
-      rule({:lstatement => subtree(:l),
-       :boolean_operator=> simple(:op),
-       :rstatement=>{:lstatement=>subtree(:r)}}) do {:lstatement => l, :boolean_operator => operator(op), :rstatement => r} end
+      rule({:rstatement => subtree(:r), :boolean_operator=> simple(:op), :lstatement=>{:lstatement=>subtree(:l)}}) do
+        {:lstatement => l, :boolean_operator => operator(op), :rstatement => r} 
+      end
 
-      rule({:rstatement => subtree(:r),
-       :boolean_operator=> simple(:op),
-       :lstatement=>{:lstatement=>subtree(:l)}}) do {:lstatement => l, :boolean_operator => operator(op), :rstatement => r} end
 
+      rule(:boolean_operator => simple(:op), :lstatement => subtree(:l), :rstatement => subtree(:r) ) do 
+        {operator(op) => [l, r] } 
+      end
 
-      rule(:boolean_operator => simple(:op), :lstatement => subtree(:l), :rstatement => subtree(:r) ) { {operator(op) => [l, r] } }
+      rule(:not => simple(:n), :lvalue=> subtree(:l), :operator=> simple(:op), :rvalue=> subtree(:r)) do
+        {bool(n) => {:lvalue => l, :operator => op, :rvalue => r}}
+      end
 
 
     end
@@ -48,4 +73,12 @@ class Parslet::Pattern::Context
     end
   end
 
+  def bool(n)
+    if (b = String(n).downcase) == 'not' 
+      operator('not_bool') 
+    else
+      n
+    end
+  end
+
 end

data/lib/abstract-sql/version.rb

@@ -1,5 +1,5 @@
 module Abstract
   module Sql
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/test/test_abstract.rb

@@ -7,22 +7,35 @@ class TestAbstract < Test::Unit::TestCase
   end
 
   test "parse a simple condition" do
-    assert_equal( {:"-and" => [{:"-=" => { :id => 1}}, {:"-like" => {:label => '%webo%'}}]}, @abstract.parse("id = 1 and label like '%webo%'"))
-    assert_equal( {:"-and" => [{:"-=" => { :id => 1}}, {:"-like" => {:label => '%webo%'}}]}, @abstract.parse("((id = 1 )) and label like '%webo%'"))
+    assert_equal( {:"-and" => [{:id => { :"-=" => 1}}, {:label => {:"-like" => '%webo%'}}]}, @abstract.parse("id = 1 and label like '%webo%'"))
+    assert_equal( {:"-and" => [{:id => { :"-=" => 1}}, {:label => {:"-like" => '%webo%'}}]}, @abstract.parse("((id = 1 )) and label like '%webo%'"))
   end
 
   test "parse a complex condition" do
     assert_equal( 
                  {
       :"-or" => [
-        {:"-and" => [{:"-=" => { :id => 1}}, {:"-like" => {:label => '%webo%'}}]},
-        {:"-and" => [{:"-!=" => { :id => 1}}, {:"-like" => {:label => '%api%'}}]}
+        {:"-and" => [{:id => { :"-=" => 1}}, {:label => {:"-like" => '%webo%'}}]},
+        {:"-and" => [{:id => { :"-!=" => 1}}, {:label => {:"-like" => '%api%'}}]}
     ]
     }, 
       @abstract.parse("(id = 1 AND label like '%webo%') OR (id !=1 and label like '%api%')")
                 )
   end
 
+  test "Very complex condition" do
+    assert_equal(
+      {
+      :"-and" => [
+        { :"-or" => [ {:criterion_7 => {:"->=" => 8}}, {:criterion_1 => {:"-<" => 8}} ] },
+        { :"-or" => [ {:segment_1 => {:"-<" => 4}}, {:"-not_bool" => { :segment_2 => {:"-<" => 1} }}] }
+    ]
+    },
+      @abstract.parse("( criterion_7 >= 8 or criterion_1 < 8 ) and ( segment_1 < 4 or not segment_2 < 1 )")
+    )
+    
+  end
+
   test "raise error when bad formatted sql" do
     assert_raise Parslet::ParseFailed do
       # No AND

metadata

@@ -1,67 +1,91 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: abstract-sql
-version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
 platform: ruby
-authors:
+authors: 
 - Hallelujah
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-01 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2011-08-01 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: parslet
-  requirement: &9785380 !ruby/object:Gem::Requirement
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   prerelease: false
-  version_requirements: *9785380
-- !ruby/object:Gem::Dependency
+  requirement: *id001
+  type: :runtime
+- !ruby/object:Gem::Dependency 
   name: test-unit
-  requirement: &9784880 !ruby/object:Gem::Requirement
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
         version: 2.1.0
-  type: :development
   prerelease: false
-  version_requirements: *9784880
-- !ruby/object:Gem::Dependency
+  requirement: *id002
+  type: :development
+- !ruby/object:Gem::Dependency 
   name: rcov
-  requirement: &9784460 !ruby/object:Gem::Requirement
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   prerelease: false
-  version_requirements: *9784460
-- !ruby/object:Gem::Dependency
+  requirement: *id003
+  type: :development
+- !ruby/object:Gem::Dependency 
   name: rake
-  requirement: &9784000 !ruby/object:Gem::Requirement
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   prerelease: false
-  version_requirements: *9784000
+  requirement: *id004
+  type: :development
 description: It reverse an SQL statement to a Perl SQL::Abstract JSON format.
-email:
+email: 
 - hery@rails-royce.org
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .rvmrc
 - Gemfile
@@ -74,30 +98,40 @@ files:
 - lib/abstract-sql/version.rb
 - test/helper.rb
 - test/test_abstract.rb
-homepage: https://github.com/hallelujah/sql-abstract
+has_rdoc: true
+homepage: https://github.com/hallelujah/abstract-sql
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.6
+
+rubyforge_project: abstract-sql
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Transform a SQL statement to Perl SQL::Abstract JSON format
-test_files:
+test_files: 
 - test/helper.rb
 - test/test_abstract.rb