gummi 0.1.2 → 0.2.0

data/lib/gummi/repository_layer/repository.rb

@@ -0,0 +1,39 @@
+module Gummi
+  module RepositoryLayer
+    module Repository
+      extend ActiveSupport::Concern
+
+      included do
+        include Repobahn::Repository
+        after_conversion :set_id_and_version
+      end
+
+      module ClassMethods
+
+        def get(id)
+          document = db_class.get id
+          db_instance_to_entity document if document
+        end
+
+        def search(&block)
+          search = db_class.new_filtered_search
+          yield search
+          Repository::Result.new search.execute, self
+        end
+
+        def overwrite(entity)
+          return false unless entity.valid?
+          document = db_class.new(entity.attributes)
+          document.overwrite
+        end
+
+        def set_id_and_version(entity, db_instance)
+          entity.id      = db_instance.id
+          entity.version = db_instance.version
+        end
+
+      end
+
+    end
+  end
+end

data/lib/gummi/repository_layer/repository/result.rb

@@ -0,0 +1,42 @@
+module Gummi
+  module RepositoryLayer
+    module Repository
+      class Result
+
+        attr_reader :took, :total, :hits
+
+        def initialize(search_result, converter)
+          @search_result  = search_result
+          @took      = @search_result.took
+          @documents = @search_result.documents
+          @converter = converter
+        end
+
+        def facets
+          @facets ||= begin
+            response.facets.each_with_object({}) do |(name, content), facets|
+              facets[name] = Hash[content.terms.map(&:values)]
+            end
+          end
+        end
+
+        def total
+          documents.total_entries
+        end
+
+        def records
+          @records ||= begin
+            # Passing through the Leaflet Collection, but converting the records.
+            documents.map! { |document| converter.db_instance_to_entity(document) }
+            documents
+          end
+        end
+
+        private
+
+        attr_reader :search_result, :converter, :documents
+
+      end
+    end
+  end
+end

data/lib/gummi/version.rb

@@ -1,3 +1,3 @@
 module Gummi
-  VERSION = "0.1.2"
+  VERSION = '0.2.0'
 end

data/lib/repobahn/repository.rb

@@ -2,56 +2,48 @@ module Repobahn
   module Repository
     extend ActiveSupport::Concern
 
-   included do
-     include Hooks
-     define_hook :after_conversion
-   end
+    include ::Repobahn::Repository::ActiveRecord
 
+    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
+      def db_class(*args)
+        @db_class = args.first unless args.empty?
+        @db_class || default_db_class
       end
 
-      def db_model=(klass)
-        @db_model = klass
+      def entity_class(*args)
+        @entity_class = args.first unless args.empty?
+        @entity_class || default_entity_class
       end
 
-      def find(id)
-        record = db_model.find id
-        to_entity_from_db record if record
+      def db_instances_to_entities(db_instances)
+        entities = Array(db_instances).map { |db_instance| db_instance_to_entity(db_instance) }
+        entities.length > 1 ? entities : entities.first
       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
+      def db_instance_to_entity(db_instance)
+        entity = entity_class.new(db_instance.attributes)
+        run_hook :after_conversion, entity, db_instance
+        entity
       end
 
       private
 
-      def default_entity_model
-        full_name = name.split('::')
-        model_name = full_name.pop.singularize
-        full_name << model_name
-        full_name.join('::').constantize
+      def default_db_class
+        parts = default_entity_class.to_s.split('::')
+        parts.insert -2, 'DB'
+        parts.join('::').constantize
       end
 
-      def default_db_model
-        "DB::#{name.split('::').last.singularize}".constantize
+      def default_entity_class
+        name.singularize.constantize
       end
+
     end
   end
 end

data/lib/repobahn/repository/active_record.rb

@@ -0,0 +1,17 @@
+module Repobahn
+  module Repository
+    module ActiveRecord
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def find(id)
+          record = document_class.find id.to_i
+          document_to_entity record if record
+        end
+
+      end
+
+    end
+  end
+end

data/spec/fixtures/admin/auto.rb

@@ -0,0 +1,6 @@
+module Admin
+  class Auto
+    include Repobahn::Entity
+
+  end
+end

data/spec/fixtures/admin/cars.rb

@@ -0,0 +1,12 @@
+require 'admin/db/vehicle'
+require 'admin/auto'
+
+module Admin
+  class Cars
+    include Repobahn::Repository
+
+    db_class     DB::Vehicle
+    entity_class Auto
+
+  end
+end

data/spec/fixtures/admin/countries.rb

@@ -0,0 +1,9 @@
+require 'admin/db/country'
+require 'admin/country'
+
+module Admin
+  class Countries
+    include Repobahn::Repository
+
+  end
+end

data/spec/fixtures/admin/country.rb

@@ -0,0 +1,6 @@
+module Admin
+  class Country
+    include Repobahn::Entity
+
+  end
+end

data/spec/fixtures/admin/db/country.rb

@@ -0,0 +1,7 @@
+module Admin
+  module DB
+    class Country
+
+    end
+  end
+end

data/spec/fixtures/admin/db/vehicle.rb

@@ -0,0 +1,7 @@
+module Admin
+  module DB
+    class Vehicle
+
+    end
+  end
+end

data/spec/fixtures/cities.rb

@@ -0,0 +1,7 @@
+require 'db/city'
+require 'city'
+
+class Cities
+  include Repobahn::Repository
+
+end

data/spec/fixtures/city.rb

@@ -0,0 +1,6 @@
+class City
+  include Repobahn::Entity
+
+  attribute :name, String
+
+end

