user_query 0.1.0

data/lib/user_query/parameters.rb

@@ -0,0 +1,93 @@
+# This class can be used as a stand-in for an ActiveRecord class, while
+# using the ActionPack input tag helpers and standard ActionPack::Controller
+# idiom.
+#
+module UserQuery
+
+class Parameters
+  @active_record_errors = false
+  begin
+    # Kernel.require 'active_record'
+    @@active_record_errors = ActiveRecord::Errors
+  rescue Object => err
+    @@active_record_errors = false
+  end
+
+  unless @@active_record_errors
+    # Emulate ActiverRecord::Base errors support
+    class Errors
+      def initialize(obj)
+        @obj = obj
+        @name_errors = { }
+        @errors = nil
+      end
+      def add(name, err)
+        (@name_errors[name] ||= []).push(err)
+        (@errors ||= []).push([name, err])
+      end
+      def [](name)
+        (@name_errors[name] || []).join('\n')
+      end
+      def empty?
+        (! @errors) || @errors.empty?
+      end
+    end
+    @@active_record_errors = Errors
+  end
+
+
+  def initialize(*opts)
+    @hash = opts.empty? ? {} : opts[0]
+    @hash ||= { }
+  end
+
+  def _value_hash
+    @hash
+  end
+
+  # Emulate ActiverRecord::Base errors support
+  def errors
+    # See ActiveRecord::Validations
+    @errors ||= @@active_record_errors.new(self)
+  end
+  def self.human_attribute_name(x)
+    x # PUNT
+  end
+
+  
+  def [](key)
+    @hash[key]
+  end
+
+  # OVERIDE Object
+  def id
+    @hash[:id]
+  end
+  def id=(x)
+    @hash[:id] = x
+  end
+
+  def respond_to?(meth)
+    true
+  end
+
+  def method_missing(method, *args)
+    m = method.to_s.clone
+    if m.sub!(/=$/, '') && args.size == 1
+      $stderr.puts "set #{method.inspect} #{args[0].inspect}" if @verbose
+      result = @hash[m.intern] = args[0]
+    elsif m.sub!(/_before_type_cast$/, '') && args.size == 0
+      $stderr.puts "get #{method.inspect}" if @verbose
+      result = @hash[m.intern]
+    elsif args.size == 0
+      $stderr.puts "get #{method.inspect}" if @verbose
+      result = @hash[method]
+    else
+      raise NotImplementedError, method
+    end
+      
+    result
+  end
+end
+
+end # module

data/lib/user_query/parser.rb

