filter_param 0.1.0

data/lib/filter_param/field.rb

@@ -0,0 +1,45 @@
+module FilterParam
+  class Field
+    TYPES = %i[boolean string integer decimal date datetime].freeze
+
+    attr_reader :type, :name
+
+    def initialize(name, type, options = {})
+      @name = name
+      @type = field_type(type)
+      @rename = field_rename(options[:rename])
+      @value_transformer = options[:value]
+    end
+
+    def transform_value(value)
+      return value if value_transformer.blank?
+
+      value_transformer.call(value)
+    end
+
+    def actual_name
+      rename.presence || name
+    end
+
+    def allow_operator?(operator)
+      true
+    end
+
+    private
+
+    attr_reader :value_transformer, :rename
+
+    def field_rename(rename)
+      return rename.call(name) if rename.is_a?(Proc)
+
+      rename
+    end
+
+    def field_type(type)
+      type = (type.presence || :string).to_sym
+      return type if type.in?(TYPES)
+
+      raise UnknownType.new("Unknown type '#{type}' for field '#{name}'. Allowed types: #{TYPES}.")
+    end
+  end
+end

data/lib/filter_param/operator.rb

@@ -0,0 +1,46 @@
+module FilterParam
+  class Operator
+    class << self
+      def type
+        return :unary if method(:sql).arity == 1
+
+        :binary
+      end
+
+      def operator_tag(operator_tag)
+        @operator_tag ||= operator_tag
+      end
+
+      def register(operator_clazz)
+        operator_tag = operator_clazz.tag
+        registry[operator_tag] = operator_clazz
+      end
+
+      def tag
+        @operator_tag
+      end
+
+      def for(operator_tag)
+        registry[operator_tag]
+      end
+
+      def binaries
+        with_type(:binary).map(&:tag)
+      end
+
+      def unaries
+        with_type(:unary).map(&:tag)
+      end
+
+      private
+
+      def with_type(type)
+        registry.values.select { |op| op < self && op.type == type }
+      end
+
+      def registry
+        @@registry ||= {}
+      end
+    end
+  end
+end

data/lib/filter_param/operators/and.rb

@@ -0,0 +1,13 @@
+module FilterParam
+  module Operators
+    class And < Operator
+      operator_tag :and
+
+      def self.sql(left, right)
+        "#{left} AND #{right}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::And)

data/lib/filter_param/operators/case_insensitive_equal.rb

@@ -0,0 +1,16 @@
+module FilterParam
+  module Operators
+    class CaseInsensitiveEqual < FieldFilterOperator
+      operator_tag :eq_ci
+      operand_data_type :string
+
+      def self.sql(field, literal)
+        super
+
+        "lower(#{field.actual_name}) = #{sql_quote(literal.value.downcase)}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::CaseInsensitiveEqual)

data/lib/filter_param/operators/contains.rb

@@ -0,0 +1,18 @@
+module FilterParam
+  module Operators
+    class Contains < FieldFilterOperator
+      operator_tag :co
+      operand_data_type :string
+
+      def self.sql(field, literal)
+        super
+
+        pattern = "%#{literal.value}%"
+
+        "#{field.actual_name} LIKE #{sql_quote(pattern)}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::Contains)

data/lib/filter_param/operators/ends_with.rb

@@ -0,0 +1,18 @@
+module FilterParam
+  module Operators
+    class EndsWith < FieldFilterOperator
+      operator_tag :ew
+      operand_data_type :string
+
+      def self.sql(field, literal)
+        super
+
+        pattern = "%#{literal.value}"
+
+        "#{field.actual_name} LIKE #{sql_quote(pattern)}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::EndsWith)

data/lib/filter_param/operators/equal.rb

