saringan 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14714e62396c119de8d76254c91fdb1eba523c4042ed0b267f6c85722addf6f6
-  data.tar.gz: ae2440972f2ac820a684fb744d29838ff8b67ea21e5e7221382c362e656828a4
+  metadata.gz: 9eb1091f0f3aae7508e4012b7ae7b820c237beff838c2535e022e18745b91513
+  data.tar.gz: be906a1fe3e01bbb26b04741e5cd12e25184d1184063b3711046488de16dbcc0
 SHA512:
-  metadata.gz: '0272149bca14917ce4e26e692124d620db706f42ee322121387da38151c6ed6c29ae3ca1b1963c7cf44bc9f3758c931f2bdfa7bef341b4e25e2d1d2d2d35a921'
-  data.tar.gz: 55f23a72543de8a5e1989ba37f5f29e1c12a185096e185f95f59c0e8e9881a6f4ca05d3406c1e8df82aeaf479d321ea3c27bd4b0fcd37ef35da851633fdcceb3
+  metadata.gz: ddd2030b69479a87b2100ee3fe65adaaee69807b03f362bfdb2bce31366c28fee8373c7df3c116d9f15213ffca3ae98ec7d34e1a4acd6779f990587ce6c8eba7
+  data.tar.gz: b781ae99878fbd2e3377b72c9f855864c86606115d720b2ae8ed9e44de2883207a3073669597a138dadd82fdd8ffc2bb8c6bd3b1923aa97630ec3ccf2987e015

data/README.md

@@ -1,4 +1,4 @@
-# Saringan
+# Saringan · [![Build Status](https://travis-ci.org/reinaldooli/saringan.svg?branch=master)](https://travis-ci.org/reinaldooli/saringan) [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg?style=square)](https://github.com/reinaldooli/saringan/blob/master/MIT-LICENSE) [![Gem Version](https://badge.fury.io/rb/saringan.svg)](https://badge.fury.io/rb/saringan)
 
 Translate query strings to activerecord query parameters.
 

data/lib/saringan/matcher.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+module Saringan
+  module Matcher
+    def match?(term)
+      term =~ matcher
+    end
+  end
+end

data/lib/saringan/operator.rb

@@ -1,10 +1,15 @@
-require 'saringan/operators'
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require "saringan/operators/equal"
+require "saringan/operators/range"
 
 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
@@ -12,6 +17,10 @@ module Saringan
         def equal
           Saringan::Operators::Equal
         end
+
+        def range
+          Saringan::Operators::Range
+        end
     end
   end
 end

data/lib/saringan/operators/equal.rb

@@ -1,12 +1,19 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
 require 'saringan/parser'
+require 'saringan/matcher'
 
 module Saringan
   module Operators
     class Equal
+      extend Saringan::Matcher
 
       OP_EQUAL = /::/
 
       class << self
+
+        # TODO: Create an absolute qualifier
         def to_h(term)
           splitted = split(term)
           { "#{splitted[:key]}": parser.parse(splitted[:value]) }
@@ -17,15 +24,15 @@ module Saringan
           { query: "#{splitted[:key]} = ?", params: splitted[:value] }
         end
 
-        def match?(term)
-          term =~ OP_EQUAL
-        end
-
         def split(term)
           splitted = term.split(OP_EQUAL)
           { key: splitted[0], value: splitted[1] }
         end
 
+        def matcher
+          OP_EQUAL
+        end
+
         private
 
           def parser

data/lib/saringan/operators/range.rb

@@ -0,0 +1,55 @@
+# 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/parser.rb

@@ -1,27 +1,25 @@
-require 'saringan/parsers'
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'saringan/parsers/date_time'
 
 module Saringan
   class Parser
     class << self
       def parse(value)
-        return range.to_h(value) if range.match?(value)
-        return datetime_range_parser(value) if date_time_range.match?(value)
+        return date_time.parse(value) if date_time.match?(value)
         value
       end
 
-      def datetime_range_parser(value)
-        values  = date_time_range.to_h(value)
-        values[:from]..values[:to]
+      def build(value)
+        return {value: date_time.clean(value), parser: date_time} if date_time.match?(value)
+        { value: value, parser: nil }
       end
 
       private
 
-        def range
-          Saringan::Parsers::Range
-        end
-
-        def date_time_range
-          Saringan::Parsers::DateTimeRange
+        def date_time
+          Saringan::Parsers::DateTime
         end
     end
   end

