abstract-sql 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.swp
+*~
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create ruby-1.9.2@abstract-sql

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in abstract-sql.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,23 @@
+# Abstract SQL
+
+You ca use this project to transform a SQL string into a Perl SQL::Abstract statement format (as a Hash)
+
+## Usage
+
+All you need to do is to add this line in your Gemfile
+
+      gem 'abstract-sql'
+
+Then use it like this :
+
+    statement = "(id = 1 AND label like '%webo%') OR (id !=1 and label like '%api%')"
+    abstract = SQL::Abstract.new
+    abstract.parse statement
+    #=> {
+          :"-or"=>
+            [{:"-and"=>[{:"-="=>{:id=>1}}, {:"-like"=>{:label=>"%webo%"}}]},
+             {:"-and"=>[{:"-!="=>{:id=>1}}, {:"-like"=>{:label=>"%api%"}}]}
+            ]
+        }
+
+

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.options = '--verbose --use-color'
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+    test.rcov_opts += ["--exclude /gems/"]
+  end
+rescue LoadError
+ puts "Install rcov gem : `gem install rcov`"
+end
+
+desc "Default task"
+task :default => "test"

data/abstract-sql.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "abstract-sql/version"
+
+Gem::Specification.new do |s|
+  s.name        = "abstract-sql"
+  s.version     = Abstract::Sql::VERSION
+  s.authors     = ["Hallelujah"]
+  s.email       = ["hery@rails-royce.org"]
+  s.homepage    = "https://github.com/hallelujah/sql-abstract"
+  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.add_dependency 'parslet'
+  s.add_development_dependency 'test-unit', '>= 2.1.0'
+  s.add_development_dependency 'rcov'
+  s.add_development_dependency 'rake'
+
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/abstract-sql.rb

@@ -0,0 +1,23 @@
+require "abstract-sql/version"
+require "abstract-sql/parser/statement"
+require "abstract-sql/transform/statement"
+
+module SQL
+  class Abstract
+
+    attr_reader :parser, :transformer
+
+    def initialize
+      @parser = Parser::Statement.new
+      @transformer = Transform::Statement.new
+    end
+
+    def parse(sql)
+      tree = @parser.parse(sql)
+      while tree != (t = @transformer.apply(tree) )
+        tree = t
+      end
+      t
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'parslet'
+module SQL
+  module Parser
+    class Statement < Parslet::Parser
+      # At least one space character (space, tab, new line, carriage return)
+      rule(:spaces) { match('\s').repeat(1) }
+      rule(:lparen){ spaces? >> str('(') >> spaces?}
+      rule(:rparen){ spaces? >> str(')') >> spaces?}
+      rule(:spaces?){ spaces.maybe}
+      rule(:digit) { match('[0-9]') }
+      rule(:int){ digit.repeat(1).as(:int) }
+      rule(:float) do
+        (str('-').maybe >> (
+                str('0') | (match('[1-9]') >> digit.repeat)
+              ) >> (
+                str('.') >> digit.repeat(1)
+              ) >> (
+                match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
+              ).maybe
+            ).as(:float)
+      end
+
+      rule(:string) do
+        (str('"') >> (str('\\') >> any | str('"').absent? >> any).repeat.as(:string) >> str('"')) |
+         (str('\'') >> (str('\\') >> any | str('\'').absent? >> any ).repeat.as(:string) >> str('\''))
+      end
+
+      rule(:boolean_operator) do
+        str('and') | str('or') | str('AND') | str('OR')
+      end
+
+      rule(:operator) do
+        (str('!=') | str('like') | str('LIKE') | str('=') | str('<=') | str('>=') | str('<') | str('>')).as(:operator)
+      end
+
+      rule(:column) do
+        match('[-_0-9a-zA-Z]').repeat.as(:column)
+      end
+
+      rule(:value) do
+        spaces? >> (val | column) >> spaces?
+      end
+
+      rule(:val) do
+        (string | int | float).as(:val)
+      end
+
+      rule(:entity) do
+       (value.as(:lvalue) >> operator >> value.as(:rvalue))
+      end
+
+      rule(:statement) do
+        (lparen >> (top | statement | entity) >> rparen) | entity
+      end
+
+      rule(:top) do
+        statement.as(:lstatement) >> (boolean_operator.as(:boolean_operator) >> top.as(:rstatement)) | statement.as(:lstatement)
+      end
+
+      root(:top)
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'parslet'
+module SQL
+  module Transform
+    class Statement < Parslet::Transform
+      rule(:val => simple(:x)){ x }
+      rule(:val =>{:float => simple(:x)}){ String(x).to_f }
+      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 } } }
+
+      # 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(: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 => 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(:boolean_operator => simple(:op), :lstatement => subtree(:l), :rstatement => subtree(:r) ) { {operator(op) => [l, r] } }
+
+
+    end
+  end
+end
+
+class Parslet::Pattern::Context
+  def operator(op)
+    if op.is_a?(Symbol)
+      op
+    else
+      ( "-" + String(op) ).downcase.to_sym
+    end
+  end
+
+end

data/lib/abstract-sql/version.rb

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

data/test/helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'test/unit'
+
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'abstract-sql'
+class Test::Unit::TestCase
+end

data/test/test_abstract.rb

@@ -0,0 +1,42 @@
+require 'helper'
+
+class TestAbstract < Test::Unit::TestCase
+
+  def setup
+    @abstract = SQL::Abstract.new
+  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%'"))
+  end
+
+  test "parse a complex condition" do
+    assert_equal( 
+                 {
+      :"-or" => [
+        {:"-and" => [{:"-=" => { :id => 1}}, {:"-like" => {:label => '%webo%'}}]},
+        {:"-and" => [{:"-!=" => { :id => 1}}, {:"-like" => {:label => '%api%'}}]}
+    ]
+    }, 
+      @abstract.parse("(id = 1 AND label like '%webo%') OR (id !=1 and label like '%api%')")
+                )
+  end
+
+  test "raise error when bad formatted sql" do
+    assert_raise Parslet::ParseFailed do
+      # No AND
+      @abstract.parse("(id = 1 label like '%webo%')")
+    end
+    assert_raise Parslet::ParseFailed do
+      @abstract.parse("label liike '%webo%'")
+    end
+    assert_raise Parslet::UnconsumedInput do
+      @abstract.parse("id = 1 ET label like '%webo%'")
+    end
+    assert_raise Parslet::UnconsumedInput do
+      @abstract.parse("(id = 1 AND label like '%webo%') OR (id !=1 and label like '%api%'")
+    end
+  end
+
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: abstract-sql
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Hallelujah
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-01 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: &9785380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *9785380
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: &9784880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: *9784880
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &9784460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9784460
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &9784000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9784000
+description: It reverse an SQL statement to a Perl SQL::Abstract JSON format.
+email:
+- hery@rails-royce.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.markdown
+- Rakefile
+- abstract-sql.gemspec
+- lib/abstract-sql.rb
+- lib/abstract-sql/parser/statement.rb
+- lib/abstract-sql/transform/statement.rb
+- lib/abstract-sql/version.rb
+- test/helper.rb
+- test/test_abstract.rb
+homepage: https://github.com/hallelujah/sql-abstract
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Transform a SQL statement to Perl SQL::Abstract JSON format
+test_files:
+- test/helper.rb
+- test/test_abstract.rb