data/spec/fixtures/db/animal.rb

@@ -0,0 +1,9 @@
+# Only defining a custom document_type
+
+module DB
+  class Animal
+    include Gummi::DbLayer::Document
+
+    document_type :wild_animal
+  end
+end

data/spec/fixtures/db/boat.rb

@@ -0,0 +1,9 @@
+# Sub-Object Type
+
+module DB
+  class Boat
+    include Gummi::DbLayer::Document::Object
+
+    attribute :length, Gummi::DbLayer::Fields::PositiveInteger
+  end
+end

data/spec/fixtures/db/car.rb

@@ -0,0 +1,9 @@
+# Has a custom Index
+
+module DB
+  class Car
+    include Gummi::DbLayer::Document
+
+    index Struct
+  end
+end

data/spec/fixtures/db/city.rb

@@ -0,0 +1,8 @@
+module DB
+  class City
+    include Virtus.model
+
+    attribute :name, String
+
+  end
+end

data/spec/fixtures/db/enemy.rb

@@ -0,0 +1,10 @@
+# Not defining the attribute type
+
+module DB
+  class Enemy
+    include Gummi::DbLayer::Document
+
+    attribute :rebel
+
+  end
+end

data/spec/fixtures/db/game.rb

@@ -0,0 +1,7 @@
+# Blank as can be, just the inclusion.
+
+module DB
+  class Game
+    include Gummi::DbLayer::Document
+  end
+end

data/spec/fixtures/db/person.rb

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

data/spec/fixtures/db/rating.rb

@@ -0,0 +1,11 @@
+# Is a child document
+
+module DB
+  class Rating
+    include Gummi::DbLayer::Document
+
+    parent    Person
+    attribute :stars, Gummi::DbLayer::Fields::Integer
+
+  end
+end

data/spec/fixtures/db/ship.rb

@@ -0,0 +1,18 @@
+# Various attribute field types
+
+require 'db/boat'
+
+module DB
+  class Ship
+    include Gummi::DbLayer::Document
+
+    attribute :name,        Gummi::DbLayer::Fields::String
+    attribute :tags,        Gummi::DbLayer::Fields::Keyword
+    attribute :category,    Gummi::DbLayer::Fields::PathHierarchy
+    attribute :height,      Gummi::DbLayer::Fields::PositiveInteger
+    attribute :unsinkable,  Gummi::DbLayer::Fields::Boolean
+    attribute :freetext,    Gummi::DbLayer::Fields::NgramAndPlain
+    attribute :boat,        Boat
+
+  end
+end

data/spec/{models → fixtures}/people.rb

@@ -1,9 +1,13 @@
+require 'db/person'
+require 'person'
+
 class People
-  include Gummi::Repository
+  include Gummi::RepositoryLayer::Repository
 
   after_conversion :convert_name
 
   def self.convert_name(entity, db)
     entity.converted_name = db.name.reverse
   end
-end
+
+end

data/spec/{models → fixtures}/person.rb

@@ -1,13 +1,14 @@
 # example entity model
+
 class Person
 
   class Car
-    include Gummi::Entity
+    include Gummi::EntityLayer::Entity
 
     attribute :model, String
   end
 
-  include Gummi::Entity
+  include Gummi::EntityLayer::Entity
 
   attribute :name, String
   attribute :converted_name, String

data/spec/lib/gummi/db_layer/document_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+require 'db/animal'
+require 'db/car'
+require 'db/enemy'
+require 'db/game'
+require 'db/person'
+require 'db/rating'
+require 'db/ship'
+
+describe Gummi::DbLayer::Document do
+
+  context 'included' do
+    it 'adds accessors for id and version' do
+      model = DB::Ship.new
+      model.should respond_to :id
+      model.should respond_to :version
+    end
+
+    it 'adds default attributes methods' do
+      model = DB::Ship.new name: 'Joe'
+      model.name.should == 'Joe'
+    end
+
+    it 'does not accept attributes without explicit type definition' do
+      expect { DB::Enemy.sync_mapping! }.to raise_error(Gummi::Errors::ImplicitMappingForbidden)
+    end
+  end
+
+  describe '.index' do
+    context 'without being specified' do
+      it 'defaults to the default index' do
+        DB::Game.index.should == Gummi::DbLayer::DefaultIndex
+      end
+    end
+
+    context 'explicitly specified' do
+      it 'accepts the specification' do
+        DB::Car.index.should == Struct
+      end
+    end
+  end
+
+  describe '.document_type' do
+    context 'without being specified' do
+      it 'defaults to the demodulized name' do
+        DB::Game.document_type.should == :game
+      end
+    end
+
+    context 'explicitly specified' do
+      it 'accepts the specification' do
+        DB::Animal.document_type.should == :wild_animal
+      end
+    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 document_class' do
+      person_from_es = DB::Person.get(person.id)
+      person_from_es.should be_a DB::Person
+    end
+  end
+
+  context 'child documents' do
+    let(:person) { DB::Person.create name: 'Superman' }
+    let(:rating) { DB::Rating.create person_id: person.id, stars: 5 }
+
+    it 'creates and retrieves child documents' do
+      persisted_rating = DB::Rating.get(rating.id, person.id)
+      persisted_rating.person_id.should == person.id
+    end
+
+    describe '#get' do
+      it 'demands the parent_id' do
+        expect { DB::Rating.get(rating.id) }.to raise_error(ArgumentError)
+      end
+    end
+
+  end
+end