lycra 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f6b763be6e3d625f7ce696812f062ea5cb4f872
-  data.tar.gz: 801867731e2be4d690668c6268358ce26369ae37
+  metadata.gz: 3ea417f626bf68c1e6f119212965332911aa6500
+  data.tar.gz: 66f08754c51707c08120be29fd4d9560d63683e3
 SHA512:
-  metadata.gz: 5cbb169b8c12801e70c6ef6bdf526b90c08044f08279862a08bf835deb31f347c76f041e81ebd138ac45f28842dc331ff39b4ada881bc553fd563ffccb5bf0c4
-  data.tar.gz: c640a28436b4039b3e01a611e9ba5c5ada95cb15d29a8510fd2a67f6545038f7c2abfcf63b7a5ea4171b137aaa9e197cc541e9be0869e7571f7892475023c694
+  metadata.gz: cd1f851885ead6d4fa92fded263ed0d15a8efb7ab1006a52b5b66396cba5accf9770e2bc70124bb834a539e55126dc5fa3c56f177c287a45f5a0be6960f9067a
+  data.tar.gz: d0decf59b1e7a67c5b18aab8dab21ac586a5aed6bd9e2dabd874b80723889c44d76af0db32fafb1ed4724a1d7c8a14efa43f479fd06633fd1e60d978c22daf3d

data/lib/lycra/engine.rb

@@ -0,0 +1,15 @@
+module Lycra
+  class Engine < ::Rails::Engine
+    isolate_namespace Lycra
+
+    initializer "lycra.configure_rails_logger" do
+      Lycra.configure do |config|
+        config.logger = Rails.logger
+      end
+    end
+
+    initializer "lycra.elasticsearch.client" do |app|
+      Elasticsearch::Model.client = Lycra.client
+    end
+  end
+end

data/lib/lycra/errors.rb

@@ -0,0 +1,53 @@
+module Lycra
+  class DocumentNotFoundError < StandardError
+    attr_reader :model
+
+    def initialize(model=nil)
+      @model = model
+
+      if model.nil? || model.name.nil?
+        msg = <<MSG
+You must define a corresponding document class for all models utilizing Lycra::Model. For example, if your model is called BlogPost:
+
+  # /app/documents/blog_post_document.rb
+  class BlogPostDocument < Lycra::Document
+    index_name 'blog-posts'
+  end
+MSG
+      else
+        msg = <<MSG
+You must define a corresponding document class for your #{model.name} model. For example:
+
+  # /app/documents/#{model.name.split('::').map { |n| n.underscore }.join('/')}_document.rb
+  class #{model.name}Document < Lycra::Document
+    index_name '#{model.name.parameterize.pluralize}'
+  end
+MSG
+      end
+
+      super(msg)
+    end
+  end
+
+  class UndefinedIndexError < StandardError
+    attr_reader :document
+
+    def initialize(document=nil)
+      @document = document
+
+      if document.nil?
+        super("You must define an index_name for your document class. Try: `index_name 'my-searchable-things'`")
+      else
+        super("You must define an index_name for your #{document.class.name}. Try: `index_name '#{subject_name.underscore.pluralize}'`")
+      end
+    end
+
+    def subject_name
+      if document.subject.is_a?(Class)
+        document.subject.name
+      else
+        document.subject.class.name
+      end
+    end
+  end
+end

data/lib/lycra/model.rb

