saringan 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 791993cb596de66e181c0b65604c7a8c8966806174e7ce974f4d30b76a0d9afd
-  data.tar.gz: cdc0e6d8e7fce69c3f43f8aa3e42ee4193ed1305aadecccf4cad57d74922691b
+  metadata.gz: d91fddd56fb7a75587ea167883cc517de89c4865c03effe5da0cc59337499ccb
+  data.tar.gz: fcbe331554be9d86cc74efcc743c46ab8172fde974804907851544bed702687e
 SHA512:
-  metadata.gz: eb697205169202b661ede5b47cc681cf069f59d34e9069a0618035485f8842723e679e577879948085767145e4b13659469530db410370a4e9f5b7c64d7a6626
-  data.tar.gz: 6cdf0fdaae73799c625104b27f6062e1c4fb287fcaea484592c7fd559baf0aa113e0f245b8cb9ebfd9e78c39bdbefd6e21bf0c9aa23e3b962cc6751f7523d445
+  metadata.gz: f798d7b85db4b9cfaafe4a3967a7d69b1ab1f22722e2bfabe88fbea0e55ab498f9c63fd44d20c8f03e36452a5751f6ba06e2c82918ef8ff0697407fbf00d068c
+  data.tar.gz: a49cfa55062c6944cbc02e25edf5c5a230c86f1097e1eacbe1c3f7e94d5c5210e444b8ec429ea6cf5f82fe2972369941c62114609810996e0a98b141754d414b

data/lib/saringan/operator.rb

@@ -1,26 +1,24 @@
 # frozen_string_literal: true
 # -*- encoding: utf-8 -*-
 
-require "saringan/operators/equal"
-require "saringan/operators/range"
+require 'saringan/operators/equal'
+require 'saringan/operators/greater'
+require 'saringan/operators/greater_equal'
 
 module Saringan
   class Operator
-    class << self
-      def parse(term)
-        return equal.to_h(term) if equal.match?(term)
-        return range.to_h(term) if range.match?(term)
-      end
-
-      private
 
-        def equal
-          Saringan::Operators::Equal
-        end
+    OPERATORS = [
+      Saringan::Operators::Equal,
+      Saringan::Operators::GreaterEqual
+    ]
 
-        def range
-          Saringan::Operators::Range
+    class << self
+      def build(term)
+        OPERATORS.each do |operator|
+          return operator.new(term) if operator.match?(term)
         end
+      end
     end
   end
 end

data/lib/saringan/operators/equal.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 # -*- encoding: utf-8 -*-
 
-require 'saringan/parser'
 require 'saringan/matcher'
+require 'saringan/statements/equal'
 
 module Saringan
   module Operators
@@ -11,34 +11,17 @@ module Saringan
 
       OP_EQUAL = /::/
 
-      class << self
+      attr_reader :subject, :value
 
-        # TODO: Create an absolute qualifier
-        def to_h(term)
-          splitted = split(term)
-          { "#{splitted[:key]}": parser.parse(splitted[:value]) }
-        end
-
-        def to_query(term)
-          splitted = split(term)
-          { query: "#{splitted[:key]} = ?", params: splitted[:value] }
-        end
+      def initialize(term)
+        @subject, @value = term.split(OP_EQUAL, 2)
+      end
 
-        def split(term)
-          splitted = term.split(OP_EQUAL)
-          { key: splitted[0], value: splitted[1] }
-        end
+      private
 
-        def matcher
+        def self.matcher
           OP_EQUAL
         end
-
-        private
-
-          def parser
-            Saringan::Parser
-          end
-      end
     end
   end
 end

data/lib/saringan/operators/greater.rb

@@ -0,0 +1,24 @@
+require 'saringan/matcher'
+require 'saringan/parser'
+
+module Saringan
+  module Operators
+    class Greater
+      extend Saringan::Matcher
+
+      OP_GREATER = /:>/
+
+      attr_reader :subject, :value
+
+      def initialize(term)
+        @subject, @value = term.split(OP_GREATER)
+      end
+
+      private
+
+        def self.matcher
+          OP_GREATER
+        end
+    end
+  end
+end

data/lib/saringan/operators/greater_equal.rb

@@ -0,0 +1,24 @@
+require 'saringan/matcher'
+# require 'saringan/parser'
+
+module Saringan
+  module Operators
+    class GreaterEqual
+      extend Saringan::Matcher
+
+      OP_GREATER_EQUAL = />:/
+
+      attr_reader :subject, :value
+
+      def initialize(term)
+        @subject, @value = term.split(OP_GREATER_EQUAL)
+      end
+
+      private
+
+        def self.matcher
+          OP_GREATER_EQUAL
+        end
+    end
+  end
+end