data/lib/saringan/parsers/date_time.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'active_support/core_ext/time'
+require 'active_support/core_ext/date_time'
+require 'saringan/matcher'
+
+module Saringan
+  module Parsers
+    class DateTime
+      extend Saringan::Matcher
+
+      MATCHER = /^dt\[(.+)\]$/
+      FORMAT = '%Y-%m-%d %H:%M:%S'
+
+      class << self
+        def clean(value)
+          value.gsub(/^dt\[|\]$/, '')
+        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 matcher
+          MATCHER
+        end
+      end
+    end
+  end
+end

data/lib/saringan/parsers/integer_range.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
 module Saringan
   module Parsers
     class IntegerRange < Range

data/lib/saringan/qualifier.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'saringan/qualifiers/range'
+
+module Saringan
+  class Qualifier
+
+    class << self
+      def qualify(value)
+        range.parse_value(value) if range.match?(value)
+      end
+
+      private
+
+        def range
+          Saringan::Qualifiers::Range
+        end
+
+    end
+  end
+end

data/lib/saringan/qualifiers/between.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'saringan/matcher'
+
+module Saringan
+  module Qualifiers
+    class Between
+      extend Saringan::Matcher
+
+      QL_BETWEEN = /\~+/
+
+      class << self
+        def matcher
+          QL_BETWEEN
+        end
+
+        def qualify(value, parser = nil)
+          splitted = value.split(QL_BETWEEN)[0,2]
+          splitted.map{|v| parser.nil? ? v : parser.parse(v)}
+        end
+      end
+    end
+  end
+end

data/lib/saringan/qualifiers/inclusion.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'saringan/matcher'
+
+module Saringan
+  module Qualifiers
+    class Inclusion
+      extend Saringan::Matcher
+
+      QL_INCLUSION = /\;+/
+
+      class << self
+        def qualify(value, parser = nil)
+          splitted = value.split(QL_INCLUSION)
+          parser.nil? ? splitted : splitted.map(&parser)
+        end
+
+        def matcher
+          QL_INCLUSION
+        end
+      end
+    end
+  end
+end

data/lib/saringan/qualifiers/range.rb

@@ -0,0 +1,42 @@
+require 'saringan/matcher'
+require 'saringan/qualifiers/inclusion'
+require 'saringan/qualifiers/between'
+
+module Saringan
+  module Qualifiers
+    class Range
+      extend Saringan::Matcher
+
+      QL_RANGE     = /(^\[(.+)\])/
+      QL_REPLACER  = /(^\[|\]$)/
+
+      class << self
+        def matcher
+          QL_RANGE
+        end
+
+        def qualify(value, parser)
+          cleaned = value.gsub(QL_REPLACER, '')
+
+          if inclusion.match?(value)
+            { type: :in, value: inclusion.qualify(cleaned, parser) }
+          elsif between.match?(value)
+            { type: :between, value: between.qualify(cleaned, parser) }
+          else
+            raise ArgumentError.new('Value is not a range')
+          end
+        end
+
+        private
+
+          def inclusion
+            Saringan::Qualifiers::Inclusion
+          end
+
+          def between
+            Saringan::Qualifiers::Between
+          end
+      end
+    end
+  end
+end

data/lib/saringan/translator.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
 require 'saringan/operator'
 
 module Saringan
@@ -5,10 +8,9 @@ module Saringan
     class << self
       def translate(query)
         terms = term.split(query)
-        parsed = terms.map do |term|
-          operator.parse(term)
-        end
-        (parsed.size > 1) ? parsed : parsed.first
+        parsed = {}
+        terms.each{|term| parsed.merge!(operator.parse(term))}
+        parsed
       end
 
       private

data/lib/saringan/version.rb

@@ -1,3 +1,3 @@
 module Saringan
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/saringan.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
 require "date"
 
 require "saringan/version"

data/spec/operators/equal_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
 require 'support/spec_helper'
 
 describe Saringan::Operators::Equal do

data/spec/operators/range_spec.rb

@@ -0,0 +1,83 @@
+# 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

data/spec/parsers/{date_time_range_spec.rb → date_time_spec.rb}

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
 require 'support/spec_helper'
 
-describe Saringan::Parsers::DateTimeRange do
-  let(:parser) { Saringan::Parsers::DateTimeRange }
+describe Saringan::Parsers::DateTime, type: :parsers do
+  let(:parser) { described_class }
   let(:from ) { DateTime.new(2018, 06, 01, 00, 00, 00, DateTime.current.zone) }
   let(:to) { DateTime.new(2018, 06, 30, 23, 59, 59, DateTime.current.zone) }
 
