springy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 993710d7e496323dcfb22680fd7ed879e105c7b1
+  data.tar.gz: bcf3f7281b0cf7061251ab6ed4aec75bc67d4b9c
+SHA512:
+  metadata.gz: 9f1bc21a4846df0bbcd13738204e9500ab20115d67457b550bf9d9e9a3ee04c9b6e0d1cd794b6119d94f5e9386f45c77436e57765740973a11b9799dec3d8f36
+  data.tar.gz: 8233643b6d3d6aac589acee9e1e7ae1b717fba201252e534e3255f4f29e4930f613195d807e09dcfddba757a9b81dbca0f0573a09718c8f845054964225f2854

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-version

@@ -0,0 +1 @@
+2.4.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in springy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 eubelts
+
+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,39 @@
+# Springy
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/springy`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'springy'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install springy
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/springy/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,34 @@
+require "bundler/gem_tasks"
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+end
+
+$LOAD_PATH.unshift File.expand_path('lib', __FILE__)
+require 'springy'
+
+namespace :fixtures do
+  task :gen do
+    require 'json'
+
+    q = Springy.query(index: 'springy_test', type: 'game_dev')
+          .match(_all: 'game')
+          .where(url_slug: [
+            'masahiro-sakurai',
+            'tetsuya-mizuguchi',
+            'suda-51'
+          ])
+          .explain
+          .page(1, per_page: 20)
+
+      File.open('spec/fixtures/request_stub.json', 'w') do |f|
+      f.puts JSON.pretty_generate(q.request)
+    end
+
+    File.open('spec/fixtures/response_stub.json', 'w') do |f|
+      f.puts JSON.pretty_generate(q.response)
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "springy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# 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 "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/springy/and_collector.rb

@@ -0,0 +1,102 @@
+module Springy
+  class AndCollector
+
+    extend Forwardable
+    delegate [:json, :as_json] => :node
+    delegate [:each] => :nodes
+    include Enumerable
+
+    attr_reader :nodes, :context
+
+    def initialize(nodes, context = {})
+      @nodes    = nodes
+      @context  = context
+    end
+
+    def with_context(new_context)
+      self.class.new nodes, new_context
+    end
+
+    def context?(*args)
+      args.all? {|c| !!context[c] }
+    end
+
+    def node
+      @node ||= if function_score_node?
+        function_score_node
+      elsif query_nodes.any?
+        query_node
+      else
+        Node.new({match_all: {}}, context)
+      end
+    end
+
+    def query_nodes
+      @query_nodes ||= nodes.reject {|n| n.context? :boost }
+    end
+
+    def boost_nodes
+      @boost_nodes ||= nodes.select {|n| n.context? :boost }
+    end
+
+    def function_score_node?
+      boost_nodes.reject { |n| n.empty? }.any?
+    end
+
+    private
+
+      def query_node
+        if query_nodes.size > 1 || multicontext?(query_nodes)
+          compile_bool query_nodes
+        else
+          query_nodes.first
+        end
+      end
+
+      def multicontext?(node_arr)
+        Array(node_arr).any? {|n| n.context?(:must_not) || n.context?(:should) }
+      end
+
+      def compile_bool(bool_nodes)
+        split_nodes = split_nodes_for_bool(bool_nodes)
+        refined = bool_ctx.each_with_object(split_nodes) do |k, hash|
+          hash[k] = Array(compile_bool(hash[k])) if multicontext? hash[k]
+        end
+        bool_json = Hash[refined.map{|k,v| [k, v.map(&:as_json)] }]
+        Node.new(bool: bool_json)
+      end
+
+      def bool_ctx
+        [:filter, :must_not, :should]
+      end
+
+      def split_nodes_for_bool(bool_nodes)
+        bool_nodes.each_with_object({}) do |n, hash|
+          key = bool_ctx.find{|c| n.context? c } || :must
+          hash[key] ||= []
+          hash[key] << Node.new(n.json, n.context.merge(key => nil))
+        end
+      end
+
+      def compile_boost_functions
+        boost_nodes.map do |n|
+          next if n.empty?
+          n.json
+        end.compact
+      end
+
+      def compile_function_score_options
+        boost_nodes.reduce({}) do |options, node|
+          options.merge(node.context[:fn_score] || {})
+        end
+      end
+
+      def function_score_node
+        function_score_json = compile_function_score_options
+        function_score_json[:functions] = compile_boost_functions
+        function_score_json[:query] = query_node.json if query_nodes.any?
+
+        Node.new({function_score: function_score_json}, context)
+      end
+  end
+end

data/lib/springy/api.rb

@@ -0,0 +1,237 @@
+require 'springy/utils'
+
+module Springy
+  class API
+    DEFAULT_BOOST     = 2.0
+    DEFAULT_PER_PAGE  = 10
+
+    extend  Forwardable
+    include Enumerable
+    include Utils::Methods
+
+    attr_reader :collector, :opts, :root, :body, :context
+
+    delegate [:with_context, :json, :as_json] => :collector
+
+    delegate [
+      :total, :total_count, :length, :size, :total_pages, :results, :hits,
+      :to_a, :ids, :scores, :explanations, :aggregations, :each
+    ] => :results_obj
+
+    def initialize(opts = {})
+      @opts       = opts
+      @collector  = AndCollector.new(opts[:nodes] || [], query: true)
+      @root       = opts[:root]     || {}
+      @body       = opts[:body]     || {}
+      @context    = opts[:context]  || {}
+    end
+
+    # def context?(*args)
+    #   (args - context.keys).empty?
+    # end
+    #
+    def limit(size = nil)
+      return @root[:size] || DEFAULT_PER_PAGE unless size
+      add_root size: size.to_i
+    end
+    alias :limit_value :limit
+
+    def offset(from = nil)
+      return @root[:from] || 0 unless from
+      add_root from: from.to_i
+    end
+
+    # page 1 = from: 0, size: per_page
+    # page 2 = from: per_page, size: per_page
+    def page(num = nil, params = {})
+      return current_page if num.nil?
+      per   = params[:limit] || params[:per_page] || limit
+      per   = per.to_i > 0 ? per.to_i : 1
+      start = [num.to_i - 1, 0].max
+      add_root from: start * per, size: per
+    end
+
+    def per(num = nil)
+      return limit if num.nil?
+      add_root size: [num.to_i, 1].max
+    end
+    alias :per_page :per
+
+    def current_page
+      Utils.current_page(offset, limit)
+    end
+
+    def explain
+      add_root explain: true
+    end
+
+    def fields(*list)
+      add_root _source: list
+    end
+
+    alias :source :fields
+
+    def aggs(params = {})
+      add_body aggs: params
+    end
+
+    def highlight(params = {})
+      add_body highlight: params
+    end
+
+    def where(params = {})
+      subcontext = {filter: true}
+      subcontext[:nested] = params.delete(:nested) if params[:nested]
+      add_params params, subcontext, :context_nodes
+    end
+
+    def match(params = {})
+      if params.is_a? Hash
+        subcontext = {query: true}
+        subcontext[:nested] = true if params.delete(:nested)
+        add_params params, subcontext, :context_nodes
+      else
+        add_params Hash[_all: params], :query, :context_nodes
+      end
+    end
+
+    def more_like(params = {})
+      params[:ids] = Array(params[:ids]) if params[:ids]
+      add_params params, :query, :more_like_node
+    end
+
+    def fulltext(params = '')
+      unless params.is_a?(String)
+        raise Errors::InvalidParamsError.new('.fulltext only takes a string')
+      end
+      add_nodes Factory.fulltext_nodes_from_string(params, context)
+    end
+
+    def query(params = {})
+      add_params params, :query, :raw_node
+    end
+
+    def filter(params = {})
+      add_params params, :filter, :raw_node
+    end
+
+    def should(params = {})
+      add_params params, :should, :context_nodes
+    end
+
+    def not(params = {})
+      add_params params, :must_not, :context_nodes
+    end
+
+    def range(params = {})
+      add_params params, nil, :range_node
+    end
+
+    def geo_distance(params = {})
+      add_params params, nil, :geo_distance_node
+    end
+
+    def boost(params = {}, options = {})
+      return add_context(:boost) if Utils.is_empty? params
+
+      subcontext = context.merge(boost: true)
+      if params.is_a? self.class
+        boost_json = options.merge(filter: params.json)
+        add_nodes Node.new(boost_json, subcontext)
+      else
+        add_nodes Factory.raw_boost_node(params, subcontext)
+      end
+    end
+
+    def field_value(params = {})
+      add_params params, :boost, :field_value_function_node
+    end
+
+    def random(params)
+      if params.is_a? Hash
+        add_params params, :boost, :random_score_function_node
+      else
+        add_params Hash[seed: params], :boost, :random_score_function_node
+      end
+    end
+
+    def near(params = {})
+      add_params params, :boost, :decay_function_node
+    end
+
+    def request
+      @request ||= begin
+        root.merge(body: body.merge(query: collector.as_json))
+      end
+    end
+
+    def response
+      @response ||= Springy.search(request)
+    end
+
+    def results_obj
+      @results ||= Results.new request, response
+    end
+    #
+    # def count
+    #   results_obj.ids.count
+    # end
+
+    private
+
+      def args_to_context(*args)
+        args.reduce({}) do |ctx, item|
+          next ctx if item.nil?
+          item.is_a?(Hash) ? ctx.merge(item) : ctx.merge({item => true})
+        end
+      end
+
+      def add_params(params = {}, new_context, factory_method)
+        return add_context(new_context) if is_empty?(params)
+        subcontext = context.merge(args_to_context(new_context))
+
+        if params.is_a? self.class
+          add_nodes params.with_context(subcontext)
+        else
+          add_nodes Factory.send(factory_method, params, subcontext)
+        end
+      end
+
+      def add_nodes(additional)
+        self.class.new(opts.merge(
+          nodes: collector.nodes + Array(additional),
+          root:  root,
+          body:  body,
+          context: {}
+        ))
+      end
+
+      def add_root(options = {})
+        self.class.new(opts.merge(
+          nodes:    collector.nodes,
+          root:     root.merge(options),
+          body:     body,
+          context:  context
+        ))
+      end
+
+      def add_body(options = {})
+        self.class.new(opts.merge(
+          nodes:    collector.nodes,
+          root:     root,
+          body:     body.merge(options),
+          context:  context
+        ))
+      end
+
+      def add_context(*args)
+        self.class.new(opts.merge(
+          nodes:   collector.nodes,
+          root:    root,
+          body:    body,
+          context: context.merge(args_to_context(*args))
+        ))
+      end
+
+  end
+end

data/lib/springy/errors.rb

@@ -0,0 +1,6 @@
+module Springy
+  module Errors
+    class InvalidParamsError < StandardError; end
+    class IndexDoesNotExistError < StandardError ; end
+  end
+end

data/lib/springy/factory.rb

@@ -0,0 +1,197 @@
+module Springy
+  module Factory
+
+    DEFAULT_WEIGHT  = 1.5
+    DEFAULT_SLOP    = 50
+    BOOST_OPTIONS   = [
+      :filter,
+      :function,
+      :weight
+    ]
+    FUNCTION_SCORE_OPTIONS = [
+      :boost,
+      :max_boost,
+      :score_mode,
+      :boost_mode,
+      :min_score
+    ]
+
+    module_function
+
+    def default_context
+      {}
+    end
+
+    def extract_boost_params!(params)
+      Utils.extract_options!(params, BOOST_OPTIONS)
+    end
+
+    def extract_function_score_options!(params)
+      Utils.extract_options!(params, FUNCTION_SCORE_OPTIONS)
+    end
+
+    def dotify_params(params, context)
+      if context[:nested]
+        Utils.nestify(params)
+      else
+        Utils.dotify(params)
+      end
+    end
+
+    def raw_node(params, context)
+      if context[:boost]
+        raw_boost_node(params, context)
+      else
+        Node.new(params, context)
+      end
+    end
+
+    def raw_boost_node(params, context)
+      boost_params       = extract_boost_params!(params)
+      context[:fn_score] = extract_function_score_options!(params)
+      context[:boost]    = true
+      context[:filter]   = true
+      boost_params.merge!(filter: params) unless Utils.is_empty? params
+      Node.new(boost_params, context)
+    end
+
+    def context_nodes(params, context = default_context)
+      if context[:boost]
+        params_to_boost(params, context)
+      elsif context[:filter] && !context[:query]
+        params_to_filters(dotify_params(params, context), context)
+      else
+        params_to_queries(dotify_params(params, context), context)
+      end
+    end
+
+    def params_to_boost(params, context = default_context)
+      boost_params        = extract_boost_params!(params)
+      context[:fn_score]  = extract_function_score_options!(params)
+      subcontext          = context.merge(boost: nil)
+      nodes               = context_nodes(params, subcontext)
+      collector           = AndCollector.new(nodes, subcontext)
+
+      boost_params.merge!(filter: collector.json) if collector.any?
+      if boost_params.count == 1 && boost_params.key?(:filter)
+        boost_params[:weight] = DEFAULT_WEIGHT
+      end
+
+      Node.new(boost_params, context)
+    end
+
+    def params_to_queries(params, context = default_context)
+      params.map do |field, val|
+        case val
+        when Array
+          Node.new({match: {
+            field => {query: val.join(' '), :operator => :or}
+          }}, context)
+        when Range
+          Node.new({range: {
+            field => {gte: val.min, lte: val.max}
+          }}, context)
+        when Hash
+          nested(val, field, context)
+        else
+          Node.new({match: {field => val}}, context)
+        end
+      end
+    end
+
+    def params_to_filters(params, context = default_context)
+      params.map do |field, val|
+        case val
+        when Range
+          Node.new({range: {field => {gte: val.min, lte: val.max}}}, context)
+        when nil
+          nil_ctx = context.merge(must_not: true)
+          Node.new({exists: {field: field}}, nil_ctx)
+        when Hash
+          nested(val, field, context)
+        else
+          Node.new({terms: {field => Array(val)}}, context)
+        end
+      end
+    end
+
+    def nested(params, path, context = default_context)
+      nodes = if context[:filter] && !context[:query]
+        params_to_filters(params, context)
+      else
+        params_to_queries(params, context)
+      end
+      json  = AndCollector.new(nodes, context).json
+
+      Node.new({nested: {
+        path:   path,
+        query:  json
+      }}, context)
+    end
+
+    # https://www.elastic.co/guide/en/elasticsearch/guide/current/proximity-relevance.html
+    def fulltext_nodes_from_string(params, context = default_context)
+      subcontext = context.merge(query: true)
+      nodes = [raw_node({
+        match: {
+          _all: {
+            query: params,
+            minimum_should_match: 1
+          }
+        }
+      }, subcontext)]
+
+      subcontext = subcontext.merge(should: true)
+      nodes << Factory.raw_node({
+        match_phrase: {
+          _all: {
+            query: params,
+            slop:  DEFAULT_SLOP
+          }
+        }
+      }, subcontext)
+
+      nodes
+    end
+
+    # https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-mlt-query.html
+    def more_like_node(params = {}, context = default_context)
+      Node.new({more_like_this: params}, context)
+    end
+
+    # query and filter use the same syntax
+    # https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-range-query.html
+    # https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-range-filter.html
+    def range_node(params = {}, context = default_context)
+      Node.new({range: params}, context)
+    end
+
+    # https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-geo-distance-filter.html
+    def geo_distance_node(params = {}, context = default_context)
+      Node.new({geo_distance: params}, context)
+    end
+
+    # https://www.elastic.co/guide/en/elasticsearch/reference/current/querydslfunctionscorequery.html#functionfieldvaluefactor
+    def field_value_function_node(params = {}, context = default_context)
+      context[:fn_score] = extract_function_score_options!(params)
+      boost_params       = extract_boost_params!(params)
+      Node.new(boost_params.merge(field_value_factor: params), context)
+    end
+
+    # https://www.elastic.co/guide/en/elasticsearch/reference/current/querydslfunctionscorequery.html#functionrandom
+    def random_score_function_node(params, context = default_context)
+      json          = {random_score: {seed: params[:seed]}}
+      json[:weight] = params[:weight] if params[:weight]
+      Node.new(json, context)
+    end
+
+    # https://www.elastic.co/guide/en/elasticsearch/reference/current/querydslfunctionscorequery.html#functiondecay
+    def decay_function_node(params = {}, context = default_context)
+      boost_params        = extract_boost_params!(params)
+      context[:fn_score]  = extract_function_score_options!(params)
+      decay_fn            = params.delete(:decay_function)
+      field               = params.delete(:field)
+      Node.new({decay_fn => { field => params}}.merge(boost_params), context)
+    end
+  end
+end

data/lib/springy/node.rb

@@ -0,0 +1,21 @@
+module Springy
+  class Node
+
+    attr_reader :json, :context
+    alias :as_json :json
+
+    def initialize(json, context = {})
+      @json    = json
+      @context = context
+    end
+
+    def empty?
+      !@json.any?
+    end
+
+    def context?(*args)
+      args.all? {|c| !!context[c] }
+    end
+
+  end
+end

data/lib/springy/results.rb

@@ -0,0 +1,103 @@
+module Springy
+  class Results
+
+    extend  Forwardable
+    include Enumerable
+    include Utils::Methods
+    delegate [:first, :last, :each] => :results
+
+    attr_reader :request, :response
+
+    # implements null object pattern
+    def self.fake
+      self.new(
+        {size: API::DEFAULT_PER_PAGE, fake: true},
+        {'hits' => {'total' => 0, 'hits' => [], 'aggregations' => {}}}
+      )
+    end
+
+    def initialize(request, response)
+      @request  = request
+      @response = response
+    end
+
+    def fake?
+      !!request[:fake]
+    end
+
+    def limit
+      (request['size'] || request[:size] || API::DEFAULT_PER_PAGE).to_i
+    end
+
+    alias :size         :limit
+    alias :limit_value  :limit
+    alias :per_page     :limit
+
+    def offset
+      (request['from'] || request[:from] || 0).to_i
+    end
+    alias :from         :offset
+    alias :offset_value :offset
+
+    def current_page
+      Utils.current_page(offset, limit)
+    end
+
+    def total
+      response['hits']['total']
+    end
+    alias :total_count  :total
+    alias :count        :total
+    alias :length       :total
+    alias :size         :total
+
+    def total_pages
+      (total.to_f / limit_value).ceil
+    end
+
+    def results
+      @results ||= response['hits']['hits'].map do |r|
+        fields        = r.reject {|k, _| k == '_source' || k == 'fields'}
+        fields['_id'] = coerce_id(fields['_id']) if fields['_id']
+        source        = r['_source'] || {}
+
+        # Elasticsearch always returns array values when specific
+        # fields are selected. Undesirable for single values, so
+        # coerce to single values when appropriate
+        selected      = r['fields']  || {}
+        selected      = Hash[selected.map do |k,v|
+          v.is_a?(Array) && v.count == 1 ? [k,v.first] : [k,v]
+        end]
+
+        source.merge(selected).merge(fields)
+      end
+    end
+
+    alias :hits :results
+    alias :to_a :results
+
+    def ids
+      @ids ||= response['hits']['hits'].map {|r| coerce_id r['_id'] }
+    end
+
+    def scores
+      @scores ||= Hash[results.map {|r| [coerce_id(r['_id']), r['_score']]}]
+    end
+
+    def explanations
+      @explanations ||= Hash[results.map {|r|
+        [coerce_id(r['_id']), r['_explanation']]
+      }]
+    end
+
+    def aggregations(*args)
+      key = args.map(&:to_s).join('.')
+      @aggregations ||= {}
+      @aggregations[key] ||= begin
+        args.reduce(response['aggregations']) do |agg, name|
+          agg = agg[name.to_s] unless agg.nil?
+        end
+      end
+    end
+  end
+end

data/lib/springy/scopes.rb

@@ -0,0 +1,30 @@
+module Springy
+  module Scopes
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def stretchify(options = {})
+        @stretchy_options = options
+      end
+
+      def search(options = {})
+        stretchy_scope.new stretchy_options.merge(options)
+      end
+
+      def stretchy_options
+        Hash(@stretchy_options)
+      end
+
+      def stretchy_scope
+        @scopes_class ||= Class.new Springy::API
+      end
+
+      def stretch(name, block)
+        stretchy_scope.send(:define_method, name, &block)
+      end
+    end
+  end
+end

data/lib/springy/utils.rb

@@ -0,0 +1,76 @@
+module Springy
+  module Utils
+    module Methods
+
+      # detects empty string, empty array, empty hash, nil
+      def is_empty?(arg = nil)
+        return true if arg.nil?
+        if arg.respond_to?(:collector)
+          !arg.collector.any?
+        elsif arg.respond_to?(:any?)
+          !arg.any? {|a| !is_empty?(a) }
+        elsif arg.respond_to?(:empty?)
+          arg.empty?
+        else
+          !arg
+        end
+      end
+
+      # raises error if required parameters are missing
+      def require_params!(method, params, *fields)
+        raise Errors::InvalidParamsError.new(
+          "#{method} requires at least #{fields.join(' and ')} params, but " +
+          "found: #{params}"
+        ) if fields.any? {|f| is_empty? params[f] }
+
+        true
+      end
+
+      # generates a hash of specified options,
+      # removing them from the original hash
+      def extract_options!(params, list)
+        output = Hash[list.map do |opt|
+          [opt, params.delete(opt)]
+        end].keep_if {|k,v| !is_empty?(v)}
+      end
+
+      # must be shared between api & results
+      def current_page(offset, limit)
+        ((offset + 1.0) / limit).ceil
+      end
+
+      # coerces ids to integers, unless they contain non-integers
+      def coerce_id(id)
+        id =~ /^\d+$/ ? id.to_i : id
+      end
+
+      def dotify(hash, prefixes = [])
+        hash.reduce({}) do |memo, kv|
+          key, val    = kv
+          subprefixes = (prefixes + [key])
+          prefix      = subprefixes.join('.')
+          if val.is_a? Hash
+            memo.merge(dotify(val, subprefixes))
+          else
+            memo.merge(prefix => val)
+          end
+        end
+      end
+
+      def nestify(hash, prefixes = [])
+        hash.reduce({}) do |memo, kv|
+          key, val = kv
+          subprefixes = (prefixes + [key])
+          prefix = subprefixes.join('.')
+          if val.is_a? Hash
+            memo.merge(prefix => nestify(val, subprefixes))
+          else
+            memo.merge(prefix => val)
+          end
+        end
+      end
+    end
+
+    extend Methods
+  end
+end

data/lib/springy/version.rb

@@ -0,0 +1,3 @@
+module Springy
+  VERSION = "0.1.0"
+end

data/lib/springy.rb

@@ -0,0 +1,70 @@
+require 'json'
+require 'logger'
+require 'forwardable'
+require 'elasticsearch'
+
+require "springy/version"
+require 'springy/api'
+require 'springy/utils'
+require 'springy/and_collector'
+require 'springy/factory'
+require 'springy/node'
+require 'springy/results'
+require 'springy/scopes'
+require 'springy/errors'
+
+module Springy
+
+  module_function
+
+  def client
+    @client ||= Elasticsearch::Client.new
+  end
+
+  def client=(client)
+    @client = client
+  end
+
+  def search(options = {})
+    client.search(options)
+  rescue Elasticsearch::Transport::Transport::Errors::BadRequest => bre
+    msg = bre.message[-150..-1]
+    msg << "\n\n"
+    msg << JSON.pretty_generate(options)
+    raise msg
+  end
+
+  def index_exists?(name)
+    client.indices.exists? index: name
+  end
+
+  def delete_index(name)
+    client.indices.delete(index: name) if index_exists? name
+  end
+
+  def create_index(name, params = {})
+    client.indices.create({index: name}.merge(params)) unless index_exists? name
+  end
+
+  def refresh_index(name, params = {})
+    client.indices.refresh({index: name}.merge(params)) if index_exists? name
+  end
+
+  def count_index(name, params = {})
+    client.count({index: name}.merge(params))['count']
+  end
+
+  def index_document(params = {})
+    Utils.require_params!(:index_document, params, :index, :type, :body)
+
+    raise IndexDoesNotExistError.new(
+      "index #{params[:index]} does not exist"
+    ) unless index_exists? params[:index]
+
+    client.index(params)
+  end
+
+  def query(options = {})
+    API.new(root: options)
+  end
+end

data/springy.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'springy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "springy"
+  spec.version       = Springy::VERSION
+  spec.authors       = ["eubelts"]
+  spec.email         = ["eunicesausbeltran@yahoo.com"]
+
+  spec.summary       = %q{Query builder for Elasticsearch}
+  spec.description   = %q{ActiveRecord-like query builder for Elasticsearch}
+  # spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "elasticsearch",  "~> 5.0"
+
+  spec.add_development_dependency "rspec",          "~> 3.2"
+  spec.add_development_dependency "fuubar",         "~> 2.0"
+  spec.add_development_dependency "pry",            "~> 0.10"
+  spec.add_development_dependency "awesome_print",  "~> 1.6"
+  spec.add_development_dependency "yard",           "~> 0.9"
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: springy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- eubelts
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: elasticsearch
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: ActiveRecord-like query builder for Elasticsearch
+email:
+- eunicesausbeltran@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/springy.rb
+- lib/springy/and_collector.rb
+- lib/springy/api.rb
+- lib/springy/errors.rb
+- lib/springy/factory.rb
+- lib/springy/node.rb
+- lib/springy/results.rb
+- lib/springy/scopes.rb
+- lib/springy/utils.rb
+- lib/springy/version.rb
+- springy.gemspec
+homepage: 
+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.6.13
+signing_key: 
+specification_version: 4
+summary: Query builder for Elasticsearch
+test_files: []