@@ -0,0 +1,62 @@
+module Lycra
+  module Model
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, Elasticsearch::Model
+      base.send :include, Elasticsearch::Model::Callbacks
+
+      base.send :lycra_document
+
+      base.send :delegate, :as_indexed_json, to: :lycra_document
+    end
+
+    def lycra_document
+      self.class.lycra_document.new(self)
+    end
+
+    module ClassMethods
+      def index_name(idx=nil)
+        lycra_document.index_name idx
+      end
+
+      def document_type(doctype=nil)
+        lycra_document.document_type doctype
+      end
+
+      def mapping(options={}, &block)
+        lycra_document.mapping options, &block
+      end
+      alias_method :mappings, :mapping
+
+      def lycra_document(klass=nil)
+        if klass.present?
+          if klass.respond_to?(:constantize)
+            @lycra_document = klass.constantize.new(self)
+          else
+            @lycra_document = klass.new(self)
+          end
+        end
+
+        @lycra_document ||= lycra_document_klass.new(self)
+      end
+
+      def lycra_document_klass
+        begin
+          return "#{self.name}Document".constantize
+        rescue NameError => e
+          # noop, we just continue
+        end
+
+        if respond_to?(:base_class) && self.base_class.name != self.name
+          begin
+            return "#{self.base_class.name}Document".constantize
+          rescue NameError => e
+            # noop, we just continue
+          end
+        end
+
+        raise Lycra::DocumentNotFoundError.new(self)
+      end
+    end
+  end
+end

data/lib/lycra/search/aggregations.rb

@@ -0,0 +1,15 @@
+module Lycra
+  module Search
+    class Aggregations < Array
+      def to_query
+        return {} if empty?
+
+        # can probably inject here or be a bit more elegant?
+        aggregations = {}
+        each { |agg| aggregations.merge!(agg) }
+        aggregations
+      end
+      alias_method :to_q, :to_query
+    end
+  end
+end

data/lib/lycra/search/enumerable.rb

@@ -0,0 +1,200 @@
+module Lycra
+  module Search
+    module Enumerable
+      def self.included(base)
+        base.send :delegate, :count, :size, :results, :records, :total_count, to: :response
+        base.send :delegate, :first, to: :to_a
+
+        base.send :alias_method, :total, :total_count
+      end
+
+      def result_type
+        @result_type ||= :results
+      end
+
+      def as_results!
+        @result_type = :results
+        self
+      end
+
+      def as_records!
+        @result_type = :records
+        self
+      end
+
+      def as_results?
+        @result_type != :records
+      end
+
+      def as_records?
+        @result_type == :records
+      end
+
+      def decorate!
+        @decorated = true
+        self
+      end
+      alias_method :decorated!, :decorate!
+
+      def undecorate!
+        @decorated = false
+        self
+      end
+      alias_method :undecorated!, :undecorate!
+
+      def decorate?
+        @decorated == true
+      end
+
+      def undecorate?
+        @decorated != true
+      end
+
+      #### Enumeration ####
+
+      def enumerable_method
+        "#{'decorated_' if decorate?}#{result_type}".to_sym
+      end
+
+      def to_ary
+        if decorate?
+          send(enumerable_method)
+        else
+          send(enumerable_method).each do |result|
+            apply_transformers(result)
+          end.to_a
+        end
+      end
+      alias_method :to_a, :to_ary
+
+      def each(&block)
+        if decorate?
+          send("each_#{enumerable_method}", &block)
+        else
+          send(enumerable_method).each do |result|
+            apply_transformers(result)
+            yield(result) if block_given?
+          end
+        end
+      end
+
+      def map(&block)
+        if decorate?
+          send("map_#{enumerable_method}", &block)
+        else
+          send(enumerable_method).map do |result|
+            apply_transformers(result)
+            yield(result) if block_given?
+          end
+        end
+      end
+
+      #### Decoration & Transformations ####
+
+      def transform(&block)
+        (@transformers ||= []) << block
+        self
+      end
+
+      def transformers
+        @transformers ||= []
+      end
+
+      def apply_transformers(result)
+        transformers.each do |transformer|
+          transformer.call(result)
+        end
+      end
+
+      def each_decorated_results(decorator=nil, &block)
+        map_decorated_results(decorator, &block)
+        @decorated_results
+      end
+      alias_method :decorated_results, :each_decorated_results
+      alias_method :each_decorated_result, :each_decorated_results
+
+      def map_decorated_results(decorator=nil, &block)
+        mapped = []
+        if @decorated_results
+          mapped = @decorated_results.map(&block)
+        else
+          @decorated_results ||= results.map do |result|
+            decorated = decorate_result(result, decorator)
+
+            apply_transformers(decorated)
+            mapped << (block_given? ? yield(decorated) : decorated)
+
+            decorated
+          end
+        end
+        mapped
+      end
+
+      def decorate_result(result, decorator=nil)
+        if decorator
+          decorator.decorate(result)
+        else
+          SearchDecorator.decorate(result)
+        end
+      end
+
+      def each_decorated_records(decorator=nil, &block)
+        map_decorated_records(decorator, &block)
+        @decorated_records
+      end
+      alias_method :decorated_records, :each_decorated_records
+      alias_method :each_decorated_record, :each_decorated_records
+
+      def map_decorated_records(decorator=nil, &block)
+        mapped = []
+        if @decorated_records
+          mapped = @decorated_records.map(&block)
+        else
+          @decorated_records ||= records.map do |record|
+            decorated = decorate_record(record, decorator)
+
+            apply_transformers(decorated)
+            mapped << (block_given? ? yield(decorated) : decorated)
+
+            decorated
+          end
+        end
+        mapped
+      end
+
+      def decorate_record(record, decorator=nil)
+        if decorator
+          decorator.decorate(record)
+        else
+          record.decorate
+        end
+      end
+
+      def records_with_hit(&block)
+        @records_with_hit ||= records.map_with_hit do |record,hit|
+          mash = Hashie::Mash.new(record: record, hit: hit)
+          apply_transformers(mash)
+          yield(mash) if block_given?
+          mash
+        end
+      end
+
+      def decorated_with_hit(decorator=nil, &block)
+        @decorated_with_hit ||= records.map_with_hit do |record,hit|
+          decorated = begin
+            if decorator
+              Hashie::Mash.new(record: decorator.decorate(record), hit: hit)
+            else
+              Hashie::Mash.new(record: record.decorate, hit: hit)
+            end
+          end
+
+          apply_transformers(decorated)
+          yield(decorated) if block_given?
+
+          decorated
+        end
+      end
+    end
+  end
+end