data/lib/saringan/parser.rb

@@ -2,25 +2,24 @@
 # -*- encoding: utf-8 -*-
 
 require 'saringan/parsers/date_time'
+require 'saringan/parsers/date'
+require 'saringan/parsers/string'
 
 module Saringan
   class Parser
-    class << self
-      def parse(value)
-        return date_time.parse(value) if date_time.match?(value)
-        value
-      end
-
-      def build(value)
-        return {value: date_time.clean(value), parser: date_time} if date_time.match?(value)
-        { value: value, parser: nil }
-      end
 
-      private
+    PARSERS = [
+      Saringan::Parsers::DateTime,
+      Saringan::Parsers::Date
+    ]
 
-        def date_time
-          Saringan::Parsers::DateTime
+    class << self
+      def build(value)
+        PARSERS.each do |parser|
+          return parser if parser.match?(value)
         end
+        Saringan::Parsers::String
+      end
     end
   end
 end

data/lib/saringan/parsers/date.rb

@@ -0,0 +1,28 @@
+require 'saringan/matcher'
+
+module Saringan
+  module Parsers
+    class Date
+      extend Saringan::Matcher
+
+      MATCHER = /^d\((.+)\)$/
+      FORMAT = '%Y-%m-%d'
+
+      class << self
+        def clean(value)
+          value.gsub(/^d\(|\)$/, '')
+        end
+
+        def parse(value)
+          cleaned = clean(value)
+          ::Date.strptime(cleaned, FORMAT)
+        end
+        alias_method :to_proc, :parse
+
+        def matcher
+          MATCHER
+        end
+      end
+    end
+  end
+end

data/lib/saringan/parsers/date_time.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 # -*- encoding: utf-8 -*-
-
 require 'active_support/core_ext/time'
 require 'active_support/core_ext/date_time'
 require 'saringan/matcher'
@@ -10,26 +9,24 @@ module Saringan
     class DateTime
       extend Saringan::Matcher
 
-      MATCHER = /^dt\[(.+)\]$/
-      FORMAT = '%Y-%m-%d %H:%M:%S'
+      MATCHER = /^dt(\(|\[)(.+)(\)|\])$/
+      FORMAT = '%Y-%m-%dT%H:%M:%S'
 
-      class << self
-        def clean(value)
-          value.gsub(/^dt\[|\]$/, '')
-        end
+      def self.parse(value)
+        date = ::DateTime.strptime(value, FORMAT)
+        ::DateTime.new date.year, date.month, date.day, date.hour, date.min, \
+          date.sec, ::DateTime.current.zone
+      end
 
-        def parse(value)
-          cleaned = clean(value)
-          date = ::DateTime.strptime(cleaned, FORMAT)
-          ::DateTime.new date.year, date.month, date.day, date.hour, date.min, \
-            date.sec, ::DateTime.current.zone
-        end
-        alias_method :to_proc, :parse
+      def self.clean(value)
+        value.gsub(/^dt/, '')
+      end
+
+      private
 
-        def matcher
+        def self.matcher
           MATCHER
         end
-      end
     end
   end
 end

data/lib/saringan/parsers/string.rb

@@ -0,0 +1,14 @@
+module Saringan
+  module Parsers
+    class String
+
+      def self.parse(value)
+        value.to_s
+      end
+
+      def self.clean(value)
+        parse value
+      end
+    end
+  end
+end

data/lib/saringan/qualifier.rb

@@ -1,14 +1,36 @@
 # frozen_string_literal: true
 # -*- encoding: utf-8 -*-
 
+require 'saringan/qualifiers/absolute'
+require 'saringan/qualifiers/between'
+require 'saringan/qualifiers/inclusion'
 require 'saringan/qualifiers/range'
 
 module Saringan
   class Qualifier
 
+    RANGE_QUALIFIERS = [
+      Saringan::Qualifiers::Between
+    ]
+
     class << self
-      def qualify(value)
-        range.parse_value(value) if range.match?(value)
+      def build(value)
+        parser = Saringan::Parser.build(value)
+        value = parser.clean(value)
+        qualifier = nil
+
+        if range.match?(value)
+          value = range.clean(value)
+          RANGE_QUALIFIERS.each do |q|
+            qualifier = q if q.match?(value)
+          end
+          qualifier ||= Saringan::Qualifiers::Inclusion
+        else
+          value = absolute.clean(value)
+          qualifier = absolute
+        end
+
+        qualifier.new(value, parser)
       end
 
       private
