rddd 0.2.1 → 0.2.2

data/Gemfile

@@ -4,6 +4,7 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'rake'
+gem 'curb'
 
 group :testing do
   gem 'rspec'

data/Gemfile.lock

@@ -1,29 +1,31 @@
 PATH
   remote: .
   specs:
-    rddd (0.2.0)
+    rddd (0.2.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    curb (0.8.3)
     diff-lcs (1.1.3)
     metaclass (0.0.1)
-    mocha (0.12.7)
+    mocha (0.13.1)
       metaclass (~> 0.0.1)
-    rake (0.9.2.2)
-    rspec (2.11.0)
-      rspec-core (~> 2.11.0)
-      rspec-expectations (~> 2.11.0)
-      rspec-mocks (~> 2.11.0)
-    rspec-core (2.11.1)
-    rspec-expectations (2.11.3)
+    rake (10.0.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.3)
+    rspec-mocks (2.12.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  curb
   mocha
   rake
   rddd!

data/README.md

@@ -14,69 +14,11 @@ Intention of rddd is to provide basic skeleton for DDD ruby application. Its fra
 * Provide basic DDD elements
 * Support separation of domain from delivery mechanism (mostly web framework such Rails or Sinatra)
 * Support separation of domain from persistancy mechanism
+* Make it easy to postpone decisions about background jobs processing or spliting the application into pieces
 
-## Basic architecture
+## Elements
 
-![Architecture overview](https://github.com/petrjanda/rddd/blob/master/documentation/rddd.png?raw=true)
-
-There are two major entry points to the domain layer from the delivery mechanism. Service bus, for a command execution and 
-Presenter factory, to build up the presented business data (views / reports).
-
-### Service bus
-
-To further enhance the separation of delivery mechanism and domain from each other, every call to the domain service is done through the ```Service bus```. The key design goal is to decouple concrete service implementation from the non-domain code, so they never have to be directly instantiated outside the domain itself. Instead, service bus defines simple protocol for any object, which can call its ```execute``` method with service name and parameters. The instantiation of the service object then becomes implementation detail of domain code, thus leaves the flexibility for alternative solutions within domain.
-
-In Rails application, it might look like:
-
-    class ProjectsController < ApplicationController
-      include ServiceBus
-
-      def create
-        execute(:create_project, params) do |errors|
-          render :new, :errors => errors
-          return
-        end
-
-        redirect_to projects_path, :notice => 'Project was successfully created!'
-      end
-    end 
-
-### Presenter factory
-
-We dont wanna DM (Delivery mechanism) know too much about domain implementation internals. Neither about specific presenter classes. We apply same approach as for Service bus and define simple interface to load a specific view.
-
-In Rails application, it might be used as:
-
-    class ProjectsController < ApplicationController
-      def index
-        PresenterFactory.build(:projects_by_account, :account_id => params[:account_id])
-      end
-    end
-
-### Services
-
-Service is the object to represent a single use case. Its responsibility is to orchestrate the cooperation of multiple aggregate roots (and entities), in a given order defined by use case.
-
-Service takes a list of attributes, which are necessary to execute the given use case. At the end nothing is returned, so service represent the command to the domain and doesn't return any data back. Therefore, client code should construct and pass all the data for the given use case and keep them, so it doesn't have to use presenters to load the result of the operation back.
-
-### Presenters
-
-Presenter is the view to the domain data, which is typically aggregation over multiple aggregate roots and entities. In other
-language presenter is report. In Rddd, views output plain Ruby hashes, thus no domain object is leaking outside the domain
-itself. The key design goal was to dont let framework later call any additional adhoc methods. Thats why framework doesn't interact with view object directly and pure Hash is returned back.
-
-### Aggregate root
-
-### Entity
-
-### Repository
-
-### Factory
-
-## Planned features
-
-* Asynchronous notifications from services - Services might be executed synchronous but also asynchronous way. Simple extension of Service bus would do the trick (add ```execute_async``` method). Its a common case that client code might
-be waiting for the result from background job execution so it can talk back to user. There is a plan to add ```Notifier``` interface, which would be available during service execution. This interface should get concrete implementation within delivery mechanism (websockets, ...).
+![Elements](https://github.com/petrjanda/rddd/blob/master/documentation/rddd-elements.png?raw=true)
 
 ## Project file structure
 

data/lib/rddd/configuration.rb

@@ -8,6 +8,9 @@ module Rddd
   class Configuration
     include Singleton
 
-    attr_accessor :service_creator, :repository_creator
+    attr_accessor :service_creator, 
+      :repository_creator, 
+      :caching_strategy, 
+      :remote_services
   end
 end

data/lib/rddd/presenters/cache_entry.rb

@@ -0,0 +1,28 @@
+module Rddd
+  module Presenters
+    #
+    # Cache object providing several caching methods on top of the chosen
+    # strategy.
+    #
+    class CacheEntry
+      def initialize(key, strategy)
+        @key = key
+        @strategy = strategy
+      end
+
+      def delete
+        write(nil)
+      end
+
+      def read
+        @strategy.get(@key)
+      end
+
+      def write(data, timeout = nil)
+        expire_at = timeout ? Time.now + timeout : nil
+
+        @strategy.set(@key, data, expire_at)
+      end
+    end
+  end
+end

data/lib/rddd/presenters/cacheable.rb

@@ -0,0 +1,148 @@
+module Rddd
+  module Presenters
+    #
+    # View extension, which would make it cacheable. In case you wanna use it
+    # be sure to have a CacheStrategy set in the configuration. As soon as you
+    # include the module, View is gonna start caching without any timeout.
+    #
+    # Here is how you configure your caching with simple strategy:
+    #
+    #   class InMemoryStrategy
+    #     def get(key)
+    #       @entries[key]
+    #     end
+    #
+    #     def set(key, value, options)
+    #       @entries ||= {}
+    #       @entries[key] = value
+    #     end
+    #   end
+    #
+    #   Rddd.configure do |config|
+    #     config.cache_strategy = InMemoryStrategy.new
+    #   end
+    #
+    #
+    # Each time you hit data method, cache is first checked for presence of the
+    # data and if none is there build method is called to compose the view,
+    # result is updated to the cache and returned.
+    #
+    # Usage:
+    #
+    #   class ProjectsView < Rddd::Presenters::Presenter
+    #     extend Rddd::Presenters::Cacheable
+    #
+    #     def build
+    #       Projects.find_by_account_id(@id).map { |project| format(project) }
+    #     end
+    #
+    #     def format(project)
+    #       {
+    #         :name => project.name,
+    #         :deathline => project.deathline.strftime("%d %B %Y")
+    #       }
+    #     end
+    #   end
+    #
+    # ProjectsView.new(account_id).data #= [{:name => 'Rddd', :deathline => '01 January 2013'}]
+    #
+    # ## Timeout
+    #
+    # By default, there is no expiration to the values you store in the cache.
+    # This means, value is theoretically stored for infinite time or until some
+    # purging mechanism clean the code from cache as the less queried one.
+    #
+    # If you want to have more control of when the certain key should be removed
+    # you can use :timeout option. Its configurable per view.
+    #
+    #   class ProjectsView < Rddd::Presenters::Presenter
+    #     extend Rddd::Presenters::Cacheable
+    #
+    #      cache :timeout => 60 * 24
+    #    end
+    #
+    # Above call to ```cache``` with timeout changed its behavior. Each key for a given
+    # view now expires in 24 * 60 minutes, therefore in a day from its creation.
+    #
+    # ## Serialization
+    #
+    # By default cache does no serialization so in general String values are expected
+    # as caches almost exclusively work with Strings. You can inject serializor with
+    # cache configuration.
+    #
+    #   class ProjectsView < Rddd::Presenters::Presenter
+    #     extend Rddd::Presenters::Cacheable
+    #
+    #      cache :serializer => Marshal
+    #    end
+    #
+    # Above would call ```Marshal::dump``` each time before write to cache and
+    # ```Marshal::load``` each time the value is retrieved from it. Yo can inject
+    # your custom serializor class. Make sure it implements the same interface as
+    # Ruby standard ```Marshal::dump``` and ```Marshal::load```.
+    #
+    module Cacheable
+      def self.included(base)
+        base.extend CacheableConfig
+      end
+
+      def self.extended(base)
+        base.class.extend CacheableConfig
+      end
+
+      #
+      # Invalidate the given view so next time its requested no cached value
+      # would be given.
+      #
+      def invalidate
+        __cache__.delete
+      end
+
+      #
+      # Trigger the warming up of the cache for a given view.
+      #
+      def warm_up
+        __update__(build)
+      end
+
+      def data
+        __read__ || __update__(build)
+      end
+
+      private
+
+      def __read__
+        data = __cache__.read
+
+        return nil unless data
+        
+        self.class.serializer ? self.class.serializer::load(data) : data
+      end
+
+      def __update__(data)
+        data = self.class.serializer::dump(data) if self.class.serializer
+
+        __cache__.write(data, self.class.timeout)
+
+        data
+      end
+
+      def __cache__
+        CacheEntry.new(
+          "#{self.class.name.downcase.to_sym}#{id}", 
+          @strategy ||= Configuration.instance.caching_strategy
+        )
+      end
+    end
+
+    module CacheableConfig
+      attr_reader :timeout, :serializer
+
+      def cache(attributes)
+        @timeout = attributes.fetch(:timeout, nil)
+        @timeout = @timeout && 60 * @timeout
+        @serializer = attributes.fetch(:serializer, nil)
+      end
+    end
+  end
+end

data/lib/rddd/presenters/presenter.rb

@@ -0,0 +1,64 @@
+require 'rddd/presenters/cacheable'
+require 'rddd/presenters/cache_entry'
+
+module Rddd
+  #
+  # Presenter is simply a view on the domain data. Presenters should be used
+  # each time, you are about to get some data out of the domain. The result
+  # returned from presenter should be either very dumb DTO (data transfer object)
+  # or one of the base data types like Array, Hash or even some scalar value.
+  #
+  # Key goal is to make a clear boundary to the domain, so none full fledged
+  # business object is leaked outside of it.
+  #
+  # Presenter output is composed inside ```build``` method, which is called each
+  # time someone tries to access view ```data```. Lets take a look at simple example:
+  #
+  #   class EventsByCityAndDatePresenter < Rddd::Presenters::View
+  #     def initialize(city_id, date)
+  #       @city_id = city_id
+  #       @date = date
+  #       
+  #       super("#{city_id}-#{date}")
+  #     end
+  #
+  #     private
+  #
+  #     def build
+  #       format(City.find(@city_id).events_by_date(@date))
+  #     end
+  #
+  #     def format(events)
+  #       events.map { |event| {:name => event.name, :time => event.time} }
+  #     end
+  #   end
+  #
+  #   EventsByCityAndDatePresenter.new(city_id, Date.today).data #= [{:name => 'Happy new year!', :time => '00:00'}]
+  #
+  # ## Caching
+  #
+  # So far we didn't got too many benefits from use of the cache, although
+  # because the View made a clear boundary, there are some benefits which
+  # we can easily build on top of it. First is the caching. In order to plug
+  # it in simply extend Rddd::Presenters::Cacheable. See its documentation.
+  #
+  module Presenters
+    class View
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def data
+        build
+      end
+
+      private
+
+      def build
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rddd/services/remote_service.rb

@@ -0,0 +1,59 @@
+require 'json'
+require 'curb'
+require 'rddd/services/service'
+
+module Rddd
+  module Services
+    #
+    # Remote service is the way to execute logic on different application.
+    # Currently JSON encoded, HTTP based transport is supported. In future
+    # there is a plan for more generic RPC support.
+    #
+    # Usage:
+    #
+    #   # Configure the remote endpoint.
+    #   Rddd.configure do |config|
+    #     config.remote_services = [
+    #       {:namespace => 'projects', :endpoint => 'http://products.dev/'}
+    #     ]
+    #   end
+    #
+    #   # Execute service
+    #   class Test < Sinatra:Base
+    #     get '/:account_id/projects' do
+    #       execute_service(:projects__list, params[:account_id])
+    #     end
+    #   end
+    #
+    #   # Finally here is the remote app
+    #   class Projects < Sinatra:Base
+    #     post ':service_name' do
+    #       execute_service(params[:service_name], request.body)
+    #     end
+    #   end
+    #
+    # As you can see remote app uses the service bus as well. This architecture
+    # would allow you pull part of your application to separate box without need
+    # for any change in your client or services code base.
+    #
+    class RemoteService < Service
+      def initialize(url, attributes = {})
+        super(attributes)
+
+        @url = url
+      end
+
+      def execute
+        JSON.parse(Curl.post(@url, @attributes).body_str)
+      end
+
+      def self.build(namespace, service_name, attributes)
+        remote = Configuration.instance.remote_services.find do |item|
+          item[:namespace] == namespace
+        end
+
+        RemoteService.new("#{remote[:endpoint]}#{service_name}", attributes)
+      end
+    end
+  end
+end

data/lib/rddd/services/service_bus.rb

@@ -1,4 +1,5 @@
 require 'rddd/services/service_factory'
+require 'rddd/services/remote_service'
 
 module Rddd
   #
@@ -41,7 +42,11 @@ module Rddd
       # @param [Block] optional error callback block.
       #
       def execute_service(service_name, attributes = {})
-        service = build_service(service_name, attributes)
+        namespace, service_name = service_name.to_s.split('__') if service_name.to_s.include?('__')
+
+        service = namespace ? \
+          build_remote_service(namespace.to_sym, service_name.to_sym, attributes) : \
+          build_service(service_name, attributes)
 
         unless service.valid?
           yield(service.errors) if block_given?
@@ -56,6 +61,10 @@ module Rddd
       def build_service(service_name, attributes)
         ServiceFactory.build(service_name, attributes)
       end
+
+      def build_remote_service(namespace, service_name, attributes)
+        RemoteService.build(namespace, service_name, attributes)
+      end
     end
   end
 end

data/lib/rddd/version.rb

@@ -1,3 +1,3 @@
 module Rddd
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/spec/lib/presenters/integration_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+require 'rddd/presenters/presenter'
+require 'rddd/aggregates/repositories/base'
+
+class NilStrategy
+  def get(id)
+    nil
+  end
+
+  def set(id, value, timeout)
+    value
+  end
+end
+
+describe Rddd::Presenters::View do
+  before do
+    Rddd.configure do |config|
+      config.caching_strategy = NilStrategy.new
+    end
+  end
+
+  let(:id) { :id }
+
+  let(:view) { Rddd::Presenters::View.new(id).tap {|view| view.extend Rddd::Presenters::Cacheable } }
+
+  let(:nil_strategy) { stub('nil_strategy') }
+
+  let(:data) { stub('data') }
+
+  subject { view }
+
+  describe '#initialize' do
+    its(:id) { should == id}
+  end
+
+  describe '#data' do
+    subject { view.data }
+
+    it { lambda {subject}.should raise_exception NotImplementedError }
+  end
+
+  describe '#warm_up' do
+    subject { view.warm_up }
+
+    before do
+      view.expects(:build).returns(data)
+
+      NilStrategy.any_instance.expects(:set).with("rddd::presenters::#{:view}#{:id}", data, anything)
+    end
+
+    it { subject }
+  end
+
+  describe '#invalidate' do
+    subject { view.invalidate }
+
+    before do
+      NilStrategy.any_instance.expects(:set).with("rddd::presenters::#{:view}#{:id}", nil, nil)
+    end
+
+    it { subject }
+  end
+
+  describe '#data' do
+    subject { view.data }
+
+    context 'without view repository' do
+      before do
+        view.expects(:build).returns(data)
+      end
+
+      it { subject.should == data }
+    end
+
+    context 'not cached' do
+      before do
+        NilStrategy.any_instance.expects(:get).with("rddd::presenters::#{:view}#{:id}").returns(nil)
+
+        view.expects(:build).returns(data)
+
+        NilStrategy.any_instance.expects(:set).with("rddd::presenters::#{:view}#{:id}", data, nil)
+      end
+
+      it { subject.should == data }
+    end
+
+    context 'cached' do
+      before do
+        NilStrategy.any_instance.expects(:get).with("rddd::presenters::#{:view}#{:id}").returns(data)
+      end
+
+      it { subject.should == data }
+    end
+  end
+
+  describe 'view without cache' do
+    class CacheLessView < Rddd::Presenters::View
+      def build
+      end
+    end
+
+    let(:id) { stub('id') }
+
+    let(:cache_less_view) do
+      CacheLessView.new(id)
+    end
+
+    it 'should not try to load data from cache' do
+      NilStrategy.expects(:new).never
+
+      cache_less_view.expects(:build).returns(data)
+
+      cache_less_view.data.should == data
+    end
+  end
+
+  describe 'timeout enabling' do
+    class TimeoutingView < Rddd::Presenters::View
+      include Rddd::Presenters::Cacheable
+
+      cache :timeout => 24 * 60
+
+      def build
+      end
+    end
+
+    let(:id) { :id }
+
+    let(:timeouting_view) do
+      TimeoutingView.new(id)
+    end
+
+    it 'should set timeout to cache data' do
+      NilStrategy.any_instance.expects(:get).with("#{:timeoutingview}#{:id}").returns(nil)
+
+      timeouting_view.expects(:build).returns(data)
+
+      NilStrategy.any_instance.expects(:set).with do |got_id, got_data, got_time|
+        got_id == "#{:timeoutingview}#{:id}" &&
+        got_data == data &&
+        got_time.to_i == (Time.now + 24 * 60 * 60).to_i
+      end
+
+      timeouting_view.data
+    end
+  end
+
+  describe 'with serializer' do
+    class SerializingView < Rddd::Presenters::View
+      include Rddd::Presenters::Cacheable
+
+      cache :serializer => Marshal
+
+      def build
+      end
+    end
+
+    let(:id) { :id }
+
+    let(:data) { SerializingView.new(1) }
+
+    let(:serializing_view) do
+      SerializingView.new(id)
+    end
+
+    it 'should marshal data on write' do
+      NilStrategy.any_instance.expects(:get).with("#{:serializingview}#{:id}").returns(nil)
+
+      serializing_view.expects(:build).returns(data)
+
+      NilStrategy.any_instance.expects(:set).with do |got_id, got_data, got_time|
+        got_id == "#{:serializingview}#{:id}" &&
+        got_data == Marshal::dump(data) &&
+        got_time == nil
+      end
+
+      serializing_view.data
+    end
+
+    it 'should marshal data on read' do
+      NilStrategy.any_instance.expects(:get).twice.with("#{:serializingview}#{:id}") \
+      .returns(Marshal::dump(data))
+
+      serializing_view.data.should be_instance_of SerializingView
+      serializing_view.data.id.should be 1
+    end
+  end
+end

data/spec/lib/services/remote_service_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'rddd/services/remote_service'
+
+module Rddd
+  module Services
+    describe RemoteService do
+      let(:attributes) { stub('attributes') }
+
+      let(:url) { 'http://remote.dev/' }
+
+      describe '#initialize' do
+        subject { RemoteService.new(url, attributes) }
+
+        it 'should store attributes' do
+          subject.instance_variable_get(:@attributes).should == attributes
+        end
+      end  
+
+      describe '#valid?' do
+        subject { RemoteService.new(url).valid? }
+
+        it { should be_true }
+      end
+
+      describe '#execute' do
+        subject { RemoteService.new(url, attributes).execute }
+
+        let(:curl) { stub('curl', :body_str => '{"foo": "bar"}')}
+
+        it 'should raise not implemented' do
+          Curl.expects(:post).with(url, attributes).returns(curl)
+
+          subject.should == {'foo' => 'bar'}
+        end
+      end
+    end
+  end
+end

data/spec/lib/services/service_bus_spec.rb

@@ -22,6 +22,17 @@ describe Rddd::Services::ServiceBus do
       end
     end
 
+    context 'namespaced service with remote http transport' do
+      let(:service) { stub('service', :valid? => true, :execute => nil) }
+
+      it do
+        Rddd::Services::RemoteService.expects(:build).with(:remote, :foo, attributes).returns(service)
+        service.expects(:execute)
+
+        controller.execute_service(:remote__foo, attributes)
+      end
+    end
+
     context 'not valid call to service' do
       context 'without block' do
         before { service.stubs(:valid?).returns(false) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rddd
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-27 00:00:00.000000000 Z
+date: 2013-01-19 00:00:00.000000000 Z
 dependencies: []
 description: Ruby DDD framework
 email:
@@ -27,6 +27,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- documentation/rddd-elements.png
 - documentation/rddd.png
 - lib/core_ext/string.rb
 - lib/rddd.rb
@@ -39,13 +40,14 @@ files:
 - lib/rddd/authorization/rule.rb
 - lib/rddd/authorization/rules_builder.rb
 - lib/rddd/configuration.rb
+- lib/rddd/presenters/cache_entry.rb
+- lib/rddd/presenters/cacheable.rb
+- lib/rddd/presenters/presenter.rb
+- lib/rddd/services/remote_service.rb
 - lib/rddd/services/service.rb
 - lib/rddd/services/service_bus.rb
 - lib/rddd/services/service_factory.rb
 - lib/rddd/version.rb
-- lib/rddd/views/cache.rb
-- lib/rddd/views/cacheable.rb
-- lib/rddd/views/view.rb
 - rddd.gemspec
 - spec/integration_spec.rb
 - spec/lib/aggregates/entity_spec.rb
@@ -54,12 +56,13 @@ files:
 - spec/lib/authorization/integration_spec.rb
 - spec/lib/authorization/rule_spec.rb
 - spec/lib/authorization/rules_builder_spec.rb
+- spec/lib/presenters/integration_spec.rb
 - spec/lib/repositories/repository_factory_spec.rb
 - spec/lib/repositories/repository_spec.rb
+- spec/lib/services/remote_service_spec.rb
 - spec/lib/services/service_bus_spec.rb
 - spec/lib/services/service_factory_spec.rb
 - spec/lib/services/service_spec.rb
-- spec/lib/views/integration_spec.rb
 - spec/spec_helper.rb
 homepage: http://blog.ngneers.com
 licenses: []
@@ -95,11 +98,12 @@ test_files:
 - spec/lib/authorization/integration_spec.rb
 - spec/lib/authorization/rule_spec.rb
 - spec/lib/authorization/rules_builder_spec.rb
+- spec/lib/presenters/integration_spec.rb
 - spec/lib/repositories/repository_factory_spec.rb
 - spec/lib/repositories/repository_spec.rb
+- spec/lib/services/remote_service_spec.rb
 - spec/lib/services/service_bus_spec.rb
 - spec/lib/services/service_factory_spec.rb
 - spec/lib/services/service_spec.rb
-- spec/lib/views/integration_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/lib/rddd/views/cache.rb

@@ -1,24 +0,0 @@
-module Rddd
-  module Views
-    class Cache
-      def initialize(id, repository)
-        @id = id
-        @repository = repository
-      end
-
-      def read
-        @repository.get(@id) if @repository
-      end
-
-      def invalidate
-        @repository.set(@id, nil)
-      end
-
-      def write(data, timeout)
-        expire_at = timeout ? Time.now + timeout : nil
-
-        @repository.set(@id, data, expire_at)
-      end
-    end
-  end
-end

data/lib/rddd/views/cacheable.rb

@@ -1,50 +0,0 @@
-module Rddd
-  module Views
-    module Caching
-      attr_reader :cache_disabled, :timeout
-
-      def cache(attributes)
-        @cache_disabled = attributes.has_key?(:enabled) ? !attributes[:enabled] : false
-        @timeout = attributes.has_key?(:timeout) ? 60 * attributes[:timeout] : nil
-      end
-    end
-
-    module Cacheable
-      def invalidate
-        cache.invalidate if cache
-      end
-
-      def warm_cache
-        update_cache(build)
-      end
-
-      private
-
-      def read_cache
-        cache.read if cache
-      end
-
-      def update_cache(data)
-        cache.write(data, self.class.timeout) if cache
-      end
-
-      def cache
-        nil unless repository
-
-        @cache ||= Cache.new(cache_id, repository)
-      end
-
-      def cache_id
-        "#{name}#{id}"
-      end
-
-      def repository
-        begin
-          @repository ||= ViewRepository.new
-        rescue
-          nil 
-        end
-      end
-    end
-  end
-end

data/lib/rddd/views/view.rb

@@ -1,38 +0,0 @@
-require 'rddd/views/cache'
-require 'rddd/views/cacheable'
-
-module Rddd
-  module Views
-    class View
-      include Cacheable
-      extend Caching
-
-      attr_reader :id
-
-      def initialize(id)
-        @id = id
-      end
-
-      def name
-        self.class.name.downcase.to_sym
-      end
-
-      def build
-        raise NotImplementedError
-      end
-
-      def data
-        return build if self.class.cache_disabled
-
-        cached_data = read_cache
-
-        return cached_data if cached_data
-
-        data = build
-        update_cache(data)
-
-        data
-      end
-    end
-  end
-end

data/spec/lib/views/integration_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-require 'rddd/views/view'
-require 'rddd/aggregates/repositories/base'
-
-class ViewRepository < Rddd::Repositories::Base
-  def get(id)
-  end
-
-  def set(id, value, timeout)
-  end
-end
-
-describe Rddd::Views::View do
-  let(:id) { :id }
-
-  let(:view) { Rddd::Views::View.new(id) }
-
-  let(:view_repository) { stub('view_repository') }
-
-  let(:data) { stub('data') }
-
-  subject { view }
-
-  describe '#initialize' do
-    its(:id) { should == id}
-  end
-
-  describe '#name' do
-    its(:name) { should == :'rddd::views::view' }
-  end
-
-  describe '#build' do
-    subject { view.build }
-
-    it { lambda {subject}.should raise_exception NotImplementedError }
-  end
-
-  describe '#warm_cache' do
-    subject { view.warm_cache }
-
-    before do
-      ViewRepository.expects(:new).returns(view_repository)
-
-      view.expects(:build).returns(data)
-
-      view_repository.expects(:set).with("rddd::views::#{:view}#{:id}", data, anything)
-    end
-
-    it { subject }
-  end
-
-  describe '#invalidate' do
-    subject { view.invalidate }
-
-    before do
-      ViewRepository.expects(:new).returns(view_repository)
-
-      view_repository.expects(:set).with("rddd::views::#{:view}#{:id}", nil)
-    end
-
-    it { subject }
-  end
-
-  describe '#data' do
-    subject { view.data }
-
-    context 'without view repository' do
-      before do
-        view.expects(:build).returns(data)
-      end
-
-      it { subject.should == data }
-    end
-
-    context 'not cached' do
-      before do
-        ViewRepository.expects(:new).returns(view_repository)
-      end
-
-      before do
-        view_repository.expects(:get).with("rddd::views::#{:view}#{:id}").returns(nil)
-
-        view.expects(:build).returns(data)
-
-        view_repository.expects(:set).with("rddd::views::#{:view}#{:id}", data, nil)
-      end
-
-      it { subject.should == data }
-    end
-
-    context 'cached' do
-      before do
-        ViewRepository.expects(:new).returns(view_repository)
-        view_repository.expects(:get).with("rddd::views::#{:view}#{:id}").returns(data)
-      end
-
-      it { subject.should == data }
-    end
-  end
-
-  describe 'cache disabling' do
-    class CacheLessView < Rddd::Views::View
-      cache :enabled => false
-
-      def build
-      end
-    end
-
-    let(:id) { stub('id') }
-
-    let(:cache_less_view) do
-      CacheLessView.new(id)
-    end
-
-    it 'should not try to load data from cache' do
-      ViewRepository.expects(:new).never
-
-      cache_less_view.expects(:build).returns(data)
-
-      cache_less_view.data.should == data
-    end
-  end
-
-  describe 'timeout enabling' do
-    class TimeoutingView < Rddd::Views::View
-      cache :timeout => 24 * 60
-
-      def build
-      end
-    end
-
-    let(:id) { :id }
-
-    let(:timeouting_view) do
-      TimeoutingView.new(id)
-    end
-
-    it 'should set timeout to cache data' do
-      ViewRepository.expects(:new).returns(view_repository)
-      view_repository.expects(:get).with("#{:timeoutingview}#{:id}").returns(nil)
-
-      timeouting_view.expects(:build).returns(data)
-
-      view_repository.expects(:set).with do |got_id, got_data, got_time|
-        got_id == "#{:timeoutingview}#{:id}" &&
-        got_data == data &&
-        got_time.to_i == (Time.now + 24 * 60 * 60).to_i
-      end
-
-      timeouting_view.data
-    end
-  end
-end