@@ -0,0 +1,21 @@
+module FilterParam
+  module Operators
+    class Equal < FieldFilterOperator
+      operator_tag :eq
+
+      def self.sql(field, literal)
+        super
+
+        return "#{field.actual_name} IS NULL" if literal.value.nil?
+
+        "#{field.actual_name} = #{sql_quote(literal.value)}"
+      end
+
+      def self.negated_sql(field, literal)
+        Operators::NotEqual.sql(field, literal)
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::Equal)

data/lib/filter_param/operators/field_filter_operator.rb

@@ -0,0 +1,40 @@
+module FilterParam
+  module Operators
+    class FieldFilterOperator < Operator
+      class << self
+        attr_reader :operand_data_types
+
+        def operand_data_type(*data_types)
+          @operand_data_types ||= Set.new
+          @operand_data_types.merge(data_types)
+          @operand_data_types
+        end
+
+        def sql(field, literal)
+          validate_field!(field)
+          validate_literal!(literal)
+        end
+
+        private
+
+        def validate_field!(field)
+          field.allow_operator?(tag)
+        end
+
+        def validate_literal!(literal)
+          return if literal.nil?
+          return if operand_data_types.nil?
+          return if literal.data_type.in?(operand_data_types)
+
+          raise FilterParam::InvalidLiteral.new(
+            "Unexpected #{literal.data_type} operand for operator '#{tag}'."
+          )
+        end
+
+        def sql_quote(value)
+          ActiveRecord::Base.connection.quote(value)
+        end
+      end
+    end
+  end
+end

data/lib/filter_param/operators/greater_than.rb

@@ -0,0 +1,16 @@
+module FilterParam
+  module Operators
+    class GreaterThan < FieldFilterOperator
+      operator_tag :gt
+      operand_data_type :string, :integer, :decimal, :date, :datetime
+
+      def self.sql(field, literal)
+        super
+
+        "#{field.actual_name} > #{sql_quote(literal.value)}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::GreaterThan)

data/lib/filter_param/operators/greater_than_equal.rb

@@ -0,0 +1,16 @@
+module FilterParam
+  module Operators
+    class GreaterThanEqual < FieldFilterOperator
+      operator_tag :ge
+      operand_data_type :string, :integer, :decimal, :date, :datetime
+
+      def self.sql(field, literal)
+        super
+
+        "#{field.actual_name} >= #{sql_quote(literal.value)}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::GreaterThanEqual)

data/lib/filter_param/operators/group.rb

@@ -0,0 +1,17 @@
+module FilterParam
+  module Operators
+    class Group < Operator
+      operator_tag :group
+
+      def self.sql(expression)
+        "(#{expression})"
+      end
+
+      def self.negated_sql(expression)
+        "NOT (#{expression})"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::Group)

data/lib/filter_param/operators/less_than.rb

@@ -0,0 +1,16 @@
+module FilterParam
+  module Operators
+    class LessThan < FieldFilterOperator
+      operator_tag :lt
+      operand_data_type :string, :integer, :decimal, :date, :datetime
+
+      def self.sql(field, literal)
+        super
+
+        "#{field.actual_name} < #{sql_quote(literal.value)}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::LessThan)

data/lib/filter_param/operators/less_than_equal.rb

@@ -0,0 +1,16 @@
+module FilterParam
+  module Operators
+    class LessThanEqual < FieldFilterOperator
+      operator_tag :le
+      operand_data_type :string, :integer, :decimal, :date, :datetime
+
+      def self.sql(field, literal)
+        super
+
+        "#{field.actual_name} <= #{sql_quote(literal.value)}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::LessThanEqual)

data/lib/filter_param/operators/not.rb

@@ -0,0 +1,16 @@
+module FilterParam
+  module Operators
+    class Not < Operator
+      operator_tag :not
+
+      def self.sql(expression_operator, *expression_operands)
+        operator = Operator.for(expression_operator)
+        return operator.negated_sql(*expression_operands) if operator.respond_to?(:negated_sql)
+
+        "NOT #{operator.sql(*expression_operands)}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::Not)