@@ -17,6 +39,10 @@ module Saringan
           Saringan::Qualifiers::Range
         end
 
+        def absolute
+          Saringan::Qualifiers::Absolute
+        end
+
     end
   end
 end

data/lib/saringan/qualifiers/absolute.rb

@@ -0,0 +1,23 @@
+module Saringan
+  module Qualifiers
+    class Absolute
+
+      QL_REPLACER  = /^\(|\)$/
+      TYPE = :absolute
+
+      def initialize(value, parser)
+        @value = self.class.clean(value)
+        @parser = parser
+      end
+
+      def value
+        @parser.parse(@value)
+      end
+
+      def self.clean(value)
+        value.gsub(QL_REPLACER,  '')
+      end
+
+    end
+  end
+end

data/lib/saringan/qualifiers/between.rb

@@ -8,18 +8,28 @@ module Saringan
     class Between
       extend Saringan::Matcher
 
-      QL_BETWEEN = /\~+/
+      MATCHER = /\~+/
+      TYPE = :between
 
-      class << self
-        def matcher
-          QL_BETWEEN
-        end
+      def initialize(value, parser)
+        @value = value
+        @parser = parser
+        qualify
+      end
 
-        def qualify(value, parser = nil)
-          splitted = value.split(QL_BETWEEN)[0,2]
-          splitted.map{|v| parser.nil? ? v : parser.parse(v)}
-        end
+      def qualify
+        @from, @to = @value.split(MATCHER, 2)
+      end
+
+      def value
+        @parser.parse(@from)..@parser.parse(@to)
       end
+
+      private
+
+        def self.matcher
+          MATCHER
+        end
     end
   end
 end

data/lib/saringan/qualifiers/inclusion.rb

@@ -8,18 +8,29 @@ module Saringan
     class Inclusion
       extend Saringan::Matcher
 
-      QL_INCLUSION = /\;+/
+      MATCHER = /\|+/
+      TYPE = :inclusion
 
-      class << self
-        def qualify(value, parser = nil)
-          splitted = value.split(QL_INCLUSION)
-          parser.nil? ? splitted : splitted.map(&parser)
-        end
+      def initialize(value, parser)
+        @value = value
+        @parser = parser
+        qualify
+      end
 
-        def matcher
-          QL_INCLUSION
-        end
+      def qualify
+        @values = @value.split(MATCHER).map(&:strip)
+      end
+
+      def value
+        @values.map{|val| @parser.parse(val)}
       end
+
+      private
+
+        def self.matcher
+          MATCHER
+        end
+
     end
   end
 end

data/lib/saringan/qualifiers/range.rb

@@ -1,6 +1,4 @@
 require 'saringan/matcher'
-require 'saringan/qualifiers/inclusion'
-require 'saringan/qualifiers/between'
 
 module Saringan
   module Qualifiers
@@ -15,25 +13,10 @@ module Saringan
           QL_RANGE
         end
 
-        def qualify(value, parser)
-          cleaned = value.gsub(QL_REPLACER, '')
-
-          if between.match?(value)
-            { type: :between, value: between.qualify(cleaned, parser) }
-          else
-            { type: :in, value: inclusion.qualify(cleaned, parser) }
-          end
+        def clean(value)
+          value.gsub(QL_REPLACER,  '')
         end
 
-        private
-
-          def inclusion
-            Saringan::Qualifiers::Inclusion
-          end
-
-          def between
-            Saringan::Qualifiers::Between
-          end
       end
     end
   end

data/lib/saringan/statement.rb

@@ -0,0 +1,17 @@
+require 'saringan/statements/equal'
+require 'saringan/statements/greater_equal'
+
+module Saringan
+  class Statement
+    def self.build(term)
+      operator = Saringan::Operator.build(term)
+
+      case operator
+      when Operators::Equal
+        Statements::Equal.new(operator)
+      when Operators::GreaterEqual
+        Statements::GreaterEqual.new(operator)
+      end
+    end
+  end
+end

data/lib/saringan/statements/abstract_statement.rb