data/lib/lycra/search/filters.rb

@@ -0,0 +1,43 @@
+module Lycra
+  module Search
+    class Filters < Array
+      def to_query
+        return {} if empty?
+
+        filters = {}
+        filters.merge!(must_filters) unless must_filters.empty?
+        filters.merge!(must_not_filters) unless must_not_filters.empty?
+        {bool: filters}
+      end
+      alias_method :to_q, :to_query
+
+      protected
+
+      def must_filters
+        queries = select { |q| q.key?(:must) || !q.key?(:must_not) }
+        return {} if queries.empty?
+
+        matchers = {must: []}
+        queries.each do |query|
+          if query.key?(:must)
+            matchers[:must].concat(query[:must])
+          else
+            matchers[:must] << query
+          end
+        end
+        matchers
+      end
+
+      def must_not_filters
+        queries = select { |q| q.key?(:must_not) }
+        return {} if queries.empty?
+
+        matchers = {must_not: []}
+        queries.each do |query|
+          matchers[:must_not].concat(query[:must_not])
+        end
+        matchers
+      end
+    end
+  end
+end

data/lib/lycra/search/pagination.rb

@@ -0,0 +1,32 @@
+module Lycra
+  module Search
+    module Pagination
+      def self.included(base)
+        base.send :delegate, :total_pages, :current_page, :limit_value, :offset_value, :last_page?, to: :response
+
+        base.send :alias_method, :pages, :total_pages
+      end
+
+      def page(pg=nil)
+        @response = response.page(pg || 1)
+        self
+      end
+
+      def per(pr=nil)
+        @response = response.per(pr || Lycra.configuration.per_page)
+        self
+      end
+
+      def offset(ofst=nil)
+        @response = response.offset(ofst || 0)
+        self
+      end
+
+      def limit(lmt=nil)
+        @response = response.limit(lmt || Lycra.configuration.per_page)
+        self
+      end
+
+    end
+  end
+end

data/lib/lycra/search/query.rb

