gum 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b429a022f13c73d2ce6631b8a2d2a316fb957480
-  data.tar.gz: e847b27a7c0b6ebe38f39a6c3db87f964ff33c1a
+  metadata.gz: e525c89a73abcb7ad8ea62b1526809239ee85262
+  data.tar.gz: b8518e7f610131e0de9738cb78dc8761788d7fc6
 SHA512:
-  metadata.gz: 8183f45450f9fd2469dc55bae5a35b305e529d667e53775813788dcd48816f3f83d8a70ec00da791ca3833fa285ef5068d83c484069a35a50dc1b69d363da31e
-  data.tar.gz: a2a03eb5d49e4b85923f1e2a61eda74c224d1c1cfa5ec2ed4550846aedfc636a8a311fe17d347705aa3ae1509cf9e2b129926dac700c166a57312887626ad564
+  metadata.gz: 1875400f0fb7eafd0f5aabc1952cc4df34dd26cd7f138b887c6fdc68e3266fd91f392f986d56711f3bf771a3b740d746de575375cc36ff27774ea2272d119ddb
+  data.tar.gz: 952bf47456985f1e8845f08b8def61ca72515186590fee02f2e302b011d74a4401287f07519efe839ba889a3392f6a92bc3f613ce10f50c61312b3f8a52bf426

data/bin/console

@@ -7,8 +7,8 @@ require 'gum'
 # with your gem easier. You can also use a different console, if you like.
 
 # (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
+require 'pry'
+Pry.start
 
-require 'irb'
-IRB.start
+# require 'irb'
+# IRB.start

data/gum.gemspec

@@ -32,6 +32,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.13'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_dependency 'activesupport', '>= 3.2'
+  spec.add_development_dependency 'pry-byebug', '~> 3.4'
+  spec.add_development_dependency 'simplecov', '~> 0'
+  spec.add_dependency 'activesupport', '>=3.2', '<5.1'
   spec.add_dependency 'chewy', '~> 0.8.4'
 end

data/lib/gum.rb

@@ -3,8 +3,10 @@ require 'gum/version'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/hash/compact'
+require 'active_support/core_ext/object/try'
+require 'active_support/inflector'
 
-require 'gum/coerce'
+require 'gum/filter'
 require 'gum/filters'
 require 'gum/search'
 

data/lib/gum/factory.rb

@@ -0,0 +1,33 @@
+module Gum
+  class Factory
+    def self.build(type, args)
+      mapping = args_to_mapping(args)
+      options = mapping.delete(:options)
+      mapping.each do |param, field|
+        yield new(type, param, field, options)
+      end
+    end
+
+    def self.args_to_mapping(args)
+      args.inject({}) do |mapping, arg|
+        mapping.update normalize_mapping(arg)
+      end
+    end
+
+    def self.normalize_mapping(mapping)
+      case mapping
+        when Hash
+          mapping
+        when Array
+          mapping.zip(mapping).to_h
+        else
+          { mapping => mapping }
+      end
+    end
+
+    def self.new(type, param, field, options)
+      filter = type.is_a?(Class) ? type : Filters.const_get(type.to_s.camelize, false)
+      filter.new param, field, options
+    end
+  end
+end

data/lib/gum/filter.rb

@@ -0,0 +1,28 @@
+module Gum
+  class Filter
+    attr_reader :param, :field, :options
+
+    def initialize(param, field, options)
+      @param = param
+      @field = field
+      @options = options || {}
+    end
+
+    def render(params)
+      return if empty?(params)
+      __render__ value_from(params)
+    end
+
+    def value_from(params)
+      params[param].presence
+    end
+
+    def empty?(params)
+      params[param].blank?
+    end
+
+    def __render__(value)
+      raise NoMethodError
+    end
+  end
+end

data/lib/gum/filters.rb

@@ -1,91 +1,35 @@
+require 'gum/factory'
+require 'gum/filter'
+require 'gum/filters/term'
+require 'gum/filters/terms'
+require 'gum/filters/exists'
+require 'gum/filters/prefix'
+require 'gum/filters/wildcard'
+require 'gum/filters/regexp'
+require 'gum/filters/fuzzy'
+require 'gum/filters/range'
+require 'gum/filters/geo'
+require 'gum/filters/geo/bbox'
+require 'gum/filters/geo/distance'
+require 'gum/filters/geo/range'
+require 'gum/order'
+
 module Gum
   module Filters