@@ -0,0 +1,18 @@
+require 'saringan/qualifier'
+
+module Saringan
+  module Statements
+    class AbstractStatement
+      attr_reader :operator, :qualifier, :field, :value, :type,
+        :subject, :params
+
+      def initialize(operator)
+        @operator = operator
+        @qualifier = Saringan::Qualifier.build(@operator.value)
+        @field = @operator.subject
+        @value = @qualifier.value
+        @type = @qualifier.class::TYPE
+      end
+    end
+  end
+end

data/lib/saringan/statements/equal.rb

@@ -0,0 +1,11 @@
+require 'saringan/statements/abstract_statement'
+
+module Saringan
+  module Statements
+    class Equal < AbstractStatement
+      def to_query
+        {"#{@operator.subject}": @qualifier.value}
+      end
+    end
+  end
+end

data/lib/saringan/statements/greater_equal.rb

@@ -0,0 +1,20 @@
+require 'active_support/concern'
+require 'saringan/statements/abstract_statement'
+
+module Saringan
+  module Statements
+    class GreaterEqual < AbstractStatement
+      def to_query
+        [subject, params]
+      end
+
+      def subject
+        "#{@operator.subject} >= ?"
+      end
+
+      def params
+        @qualifier.value
+      end
+    end
+  end
+end

data/lib/saringan/term.rb

@@ -5,11 +5,6 @@ module Saringan
   class Term
     TERM_SEP = ','
 
-    OP_N_EQUAL_S = /:!:/
-    OP_N_EQUAL_I = /:<>:/
-    OP_LESS      = /:<:/
-    OP_BIGGER    = /:>:/
-
     class << self
       def split(query)
         query.split(TERM_SEP)

data/lib/saringan/translator.rb

@@ -2,15 +2,16 @@
 # -*- encoding: utf-8 -*-
 
 require 'saringan/operator'
+require 'saringan/statement'
 
 module Saringan
   class Translator
     class << self
       def translate(query)
         terms = term.split(query)
-        parsed = {}
-        terms.each{|term| parsed.merge!(operator.parse(term))}
-        parsed
+        terms.map do |t|
+          Saringan::Statement.build(t).to_query
+        end
       end
 
       private

data/lib/saringan/version.rb

@@ -1,3 +1,3 @@
 module Saringan
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/spec/operators/equal_spec.rb

@@ -4,6 +4,8 @@
 require 'support/spec_helper'
 
 describe Saringan::Operators::Equal do
+  let(:operator) { described_class }
+
   describe '#match?' do
     it 'should match equals operator' do
       term = 'name::john'
@@ -16,51 +18,15 @@ describe Saringan::Operators::Equal do
     end
   end
 
-  describe '#split' do
-    let(:term) { 'name::john' }
-
-    it 'should split term' do
-      splitted = Saringan::Operators::Equal.split(term)
-      expect(splitted.size).to eq(2)
-    end
-
-    context 'splitted key' do
-      it 'should match term key' do
-        splitted = Saringan::Operators::Equal.split(term)
-        expect(splitted[:key]).to eq('name')
-      end
-    end
+  context 'initialization' do
+    let(:instance) { operator.new('name::john') }
 
-    context 'splitted value' do
-      it 'should match term value' do
-        splitted = Saringan::Operators::Equal.split(term)
-        expect(splitted[:value]).to eq('john')
-      end
+    it 'extract term subject' do
+      expect(instance.subject).to eq('name')
     end
-  end
-
-  describe '#to_h' do
-    it 'should transform term into hash' do
-      term = 'name::john'
-      parsed = Saringan::Operators::Equal.to_h(term)
-
-      expect(parsed).to eq({name: 'john'})
-    end
-  end
-
-  describe '#to_query' do
-    it 'should transform term keys into query' do
-      term = 'name::john'
-      parsed = Saringan::Operators::Equal.to_query(term)
-
-      expect(parsed[:query]).to eq("name = ?")
-    end
-
-    it 'should transform term values into params to query' do
-      term = 'name::john'
-      parsed = Saringan::Operators::Equal.to_query(term)
 
-      expect(parsed[:params]).to eq('john')
+    it 'extract term value' do
+      expect(instance.value).to eq('john')
     end
   end
 end

data/spec/operators/greater_equal_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'support/spec_helper'
+
+describe Saringan::Operators::GreaterEqual do
+  let(:operator) { described_class }
+
+  describe '#match?' do
+    it 'should match greater operator' do
+      term = 'name>:john'
+      expect(operator.match?(term)).to be_truthy
+    end
+
+    it 'should not match other operators' do
+      term = 'name!:john'
+      expect(operator.match?(term)).to be_falsy
+    end
+  end
+
+  context 'initialization' do
+    let(:instance) { operator.new('name>:john') }
+
+    it 'extract term subject' do
+      expect(instance.subject).to eq('name')
+    end
+
+    it 'extract term value' do
+      expect(instance.value).to eq('john')
+    end
+  end
+end