@@ -0,0 +1,63 @@
+module Lycra
+  module Search
+    class Query < Array
+      def to_query
+        return {} if empty? && filters.empty?
+
+        query_matcher = {}
+        query_matcher.merge!(must_matchers) unless must_matchers.empty?
+        query_matcher.merge!(should_matchers) unless should_matchers.empty?
+        query_filters = {filter: filters.to_query}
+        {
+          bool: query_matcher.merge(query_filters)
+        }
+      end
+      alias_method :to_q, :to_query
+
+      def filters
+        @filters ||= Lycra::Search::Filters.new
+      end
+
+      def filter(fltr=nil)
+        if fltr.present?
+          filters << fltr
+        end
+
+        self
+      end
+
+      def refilter(fltr)
+        @filters = Lycra::Search::Filters.new
+        filter fltr
+      end
+
+      protected
+
+      def must_matchers
+        queries = select { |q| q.key?(:must) || !q.key?(:should) }
+        return {} if queries.empty?
+
+        matchers = {must: []}
+        queries.each do |query|
+          if query.key?(:must)
+            matchers[:must].concat(query[:must])
+          else
+            matchers[:must] << query
+          end
+        end
+        matchers
+      end
+
+      def should_matchers
+        queries = select { |q| q.key?(:should) }
+        return {} if queries.empty?
+
+        matchers = {should: []}
+        queries.each do |query|
+          matchers[:should].concat(query[:should])
+        end
+        matchers
+      end
+    end
+  end
+end

data/lib/lycra/search/scoping.rb

@@ -0,0 +1,136 @@
+module Lycra
+  module Search
+    module Scoping
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      def aggregations
+        @aggregations ||= Lycra::Search::Aggregations.new
+      end
+
+      def aggregate(agg=nil)
+        aggregations << agg unless agg.nil?
+        self
+      end
+      alias_method :aggregation, :aggregate
+
+      def reaggregate(agg)
+        @aggregations = Lycra::Search::Aggregations.new
+        aggregate agg
+      end
+
+      def filters
+        @filters ||= Lycra::Search::Filters.new
+      end
+
+      def filter(fltr=nil)
+        filters << fltr unless fltr.nil?
+        self
+      end
+
+      def refilter(fltr)
+        @filters = Lycra::Search::Filters.new
+        filter fltr
+      end
+
+      def query_filters
+        query.filters
+      end
+
+      def query_filter(fltr=nil)
+        query.filter fltr
+        self
+      end
+
+      def requery_filter(fltr)
+        query.refilter fltr
+        self
+      end
+
+      def post_filters
+        @post_filters ||= Lycra::Search::Filters.new
+      end
+
+      def post_filter(fltr=nil)
+        post_filters << fltr unless fltr.nil?
+        self
+      end
+
+      def repost_filter(fltr)
+        @post_filters = Lycra::Search::Filters.new
+        post_filter fltr
+      end
+
+      def sorter
+        @sorter ||= Lycra::Search::Sort.new
+      end
+
+      def sort(srt=nil)
+        sorter << srt unless srt.nil?
+        self
+      end
+
+      def resort(srt=nil)
+        @sorter = Lycra::Search::Sort.new
+        sort srt
+      end
+
+      def filter_by(attr, vals)
+        return self if vals.nil? || vals.empty?
+
+        attr_filter = {
+          bool: {
+            must: [{
+              or: vals.map { |val| {term: {attr.to_sym => val}} }
+            }]
+          }
+        }
+
+        filter(filter << attr_filter)
+
+        self
+      end
+
+      def where(*args)
+        args.extract_options!.each do |attr, vals|
+          vals = [vals] unless vals.is_a?(Array)
+          filter_by(attr, vals)
+        end
+
+        self
+      end
+
+      def find_by(*args)
+        unfiltered.offset(0).limit(1).where(*args).first
+      end
+
+      def find(id)
+        find_by(id: id).first
+      end
+
+      module ClassMethods
+        def self.extended(base)
+          # Generic Shared Scopes
+          base.send :scope, :all, -> { offset(0).limit(10_000) }
+          base.send :scope, :unfiltered, -> { refilter }
+          base.send :scope, :unsorted, -> { resort }
+          base.send :scope, :sort_by, -> (field, order=:asc) { sort({field => {order: order}}) }
+          base.send :scope, :by_id, -> (*objs) {
+            filter_by(:id, [objs].flatten.map { |obj| obj.respond_to?(:id) ? obj.id : obj })
+          }
+        end
+
+        def scope(name, block)
+          instance_eval do
+            define_method name.to_sym do |*args|
+              @response = nil
+              instance_exec *args, &block
+              self
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lycra/search/sort.rb