-    module_function
-
-    def range(attr, flags = {})
-      lambda do |params|
-        attr_from = params["#{attr}_from"]
-        attr_to = params["#{attr}_to"]
-        return if attr_from.blank? && attr_to.blank?
-        Coerce.range(attr, params) do |value|
-          { range: { attr => value.update(flags) } }
-        end
-      end
-    end
-
-    def term(attr, flags = {})
-      lambda do |params|
-        Coerce.term(attr, params) do |value|
-          if flags[:boost]
-            { term: { attr => { value: value, boost: flags[:boost] } } }
-          else
-            { term: { attr => value }.update(flags) }
-          end
-        end
-      end
-    end
-
-    def terms(attr, _flags = {})
-      lambda do |params|
-        Coerce.terms(attr, params) do |value|
-          { terms: { attr => value } }
-        end
-      end
-    end
-
-    def exists(attr, _flags = {})
-      lambda do |params|
-        Coerce.exists(attr, params) do |value|
-          if value
-            { exists: { field: attr } }
-          else
-            { bool: { must_not: { exists: { field: attr } } } }
-          end
+    def self.register(method, klass = nil)
+      define_method method do |*args|
+        Factory.build(klass || method, args) do |filter|
+          filters.push filter
         end
       end
     end
 
-    def prefix(attr, flags = {})
-      lambda do |params|
-        Coerce.term(attr, params) do |value|
-          { prefix: { attr => value }.update(flags) }
-        end
-      end
-    end
-
-    def wildcard(attr, flags = {})
-      lambda do |params|
-        Coerce.term(attr, params) do |value|
-          { wildcard: { attr => value }.update(flags) }
-        end
-      end
-    end
-
-    def regexp(attr, flags = {})
-      lambda do |params|
-        Coerce.term(attr, params) do |value|
-          { regexp: flags.update(attr => value) }
-        end
-      end
-    end
-
-    def fuzzy(attr, separator: '_', **flags)
-      lambda do |params|
-        Coerce.split(attr, params, separator: separator, default: flags[:fuzziness]) do |value, fuzziness|
-          { fuzzy: { attr => { value: value, fuzziness: fuzziness }.update(flags) } }
-        end
-      end
+    def self.define_filter(method, &block)
+      register method, Class.new(Gum::Filter, &block)
     end
 
-    def default_range_result(attr_from, attr_to)
-      {
-        range: {
-          attr => {
-            gte: attr_from,
-            lte: attr_to
-          }
-        }
-      }
+    %i(term terms prefix wildcard regexp fuzzy exists geo range).each do |method|
+      register method
     end
   end
 end

data/lib/gum/filters/exists.rb

@@ -0,0 +1,25 @@
+module Gum
+  module Filters
+    class Exists < Filter
+      private
+
+      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
+
+      def __render__(value)
+        if value
+          { exists: { field: field } }
+        else
+          { bool: { must_not: { exists: { field: field } } } }
+        end
+      end
+
+      def value_from(params)
+        !FALSE_VALUES.include?(super)
+      end
+
+      def empty?(value)
+        value.nil? || value.try(:empty?)
+      end
+    end
+  end
+end

data/lib/gum/filters/fuzzy.rb

@@ -0,0 +1,11 @@
+module Gum
+  module Filters
+    class Fuzzy < Filter
+      private
+
+      def __render__(value)
+        { fuzzy: { field => { value: value }.merge(options) } }
+      end
+    end
+  end
+end

data/lib/gum/filters/geo.rb

@@ -0,0 +1,10 @@
+module Gum
+  module Filters
+    class Geo
+      def self.new(param, field, options)
+        filter = const_get options.delete(:type).to_s.camelize
+        filter.new param, field, options
+      end
+    end
+  end
+end

data/lib/gum/filters/geo/bbox.rb

@@ -0,0 +1,70 @@
+module Gum
+  module Filters
+    class Geo
+      class Bbox < Filter
+        private
+
+        def __render__(value)
+          {
+            geo_bounding_box: {
+              field => {
+                top: value.top,
+                left: value.left,
+                bottom: value.bottom,
+                right: value.right
+              }
+            }
+          }
+        end
+
+        def parser
+          @_parser ||= ParamParser.new(options[:pattern])
+        end
+
+        def value_from(params)
+          parser.parse(super)
+        end
+
+        def empty?(params)
+          super || parser.empty?(params[param])
+        end
+
+        class ParamParser
+          attr_reader :top, :left, :bottom, :right
+
+          def initialize(order)
+            @order = order || 'top,left,bottom,right'
+            @regexp = regexp
+          end
+
+          def empty?(value)
+            !@regexp.match(value)
+          end
+
+          def parse(value)
+            match_data = @regexp.match(value)
+            return unless match_data
+            @top = match_data[:top].to_f
+            @left = match_data[:left].to_f
+            @bottom = match_data[:bottom].to_f
+            @right = match_data[:right].to_f
+            self
+          end
+
+          private
+
+          def number_pattern
+            '-?\\d{,3}\\.?\\d{,12}'
+          end
+
+          def regexp
+            order = @order.split(',').map do |param|
+              "(?<#{param}>#{number_pattern})"
+            end.join(',')
+            /^#{order}$/
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gum/filters/geo/distance.rb

