saringan 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 14714e62396c119de8d76254c91fdb1eba523c4042ed0b267f6c85722addf6f6
+  data.tar.gz: ae2440972f2ac820a684fb744d29838ff8b67ea21e5e7221382c362e656828a4
+SHA512:
+  metadata.gz: '0272149bca14917ce4e26e692124d620db706f42ee322121387da38151c6ed6c29ae3ca1b1963c7cf44bc9f3758c931f2bdfa7bef341b4e25e2d1d2d2d35a921'
+  data.tar.gz: 55f23a72543de8a5e1989ba37f5f29e1c12a185096e185f95f59c0e8e9881a6f4ca05d3406c1e8df82aeaf479d321ea3c27bd4b0fcd37ef35da851633fdcceb3

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# Saringan
+
+Translate query strings to activerecord query parameters.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'saringan'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install saringan
+
+## Usage
+
+Use Saringan::Translator to translate query string to activerecord parameters:
+
+```ruby
+irb> query = "name::John"
+irb> Saringan::Translator.translate(query)
+{ name: 'John' }
+```
+
+### Operators
+
+**Obs.:** This is a preliminar version, so others operators will be implemented in future versions.
+
+#### Equals
+
+This handle absolute equals query like "WHERE name = 'John'".
+To do it you must use Saringan equals operator '::'
+
+In URL: http://site.com?query=name::John
+
+In code:
+```ruby
+irb> query = params[:query]
+irb> Saringan::Translator.translate(query)
+{ name: 'John' }
+```
+
+### Parsers
+
+**Obs.:** This is a preliminar version, so others parsers will be implemented in future versions.
+
+#### String Parser
+
+Just pass value without any qualifier
+
+#### Date Time Parser
+
+Pass value using Saringan Date Time qualifier.
+Saringan will parse value to DateTime object. It expect date time in '%Y-%m-%d %H:%M:%S' format, see:
+
+In URL: http://site.com?query=starts_at::dt[2018-06-30 00:00:00]
+
+In code:
+```ruby
+irb> query = params[:query]
+irb> Saringan::Translator.translate(query)
+{ starts_at: DateTime object }
+```
+
+##### Range
+
+Pass value using Saringan range operator '|'
+
+In URL: http://site.com?query=starts_at::dt[2018-06-30 00:00:00|2018-06-30 23:59:59]
+
+In code:
+```ruby
+irb> query = params[:query]
+irb> Saringan::Translator.translate(query)
+{ starts_at: DateTime object..DateTime object }
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/saringan/operator.rb

@@ -0,0 +1,17 @@
+require 'saringan/operators'
+
+module Saringan
+  class Operator
+    class << self
+      def parse(term)
+        return equal.to_h(term) if equal.match?(term)
+      end
+
+      private
+
+        def equal
+          Saringan::Operators::Equal
+        end
+    end
+  end
+end

data/lib/saringan/operators/equal.rb

@@ -0,0 +1,37 @@
+require 'saringan/parser'
+
+module Saringan
+  module Operators
+    class Equal
+
+      OP_EQUAL = /::/
+
+      class << self
+        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 match?(term)
+          term =~ OP_EQUAL
+        end
+
+        def split(term)
+          splitted = term.split(OP_EQUAL)
+          { key: splitted[0], value: splitted[1] }
+        end
+
+        private
+
+          def parser
+            Saringan::Parser
+          end
+      end
+    end
+  end
+end

data/lib/saringan/operators.rb

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

data/lib/saringan/parser.rb

@@ -0,0 +1,28 @@
+require 'saringan/parsers'
+
+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)
+        value
+      end
+
+      def datetime_range_parser(value)
+        values  = date_time_range.to_h(value)
+        values[:from]..values[:to]
+      end
+
+      private
+
+        def range
+          Saringan::Parsers::Range
+        end
+
+        def date_time_range
+          Saringan::Parsers::DateTimeRange
+        end
+    end
+  end
+end

data/lib/saringan/parsers/date_time_range.rb

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

@@ -0,0 +1,7 @@
+module Saringan
+  module Parsers
+    class IntegerRange < Range
+      MATCHER = /^i\[(.+)\]$/
+    end
+  end
+end

data/lib/saringan/parsers/range.rb

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

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

data/lib/saringan/term.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+# -*- encoding: utf-8 -*-
+
+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)
+      end
+    end
+  end
+end

data/lib/saringan/translator.rb

@@ -0,0 +1,25 @@
+require 'saringan/operator'
+
+module Saringan
+  class Translator
+    class << self
+      def translate(query)
+        terms = term.split(query)
+        parsed = terms.map do |term|
+          operator.parse(term)
+        end
+        (parsed.size > 1) ? parsed : parsed.first
+      end
+
+      private
+
+        def term
+          Saringan::Term
+        end
+
+        def operator
+          Saringan::Operator
+        end
+    end
+  end
+end

data/lib/saringan/version.rb

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

data/lib/saringan.rb

@@ -0,0 +1,6 @@
+require "date"
+
+require "saringan/version"
+
+require "saringan/term"
+require "saringan/translator"

data/spec/operators/equal_spec.rb

@@ -0,0 +1,63 @@
+require 'support/spec_helper'
+
+describe Saringan::Operators::Equal do
+  describe '#match?' do
+    it 'should match equals operator' do
+      term = 'name::john'
+      expect(Saringan::Operators::Equal.match?(term)).to be_truthy
+    end
+
+    it 'should not match other operators' do
+      term = 'name:!:john'
+      expect(Saringan::Operators::Equal.match?(term)).to be_falsy
+    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 'splitted value' do
+      it 'should match term value' do
+        splitted = Saringan::Operators::Equal.split(term)
+        expect(splitted[:value]).to eq('john')
+      end
+    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')
+    end
+  end
+end

data/spec/parsers/date_time_range_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require 'support/spec_helper'
+
+describe Saringan::Parsers::DateTimeRange do
+  let(:parser) { Saringan::Parsers::DateTimeRange }
+  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) }
+
+  describe '#match?' do
+    it 'should match date time range value' do
+      value = 'dt[2018-06-01 00:00:00|2018-06-30 23:59:59]'
+      expect(parser.match?(value)).to be_truthy
+    end
+
+    it 'should not match non date time range value' do
+      value = 'i[1|5]'
+      expect(parser.match?(value)).to be_falsy
+    end
+  end
+
+  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')
+    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])
+    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
+end

data/spec/parsers/integer_range_spec.rb

@@ -0,0 +1,17 @@
+# require 'support/spec_helper'
+#
+# describe Saringan::Parsers::IntegerRange do
+#   let(:parser){ Saringan::Parsers::IntegerRange }
+#
+#   describe '#match?' do
+#     it 'should match range value' do
+#       value = 'i[1|3]'
+#       expect(parser.match?(value)).to be_truthy
+#     end
+#
+#     it 'should not match non integer range value' do
+#       value = '[1|3]'
+#       expect(parser.match?(value)).to be_falsy
+#     end
+#   end
+# end

data/spec/parsers/range_spec.rb

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

data/spec/saringan_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Saringan do
+  it "has a version number" do
+    expect(Saringan::VERSION).not_to be nil
+  end
+end

data/spec/support/spec_helper.rb

@@ -0,0 +1,6 @@
+require "saringan"
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.order = 'random'
+end

data/spec/terms_spec.rb

@@ -0,0 +1,16 @@
+require 'support/spec_helper'
+
+describe Saringan::Term do
+  let(:query) { 'name:name,age:18,gender:male' }
+
+  it 'should separate query terms' do
+    terms = Saringan::Term.split(query)
+    expect(terms.size).to eq(3)
+  end
+
+  it 'should match query terms' do
+    splited = %w(name:name age:18 gender:male)
+    terms = Saringan::Term.split(query)
+    expect(terms).to eq(splited)
+  end
+end

data/spec/translator_spec.rb

@@ -0,0 +1,28 @@
+require 'support/spec_helper'
+
+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)
+
+        expect(translator.translate(query)).to eq({ created_at: from..to })
+      end
+    end
+
+    context 'for absolute equal values' do
+      context 'and value is string' do
+        let(:query) { 'name::john' }
+
+        it 'translate query string to ruby hash' do
+          expect(translator.translate(query)).to eq({ name: 'john' })
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: saringan
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Reinaldo Olivera (k1ng)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry-meta
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+description: Simple way to send filter parameters to rails models.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/saringan.rb
+- lib/saringan/operator.rb
+- lib/saringan/operators.rb
+- lib/saringan/operators/equal.rb
+- lib/saringan/parser.rb
+- lib/saringan/parsers.rb
+- lib/saringan/parsers/date_time_range.rb
+- lib/saringan/parsers/integer_range.rb
+- lib/saringan/parsers/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/parsers/integer_range_spec.rb
+- spec/parsers/range_spec.rb
+- spec/saringan_spec.rb
+- spec/support/spec_helper.rb
+- spec/terms_spec.rb
+- spec/translator_spec.rb
+homepage: https://github.com/reinaldooli/saringan
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Simple way to send filter parameters to rails models.
+test_files:
+- 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/saringan_spec.rb