gummi 0.1.2 → 0.2.0

data/lib/gummi/repository.rb

@@ -1,38 +0,0 @@
-
-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 search(&block)
-        filtered_search = db_model.new_filtered_search
-        yield filtered_search
-        result = filtered_search.execute
-        Repository::Result.new(result, self, filtered_search.per_page, filtered_search.page)
-      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/repository/result.rb

@@ -1,30 +0,0 @@
-module Gummi
-  module Repository
-    class Result
-
-      attr_reader :took, :total, :hits
-
-      def initialize(db_result, repository, per_page, page)
-        @took = db_result.took
-        @total = db_result.total
-        @hits = db_result.hits
-        @facets = db_result.facets
-        @db_records = db_result.records
-        @repository = repository
-        @per_page = per_page
-        @page = page
-      end
-
-      def facets
-        @facets.each_with_object({}) do |(name, content), facets|
-          facets[name] = Hash[content["terms"].collect{|term| term.values}]
-        end
-      end
-
-      def records
-        entities = Array(@repository.to_entity_from_db(@db_records)) if @db_records
-        Leaflet::Collection.new entities, page: @page, total: total, per_page: @per_page
-      end
-    end
-  end
-end

data/spec/lib/gummi/document_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-class GummiDummyDocument
-  include Gummi::Document
-
-  attribute :test, String
-end
-
-describe Gummi::Document do
-
-  context "included" do
-    it "adds accessors for id and version" do
-      m = GummiDummyDocument.new
-      m.respond_to?(:version).should be_true
-      m.respond_to?(:id).should be_true
-    end
-
-    it "adds attributes methods" do
-      m = GummiDummyDocument.new(test: 'hello')
-      m.test.should == 'hello'
-    end
-  end
-
-  context "attributes" do
-
-    context "date times" do
-      it "coerces 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 "always stores 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 "adds them to the attributes hash" do
-        person.name = "olof palme"
-        person.attributes[:computed_name].should == 'OLOF PALME'
-      end
-
-      it "computes 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 "provides a mapping" do
-        DB::Person.mapping.should include(:computed_name => {:type=>"string"})
-      end
-    end
-  end
-
-  context 'getting from elastic' do
-    let (:person) { DB::Person.create(name: 'Buzz Lightyear') }
-
-    it "returns an instance of the db_model" do
-      person_from_es = DB::Person.get(person.id)
-      person_from_es.should be_a DB::Person
-    end
-  end
-end

data/spec/lib/gummi/repository/result_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe Gummi::Repository::Result do
-
-  describe "#facets" do
-    it "returns the relevant terms with counts" do
-      db_result = OpenStruct.new(facets: {"categories"=>
-        {"_type"=>"terms",
-         "missing"=>0,
-         "total"=>3,
-         "other"=>0,
-         "terms"=>[{"term"=>"design", "count"=>2}, {"term"=>"silver", "count"=>1}]}})
-
-      result = Gummi::Repository::Result.new(db_result, nil, nil, nil)
-      result.facets.should == {"categories" => {"design" => 2, "silver" => 1}}
-    end
-  end
-end

data/spec/lib/gummi/repository_spec.rb

@@ -1,81 +0,0 @@
-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.create(name: 'Buzz Lightyear') }
-
-      it "should return an entity" do
-        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
-
-  describe ".search" do
-
-    before(:each) do
-      DB::Person.create(name: 'Buzz Lightyear')
-      DB::Person.create(name: 'Woody')
-      Gummi::DefaultIndex.refresh
-    end
-
-    it "should find the correct documents" do
-      result = People.search do |search|
-        search.query_string = "Woody"
-      end
-      result.total.should == 1
-      result.records.first.name.should == "Woody"
-    end
-
-    it "should convert the result to entities" do
-      result = People.search do |search|
-        search.query_string = "Woody"
-      end
-      woody = result.records.first
-      woody.converted_name.should == 'ydooW'
-      woody.should be_a Person
-    end
-  end
-
-end

data/spec/models/db/person.rb

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