@@ -0,0 +1,8 @@
+module Lycra
+  module Search
+    class Sort < Array
+      alias_method :to_query, :to_a
+      alias_method :to_q, :to_query
+    end
+  end
+end

data/lib/lycra/search.rb

@@ -0,0 +1,170 @@
+require 'lycra/search/aggregations'
+require 'lycra/search/filters'
+require 'lycra/search/query'
+require 'lycra/search/sort'
+require 'lycra/search/enumerable'
+require 'lycra/search/pagination'
+require 'lycra/search/scoping'
+
+module Lycra
+  module Search
+    def self.included(base)
+      base.send :include, Lycra::Search::Enumerable
+      base.send :include, Lycra::Search::Pagination
+      base.send :include, Lycra::Search::Scoping
+      base.send :extend, ClassMethods
+      base.send :attr_reader, :term
+    end
+
+    def initialize(term=nil, query: nil, filter: nil, post_filter: nil, sort: nil, models: nil, fields: nil, aggregations: nil, &block)
+      @term = term
+      @models = models
+      @fields = fields
+      self.query(block_given? ? instance_eval(&block) : query)
+      self.filter(filter)
+      self.post_filter(post_filter)
+      self.sort(sort)
+      self.aggregate(aggregations)
+    end
+
+    def response
+      @response ||= search
+    end
+
+    def response!
+      @response = search
+    end
+
+    def document_types
+      document_types ||= response.search.definition[:type]
+    end
+
+    def entry_name
+      if document_types.count == 1
+        document_types.first
+      elsif document_types.count > 1
+        return document_types.map(&:pluralize).to_sentence
+      else
+        'result'
+      end
+    end
+
+    def search(qry=nil, &block)
+      if block_given?
+        Elasticsearch::Model.search(instance_eval(&block), models)
+      else
+        Elasticsearch::Model.search((qry || to_query), models)
+      end
+    end
+
+    def query(qry=nil)
+      if !qry.nil?
+        @query = Lycra::Search::Query[qry]
+        self
+      else
+        @query ||= Lycra::Search::Query[send("#{query_method}_query")]
+      end
+    end
+
+    def to_query_hash
+      {
+        query: query.to_query,
+        filter: filters.to_query,
+        sort: sorter.to_query,
+        post_filter: post_filters.to_query,
+        aggregations: aggregations.to_query
+      }
+    end
+    alias_method :to_query, :to_query_hash
+    alias_method :to_q, :to_query_hash
+
+    def match_all_query
+      {match_all: {}}
+    end
+
+    def multi_match_query
+      return if term.nil?
+
+      {
+        multi_match: {
+          query: term,
+          type: :best_fields,
+          fields: fields,
+          tie_breaker: 0.5,
+          operator: 'and'
+        }
+      }
+    end
+
+    def match_phrase_prefix_query
+      return if term.nil?
+
+      field_queries = fields.map do |field|
+        {match_phrase_prefix: {field.to_s.gsub(/\^\d\Z/, '').to_sym => term}}
+      end
+
+      {or: field_queries}
+    end
+
+    def query_method(meth=false)
+      if meth == false
+        @query_method ||= :match_all
+      else
+        @query = nil
+        @query_method = meth
+        self
+      end
+    end
+
+    def models(mdls=false)
+      if mdls != false
+        @models = mdls.is_a?(Array) ? mdls : [mdls]
+      else
+        @models ||= self.class.models
+      end
+    end
+
+    def fields(flds=false)
+      if flds != false
+        @fields = flds.is_a?(Array) ? flds : [flds]
+      else
+        @fields ||= self.class.fields
+      end
+    end
+
+    module ClassMethods
+      def inherited(base)
+        # Make sure we inherit the parent's class-level instance variables whenever we inherit from the class.
+        base.send :instance_variable_set, :@models,    models.try(:dup)
+        base.send :instance_variable_set, :@fields, fields.try(:dup)
+      end
+
+      def search(term=nil, query: nil, filter: nil, post_filter: nil, sort: nil, models: nil, fields: nil, aggregations: nil, &block)
+        new(term, query: query, filter: filter, post_filter: post_filter, sort: sort, models: models, fields: fields, aggregations: aggregations, &block)
+      end
+
+      def singleton
+        @singleton ||= search
+      end
+
+      def method_missing(meth, *args, &block)
+        return search.send(meth, *args, &block) if singleton.respond_to?(meth)
+        super
+      end
+
+      def respond_to_missing?(meth, include_private=false)
+        singleton.respond_to?(meth, include_private) || super
+      end
+
+      def fields(*fields)
+        @fields = fields unless fields.empty?
+        @fields ||= []
+      end
+
+      def models(*models)
+        @models = models unless models.empty?
+        @models ||= []
+      end
+    end
+  end
+end