@@ -0,0 +1,26 @@
+module Gum
+  module Filters
+    class Geo
+      class Distance < Filter
+        private
+
+        def __render__(value)
+          {
+            geo_distance: {
+              distance: value[:distance],
+              field => value[:lat_lon]
+            }
+          }
+        end
+
+        def value_from(params)
+          return nil unless params[:"#{param}"].present? && params[:"#{param}_distance"].present?
+          {
+            distance: params[:"#{param}_distance"],
+            lat_lon: params[:"#{param}"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/gum/filters/geo/range.rb

@@ -0,0 +1,33 @@
+module Gum
+  module Filters
+    class Geo
+      class Range < Filter
+        private
+
+        def __render__(value)
+          {
+            geo_distance_range: {
+              from: value[:from],
+              to: value[:to],
+              field => value[:lat_lon]
+            }
+          }
+        end
+
+        def value_from(params)
+          {
+            from: params[:"#{param}_from"],
+            to: params[:"#{param}_to"],
+            lat_lon: params[:"#{param}"]
+          }
+        end
+
+        def empty?(params)
+          params[:"#{param}"].blank? ||
+            params[:"#{param}_from"].blank? ||
+            params[:"#{param}_to"].blank?
+        end
+      end
+    end
+  end
+end

data/lib/gum/filters/prefix.rb

@@ -0,0 +1,15 @@
+module Gum
+  module Filters
+    class Prefix < Filter
+      private
+
+      def __render__(value)
+        if options[:boost]
+          { prefix: { field => { value: value, boost: options[:boost] } } }
+        else
+          { prefix: { field => value } }
+        end
+      end
+    end
+  end
+end

data/lib/gum/filters/range.rb

@@ -0,0 +1,22 @@
+module Gum
+  module Filters
+    class Range < Filter
+      private
+
+      def __render__(value)
+        { range: { field => value.update(options) } }
+      end
+
+      def value_from(params)
+        {
+          gte: params[:"#{param}_from"],
+          lte: params[:"#{param}_to"]
+        }
+      end
+
+      def empty?(params)
+        params[:"#{param}_from"].blank? || params[:"#{param}_to"].blank?
+      end
+    end
+  end
+end

data/lib/gum/filters/regexp.rb

@@ -0,0 +1,11 @@
+module Gum
+  module Filters
+    class Regexp < Filter
+      private
+
+      def __render__(value)
+        { regexp: { field => { value: value }.merge(options) } }
+      end
+    end
+  end
+end

data/lib/gum/filters/term.rb

@@ -0,0 +1,15 @@
+module Gum
+  module Filters
+    class Term < Filter
+      private
+
+      def __render__(value)
+        if options[:boost]
+          { term: { field => { value: value, boost: options[:boost] } } }
+        else
+          { term: { field => value } }
+        end
+      end
+    end
+  end
+end

data/lib/gum/filters/terms.rb

@@ -0,0 +1,11 @@
+module Gum
+  module Filters
+    class Terms < Filter
+      private
+
+      def __render__(value)
+        { terms: { field => [value].flatten } }
+      end
+    end
+  end
+end

data/lib/gum/filters/wildcard.rb

@@ -0,0 +1,15 @@
+module Gum
+  module Filters
+    class Wildcard < Filter
+      private
+
+      def __render__(value)
+        if options[:boost]
+          { wildcard: { field => { value: value, boost: options[:boost] } } }
+        else
+          { wildcard: { field => value } }
+        end
+      end
+    end
+  end
+end

data/lib/gum/order.rb

@@ -0,0 +1,18 @@
+module Gum
+  class OrderBy < Filter
+    ALLOWED_VALUES = %w(asc desc).freeze
+
+    def __render__(value)
+      { field => value }
+    end
+
+    def value_from(params)
+      value = super.to_s
+      ALLOWED_VALUES.include?(value) ? value : options[:default]
+    end
+
+    def empty?(params)
+      ALLOWED_VALUES.exclude?(params[param].to_s) && options[:default].nil?
+    end
+  end
+end

data/lib/gum/search.rb

@@ -1,5 +1,7 @@
 module Gum
   class Search
+    extend Filters
+
     class_attribute :type
     class_attribute :scope
     class_attribute :fields
@@ -7,14 +9,15 @@ module Gum
     class_attribute :orders
     class_attribute :query_param
 
-    def self.inherited(base)
-      self.fields = Set.new
-      self.filters = {}
-      self.orders = {}
+    def self.inherited(klass)
+      klass.fields = Set.new
+      klass.filters = []
+      klass.orders = []
     end
 
     # @param [Chewy::Type] type
     def self.use(type)
+      raise ArgumentError, 'type must be a Chewy::Type' unless type < Chewy::Type
       self.type = type
     end
 
@@ -23,64 +26,49 @@ module Gum
     end
 
     def self.searchable(*attrs)
-      self.fields += attrs
+      self.fields += attrs.flatten
     end
 
     def self.query(attr)
       self.query_param = attr
     end
 
-    Filters.singleton_methods.each do |method|
-      define_singleton_method method do |*attrs|
-        options = attrs.extract_options!
-        attrs.each do |attr|
-          filters[attr] = Filters.public_send(method, attr, options)
-        end
-      end
-    end
-
-    def self.order_by(*attrs)
-      attrs.each do |attr|
-        orders[attr] =
-          lambda do |params|
-            Coerce.split(attr, params) do |field, direction|
-              { field => direction }
-            end
-          end
+    def self.order_by(*args)
+      Factory.build(Gum::OrderBy, args) do |order|
+        orders.push order
       end
     end
 
     def initialize(params)
       @params = params
-      @sort_params = @params[:sort].split(',') if @params[:sort]
       @q = params[query_param]
     end
 
-    def compile_filters
-      filters.map do |_, proc|
-        proc.call(@params)
-      end.compact
-    end
-
-    def compile_orders
-      if @sort_params
-        self.orders = {}
-        @sort_params.each do |attr|
-          self.class.order_by(attr)
-        end
-      end
-      orders.map do |attr, proc|
-        proc.call(attr)
-      end.compact
+    def to_query
+      type.query(query).filter(compile_filters).order(compile_orders)
     end
 
     def search
-      type.query(query).filter(compile_filters).order(compile_orders).load(scope: scope)
+      to_query.load(scope: scope)
     rescue Elasticsearch::Transport::Transport::Errors::BadRequest => e
       @error = e.message.match(/QueryParsingException\[([^;]+)\]/).try(:[], 1)
       type.none
     end
 
+    private
+
+    def compile_filters
+      filters.map do |filter|
+        filter.render(@params)
+      end.compact
+    end
+
+    def compile_orders
+      orders.map do |order|
+        order.render(@params)
+      end.compact
+    end
+
     def query
       return {} unless @q.present?
       {

data/lib/gum/version.rb

@@ -1,3 +1,3 @@
 module Gum
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.2.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gum
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Anton Sozontov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-14 00:00:00.000000000 Z
+date: 2016-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -59,6 +87,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -66,6 +97,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: chewy
   requirement: !ruby/object:Gem::Requirement
@@ -98,8 +132,22 @@ files:
 - bin/setup
 - gum.gemspec
 - lib/gum.rb
-- lib/gum/coerce.rb
+- lib/gum/factory.rb
+- lib/gum/filter.rb
 - lib/gum/filters.rb
+- lib/gum/filters/exists.rb
+- lib/gum/filters/fuzzy.rb
+- lib/gum/filters/geo.rb
+- lib/gum/filters/geo/bbox.rb
+- lib/gum/filters/geo/distance.rb
+- lib/gum/filters/geo/range.rb
+- lib/gum/filters/prefix.rb
+- lib/gum/filters/range.rb
+- lib/gum/filters/regexp.rb
+- lib/gum/filters/term.rb
+- lib/gum/filters/terms.rb
+- lib/gum/filters/wildcard.rb
+- lib/gum/order.rb
 - lib/gum/search.rb
 - lib/gum/version.rb
 homepage: https://github.com/qwiqer/gum

data/lib/gum/coerce.rb

@@ -1,51 +0,0 @@
-module Gum
-  module Coerce
-    FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
-
-    module_function
-
-    def range(attr, params)
-      key_from = :"#{attr}_from"
-      key_to = :"#{attr}_to"
-
-      return unless params.values_at(key_from, key_to).all?
-
-      yield(gte: params[key_from], lte: params[key_to])
-    end
-
-    def term(attr, params)
-      return if params[attr].blank?
-
-      yield params[attr]
-    end
-
-    def terms(attr, params)
-      return if params[attr].blank?
-
-      if params[attr].is_a?(Array)
-        yield params[attr]
-      elsif params[attr].is_a?(String)
-        yield params[attr].split(',')
-      else
-        raise ArgumentError, 'Terms should be either Array or String'
-      end
-    end
-
-    def exists(attr, params)
-      return if params[attr].eql?('')
-
-      yield !FALSE_VALUES.include?(params[attr])
-    end
-
-    def split(attr, params, separator: '-', default: nil)
-      return if params[attr].blank?
-
-      value, option = params[attr].split(separator, 2)
-      option ||= default.presence
-
-      return if value.blank? || option.blank?
-
-      yield value, option
-    end
-  end
-end