data/spec/operators/greater_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'support/spec_helper'
+
+describe Saringan::Operators::Greater do
+  let(:operator) { described_class }
+
+  describe '#match?' do
+    it 'should match greater operator' do
+      term = 'name:>john'
+      expect(operator.match?(term)).to be_truthy
+    end
+
+    it 'should not match other operators' do
+      term = 'name:!:john'
+      expect(operator.match?(term)).to be_falsy
+    end
+  end
+
+  context 'initialization' do
+    let(:instance) { operator.new('name:>john') }
+
+    it 'extract term subject' do
+      expect(instance.subject).to eq('name')
+    end
+
+    it 'extract term value' do
+      expect(instance.value).to eq('john')
+    end
+  end
+end

data/spec/parsers/date_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'support/spec_helper'
+
+describe Saringan::Parsers::Date, type: :parsers do
+  let(:parser) { described_class }
+  let(:date) { Date.new(2018, 06, 01) }
+
+  describe '#match?' do
+    it 'match date value' do
+      value = 'd(2018-06-01)'
+      expect(parser.match?(value)).to be_truthy
+    end
+
+    it 'match date time value' do
+      value = 'd(2018-06-01T00:00:00.000)'
+      expect(parser.match?(value)).to be_truthy
+    end
+
+    it 'do not match non date value' do
+      value = 'i(1)'
+      expect(parser.match?(value)).to be_falsy
+    end
+  end
+
+  describe '#clean' do
+    it 'remove range markup from value' do
+      value = 'd(2018-06-01)'
+      expect(parser.clean(value)).to eq('2018-06-01')
+    end
+  end
+
+  describe '#parse' do
+    it 'parse value to Date' do
+      value = 'd(2018-06-01)'
+      expect(parser.parse(value)).to eq(date)
+    end
+
+    it 'parse value to Date even value is a DateTime' do
+      value = 'd(2018-06-01T00:00:00.000)'
+      expect(parser.parse(value)).to eq(date)
+    end
+  end
+end

data/spec/parsers/date_time_spec.rb

@@ -23,23 +23,14 @@ describe Saringan::Parsers::DateTime, type: :parsers do
   describe '#clean' do
     it 'should remove range markup from value' do
       value = 'dt[2018-06-01 00:00:00|2018-06-30 23:59:59]'
-      expect(parser.clean(value)).to eq('2018-06-01 00:00:00|2018-06-30 23:59:59')
+      expect(parser.clean(value)).to eq('[2018-06-01 00:00:00|2018-06-30 23:59:59]')
     end
   end
 
   describe '#parse' do
     it 'should parse value to DateTime' do
-      value = '2018-06-01 00:00:00'
+      value = '2018-06-01T00:00:00'
       expect(parser.parse(value)).to eq(from)
     end
   end
-
-  # describe '#to_h' do
-  #   context 'using between translator' do
-  #     it 'should translate value into from/to hash' do
-  #       value = 'dt[2018-06-01 00:00:00|2018-06-30 23:59:59]'
-  #       expect(parser.to_h(value)[:value]).to eq([from, to])
-  #     end
-  #   end
-  # end
 end

data/spec/qualifiers/between_spec.rb

@@ -19,9 +19,25 @@ describe Saringan::Qualifiers::Between, type: :qualifier do
   end
 
   describe '#qualify' do
-    it 'parse value to array' do
-      value = 'val~val~val'
-      expect(qualifier.qualify(value)).to have(2).items
+    let(:parser) { double('parser') }
+
+    before do
+      allow(parser).to receive(:parser).and_return(1, 10)
+    end
+
+    it 'split values in two parts' do
+      value = '1~1~10'
+      instance = qualifier.new(value, parser)
+
+      expect(instance.qualify).to have(2).items
     end
+
+    it 'split values correctly' do
+      value = '1~10'
+      instance = qualifier.new(value, parser)
+
+      expect(instance.qualify).to eq(['1', '10'])
+    end
+
   end
 end

data/spec/qualifiers/inclusion_spec.rb

@@ -8,7 +8,7 @@ describe Saringan::Qualifiers::Inclusion, type: :qualifier do
 
   describe '#match?' do
     it 'matches inclusion value' do