data/lib/filter_param/operators/not_equal.rb

@@ -0,0 +1,19 @@
+module FilterParam
+  module Operators
+    class NotEqual < FieldFilterOperator
+      operator_tag :neq
+
+      def self.sql(field, literal)
+        return "#{field.actual_name} IS NOT NULL" if literal.value.nil?
+
+        "#{field.actual_name} != #{sql_quote(literal.value)}"
+      end
+
+      def self.negated_sql(field, literal)
+        Operators::Equal.sql(field, literal)
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::NotEqual)

data/lib/filter_param/operators/or.rb

@@ -0,0 +1,13 @@
+module FilterParam
+  module Operators
+    class Or < Operator
+      operator_tag :or
+
+      def self.sql(left, right)
+        "#{left} OR #{right}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::Or)

data/lib/filter_param/operators/present.rb

@@ -0,0 +1,21 @@
+module FilterParam
+  module Operators
+    class Present < FieldFilterOperator
+      operator_tag :pr
+
+      def self.sql(field)
+        return "#{field.actual_name} IS NOT NULL" unless field.type == :string
+
+        "(#{field.actual_name} IS NOT NULL AND TRIM(#{field.actual_name}) != '')"
+      end
+
+      def self.negated_sql(field)
+        return "#{field.actual_name} IS NULL" unless field.type == :string
+
+        "(#{field.actual_name} IS NULL OR TRIM(#{field.actual_name}) = '')"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::Present)

data/lib/filter_param/operators/starts_with.rb

@@ -0,0 +1,18 @@
+module FilterParam
+  module Operators
+    class StartsWith < FieldFilterOperator
+      operator_tag :sw
+      operand_data_type :string
+
+      def self.sql(field, literal)
+        super
+
+        pattern = "#{literal.value}%"
+
+        "#{field.actual_name} LIKE #{sql_quote(pattern)}"
+      end
+    end
+  end
+end
+
+FilterParam::Operator.register(FilterParam::Operators::StartsWith)

data/lib/filter_param/parser.rb