@@ -25,17 +27,19 @@ describe Saringan::Parsers::DateTimeRange do
     end
   end
 
-  describe '#split' do
-    it 'should split value into from/to array' do
-      value = 'dt[2018-06-01 00:00:00|2018-06-30 23:59:59]'
-      expect(parser.split(value)).to eq([from, to])
+  describe '#parse' do
+    it 'should parse value to DateTime' do
+      value = '2018-06-01 00:00:00'
+      expect(parser.parse(value)).to eq(from)
     end
   end
 
-  describe '#to_h' 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)).to eq({from: from, to: to })
-    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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'support/spec_helper'
+
+describe Saringan::Qualifiers::Between, type: :qualifier do
+  let(:qualifier) { described_class }
+
+  describe '#match?' do
+    it 'matches between values' do
+      value = 'val~ val~ val'
+      expect(qualifier.match?(value)).to be_truthy
+    end
+
+    it 'not matches non between value' do
+      value = 'val ; val ; val'
+      expect(qualifier.match?(value)).to be_falsy
+    end
+  end
+
+  describe '#qualify' do
+    it 'parse value to array' do
+      value = 'val~val~val'
+      expect(qualifier.qualify(value)).to have(2).items
+    end
+  end
+end

data/spec/qualifiers/inclusion_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'support/spec_helper'
+
+describe Saringan::Qualifiers::Inclusion, type: :qualifier do
+  let(:qualifier) { described_class }
+
+  describe '#match?' do
+    it 'matches inclusion value' do
+      value = 'val; val; val'
+      expect(qualifier.match?(value)).to be_truthy
+    end
+
+    it 'not matches non inclusion value' do
+      value = 'val \ val \ val'
+      expect(qualifier.match?(value)).to be_falsy
+    end
+  end
+
+  describe '#qualify' do
+    it 'parse value to array' do
+      value = 'val;val;val'
+      expect(qualifier.qualify(value)).to have(3).items
+    end
+  end
+end

data/spec/qualifiers/range_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+require 'support/spec_helper'
+
+describe Saringan::Qualifiers::Range, type: :qualifier do
+  let(:qualifier) { described_class }
+
+  describe '#match?' do
+    it 'match inclusion range value' do
+      value = '[val; val; val]'
+      expect(qualifier.match?(value)).to be_truthy
+    end
+
+    it 'match between range value' do
+      value = '[val\val]'
+      expect(qualifier.match?(value)).to be_truthy
+    end
+
+    it 'not match unclosed range value' do
+      value = '[value'
+      expect(qualifier.match?(value)).to be_falsy
+    end
+
+    it 'not match non range value' do
+      value = '(value)'
+      expect(qualifier.match?(value)).to be_falsy
+    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
+    end
+  end
+end

data/spec/support/spec_helper.rb

@@ -1,4 +1,5 @@
 require "saringan"
+require "rspec/collection_matchers"
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true

data/spec/terms_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
 require 'support/spec_helper'
 
 describe Saringan::Term do

data/spec/translator_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
 require 'support/spec_helper'
 
 describe Saringan::Translator do
@@ -5,7 +8,7 @@ describe Saringan::Translator do
 
   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]' }
+      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)
@@ -24,5 +27,13 @@ describe Saringan::Translator do
         end
       end
     end
+
+    context 'with multiple filters' do
+      let(:query) { 'name::john,age::18' }
+
+      it 'translate query string to ruby rash' do
+        expect(translator.translate(query)).to eq({ name: 'john', age: '18' })
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: saringan
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Reinaldo Olivera (k1ng)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-10 00:00:00.000000000 Z
+date: 2018-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: Simple way to send filter parameters to rails models.
 email: 
 executables: []
@@ -75,21 +89,27 @@ files:
 - MIT-LICENSE
 - README.md
 - lib/saringan.rb
+- lib/saringan/matcher.rb
 - lib/saringan/operator.rb
-- lib/saringan/operators.rb
 - lib/saringan/operators/equal.rb
+- lib/saringan/operators/range.rb
 - lib/saringan/parser.rb
-- lib/saringan/parsers.rb
-- lib/saringan/parsers/date_time_range.rb
+- lib/saringan/parsers/date_time.rb
 - lib/saringan/parsers/integer_range.rb