-      value = 'val; val; val'
+      value = 'val| val| val'
       expect(qualifier.match?(value)).to be_truthy
     end
 
@@ -19,9 +19,24 @@ describe Saringan::Qualifiers::Inclusion, type: :qualifier do
   end
 
   describe '#qualify' do
-    it 'parse value to array' do
-      value = 'val;val;val'
-      expect(qualifier.qualify(value)).to have(3).items
+    let(:parser) { double('parser') }
+
+    before do
+      allow(parser).to receive(:parse).and_return('val')
+    end
+
+    it 'parsed value match value size' do
+      value = 'val|val|val'
+      instance = qualifier.new(value, parser)
+
+      expect(instance.qualify).to have(3).items
+    end
+
+    it 'parsed value must match value' do
+      value = 'val|val|val'
+      instance = qualifier.new(value, parser)
+
+      expect(instance.qualify).to eq(['val', 'val', 'val'])
     end
   end
 end

data/spec/qualifiers/range_spec.rb

@@ -28,21 +28,10 @@ describe Saringan::Qualifiers::Range, type: :qualifier do
     end
   end
 
-  describe '#qualify' do
-    context 'for inclusion values' do
-      it 'parse inclusion values as array' do
-        value = 'val; val; val'
-        parsed = qualifier.qualify(value, nil)
-        expect(parsed[:value]).to have(3).items
-      end
-    end
-
-    context 'for between values' do
-      it 'parse between values as from/to hash' do
-        value = 'val~val~val'
-        parsed = qualifier.qualify(value, nil)
-        expect(parsed[:value]).to have(2).items
-      end
+  describe '#clean' do
+    it 'clean range value markup' do
+      value, expected = '[value]', 'value'
+      expect(qualifier.clean(value)).to eq(expected)
     end
   end
 end

data/spec/translations/absolute/date/greater_equal_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'support/spec_helper'
+
+describe Saringan::Translator do
+  let(:translator) { described_class }
+  let(:date) { Date.today }
+  let(:query) { "date>:d(#{date.iso8601})" }
+
+  describe '#translate' do
+    context 'greater equal date' do
+      it 'translates correctly' do
+        translated = translator.translate(query)
+        expect(translated[0]).to eq(["date >= ?", date])
+      end
+    end
+  end
+end

data/spec/translations/absolute/string/equal_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'support/spec_helper'
+
+describe Saringan::Translator do
+  let(:translator) { described_class }
+
+  describe '#translate' do
+    context 'equal string' do
+      it 'translates correctly' do
+        translated = translator.translate('name::john')
+        expect(translated).to eq([{name: 'john'}])
+      end
+    end
+
+    context 'multiple terms' do
+      it 'translate terms correctly' do
+        translated = translator
+          .translate('name::john,last_name::(doe),email::j.doe@email.com')
+
+        expect(translated).to eq([
+          {name: 'john'},
+          {last_name: 'doe'},
+          {email: 'j.doe@email.com'}
+        ])
+      end
+    end
+  end
+end

data/spec/translations/range/date_time_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'support/spec_helper'
+
+describe Saringan::Translator do
+  let(:translator) { described_class }
+  let(:start) { DateTime.now }
+  let(:finish) { start + 30 }
+  let(:query) { "date::dt[#{start.iso8601}~#{finish.iso8601}]" }
+
+  describe '#translate' do
+    context 'inclusion range' do
+    end
+
+    context 'between range' do
+      it 'to rails query correctly' do
+        result = translator.translate(query)
+        expected = {"date": start..finish}
+
+        expect(result.first[:date]).not_to be_nil
+      end
+    end
+  end
+end

data/spec/translator_spec.rb

@@ -7,33 +7,58 @@ describe Saringan::Translator do
   let(:translator) { Saringan::Translator }
 
   describe '#translate' do
-    context 'for date time ranges' do
-      let(:query) { 'created_at:>:dt[2018-06-01 00:00:00~2018-06-30 23:59:59]' }
 
-      it 'should translate date time query string to ruby hash' do
-        from = DateTime.new(2018, 06, 01, 00, 00, 00, DateTime.current.zone)
-        to = DateTime.new(2018, 06, 30, 23, 59, 59, DateTime.current.zone)
+    # context 'for absolute equal values' do
+    #   context 'and value is string' do
+    #     let(:query) { 'name::john' }
 