data/lib/lycra/version.rb

@@ -2,7 +2,7 @@ module Lycra
   module Version
     MAJOR = '0'
     MINOR = '0'
-    PATCH = '1'
+    PATCH = '2'
     VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
 
     class << self

data/lib/lycra.rb

@@ -1,15 +1,41 @@
+require 'logger'
 require 'canfig'
-require 'lycra/railtie' if defined?(Rails)
+require 'elasticsearch/model'
+require 'lycra/model'
+require 'lycra/search'
+require 'lycra/engine' if defined?(Rails)
 
 module Lycra
   include Canfig::Module
 
   configure do |config|
-    config.elastic_host   = nil           # the elasticsearch host to use
-    config.logger         = nil           # defaults to STDOUT but will use Rails.logger in a rails environment
+    config.elasticsearch_host = ENV['ELASTICSEARCH_HOST'] || 'localhost'    # elasticsearch host to use when connecting, defaults to ENV var if set or falls back to localhost
+    config.elasticsearch_port = ENV['ELASTICSEARCH_PORT'] || 9200           # elasticsearch port to use when connecting, defaults to ENV var if set or falls back to 9200
+    config.elasticsearch_url  = ENV['ELASTICSEARCH_URL']                    # elasticsearch URL to use when connecting (i.e. 'https://localhost:9200'), this will override host/port if set
+    config.page_size          = 50                                          # default number of results to return per-page when searching an index
+    config.index_prefix       = nil                                         # a prefix to use for index names (i.e. 'my-app' prefix and 'people' index becomes 'my-app-people')
+    config.log                = false                                       # whether or not the elasticsearch client should perform standard logging
+    config.logger             = nil                                         # logger use for standard elasticsearch logging, defaults to STDOUT but will use Rails.logger in a rails environment (via Lycra::Engine)
+    config.trace              = false                                       # whether or not the elasticsearch client should log request/response traces
+    config.tracer             = nil                                         # logger used when tracing request/response data
+
+    def elasticsearch_url
+      @state[:elasticsearch_url] || "#{self.elasticsearch_host}:#{self.elasticsearch_port}"
+    end
+
+    def logger
+      @logger ||= (@state[:logger] || Logger.new(STDOUT))
+    end
   end
 
-  def self.logger
-    configuration.logger || Logger.new(STDOUT)
+  def self.client
+    @client ||= Elasticsearch::Client.new(
+      host: configuration.elasticsearch_url,
+      log: configuration.log,
+      logger: configuration.logger,
+      trace: configuration.trace,
+      tracer: configuration.tracer
+    )
   end