@@ -0,0 +1,144 @@
+module FilterParam
+  class Parser < Parslet::Parser
+    rule(:space) { match("\s").repeat(1).ignore }
+    rule(:space?) { space.maybe }
+    rule(:dot) { str(".") }
+    rule(:lparen) { str("(") }
+    rule(:rparen) { str(")") }
+    rule(:escape_seq) { str('\\').present? >> str('\\') >> any }
+    rule(:double_quote) { str('"') }
+    rule(:single_quote) { str("'") }
+    rule(:digit) { match("[0-9]") }
+    rule(:zero) { str("0") }
+    rule(:non_zero_digit) { match("[1-9]") }
+    rule(:sig_number) { non_zero_digit >> digit.repeat(1).maybe }
+    rule(:zero_nonsig) { zero.repeat(0).maybe.ignore }
+    rule(:hyphen) { str("-") }
+    rule(:identifier) { match("[a-zA-Z_]") >> digit.maybe }
+    rule(:table) { identifier.repeat(1) >> dot }
+    rule(:attribute) { (table.maybe >> identifier.repeat(1)).as(:attribute) }
+    rule(:scope_name) { identifier.repeat(1) }
+
+    # Literals / types
+    rule(:null) { str("null").as(:null) }
+    rule(:boolean) { (str("true") | str("false")).as(:boolean) }
+
+    rule(:integer) do
+      (
+        (hyphen.maybe >> zero_nonsig >> sig_number) |
+        (hyphen.maybe.ignore >> zero >> zero_nonsig)
+      ).as(:integer)
+    end
+
+    rule(:decimal) do
+      (
+        (hyphen.maybe >> zero_nonsig >> sig_number >> dot >> digit.repeat(1)) |
+        (hyphen.maybe >> zero >> zero_nonsig >> dot >> digit.repeat(1))
+      ).as(:decimal)
+    end
+
+    rule(:string) do
+      (single_quote >> (escape_seq | match("[^\']")).repeat.as(:string) >> single_quote) |
+        (double_quote >> (escape_seq | match("[^\"]")).repeat.as(:string) >> double_quote)
+    end
+    rule(:date_yyyy) { digit.repeat(4) }
+    rule(:date_mm) { (zero >> non_zero_digit) | (str("1") >> match("[0-2]")) }
+    rule(:date_md) { (zero >> non_zero_digit) | (match("[1-2]") >> digit) | (str("3") >> match("[0-1]")) }
+    rule(:date_iso8601) { date_yyyy >> hyphen >> date_mm >> hyphen >> date_md }
+    rule(:date) { quoted date_iso8601.as(:date) }
+    rule(:time_hh_mi) do
+      (((zero | str("1")) >> digit) | (str("2") >> match("[0-3]"))) >>
+        str(":").maybe >> ((zero >> digit) | (match("[1-5]") >> digit))
+    end
+    rule(:time_hh_mi_ss) { time_hh_mi >> str(":") >> ((zero >> digit) | (match("[1-5]") >> digit)) }
+    rule(:time_hh_mi_ss_sss) { time_hh_mi_ss >> dot >> digit.repeat(3, 6) }
+    rule(:time_tz) { str("Z") | (match("[\+\-]") >> time_hh_mi) }
+    rule(:datetime_iso8601) { date_iso8601 >> str("T") >> (time_hh_mi_ss_sss | time_hh_mi_ss) >> time_tz }
+    rule(:datetime) { quoted datetime_iso8601.as(:datetime) }
+
+    # Operations
+    rule(:op_attr_binary) do
+      binary_attr_operators.as(:operator)
+    end
+    rule(:op_attr_unary) { (unary_attr_operators).as(:operator) }
+    rule(:op_logic_binary) { (str("and") | str("or")).as(:operator) }
+    rule(:op_logic_unary) { str("not").as(:operator) }
+
+    # Expressions
+    rule(:literal) { (null | boolean | decimal | integer | datetime | date | string) }
+    rule(:literal_paren) { lparen >> space? >> (literal | literal_paren) >> space? >> rparen }
+    rule(:attr_value) { literal_paren | (space >> (literal | literal_paren)) }
+    rule(:attr_exp) { (attribute >> space >> (op_attr_unary | (op_attr_binary >> attr_value.as(:val)))).as(:exp) }
+    rule(:group) do
+      empty_group.ignore |
+        (lparen >> space? >> (binary_exp | unary_exp | attr_exp) >> space? >> rparen).as(:group) |
+        (lparen >> space? >> group >> space? >> rparen)
+    end
+    rule(:empty_group) do
+      (lparen >> space? >> empty_group >> space? >> rparen) | (lparen >> space? >> rparen)
+    end
+    rule(:empty_exp) { (space | str("")).ignore }
+    rule(:scope_args) { literal >> space? >> (str(",") >> space? >> literal).repeat(0) }
+    rule(:scope) { scope_name.as(:scope) >> lparen >> space? >> scope_args.maybe.as(:args) >> space? >> rparen }
+    rule(:primary) { group | attr_exp | scope }
+
+    rule(:unary_exp) do
+      (op_logic_unary >> (space | lparen.present?) >> primary.as(:right)).as(:exp) | primary
+    end
+    rule(:binary_exp) do
+      (
+        unary_exp.as(:left) >> space >> op_logic_binary >> ((space | lparen.present?) >> exp).as(:right)
+      ).as(:exp) | unary_exp
+    end
+
+    rule(:exp) { (space? >> binary_exp >> space?) }
+    rule(:exp_root) { exp | empty_exp }
+    root(:exp_root)
+
+    def parse(expression, options = {})
+      super(expression, options)
+    rescue Parslet::ParseFailed => e
+      parse_cause = e.parse_failure_cause.children.last
+
+      raise_parse_error!(parse_cause)
+    end
+
+    private
+
+    def quoted(atom_or_seq)
+      (single_quote >> atom_or_seq >> single_quote) | (double_quote >> atom_or_seq >> double_quote)
+    end
+
+    def binary_attr_operators
+      @@binary_attr_ops = operators_to_atoms(Operators::FieldFilterOperator.binaries.map(&:to_s))
+    end
+
+    def unary_attr_operators
+      @@unary_attr_ops = operators_to_atoms(Operators::FieldFilterOperator.unaries.map(&:to_s))
+    end
+
+    def operators_to_atoms(operators)
+      operators.sort_by(&:length)
+               .reverse
+               .map { |tag| str(tag) }
+               .reduce(:|)
+    end
+
+    def raise_parse_error!(parse_cause)
+      parse_cause = parse_cause.to_s
+      invalid_expression = "Filter expression syntax error."
+
+      if parse_cause.start_with?("Expected ")
+        parse_cause = invalid_expression
+      else
+        unexpected_token = "Unexpected token"
+
+        parse_cause.sub!("Don't know what to do with", unexpected_token)
+        parse_cause.sub!(/(Failed to match).*.(at line 1)/, "#{unexpected_token} at")
+        parse_cause.sub!(/(at line 1)/, "at")
+      end
+
+      raise ParseError.new(parse_cause)
+    end
+  end
+end