-        expect(translator.translate(query)).to eq({ created_at: from..to })
+    #     it 'translate query string to ruby hash' do
+    #       expect(translator.translate(query)).to eq({ name: 'john' })
+    #     end
+    #   end
+    # end
+
+    context 'multiple filters' do
+      context 'with two string values' do
+        let(:query) { 'name::john,alias::snow' }
+
+        it 'translate query string to ruby rash' do
+          expect(translator.translate(query)).to eq([{ name: 'john' }, { alias: 'snow' }])
+        end
       end
-    end
 
-    context 'for absolute equal values' do
-      context 'and value is string' do
-        let(:query) { 'name::john' }
+      context 'with date time range and string range' do
+        let(:start) { DateTime.now }
+        let(:finish) { start + 30 }
+
+        let(:query) do
+          "date::dt[#{start.iso8601}~#{finish.iso8601}],status::[accepted|refused]"
+        end
 
         it 'translate query string to ruby hash' do
-          expect(translator.translate(query)).to eq({ name: 'john' })
+          result = translator.translate(query)
+          expected = { status: ['accepted', 'refused'] }
+
+          expect(result).to include(expected)
         end
       end
     end
 
-    context 'with multiple filters' do
-      let(:query) { 'name::john,age::18' }
+    # context 'greater equal' do
+    #   context 'for date values' do
+    #     let(:query) { 'birthdate>:d(2018-06-30)' }
 
-      it 'translate query string to ruby rash' do
-        expect(translator.translate(query)).to eq({ name: 'john', age: '18' })
-      end
-    end
+    #     it 'translate query to ruby query' do
+    #       translated = translator.translate(query)[:query]
+    #       expect(translated).to eq("birthdate >= ?")
+    #     end
+
+    #     it 'translated value should be a Date object' do
+    #       date = Date.parse('2018-06-30')
+    #       translated = translator.translate(query)[:params]
+    #       expect(translated).to eq(date)
+    #     end
+    #   end
+    # end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: saringan
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Reinaldo Olivera (k1ng)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-23 00:00:00.000000000 Z
+date: 2019-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -92,19 +92,28 @@ files:
 - lib/saringan/matcher.rb
 - lib/saringan/operator.rb
 - lib/saringan/operators/equal.rb
-- lib/saringan/operators/range.rb
+- lib/saringan/operators/greater.rb
+- lib/saringan/operators/greater_equal.rb
 - lib/saringan/parser.rb
+- lib/saringan/parsers/date.rb
 - lib/saringan/parsers/date_time.rb
-- lib/saringan/parsers/integer_range.rb
+- lib/saringan/parsers/string.rb
 - lib/saringan/qualifier.rb
+- lib/saringan/qualifiers/absolute.rb
 - lib/saringan/qualifiers/between.rb
 - lib/saringan/qualifiers/inclusion.rb
 - lib/saringan/qualifiers/range.rb
+- lib/saringan/statement.rb
+- lib/saringan/statements/abstract_statement.rb
+- lib/saringan/statements/equal.rb
+- lib/saringan/statements/greater_equal.rb
 - lib/saringan/term.rb
 - lib/saringan/translator.rb
 - lib/saringan/version.rb
 - spec/operators/equal_spec.rb
-- spec/operators/range_spec.rb
+- spec/operators/greater_equal_spec.rb
+- spec/operators/greater_spec.rb
+- spec/parsers/date_spec.rb
 - spec/parsers/date_time_spec.rb
 - spec/parsers/integer_range_spec.rb
 - spec/qualifiers/between_spec.rb
@@ -113,6 +122,11 @@ files:
 - spec/saringan_spec.rb
 - spec/support/spec_helper.rb
 - spec/terms_spec.rb
+- spec/translations/absolute/date/equal_spec.rb
+- spec/translations/absolute/date/greater_equal_spec.rb
+- spec/translations/absolute/date/greater_spec.rb
+- spec/translations/absolute/string/equal_spec.rb
+- spec/translations/range/date_time_spec.rb
 - spec/translator_spec.rb
 homepage: https://github.com/reinaldooli/saringan
 licenses:
@@ -134,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: Simple way to send filter parameters to rails models.
@@ -142,11 +156,18 @@ test_files:
 - spec/qualifiers/inclusion_spec.rb
 - spec/qualifiers/between_spec.rb
 - spec/qualifiers/range_spec.rb
-- spec/operators/range_spec.rb
+- spec/operators/greater_equal_spec.rb
+- spec/operators/greater_spec.rb
 - spec/operators/equal_spec.rb
 - spec/terms_spec.rb
 - spec/support/spec_helper.rb