+
 end

data/spec/lycra_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe Lycra do
+  describe '.logger' do
+    context 'when configured with a custom logger' do
+      let(:logger) do
+        Dir.mktmpdir do |dir|
+          Logger.new(File.open(File.join(dir, 'lycra.log'), 'w'))
+        end
+      end
+
+      before do
+        Lycra.configuration.configure(logger: logger)
+        Lycra.configuration.instance_variable_set(:@logger, nil)
+      end
+
+      it 'uses the custom logger' do
+        expect(Lycra.configuration.logger).to eq(logger)
+      end
+    end
+
+    context 'with default configuration' do
+      before do
+        Lycra.configuration.configure(logger: nil)
+        Lycra.configuration.instance_variable_set(:@logger, nil)
+      end
+
+      it 'is an instance of Logger' do
+        expect(Lycra.configuration.logger).to be_an_instance_of(::Logger)
+      end
+
+      it 'uses STDOUT' do
+        expect(Lycra.configuration.logger.instance_variable_get(:@logdev).dev).to eq(STDOUT)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,23 +1,21 @@
+require 'faker'
+require 'factory_girl'
 require 'lycra'
 require 'rspec'
-#require 'vcr'
 require 'coveralls'
 Coveralls.wear!
 
 #Dir[File.join(File.dirname(__FILE__), '..', "spec/support/**/*.rb")].each { |f| require f }
+Dir[File.join(File.dirname(__FILE__), '..', "spec/factories/**/*.rb")].each { |f| require f }
 
-#VCR.configure do |config|
-#  config.cassette_library_dir = "spec/cassettes"
-#  config.hook_into :webmock
-#end
+#LYCRA_ES1_CLIENT = Elasticsearch::Client.new host: 'localhost', port: 9201
+LYCRA_ES2_CLIENT = Elasticsearch::Client.new host: 'localhost', port: 4500
+Elasticsearch::Model.client = LYCRA_ES2_CLIENT
 
 RSpec.configure do |config|
-  #config.before(:suite) do
-  #  ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
-  #  capture_stdout { load "db/schema.rb" }
-  #  load 'support/models.rb'
-  #end
-  
+  # configure factory_girl syntax methods
+  config.include FactoryGirl::Syntax::Methods
+
   # rspec-expectations config goes here. You can use an alternate
   # assertion/expectation library such as wrong or the stdlib/minitest
   # assertions if you prefer.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lycra
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Mark Rebec
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-24 00:00:00.000000000 Z
+date: 2016-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: canfig
@@ -24,6 +24,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: elasticsearch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.18
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.18
+- !ruby/object:Gem::Dependency
+  name: elasticsearch-persistence
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: elasticsearch-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: elasticsearch-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +122,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  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: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.6
 description: Open source business intelligence based on elasticsearch queries, inspired
   by https://github.com/ankane/blazer
 email:
@@ -61,8 +159,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/lycra.rb
-- lib/lycra/railtie.rb
+- lib/lycra/engine.rb
+- lib/lycra/errors.rb
+- lib/lycra/model.rb
+- lib/lycra/search.rb
+- lib/lycra/search/aggregations.rb
+- lib/lycra/search/enumerable.rb
+- lib/lycra/search/filters.rb
+- lib/lycra/search/pagination.rb
+- lib/lycra/search/query.rb
+- lib/lycra/search/scoping.rb
+- lib/lycra/search/sort.rb
 - lib/lycra/version.rb
+- spec/lycra_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/markrebec/lycra
 licenses: []
@@ -88,4 +197,6 @@ signing_key:
 specification_version: 4
 summary: Business intelligence based on elasticsearch queries
 test_files:
+- spec/lycra_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/lib/lycra/railtie.rb

@@ -1,9 +0,0 @@
-module Lycra
-  class Railtie < Rails::Railtie
-    initializer "lycra.configure_rails_logger" do
-      Lycra.configure do |config|
-        config.logger = Rails.logger
-      end
-    end
-  end
-end