data/lib/filter_param/scope.rb

@@ -0,0 +1,24 @@
+module FilterParam
+  class Scope
+    attr_reader :name
+
+    def initialize(name, options = {})
+      @name = name
+      @rename = scope_rename(options[:rename])
+    end
+
+    def actual_name
+      rename.presence || name
+    end
+
+    private
+
+    attr_reader :rename
+
+    def scope_rename(rename)
+      return rename.call(name) if rename.is_a?(Proc)
+
+      rename
+    end
+  end
+end

data/lib/filter_param/transformer.rb

@@ -0,0 +1,37 @@
+module FilterParam
+  class Transformer < Parslet::Transform
+    include AST
+
+    rule(null: simple(:null))      { Literals::Null.instance }
+    rule(string: simple(:value))   { Literals::String.new(value) }
+    rule(boolean: simple(:value))  { value == "true" ? Literals::Boolean::TRUE : Literals::Boolean::FALSE }
+    rule(integer: simple(:value))  { Literals::Integer.new(value) }
+    rule(decimal: simple(:value))  { Literals::Decimal.new(value) }
+    rule(date: simple(:value))     { Literals::Date.new(value) }
+    rule(datetime: simple(:value)) { Literals::DateTime.new(value) }
+    rule(exp: simple(:exp))        { exp }
+    rule(group: simple(:exp))      { Group.new(exp) }
+    rule(scope: simple(:name), args: simple(:scope_arg)) do
+      scope_args = scope_arg.nil? ? [] : [scope_arg]
+
+      AST::Scope.new(name, scope_args)
+    end
+    rule(scope: simple(:name), args: sequence(:scope_args)) { AST::Scope.new(name, scope_args) }
+    rule(operator: simple(:operator), right: simple(:operand)) do
+      Expressions::UnaryExpression.new(operator, operand)
+    end
+    rule(attribute: simple(:attribute_name), operator: simple(:operator)) do
+      attribute = Attribute.new(attribute_name)
+
+      Expressions::UnaryExpression.new(operator, attribute)
+    end
+    rule(left: simple(:left), operator: simple(:operator), right: simple(:right)) do
+      Expressions::BinaryExpression.new(operator, left, right)
+    end
+    rule(attribute: simple(:attribute_name), operator: simple(:operator), val: simple(:literal)) do
+      attribute = Attribute.new(attribute_name)
+
+      Expressions::BinaryExpression.new(operator, attribute, literal)
+    end
+  end
+end