+- spec/translations/range/date_time_spec.rb
+- spec/translations/absolute/date/greater_equal_spec.rb
+- spec/translations/absolute/date/greater_spec.rb
+- spec/translations/absolute/date/equal_spec.rb
+- spec/translations/absolute/string/equal_spec.rb
 - spec/translator_spec.rb
 - spec/parsers/integer_range_spec.rb
 - spec/parsers/date_time_spec.rb
+- spec/parsers/date_spec.rb
 - spec/saringan_spec.rb

data/lib/saringan/operators/range.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-# -*- encoding: utf-8 -*-
-
-require 'saringan/matcher'
-require 'saringan/parser'
-require 'saringan/qualifiers/range'
-
-module Saringan
-  module Operators
-    class Range
-      extend Saringan::Matcher
-
-      OP_RANGE = /:>:/
-
-      class << self
-        def matcher
-          OP_RANGE
-        end
-
-        def to_h(term)
-          splitted = split(term)
-          parsed = parser(splitted[:value])
-          qualified = qualify(parsed[:value], parsed[:parser])
-
-          case qualified[:type]
-          when :in
-            { "#{splitted[:key]}": qualified[:value] }
-          when :between
-            { "#{splitted[:key]}": qualified[:value][0]..qualified[:value][1] }
-          end
-        end
-
-        def split(term)
-          splitted = term.split(OP_RANGE)
-          { key: splitted[0], value: splitted[1] }
-        end
-
-        def qualify(value, parser)
-          qualifier.qualify(value, parser)
-        end
-
-        private
-
-          def qualifier
-            Saringan::Qualifiers::Range
-          end
-
-          def parser(value)
-            Saringan::Parser.build(value)
-          end
-      end
-
-    end
-  end
-end

data/lib/saringan/parsers/integer_range.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-# -*- encoding: utf-8 -*-
-
-module Saringan
-  module Parsers
-    class IntegerRange < Range
-      MATCHER = /^i\[(.+)\]$/
-    end
-  end
-end

data/spec/operators/range_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-# -*- encoding: utf-8 -*-
-
-require 'support/spec_helper'
-
-describe Saringan::Operators::Range, type: :operator do
-  let(:operator) { described_class }
-
-  describe '#qualify' do
-    context 'for inclusion range' do
-      it 'return values qualified as array' do
-        value = 'val;val;val'
-        qualified = operator.qualify(value, nil)
-        expect(qualified[:value]).to have(3).items
-      end
-
-      it 'qualify values as inclusion' do
-        value = 'val;val;val'
-        qualified = operator.qualify(value, nil)
-        expect(qualified[:type]).to eq(:in)
-      end
-
-      it 'qualified values was not changed' do
-        value = 'val;val;val'
-        qualified = operator.qualify(value, nil)
-        expect(qualified[:value]).to eq(['val', 'val', 'val'])
-      end
-    end
-
-    context 'for between range' do
-      it 'return values qualified as array' do
-        value = 'val~val'
-        qualified = operator.qualify(value, nil)
-        expect(qualified[:value]).to have(2).items
-      end
-
-      it 'qualify values as between' do
-        value = 'val~val'
-        qualified = operator.qualify(value, nil)
-        expect(qualified[:type]).to eq(:between)
-      end
-
-      it 'between qualified values has only from/to values' do
-        value = 'val1~val2~val_'
-        qualified = operator.qualify(value, nil)
-        expect(qualified[:value]).to eq(['val1', 'val2'])
-      end
-    end
-  end
-
-  describe '#split' do
-    it 'split term as key => value hash' do
-      term = 'status:>:[todo;doing;done]'
-      expect(operator.split(term)).to eq({ key: 'status', value: '[todo;doing;done]'})
-    end
-
-    context 'splitted key' do
-      it 'match term key' do
-        term = 'status:>:[todo;doing;done]'
-        splitted = operator.split(term)
-        expect(splitted[:key]).to eq('status')
-      end
-    end
-
-    context 'splitted value' do
-      it 'match term value' do
-        term = 'status:>:[todo;doing;done]'
-        splitted = operator.split(term)
-        expect(splitted[:value]).to eq('[todo;doing;done]')
-      end
-    end
-  end
-
-  describe '#to_h' do
-    context 'for inclusion range' do
-      it 'value must be an array' do
-        term = 'status:>:[todo;doing;done]'
-        hash = operator.to_h(term)
-        expect(hash).to eq({ status: ['todo', 'doing', 'done'] })
-      end
-    end
-  end
-end