@@ -0,0 +1,762 @@
+require 'time'
+
+module UserQuery
+
+# Do:
+#   require 'currency'
+# for :type => :money
+#
+
+class Parser
+  @now = nil
+  @@now = nil
+  @today = nil
+  @@today= nil
+  @this_year = nil
+  @@this_year = nil
+
+  class Error < Exception; end
+  class SyntaxError < Error; end
+
+  attr_accessor :default_join_op
+  attr_accessor :default_literal_op
+  attr_accessor :keywords
+  attr_accessor :type
+  attr_accessor :expr
+  attr_accessor :verbose
+
+  def initialize(*opts)
+    self.verbose = false
+    self.default_join_op = :and
+    self.default_literal_op = :like
+    self.keywords = [ ]
+    self.type = :string
+    opts = Hash[*opts]
+    opts.each{|k, v| self.send("#{k}=", v)}
+  end
+
+  def parse(str)
+    return nil if str.nil?
+
+    str = str.to_s
+
+    @level = 0
+    @input_original = str.clone
+    @input = str.clone
+    @lex_next = nil
+    @expr = lex_peek && parse_top_level
+
+    eat_whitespace
+
+    @lex_extra = lex_peek
+    if @lex_extra
+      raise SyntaxError, "extra characters for #{type.to_s} field at #{@lex_extra[1].inspect}"
+    end
+
+    if @verbose
+      q_sql = UserQuery::Generator.new.sql(@expr)
+      $stderr.puts "#{str.inspect} =>\n  " + @expr.inspect + " =>\n  " + q_sql.inspect
+    end
+
+    @expr
+  end
+
+  def <<(str)
+    parse(str)
+  end
+  
+  # Configuration
+
+  def now=(t)
+    @now = t
+  end
+  def now
+    @now || @@now || Time.new
+  end
+
+  def this_year=(y)
+    @this_year = y.respond_to?(:year) ? y.year : y
+    y
+  end
+  def this_year
+    @this_year || @@this_year || now.year
+  end
+
+  def today=(t)
+    t = t && Time.utc(t.year, t.month, t.day, 0, 0, 0, 0)
+    @today = t
+  end
+  def today
+    t = @today || @@today 
+    unless t
+      t = now
+      t = Time.utc(t.year, t.month, t.day, 0, 0, 0, 0)
+    end
+    t
+  end
+
+private
+  # Recursive-descendent parser
+  def parse_top_level
+    show_where("parse_top_level")
+
+    expr = parse_expression
+
+    show_where("parse_top_level", expr)
+
+    expr
+  end
+
+  def parse_expression
+    show_where("parse_expression")
+
+    expr = parse_conditional
+
+    show_where("parse_expression", expr)
+
+    expr
+  end
+
+  def parse_conditional
+    show_where("parse_conditional")
+
+    expr = parse_logical_or
+
+    show_where("parse_conditional", expr)
+
+    expr
+  end
+
+  def parse_logical_or
+    show_where("parse_logical_or")
+
+    expr = parse_logical_and
+
+    l = lex_peek
+    case type = l && l[0]
+    when :or
+      lex_read
+      expr = [ :or, expr, parse_logical_or ]
+    end
+
+    show_where("parse_logical_or", expr)
+
+    expr
+  end
+
+  def parse_logical_and
+    show_where("parse_logical_and")
+
+    expr = parse_relational
+
+    l = lex_peek
+    case type = l && l[0]
+    when :and
+      lex_read
+      show_where("parse_logical_and: expr2")
+      expr_2 = parse_logical_and
+      show_where("parse_logical_and: expr2: ", expr_2)
+      expr = [ :and, expr, expr_2 ]
+    end
+
+    show_where("parse_logical_and", expr)
+
+    expr
+  end
+
+
+  def parse_relational
+    show_where("parse_relational")
+
+    expr = lex_peek
+    case op = expr && expr[0]
+    when :eq
+      lex_read
+      expr = ranged_value_eq(parse_literal)
+
+    when :ne
+      lex_read
+      expr = ranged_value_ne(parse_literal)
+
+    when :gt
+      lex_read
+      expr = ranged_value_gt(parse_literal)
+
+    when :lt, :ge
+      lex_read
+      expr = [ op, parse_literal ]
+
+    when :le
+      lex_read
+      expr = ranged_value_le(parse_literal)
+
+    when :between
+      lex_read
+      expr_1 = parse_literal
+      lex_eat(:and, :elipsis)
+      expr_2 = parse_literal(*range_types(expr_1[0]))
+      expr = [ op, expr_1, expr_2 ]
+
+    else
+      expr = parse_unary
+    end
+
+    show_where("parse_relational", expr)
+
+    expr
+  end
+
+  def parse_unary
+    show_where("parse_unary")
+
+    expr = lex_peek
+    case op = expr && expr[0]
+    when :not
+      lex_read
+      expr = [ op, parse_sequence ]
+    when :like
+      lex_read
+      expr = [ op, to_string(parse_literal) ]
+    else
+      expr = parse_sequence
+    end
+
+    show_where("parse_unary", expr)
+
+    expr
+  end
+
+  def parse_sequence
+    show_where("parse_sequence")
+
+    expr = parse_primary
+    
+    while l = lex_match(:word, :string, :number, :money, :year, :month, :date, :hour, :minute)
+      expr = [ default_join_op, expr, parse_primary ]
+    end
+
+    show_where("parse_sequence", expr)
+
+    expr    
+  end
+
+  def parse_primary
+    show_where("parse_primary")
+
+    expr = lex_peek
+    case type = expr && expr[0]
+    when '('
+      lex_read
+      expr = parse_expression
+      lex_eat(')')
+
+    else
+      expr = parse_singular
+    end
+
+    show_where("parse_primary", expr)
+
+    expr    
+  end
+
+
+  def parse_singular
+    show_where("parse_singular")
+
+    expr = parse_literal
+
+    l = lex_peek
+    case type = l && l[0]
+    when :elipsis
+      lex_read
+      expr = [ :between, expr, parse_literal ]
+    else
+      #  Literals are enconsed with the default literal op
+      #  
+      case type = expr && expr[0]
+      when :number, :boolean, :money
+        # Numericals should match exact.
+        expr = [ :eq, expr ]
+
+      when :string, :word
+        # Strings are usually inexact so we use the default literal op.
+        expr = [ default_literal_op, expr ]
+        
+      when :year, :month, :day, :hour, :minute, :second
+        # datetime is inexact because intutively
+        # a date should match all values with that date,
+        # but datetime values have greater precision than just date
+        # So we translate year, month, day to intuitive ranges.
+        expr = [ :range, expr, ranged_value_plus_1(expr) ]
+      end
+    end
+
+    show_where("parse_singular", expr)
+
+    expr
+  end
+
+  def parse_literal(*types)
+    types = types.flatten
+    show_where("parse_literal")
+    
+    expr = lex_peek(*types)
+
+    case type = expr && expr[0]
+    when :null, :string, :word, :number, :boolean, :money 
+      expr = lex_read(types)
+
+    when :year, :month, :day, :hour, :minute, :second
+      expr = lex_read(types)
+
+    else
+      raise SyntaxError, "Unexpected #{expr.inspect}"
+
+    end
+
+    show_where("parse_literal", expr)
+
+    expr
+  end
+
+  ############################################################
+  # Ranged values
+  #
+
+  # :datetime is a ranged value type.
+  # because intutively a date should match all DATETIME values within 
+  # that date, regardless of how much precision 
+  # DATETIME has, i.e. down to the second.
+  # 
+  # For example:
+  #
+  # The query:
+  #
+  #  "12/31/2005"
+  #
+  # should generate SQL:
+  #
+  # column >= '2005-12-31 00:00:00' AND column < '2006-01-01 00:00:00'
+  #
+  # The query:
+  #
+  #  "!= 12/31/2005"
+  #
+  # should generate SQL:
+  #
+  # column < '2005-12-31 00:00:00' AND column >= '2006-01-01 00:00:00'
+  #
+  # The query:
+  #
+  #  "> 12/31/2005"
+  #
+  # should generate SQL:
+  #
+  # column >= '2006-01-01 00:00:00'
+  #
+
+  def range_types(type)
+    case type
+    when :word, :string
+      type = [ :word, :string ]
+    when :year, :month, :day, :hour, :minute, :second 
+      type = [ :year, :month, :day, :hour, :minute, :second ]
+    else
+      type = [ type ]
+    end
+
+    type
+  end
+
+  
+  def ranged_value_eq(expr)
+    case type = expr && expr[0]
+    when :year, :month, :day, :hour, :minute, :second
+      expr_0 = expr
+      expr_1 = ranged_value_plus_1(expr)
+      expr = [ :range, expr_0, expr_1 ]
+
+    else
+      expr = [ :eq, expr ]
+    end
+
+    expr
+  end
+
+  def ranged_value_ne(expr)
+    case type = expr && expr[0]
+    when :year, :month, :day, :hour, :minute, :second
+      expr_0 = expr
+      expr_1 = ranged_value_plus_1(expr)
+      expr = [ :or,
+               [ :lt, expr_0 ],
+               [ :ge, expr_1 ],
+             ]
+
+    else
+      expr = [ :ne, expr ]
+    end
+
+    expr
+  end
+
+  def ranged_value_gt(expr)
+    case type = expr && expr[0]
+    when :year, :month, :day, :hour, :minute, :second
+      expr = ranged_value_plus_1(expr)
+      expr = [ :ge, expr ]
+
+    else
+      expr = [ :gt, expr ]
+
+    end
+
+    expr
+  end
+
+  def ranged_value_le(expr)
+    case type = expr && expr[0]
+    when :year, :month, :day, :hour, :minute
+      expr = ranged_value_plus_1(expr)
+      expr = [ :lt, expr ]
+
+    else
+      expr = [ :le, expr ]
+
+    end
+
+    expr
+  end
+
+
+  def ranged_value_plus_1(expr)
+    case type = expr && expr[0]
+    when :year
+      expr = year_plus_1(expr)
+
+    when :month
+      expr = month_plus_1(expr)
+
+    when :day
+      expr = day_plus_1(expr)
+
+    when :hour
+      expr = hour_plus_1(expr)
+
+    when :minute
+      expr = minute_plus_1(expr)
+
+    when :second
+      expr = second_plus_1(expr)
+
+    end
+
+    expr
+  end
+
+
+  ############################################################
+  # datetime helper
+  #
+
+  def year_plus_1(x)
+    x = x.clone
+    x[2] = x[2] + 1
+    x
+  end
+
+  def month_plus_1(x)
+    x = x.clone
+    x[3] = x[3] + 1
+    if x[3] > 12
+      x[3] = 1
+      x[2] = x[2] + 1
+    end
+    x
+  end
+
+  def day_plus_1(x)
+    # $stderr.puts "day_plus_1(#{x.inspect})"
+    t = Time.utc(x[2], x[3] || 1, x[4] || 1, 0, 0, 0, 0)
+    t = t + (60 * 60 * 25) # Add one day, plus fudge for leap seconds
+    x = [ x[0],
+          x[1], # str
+          t.year,
+          t.month,
+          t.day
+        ]
+    x
+  end
+
+  def hour_plus_1(x)
+    t = Time.utc(x[2], x[3] || 1, x[4] || 1, x[5] || 0, 0, 0, 0)
+    t = t + (65 * 60) # Add one hour, plus fudge for leap seconds
+    x = [ x[0],
+          x[1], # str
+          t.year,
+          t.month,
+          t.day,
+          t.hour
+        ]
+    x
+  end
+
+  def minute_plus_1(x)
+    t = Time.utc(x[2], x[3] || 1, x[4] || 1, x[5] || 0, x[6] || 0, 0, 0)
+    t = t + 65 # Add one minunte, plus fudge for leap seconds
+    x = [ x[0],
+          x[1], # str
+          t.year,
+          t.month,
+          t.day,
+          t.hour,
+          t.min
+        ]
+    x
+  end
+
+  def second_plus_1(x)
+    t = Time.utc(x[2], x[3] || 1, x[4] || 1, x[5] || 0, x[6] || 0, x[7] || 0, 0)
+    t = t + 1 # Add one second
+    x = [ x[0],
+          x[1], # str
+          t.year,
+          t.month,
+          t.day,
+          t.hour,
+          t.min,
+          t.sec
+        ]
+    x
+  end
+
+  ############################################################
+  # Push back interface w/ lexeme type checks
+  #
+
+  def show_where(str = "", expr = nil)
+    @level = @level - 1 if expr != nil
+    $stderr.puts "#{"  " * @level} #{str}: #{lex_peek.inspect} #{@input.inspect} #{expr && ' => '} #{expr && expr.inspect}" if @verbose
+    @level = @level + 1 if expr == nil
+  end
+
+  def lex_match(*types)
+    l = lex_peek
+    types = types.flatten
+    types.include?(l && l[0])
+  end
+
+  def lex_peek(*types)
+    check_types(@lex_next ||= lex, types)
+  end
+
+  def lex_read(*types)
+    l = @lex_next || lex
+    @lex_next = nil
+    check_types(l, types)
+  end
+
+  def lex_eat(*types)
+    l = lex_read
+    check_types(l, types)
+  end
+
+  def check_types(l, types)
+    types = types.flatten
+    unless types.empty?
+      raise SyntaxError, "expected #{types.inspect}, found #{l.inspect}" unless types.include?(l && l[0])
+    end
+    l
+  end
+
+  def to_string(l)
+    l = l.clone;
+    l[0] = :string
+    l[1] = l[1].to_s
+    l[2] = l[2].to_s
+    l
+  end
+
+
+  ############################################################
+  # Low-level lexer
+  #
+
+  def lex
+    # @verbose = true
+    x = @input
+    
+    l = nil
+    if eat_whitespace
+      if false
+        l = nil
+
+      elsif md = match(/^NULL\b/)
+        l = [ :null, md[0] ]
+
+      elsif md = match(/^\.\.\./)
+        l = [ :elipsis ]
+
+      elsif md = match(/^(AND\b|[&])/)
+        l = [ :and ]
+
+      elsif md = match(/^(OR\b|[|])/)
+        l = [ :or ]
+
+      elsif md = match(/^BETWEEN\b/)
+        l = [ :between ]
+
+      elsif md = match(/^(NOT\s+EQUAL(\s+TO)?\b|!=|<>)/)
+        l = [ :ne ]
+
+      elsif md = match(/^(LESS\s+THAN\s+ORs\+EQUAL\s+TO\b|<=)/)
+        l = [ :le ]
+
+      elsif md = match(/^(GREATER\s+THAN\s+ORs\+EQUAL\s+TO\b|>=)/)
+        l = [ :ge ]
+
+      elsif md = match(/^(BEFORE\b|LESS(\s+THAN)?\b|<)/)
+        l = [ :lt ]
+
+      elsif md = match(/^(AFTER\b|GREATER(\s+THAN)?\b|>)/)
+        l = [ :gt ]
+
+      elsif md = match(/^(EQUAL(\s+TO)?\b|==?)/)
+        l = [ :eq ]
+
+      elsif md = match(/^(NOT\b|!)/)
+        l = [ :not ]
+
+      elsif md = match(/^(LIKE\b|~)/)
+        l = [ :like, ]
+
+      elsif md = match(/^([\(\)])/)
+        l = [ md[1], md[0] ]
+
+      elsif md = match(/^"((\\.|[^\\"]+)*)"/)
+        l = md[1]
+        l.gsub!(/\\(.)/){|x| $1}
+        @keywords << l
+        l = [ :string, l, l ]
+
+      elsif type == :boolean && (md = match(/^(true)/i))
+        l = [ :boolean, md[0], true ]
+
+      elsif type == :boolean && (md = match(/^(false)/i))
+        l = [ :boolean, md[0], false ]
+
+      elsif type == :money && (md = match(/^(\$?[-+]?([\d,]+(\.\d+)?|\.\d+))/))
+        l = [ :money, md[0], Currency::Money.new(md[1]) ]
+
+      elsif type == :datetime && (md = match(/^(\d\d?)\/(\d\d?)\/(\d\d\d\d)(-|\s+)(\d\d?):?(\d\d):?(\d\d)\s*([ap]?)m?/i))
+        # mm/dd/yyyy hh:mm:ss(am|pm)
+        hh = fix_hh_am_pm(md[5], md[8])
+        mm = md[6].to_i
+        ss = md[7].to_i
+        l = [ :second, md[0], md[3].to_i, md[1].to_i, md[2].to_i, hh, mm, ss ]
+
+      elsif type == :datetime && (md = match(/^(\d\d?)\/(\d\d?)\/(\d\d\d\d)(-|\s+)(\d\d?):?(\d\d)\s*([ap]?)m?/i))
+        # mm/dd/yyyy hh:mm(am|pm)
+        hh = fix_hh_am_pm(md[5], md[7])
+        mm = md[6].to_i
+        l = [ :minute, md[0], md[3].to_i, md[1].to_i, md[2].to_i, hh, mm ]
+
+      elsif type == :datetime && (md = match(/^(\d\d?)\/(\d\d?)\/(\d\d\d\d)(-|\s+)(\d\d?)\s*([ap]?)m?/i))
+        # mm/dd/yyyy hh
+        hh = fix_hh_am_pm(md[5], md[6])
+        l = [ :hour, md[0], md[3].to_i, md[1].to_i, md[2].to_i, hh ]
+
+      elsif type == :datetime && (md = match(/^(\d\d\d\d)\/(\d\d?)\/(\d\d?)/))
+        # yyyy/mm/dd
+        l = [ :day, md[0], md[1].to_i, md[2].to_i, md[3].to_i ]
+
+      elsif type == :datetime && (md = match(/^(\d\d?)\/(\d\d?)\/(\d\d\d\d)/))
+        # mm/dd/yyyy
+        l = [ :day, md[0], md[3].to_i, md[1].to_i, md[2].to_i ]
+
+      elsif type == :datetime && (md = match(/^(\d\d?)\/(\d\d\d\d)/))
+        # mm/yyyy
+        l = [ :month, md[0], md[2].to_i, md[1].to_i ]
+
+      elsif type == :datetime && (md = match(/^(\d\d?)\/(\d\d?)/))
+        # mm/dd => THIS-YEAR/mm/dd
+        l = [ :day, md[0], this_year, md[1].to_i, md[2].to_i ]
+ 
+      elsif type == :datetime && (md = match(/^(\d\d\d\d)\/(\d\d?)/))
+        # yyyy/mm
+        l = [ :month, md[0], md[1].to_i, md[2].to_i ]
+
+      elsif type == :datetime && (md = match(/^(\d\d\d\d)/))
+        # yyyy
+        l = [ :year, md[0], md[1].to_i ]
+
+      elsif type == :datetime && (md = match(/^now\b/i))
+        # now
+        l = now
+        l = [ :second, md[0], l.year, l.month, l.day, l.hour, l.min, l.sec ]
+
+      elsif type == :datetime && (md = match(/^this\s*year\b/i))
+        # this year => THIS-YEAR
+        l = [ :year, md[0], this_year ]
+
+      elsif type == :datetime && (md = match(/^yesterday\b|today\s*\-\s*(\d+)/i))
+        # yesterday
+        l = today - (24 * 60 * 60) * (md[1] ? md[1].to_i : 1)
+        l = [ :day, md[0], l.year, l.month, l.day ]
+
+      elsif type == :datetime && (md = match(/^tomorrow\b|today\s*\+\s*(\d+)/i))
+        # tomorrow
+        l = today + (24 * 60 * 60) * (md[1] ? md[1].to_i : 1)
+        l = [ :day, md[0], l.year, l.month, l.day ]
+
+      elsif type == :datetime && (md = match(/^today\b/i))
+        # today
+        l = today
+        l = [ :day, md[0], l.year, l.month, l.day ]
+
+      elsif md = match(/^([-+]?((\d+|\.\d+|\d+\.\d*)[eE][-+]?\d+|\.\d+|\d+\.\d*))/)
+        l = [ :number, md[0], md[1].to_f ]
+
+      elsif md = match(/^([-+]?\d+)/)
+        l = [ :number, md[0], md[1].to_i ]
+
+      elsif type == :string && md = match(/^(\w+)/)
+        @keywords << md[1]
+        l = [ :word, md[0], md[1] ]
+      else
+        raise SyntaxError, "invalid character for #{type.to_s} field at #{@input.inspect}"
+      end
+    end
+
+    $stderr.puts "lex #{x.inspect} => #{l.inspect}" if @verbose
+
+    l
+  end
+
+  def fix_hh_am_pm(hh, am_pm)
+    hh = hh.to_i
+    if am_pm 
+      am_pm = am_pm.downcase
+      hh = 0       if am_pm == 'a' && hh == 12
+      hh = hh + 12 if am_pm == 'p' && hh != 12
+    end
+    hh
+  end
+
+  def eat_whitespace
+    @input.sub!(/^\s+/, '')
+    ! @input.empty?
+  end
+
+  def match(rx)
+    # $stderr.puts "m_a_a @ #{@input.inspect}"
+    if md = rx.match(@input)
+      @input = md.post_match
+    end
+    md
+  end
+
+end
+
+end # module
+