-- lib/saringan/parsers/range.rb
+- lib/saringan/qualifier.rb
+- lib/saringan/qualifiers/between.rb
+- lib/saringan/qualifiers/inclusion.rb
+- lib/saringan/qualifiers/range.rb
 - lib/saringan/term.rb
 - lib/saringan/translator.rb
 - lib/saringan/version.rb
 - spec/operators/equal_spec.rb
-- spec/parsers/date_time_range_spec.rb
+- spec/operators/range_spec.rb
+- spec/parsers/date_time_spec.rb
 - spec/parsers/integer_range_spec.rb
-- spec/parsers/range_spec.rb
+- spec/qualifiers/between_spec.rb
+- spec/qualifiers/inclusion_spec.rb
+- spec/qualifiers/range_spec.rb
 - spec/saringan_spec.rb
 - spec/support/spec_helper.rb
 - spec/terms_spec.rb
@@ -119,11 +139,14 @@ signing_key:
 specification_version: 4
 summary: Simple way to send filter parameters to rails models.
 test_files:
+- spec/qualifiers/inclusion_spec.rb
+- spec/qualifiers/between_spec.rb
+- spec/qualifiers/range_spec.rb
+- spec/operators/range_spec.rb
 - spec/operators/equal_spec.rb
 - spec/terms_spec.rb
 - spec/support/spec_helper.rb
 - spec/translator_spec.rb
-- spec/parsers/date_time_range_spec.rb
 - spec/parsers/integer_range_spec.rb
-- spec/parsers/range_spec.rb
+- spec/parsers/date_time_spec.rb
 - spec/saringan_spec.rb

data/lib/saringan/operators.rb

@@ -1 +0,0 @@
-require 'saringan/operators/equal'

data/lib/saringan/parsers/date_time_range.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-require 'active_support/core_ext/time'
-require 'active_support/core_ext/date_time'
-
-module Saringan
-  module Parsers
-    class DateTimeRange < Range
-      MATCHER = /^dt\[(.+)\]$/
-      FORMAT = '%Y-%m-%d %H:%M:%S'
-
-      class << self
-        def split(value)
-          splitted = super(value)
-          splitted.map do |part|
-            date = DateTime.strptime(part, FORMAT)
-            DateTime.new date.year, date.month, date.day, date.hour, date.min, \
-              date.sec, DateTime.current.zone
-          end
-        end
-
-        def clean(value)
-          value.gsub(/^dt\[/, '').gsub(/\]$/, '')
-        end
-      end
-    end
-  end
-end

data/lib/saringan/parsers/range.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-# -*- encoding: utf-8 -*-
-
-module Saringan
-  module Parsers
-    class Range
-      MATCHER = /^\[(.+)\]$/
-
-      class << self
-        def match?(value)
-          value =~ matcher
-        end
-
-        def to_h(value)
-          splitted = split(value)
-          { from: parse_value(splitted[0]), to: parse_value(splitted[1]) }
-        end
-
-        def split(value)
-          cleaned = clean(value)
-          cleaned.split('|')
-        end
-
-        def clean(value)
-          value.gsub(/^\[/, '').gsub(/\]$/, '')
-        end
-
-        def parse_value(value)
-          value
-        end
-
-        private
-
-          def matcher
-            self::MATCHER
-          end
-      end
-    end
-  end
-end

data/lib/saringan/parsers.rb

@@ -1,4 +0,0 @@
-require 'saringan/parsers/range'
-require 'saringan/parsers/date_time_range'
-
-require 'saringan/parser'

data/spec/parsers/range_spec.rb

@@ -1,31 +0,0 @@
-require 'support/spec_helper'
-
-describe Saringan::Parsers::Range do
-  let(:parser){ Saringan::Parsers::Range }
-
-  describe '#match?' do
-    it 'should match range value' do
-      value = '[1|10]'
-      expect(parser.match?(value)).to be_truthy
-    end
-
-    it 'should not match non range value' do
-      value = '[1|10'
-      expect(parser.match?(value)).to be_falsy
-    end
-  end
-
-  describe '#clean' do
-    it 'should remove range markup from value' do
-      value = '[1|3]'
-      expect(parser.clean(value)).to eq('1|3')
-    end
-  end
-
-  describe '#splt' do
-    it 'should separate range in from/to array' do
-      value = '[1|3]'
-      expect(parser.split(value)).to eq(["1", "3"])
-    end
-  end
-end