gummi 0.0.6

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+*.DS_Store
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gummi.gemspec
+gemspec
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jens Norrgrann
+
+MIT License
+
+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,31 @@
+[![Code Climate](https://codeclimate.com/github/bukowskis/gummi.png)](https://codeclimate.com/github/bukowskis/gummi)
+# Gummi
+
+A minimal wrapper around elasticsearch-ruby using a repository pattern.
+Still very much alpha. Use at your own risk...
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'gummi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gummi
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/gummi.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gummi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gummi"
+  spec.version       = Gummi::VERSION
+  spec.authors       = ["bukowskis"]
+  spec.description   = %q{A small wrapper around Elasticsearch}
+  spec.summary       = %q{A small wrapper around Elasticsearch}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/) - ['.travis.yml']
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency('virtus', '~> 1.0.0')
+  spec.add_dependency('elasticsearch', '~> 0.4.0')
+  spec.add_dependency('activesupport', '>= 3.0')
+  spec.add_dependency('activemodel', '>= 3.0')
+  spec.add_dependency('hooks', '~>0.3.3')
+  spec.add_dependency('leaflet')
+
+  spec.add_development_dependency('bundler', '~> 1.3')
+  spec.add_development_dependency('rake')
+  spec.add_development_dependency('rspec')
+end

data/lib/gummi.rb

@@ -0,0 +1,42 @@
+require 'virtus'
+require 'elasticsearch'
+require 'active_support/core_ext'
+require 'active_model'
+require 'hooks'
+require 'leaflet'
+
+require "repobahn/repository"
+require "repobahn/entity"
+
+require "gummi/version"
+require "gummi/api"
+require "gummi/attributes"
+require "gummi/document"
+require "gummi/entity"
+require "gummi/index"
+require "gummi/object"
+require "gummi/repository"
+require "gummi/fields/boolean"
+require "gummi/fields/time"
+require "gummi/fields/integer"
+require "gummi/fields/positive_integer"
+require "gummi/fields/keyword"
+require "gummi/fields/ngram_and_plain"
+require "gummi/fields/path_hierarchy"
+require "gummi/fields/string"
+require "gummi/fields/sanitized_string"
+require "gummi/default_index"
+require "gummi/search/searching"
+require "gummi/search/filtered"
+require "gummi/search/raw"
+require "gummi/search/result"
+
+module Gummi
+  def self.env
+    if defined? Rails
+      Rails.env
+    else
+      RAILS_ENV || "development"
+    end
+  end
+end

data/lib/gummi/api.rb

@@ -0,0 +1,7 @@
+module Gummi
+  module API
+    def self.client
+      @client ||= ::Elasticsearch::Client.new log: true
+    end
+  end
+end

data/lib/gummi/attributes.rb

@@ -0,0 +1,26 @@
+module Gummi
+  module Attributes
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def mapping_for_attribute(attribute)
+        if attribute.is_a? Virtus::Attribute::EmbeddedValue
+          {properties: attribute.primitive.mapping}
+        elsif attribute.is_a? Virtus::Attribute::Collection
+          mapping_for_attribute(attribute.member_type)
+        else
+          attribute.mapping
+        end
+      end
+
+      def mapping
+        result = {}
+        attribute_set.each do |attribute|
+          result.merge!({ attribute.name => mapping_for_attribute(attribute)})
+        end
+        result
+      end
+    end
+  end
+end

data/lib/gummi/default_index.rb

@@ -0,0 +1,13 @@
+module Gummi
+  class DefaultIndex
+    include Gummi::Index
+
+    def self.name
+      if defined? Rails
+        "#{Rails.application.class.name.deconstantize.underscore}_#{Rails.env}"
+      else
+        "gummi_#{Gummi.env}"
+      end
+    end
+  end
+end

data/lib/gummi/document.rb

@@ -0,0 +1,118 @@
+module Gummi
+  module Document
+    extend ActiveSupport::Concern
+
+    included do
+      include Virtus.model
+      include Gummi::Attributes
+    end
+
+    attr_accessor :id
+    attr_accessor :version
+
+    def overwrite
+      response = client.index index: index.name, type: document_type, id: id, body: attributes
+      if response["ok"]
+        self.version = response["_version"]
+        self.id = response["_id"]
+        true
+      else
+        false
+      end
+    end
+
+    def update
+      response = client.update index: index.name, type: document_type, id: id, retry_on_conflict: 0, version: version, body: { doc: attributes.as_json }
+      if response["ok"]
+        self.version = response["_version"]
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def client
+      Gummi::API.client
+    end
+
+    def document_type
+      self.class.document_type
+    end
+
+    def index
+      self.class.index
+    end
+
+    module ClassMethods
+
+      def get!(id)
+        response = client.get index: index.name, type: document_type, id: id
+        doc_hash = {id: response["_id"], version: response["_version"]}.merge(response["_source"])
+        lot = self.new(doc_hash)
+        lot.version = response["_version"]
+        lot
+      end
+
+      def get(id)
+        get!(id)
+      rescue ::Elasticsearch::Transport::Transport::Errors::NotFound
+        nil
+      end
+
+      def document_type(type_name)
+        @document_type = type_name
+      end
+
+      def document_type
+        @document_type || name.split('::').last.underscore
+      end
+
+      def index
+        @index || Gummi::DefaultIndex
+      end
+
+      def index=(index)
+        @index = index
+      end
+
+      def parent_document_type
+        nil
+      end
+
+      def sync_mapping!
+        client.indices.put_mapping creation_options
+      end
+
+      def new_filtered_search(options = {})
+        args = {}
+        args[:index] = index.name
+        args[:type]  = document_type
+        args.merge! options
+
+        Gummi::Search::Filtered.new args
+      end
+
+      def creation_options
+        result = {
+          index: index.name,
+          type:  document_type,
+          body: {
+            document_type => {
+              properties: mapping,
+            }
+          }
+        }
+        result[:body][document_type].merge!(_parent: { type: parent_document_type }) if parent_document_type.present?
+        result
+      end
+
+      private
+
+      def client
+        Gummi::API.client
+      end
+    end
+  end
+end

data/lib/gummi/entity.rb

@@ -0,0 +1,12 @@
+module Gummi
+  module Entity
+    extend ActiveSupport::Concern
+
+    included do
+      include Repobahn::Entity
+    end
+
+    attr_accessor :id
+    attr_accessor :version
+  end
+end

data/lib/gummi/fields/boolean.rb

@@ -0,0 +1,10 @@
+module Gummi
+  module Fields
+    class Boolean < Virtus::Attribute::Boolean
+
+      def mapping
+        { type: 'boolean' }
+      end
+    end
+  end
+end

data/lib/gummi/fields/integer.rb

@@ -0,0 +1,14 @@
+module Gummi
+  module Fields
+    class Integer < Virtus::Attribute
+
+      def coerce(value)
+        value.to_i if value.present?
+      end
+
+      def mapping
+        { type: 'integer' }
+      end
+    end
+  end
+end

data/lib/gummi/fields/keyword.rb

@@ -0,0 +1,13 @@
+module Gummi
+  module Fields
+    class Keyword < Virtus::Attribute
+      def coerce(value)
+        value
+      end
+
+      def mapping
+        { type: 'string', index_analyzer: 'keyword_index_analyzer', search_analyzer: 'keyword_search_analyzer' }
+      end
+    end
+  end
+end

data/lib/gummi/fields/ngram_and_plain.rb

@@ -0,0 +1,18 @@
+module Gummi
+  module Fields
+    class NgramAndPlain < Virtus::Attribute
+      def coerce(value)
+        value
+      end
+
+      def mapping
+        { type: 'multi_field',
+                    fields: {
+                              name      => { type: 'string', index_analyzer: 'text_index_analyzer',   search_analyzer: 'text_search_analyzer' },
+                              :plain    => { type: 'string', index_analyzer: 'string_index_analyzer', search_analyzer: 'text_search_analyzer' },
+                            }
+                  }
+      end
+    end
+  end
+end

data/lib/gummi/fields/path_hierarchy.rb

@@ -0,0 +1,13 @@
+module Gummi
+  module Fields
+    class PathHierarchy < Virtus::Attribute
+      def coerce(value)
+        value
+      end
+
+      def mapping
+        {type: 'string', index_analyzer: 'path_hierarchy_analyzer' }
+      end
+    end
+  end
+end

data/lib/gummi/fields/positive_integer.rb

@@ -0,0 +1,19 @@
+module Gummi
+  module Fields
+    class PositiveInteger < Virtus::Attribute
+
+      def coerce(value)
+        coerced = value.to_i
+        if coerced > 0
+          coerced
+        else
+          default_value.value
+        end
+      end
+
+      def mapping
+        { type: 'integer' }
+      end
+    end
+  end
+end

data/lib/gummi/fields/sanitized_string.rb

@@ -0,0 +1,28 @@
+module Gummi
+  module Fields
+    class SanitizedString < Virtus::Attribute
+
+      def coerce(value)
+        return nil if value.blank?
+        sanitize_string_for_query(value.to_s)
+      end
+
+      def mapping
+        { type: 'string' }
+      end
+
+      def sanitize_string_for_query(str)
+        # Escape special characters
+        escaped_characters = Regexp.escape('\/\\+-&|!(){}[]^~*?:')
+        str = str.gsub(/([#{escaped_characters}])/) do |match|
+          '\\'+match
+        end
+
+        # Escape odd quotes
+        quote_count = str.count '"'
+        str = str.gsub(/(.*)"(.*)/, '\1\"\3') if quote_count % 2 == 1
+        str
+      end
+    end
+  end
+end

data/lib/gummi/fields/string.rb

@@ -0,0 +1,15 @@
+module Gummi
+  module Fields
+    class String < Virtus::Attribute
+
+
+      def coerce(value)
+        value
+      end
+
+      def mapping
+        { type: 'string' }
+      end
+    end
+  end
+end

data/lib/gummi/fields/time.rb

@@ -0,0 +1,15 @@
+module Gummi
+  module Fields
+    class Time < Virtus::Attribute
+
+      def coerce(value)
+        return nil unless value.respond_to? :in_time_zone
+        value.in_time_zone 'UTC'
+      end
+
+      def mapping
+        {type: "date"}
+      end
+    end
+  end
+end

data/lib/gummi/index.rb

@@ -0,0 +1,146 @@
+module Gummi
+  module Index
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Return true if created or false if already created.
+      #
+      def setup
+        created_settings = client.indices.create index: name, body: { settings: settings }
+        created_settings.present?
+        refresh
+      rescue ::Elasticsearch::Transport::Transport::Errors::BadRequest => exception
+        false
+      end
+
+      # Return true if successful or already teared down.
+      #
+      # Raises NotImplementedError in production.
+      #
+      def teardown
+        raise NotImplementedError unless Gummi.env == 'development' || Gummi.env == 'test'
+        response = client.indices.delete index: name
+        response.present?
+      rescue ::Elasticsearch::Transport::Transport::Errors::NotFound
+        true
+      end
+
+      def name
+        raise "Implement me"
+      end
+
+      def refresh
+        client.indices.refresh
+        client.cluster.health wait_for_status: :yellow
+      end
+
+      def settings
+        default_settings
+      end
+
+      def default_settings
+        {
+          index: {
+            # Main Settings
+            number_of_shards: '3',
+            number_of_replicas: (Gummi.env == 'production' ? '2' : '0'),
+            refresh_interval: '1s',
+            store: { type: (Gummi.env == 'test' ? :memory : :niofs) },
+            mapper: { dynamic: false },
+
+            analysis: {
+
+              # Tokenizers are just some sort of "tool" or "module"  that can be applied to analyzers.
+              tokenizer: {
+                # This one is a little bit more general and is able to chop any word into all of its components.
+                ngram_tokenizer: {
+                  type: 'nGram',
+                  min_gram: 1,
+                  max_gram: 7,
+                  token_chars: [ 'letter', 'digit' ],
+                }
+
+              },
+
+              # Now we are ready to use our tokenizers.
+              # Let's create the most important thing: Analyzers.
+              analyzer: {
+
+                path_hierarchy_analyzer: {
+                  type: 'custom',
+                  tokenizer: 'path_hierarchy',
+                },
+                # When adding long text to Elastic, we most likely are going to use this
+                # analyzer. This is commonly used for titles and descriptions.
+                text_index_analyzer: {
+                  type: 'custom',
+                  tokenizer: 'ngram_tokenizer',  # Chopping every word up into tokens
+                  filter: {
+                    0 => 'standard',       # Some default transformations
+                    1 => 'lowercase',      # Make everything lowercase
+                    2 => 'word_delimiter', # E.g. "O'Neil" -> "O Neil", "Victoria's" -> "Victoria"
+                    2 => 'asciifolding',   # Transform everything into ASCII
+                  },
+                },
+
+                # For smaller texts, such as the city "stockholm", we don't want any
+                # tokenizing. It's enough to explicitly save the word as it is.
+                # As a matter of fact, if we would tokenize the city, then the facets
+                # would report that we have Transports in "st" "sto" "stoc" etc.
+                string_index_analyzer: {
+                  type: 'custom',
+                  tokenizer: 'standard',
+                  filter: {
+                    # The filters, however, are identical to the other analyzer.
+                    0 => 'standard',
+                    1 => 'lowercase',
+                    2 => 'word_delimiter',
+                    3 => 'asciifolding',
+                  },
+                },
+
+                # For finding Slugs
+                keyword_index_analyzer: {
+                  type: 'custom',
+                  tokenizer: 'keyword',
+                  filter: {
+                    0 => 'lowercase',
+                    1 => 'asciifolding',
+                  },
+                },
+
+                # This is an analyzer that we apply to the search query itself.
+                text_search_analyzer: {
+                  type: 'custom',
+                  tokenizer: 'standard',
+                  filter: {
+                    0 => 'standard',
+                    1 => 'lowercase',
+                    2 => 'word_delimiter',
+                    3 => 'asciifolding',
+                  },
+                },
+
+                # This is an analyzer that we apply to the search query itself.
+                keyword_search_analyzer: {
+                  type: 'custom',
+                  tokenizer: 'keyword',
+                  filter: {
+                    0 => 'lowercase',
+                    1 => 'asciifolding',
+                  },
+                },
+
+              }
+            }
+          }
+        }
+      end
+
+      def client
+        Gummi::API.client
+      end
+    end
+  end
+end

data/lib/gummi/object.rb

@@ -0,0 +1,10 @@
+module Gummi
+  module Object
+    extend ActiveSupport::Concern
+
+    included do
+      include Virtus.model
+      include Gummi::Attributes
+    end
+  end
+end

data/lib/gummi/repository.rb

@@ -0,0 +1,31 @@
+
+module Gummi
+  module Repository
+    extend ActiveSupport::Concern
+
+   included do
+     include Repobahn::Repository
+     after_conversion :set_id_and_version
+   end
+
+
+    module ClassMethods
+
+      def get(id)
+        record = db_model.get id
+        to_entity_from_db record if record
+      end
+
+      def overwrite(entity)
+        return false unless entity.valid?
+        db_record = db_model.new(entity.attributes)
+        db_record.overwrite
+      end
+
+      def set_id_and_version(entity, db)
+        entity.id = db.id
+        entity.version = db.version
+      end
+    end
+  end
+end

data/lib/gummi/search/filtered.rb

@@ -0,0 +1,36 @@
+module Gummi
+  module Search
+    class Filtered
+      include Gummi::Search::Searching
+
+      attribute :query_string,  Gummi::Fields::SanitizedString
+      attribute :query_filters, Array[Hash],                    default: []
+      attribute :facets,        Hash,                           default: {}
+
+      def to_client_args
+        args = {}
+        args[:index] = index
+        args[:type]  = type if type
+        args[:from]  = from
+        args[:body]  = {query: filtered, facets: facets }
+        args
+      end
+
+      def query
+        {query_string: { query: query_string}} if query_string.present?
+      end
+
+      def filtered
+        { 'filtered' => { 'query' => query, 'filter' => process_query_filters }}
+      end
+
+      def process_query_filters
+        if query_filters.length > 1
+          {and: query_filters}
+        else
+          query_filters.first
+        end
+      end
+    end
+  end
+end

data/lib/gummi/search/raw.rb

@@ -0,0 +1,7 @@
+module Gummi
+  module Search
+    class Raw
+      include Gummi::Search::Searching
+    end
+  end
+end

data/lib/gummi/search/result.rb

@@ -0,0 +1,23 @@
+module Gummi
+  module Search
+    class Result
+
+      attr_reader :took, :total, :hits, :facets
+
+      def initialize(result)
+        @took = result["took"]
+        @total = result["hits"]["total"]
+        @hits = result["hits"]["hits"]
+        @facets = result["facets"]
+      end
+
+      def records
+        hits.map do |hit|
+          model = "DB::#{hit["_type"].humanize}".constantize
+          doc_hash = {id: hit["_id"]}.merge(hit["_source"])
+          model.new(doc_hash)
+        end
+      end
+    end
+  end
+end

data/lib/gummi/search/searching.rb

@@ -0,0 +1,43 @@
+module Gummi
+  module Search
+    module Searching
+      extend ActiveSupport::Concern
+
+      included do
+        include Virtus.model
+
+        attribute :type,          String
+        attribute :index,         String,                         default: lambda {|search, attr| Gummi::DefaultIndex.name}
+        attribute :page,          Gummi::Fields::PositiveInteger, default: 1
+        attribute :per_page,      Gummi::Fields::PositiveInteger, default: 300
+        attribute :options,       Hash,                           default: {}
+      end
+
+      def size
+        per_page
+      end
+
+      def from
+        per_page * (page - 1)
+      end
+
+      def execute
+        Gummi::Search::Result.new client.search(to_client_args)
+      end
+
+      def to_client_args
+        args = {}
+        args[:index] = index
+        args[:type]  = type if type
+        args[:from]  = from
+        args[:size]  = size
+        args.merge options
+      end
+
+      private
+      def client
+        Gummi::API.client
+      end
+    end
+  end
+end

data/lib/gummi/version.rb

@@ -0,0 +1,3 @@
+module Gummi
+  VERSION = "0.0.6"
+end

data/lib/repobahn/entity.rb

@@ -0,0 +1,12 @@
+module Repobahn
+  module Entity
+    extend ActiveSupport::Concern
+
+    included do
+      include Virtus.model
+      include ActiveModel::Conversion
+      extend  ActiveModel::Naming
+    end
+
+  end
+end

data/lib/repobahn/repository.rb

@@ -0,0 +1,57 @@
+module Repobahn
+  module Repository
+    extend ActiveSupport::Concern
+
+   included do
+     include Hooks
+     define_hook :after_conversion
+   end
+
+
+    module ClassMethods
+
+      def entity_model
+        @entity_model || default_entity_model
+      end
+
+      def entity_model=(klass)
+        @entity_model = klass
+      end
+
+      def db_model
+        @db_model || default_db_model
+      end
+
+      def db_model=(klass)
+        @db_model = klass
+      end
+
+      def find(id)
+        record = db_model.find id
+        to_entity_from_db record if record
+      end
+
+      def to_entity_from_db(records)
+        entities = Array(records).map do |record|
+          entity = entity_model.new(record.attributes)
+          run_hook :after_conversion, entity, record
+          entity
+        end
+        entities.length > 1 ? entities : entities.first
+      end
+
+      private
+
+      def default_entity_model
+        full_name = name.split('::')
+        model_name = full_name.pop.singularize
+        full_name << model_name
+        full_name.join('::').constantize
+      end
+
+      def default_db_model
+        "DB::#{name.split('::').last.singularize}".constantize
+      end
+    end
+  end
+end

data/spec/lib/gummi/document_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+class ExampleModel
+  include Gummi::Document
+
+  attribute :test, String
+end
+
+describe Gummi::Document do
+
+  context "included" do
+    it "should add accessors for id and version" do
+      m = ExampleModel.new
+      m.respond_to?(:version).should be_true
+      m.respond_to?(:id).should be_true
+    end
+
+    it "should add attributes methods" do
+      m = ExampleModel.new(test: 'hello')
+      m.test.should == 'hello'
+    end
+  end
+
+  context "attributes" do
+
+    context "date times" do
+      it "should coerce from elastics strings to real Time" do
+        time = Time.now
+        person = DB::Person.new(born_at: time)
+        person.overwrite
+        person_from_es = DB::Person.get person.id
+        person_from_es.born_at.should be_a Time
+      end
+
+      it "should always store time in UTC" do
+        time = Time.now.in_time_zone 'CET'
+
+        person = DB::Person.new(born_at: time)
+        person.born_at.zone.should == 'UTC'
+      end
+    end
+
+    context "computed_attributes" do
+
+      let(:person) { DB::Person.new}
+
+      it "should add them to the attributes hash" do
+        person.name = "olof palme"
+        person.attributes[:computed_name].should == 'OLOF PALME'
+      end
+
+      it "should compute every time" do
+        person.name = "olof palme"
+        person.computed_name.should == person.name.upcase
+        person.name = "carl bildt"
+        person.computed_name.should == person.name.upcase
+      end
+
+      it "should provide a mapping" do
+        DB::Person.mapping.should include(:computed_name => {:type=>"string"})
+      end
+    end
+  end
+
+  context 'getting from elastic' do
+    let (:person) { DB::Person.new(name: 'Buzz Lightyear') }
+
+    it "should return an instance of the db_model" do
+      person.overwrite
+      person_from_es = DB::Person.get(person.id)
+      person_from_es.should be_a DB::Person
+    end
+  end
+end

data/spec/lib/gummi/repository_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Gummi::Repository do
+
+  let(:repository_model) { People }
+  let(:entity_model)     { Person }
+  let(:db_model)         { DB::Person }
+
+  describe ".entity_model" do
+    it "should default to singular version of repository_model" do
+      People.entity_model.should == Person
+    end
+  end
+
+  describe ".db_model" do
+    it "should default to singular version of repository_model in the DB namespace" do
+      People.db_model.should == DB::Person
+    end
+  end
+
+  context "converting from db to entity" do
+
+    let (:db_person) { DB::Person.new(name: 'Buzz Lightyear') }
+
+    it "should map the attributes from db to entity" do
+      person = People.to_entity_from_db(db_person)
+      person.name.should == 'Buzz Lightyear'
+    end
+
+    it "should run hook for after_conversion" do
+      person = People.to_entity_from_db(db_person)
+      person.converted_name.should == db_person.name.reverse
+    end
+  end
+
+  describe ".get" do
+    context "existing record" do
+
+      let (:db_person) { DB::Person.new(name: 'Buzz Lightyear') }
+
+      it "should return an entity" do
+        db_person.overwrite
+        person = People.get(db_person.id)
+        person.id.should == db_person.id
+      end
+    end
+
+    context "missing record" do
+      it "returns nil" do
+        person = People.get('missing_id')
+        person.should be_nil
+      end
+    end
+  end
+
+
+end

data/spec/models/db/person.rb

@@ -0,0 +1,15 @@
+# example db model
+
+module DB
+  class Person
+    include Gummi::Document
+
+    attribute :name,          Gummi::Fields::String
+    attribute :computed_name, Gummi::Fields::String
+    attribute :born_at,       Gummi::Fields::Time
+
+    def computed_name
+      name.upcase if name
+    end
+  end
+end

data/spec/models/people.rb

@@ -0,0 +1,9 @@
+class People
+  include Gummi::Repository
+
+  after_conversion :convert_name
+
+  def self.convert_name(entity, db)
+    entity.converted_name = db.name.reverse
+  end
+end

data/spec/models/person.rb

@@ -0,0 +1,7 @@
+# example entity model
+class Person
+  include Gummi::Entity
+
+  attribute :name, String
+  attribute :converted_name, String
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+RAILS_ENV = 'test'
+require 'gummi'
+require_relative 'models/people'
+require_relative 'models/person'
+require_relative 'models/db/person'
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    Gummi::DefaultIndex.setup
+    DB::Person.sync_mapping!
+  end
+
+  config.after(:suite) do
+    Gummi::DefaultIndex.teardown
+  end
+end

metadata

@@ -0,0 +1,232 @@
+--- !ruby/object:Gem::Specification
+name: gummi
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+  prerelease: 
+platform: ruby
+authors:
+- bukowskis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: elasticsearch
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: hooks
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: leaflet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A small wrapper around Elasticsearch
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gummi.gemspec
+- lib/gummi.rb
+- lib/gummi/api.rb
+- lib/gummi/attributes.rb
+- lib/gummi/default_index.rb
+- lib/gummi/document.rb
+- lib/gummi/entity.rb
+- lib/gummi/fields/boolean.rb
+- lib/gummi/fields/integer.rb
+- lib/gummi/fields/keyword.rb
+- lib/gummi/fields/ngram_and_plain.rb
+- lib/gummi/fields/path_hierarchy.rb
+- lib/gummi/fields/positive_integer.rb
+- lib/gummi/fields/sanitized_string.rb
+- lib/gummi/fields/string.rb
+- lib/gummi/fields/time.rb
+- lib/gummi/index.rb
+- lib/gummi/object.rb
+- lib/gummi/repository.rb
+- lib/gummi/search/filtered.rb
+- lib/gummi/search/raw.rb
+- lib/gummi/search/result.rb
+- lib/gummi/search/searching.rb
+- lib/gummi/version.rb
+- lib/repobahn/entity.rb
+- lib/repobahn/repository.rb
+- spec/lib/gummi/document_spec.rb
+- spec/lib/gummi/repository_spec.rb
+- spec/models/db/person.rb
+- spec/models/people.rb
+- spec/models/person.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A small wrapper around Elasticsearch
+test_files:
+- spec/lib/gummi/document_spec.rb
+- spec/lib/gummi/repository_spec.rb
+- spec/models/db/person.rb
+- spec/models/people.rb
+- spec/models/person.rb
+- spec/spec_helper.rb