domain_driven 0.0.8.1 → 0.0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bb12d535dea79b8e0eb9ac30203f27dc0b00670
-  data.tar.gz: d94e3602f95a715d9c750462e11f4dd452c9c6a4
+  metadata.gz: 212330e091078c401fb20be56c0afcbd6ab54743
+  data.tar.gz: 5f897a5e7a5a256d69483407f57585ee1551330f
 SHA512:
-  metadata.gz: 286f326e5e1ba7621cb5ae31c299bb780e13cd05e92eae88bf28d3e46280a8171cafacc083cdd3c9eaad1ae03cb711ecb34f434b82565206fcc4815859871d15
-  data.tar.gz: 40c132e2cc378b64db9fd2d189aaa12fe0d4768239fe894f2dae1e899a41171c7110a0b8ea45281241646bb1bd23815bea75c3f47abd49a5c143150435b3a5a0
+  metadata.gz: 3a5fa9bb7c91cf0bfa70b02801a3d1dad1c26b4101a147a0cfd3006b5aca48d00fc1cf1c20bfbb5c47a5b7b9a733db2489d3bf2fe91482cbd82bdb43c08817b2
+  data.tar.gz: c0d1fe134f69849145a3575c38d03116ee9caec6092cb6dd9a8ba74d3ca50f84646f0c4b586340fb5cbcaece05950d6008dd245022c5fee2b0e0afc11e9dd292

data/domain_driven.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = DomainDriven::VERSION
   spec.authors       = ["Mark Windholtz", "Rob Biedenharn" ]
   spec.email         = ["mark@agiledna.com", "Rob@AgileConsultingLLC.com"]
-  spec.summary       = %q{Domain Driven provides Rails hooks for a Domain Driven Design}
-  spec.description   = %q{Domain Driven provides Rails abstract classes and generators to support for a Domain Driven Design}
+  spec.summary       = %q{domain_driven allows Domain Driven Design (DDD) within RubyOnRails }
+  spec.description   = %q{domain_driven provides Rails abstract classes and generators to support for a Domain Driven Design}
   spec.homepage      = "https://github.com/mwindholtz/domain_driven"
   spec.license       = "MIT"
 

data/lib/domain_driven/block_active_record.rb

@@ -35,8 +35,8 @@ module DomainDriven
 
     private
 
-    def no_db_methods
-      fail ActiveRecordNotAvailableError, "No DB methods on Business Objects"
-    end
+      def no_db_methods
+        fail ActiveRecordNotAvailableError, "No DB methods on Business Objects"
+      end
   end
 end

data/lib/domain_driven/criteria.rb

@@ -24,17 +24,12 @@ module DomainDriven
       @chain = []
     end
 
-    def shift(criteria)
+    def merge(criteria)
       criteria.chain.each do |e| 
         add_message(e)
       end
       self
     end
-
-    def unshift(criteria)
-      criteria.shift(self)
-      criteria
-    end
   
     # sugar
     def add(name, *args)

data/lib/domain_driven/entity.rb

@@ -27,18 +27,19 @@ module DomainDriven
     def entity?
       true
     end
-
+                   
+    alias :_real_class :class
     def class
       _data.class
     end
-
+    
     def self.wrap(entity)
       entity ? new(entity) : nil
     end
 
     def self.wraps(entities)
       return nil unless entities
-      wrap(entities.extend Model).extend Collection
+      wrap(entities.extend Model).extend Collection 
     end
 
   end
@@ -46,9 +47,16 @@ module DomainDriven
   module Collection
     def each
       _data.each do |_item|
-        yield wrap(_item)
+        yield self._real_class.wrap(_item) 
+      end
+    end
+
+    def to_a
+      _data.inject([]) do |array, _item|
+        array << self._real_class.wrap(_item)
       end
     end
+    
     def include?(other)
       if other.respond_to?(:_data)
         _data.include?(other._data)

data/lib/domain_driven/model.rb

@@ -32,7 +32,7 @@ module DomainDriven
         raise DomainDriven::Error.new(error)
       end
 
-    end
+    end # ClassMethods
 
 
     def self.included(klass)

data/lib/domain_driven/repository.rb

@@ -1,11 +1,24 @@
-class DomainDriven::Repository
-   
-  protected
-    def initialize(name, logger)
-      @name   = name
-      @logger = logger
+require 'logger'
+
+module DomainDriven
+  module Repository
+    attr_accessor :logger
+    def to_s
+      "#{@name}"
     end
-    
-    def logger; @logger; end
-      
+ 
+    module ClassMethods
+    end
+  
+    protected
+      def initialize(name)
+        @name   = name
+        self.logger = Logger.new(STDOUT)
+      end
+
+      def self.included(klass)
+        super
+        klass.extend ClassMethods
+      end
+  end
 end

data/lib/domain_driven/service.rb

@@ -12,10 +12,46 @@ module DomainDriven
       raise
     rescue Pundit::NotAuthorizedError
       raise
-    # rescue => x
-    #   perform_rescue(x)
     end
 
+    module Repo  # this is the Repository Factory
+      module_function  
+
+      class << self
+        attr_writer :logger, :factory
+      end
+
+      def logger 
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      def factory
+        return @factory if @factory
+        raise "Repo has no factory initialized.  Add an intializer file with something like this: DomainDriven::Service::Repo.factory = { course:  CourseRepository, ...}" 
+      end
+
+      def for(name) 
+        logger.info("Provisioning Repo #{name}")
+        if repo_class_name = factory[name]
+          repo_class = repo_class_name.to_s.classify.constantize 
+          repo = repo_class.new(name) 
+          repo
+        else
+          raise "repository not found: (#{name})"
+        end
+      end 
+      
+      
+      def method_missing(name,*args)
+        if name.to_s[0...4] == 'for_'
+          self.for(name.to_s[4..-1].to_sym)
+        else
+          super
+        end
+      end
+
+    end  # module Repo 
+
     protected
       def current_user
         context[:current_member]
@@ -25,6 +61,10 @@ module DomainDriven
         context[:request]
       end
 
+      def criteria
+        context[:criteria] || DomainDriven::Criteria.new
+      end
+
       def perform_main
         raise "subclass responsibility for #{self.class} "
       end
@@ -34,6 +74,11 @@ module DomainDriven
         context.fail!
       end
 
-  end
+  end # class Service
+
 
+  class ServiceOrganizer
+    include Interactor::Organizer    
+  end # 
+    
 end

data/lib/domain_driven/version.rb

@@ -1,3 +1,4 @@
 module DomainDriven
-  VERSION = "0.0.8.1"
+  VERSION = "0.0.8.3"
 end
+

data/spec/domain_driven/block_active_record_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+class EntityUnderTest < DomainDriven::Entity
+end
+  
+class RaiseEverything
+  def method_missing(name,*args)
+    raise "RaiseEverything should never receieve any message"
+  end
+end
+
+describe 'Entity' do
+
+  Given! (:model)   { RaiseEverything.new }
+  Given! (:entity)  { EntityUnderTest.new(model) }
+  
+  context 'attempting to call active_record methods should not delegate to the model: ' do
+  
+    context "save"  do
+      When(:result) { entity.save }
+      Then { expect(result).to have_failed(DomainDriven::ActiveRecordNotAvailableError) }
+    end
+
+    context "save!"  do
+      When(:result) { entity.save! }
+      Then { expect(result).to have_failed(DomainDriven::ActiveRecordNotAvailableError) }
+    end
+
+    context "update_attribute"  do
+      When(:result) { entity.update_attribute }
+      Then { expect(result).to have_failed(DomainDriven::ActiveRecordNotAvailableError) }
+    end
+
+    context "update_attribute!"  do
+      When(:result) { entity.update_attribute! }
+      Then { expect(result).to have_failed(DomainDriven::ActiveRecordNotAvailableError) }
+    end
+
+    context "update_attributes"  do
+      When(:result) { entity.update_attributes }
+      Then { expect(result).to have_failed(DomainDriven::ActiveRecordNotAvailableError) }
+    end
+
+    context "update_attributes!"  do
+      When(:result) { entity.update_attributes! }
+      Then { expect(result).to have_failed(DomainDriven::ActiveRecordNotAvailableError) }
+    end
+
+
+  end
+end

data/spec/domain_driven/criteria_spec.rb

@@ -10,16 +10,11 @@ describe 'Criteria' do
     Given                { criteria1.where("id=5") }
     Given                { criteria2.page("3") }
     
-    context "shift" do
-      When(:result)  { criteria1.shift(criteria2) }
+    context "merge" do
+      When(:result)  { criteria1.merge(criteria2) }
       Then           { result.to_s.should eq("target.where(id=5).page(3)") }
     end                                                                      
     
-    context "unshift" do
-      When(:result)  { criteria2.unshift(criteria1) }
-      Then           { result.to_s.should eq("target.where(id=5).page(3)") }
-    end
-    
   end
 
   context "empty criteria has no effect" do

data/spec/domain_driven/entity_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+class EntityUnderTest < DomainDriven::Entity
+  def some_biz_logic; 42; end
+end
+                                                               
+describe 'Entity' do
+
+  Given! (:model)   { FakeModel.new  }  
+  Given! (:entity)  { EntityUnderTest.wrap(model) }
+  
+  context 'has model as _data ' do  
+    Then { entity.entity?.should == true }    
+    Then { entity._data.entity?.should == false }    
+    Then { entity._data.should == model}    
+  end 
+
+  context 'same as  _data ' do  
+    Then { entity._data == entity}    
+  end 
+
+  context 'same as self' do  
+    Then { entity == entity}    
+  end 
+
+  context 'class name' do 
+    context 'wrap same class as model' do 
+      Then { entity.class.to_s == "FakeModel" }  
+    end 
+
+    context 'wrap nil is still nil' do  
+      When(:entity)  { EntityUnderTest.wrap(nil)  }
+      Then { entity.class.to_s == "NilClass"}   
+    end 
+
+    context 'wraps nil is still nil' do  
+      When(:entity_list)  { EntityUnderTest.wraps(nil)  }
+      Then { entity_list.class.to_s == "NilClass"}   
+    end 
+
+    context 'class wraps a set of models' do  
+      When(:entity_list)  { EntityUnderTest.wraps( [model, model])  }
+      Then { entity_list.class.to_s == "Array"}   
+    end 
+
+    context 'class wraps each model into a set of models' do  
+      When(:entity_list)  { EntityUnderTest.wraps( [model, model])  }
+      Then { entity_list.each{|e| e.should be_entity } } 
+      Then { entity_list.each{|e| e.some_biz_logic.should == 42 } }       
+    end 
+
+  end 
+  
+  def self.wrap(entity)
+    entity ? new(entity) : nil
+  end
+  
+
+end

data/spec/domain_driven/model_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+  
+describe 'Model' do
+
+  Given! (:model)   { FakeModel.new  }  
+
+  Then { model._data === model }
+  Then { model.entity? == false }
+  
+  
+  context "find"  do
+    When(:result) { FakeModel.find('ignore') }
+    Then { expect(result).to have_failed( DomainDriven::RecordNotFound, 'clever message' ) }
+  end
+     
+  
+end

data/spec/domain_driven/repository_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+  
+describe 'Repository' do
+
+  Given! (:repository)   { RepositoryUnderTest.new(:fake_repo)  }  
+
+  Then { repository.to_s == 'fake_repo'}  
+end

data/spec/domain_driven/service_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'logger'
+
+class FakeService < DomainDriven::Service
+  def perform_main
+    context[:course] = 'Its a horse-course of course'
+  end
+  
+end
+  
+describe 'Service' do
+ 
+  context 'performing' do
+    When(:result) { FakeService.perform(request: {id: 123},  current_member: 'a-user', 
+                                                             page_param: 1, 
+                                                             logger: Logger.new($stdout)) }
+    Then { result.context[:course] == 'Its a horse-course of course' }
+    Then { result.context[:request][:id] == 123 }
+  end
+  
+  context 'repository exists' do
+       
+    Given(:repo) { DomainDriven::Service::Repo }
+    Given        { repo.logger = FastSpecLogger.instance }
+
+
+    context 'lookup  by string class name' do
+      Given { repo.factory  = { course:   'FakeRepository' } }
+    
+      context 'direct lookup ' do
+        When(:result)  { repo.for(:course) }   
+        Then { result.class.should == FakeRepository }
+      end
+
+      context 'method_missing lookup ' do
+        When(:result)  { repo.for_course }   
+        Then { result.class.should == FakeRepository }
+      end
+    end
+
+    context 'lookup by symbol' do
+      Given { repo.factory  = { course:   :fake_repository } }
+      When(:result)  { repo.for(:course) }   
+      Then { result.class.should == FakeRepository }
+    end
+
+    context 'lookup by lowercase string' do
+      Given { repo.factory  = { course:   'fake_repository' } }
+      When(:result)  { repo.for(:course) }  
+      Then { result.class.should == FakeRepository } 
+    end
+
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -1,6 +1,31 @@
 require 'rubygems'
 require 'rspec-given'
 require 'domain_driven'
+require 'ostruct'
+
+module ActiveRecord 
+  class RecordNotFound  < StandardError 
+  end
+end
+
+class RepositoryUnderTest  
+  include DomainDriven::Repository
+end
+
+class FakeRepository
+  include DomainDriven::Repository
+end
+
+class FakeBaseModel 
+  def self.find(*)
+    raise(ActiveRecord::RecordNotFound.new('clever message')) 
+  end
+end       
+
+class FakeModel < FakeBaseModel 
+  include DomainDriven::Model
+  def course_type; 'A'; end
+end
 
 module Given  
   module ClassExtensions
@@ -8,3 +33,13 @@ module Given
     alias Whereas! Given! 
   end
 end
+
+class FastSpecLogger 
+  def self.instance
+    @instance ||= FastSpecLogger.new
+  end
+  
+  def initialize; @last_error = ''; end
+  def error(value); @last_error = value; end
+  def info(value); @last_error = value; end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: domain_driven
 version: !ruby/object:Gem::Version
-  version: 0.0.8.1
+  version: 0.0.8.3
 platform: ruby
 authors:
 - Mark Windholtz
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-05 00:00:00.000000000 Z
+date: 2014-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -123,7 +123,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Domain Driven provides Rails abstract classes and generators to support
+description: domain_driven provides Rails abstract classes and generators to support
   for a Domain Driven Design
 email:
 - mark@agiledna.com
@@ -148,7 +148,12 @@ files:
 - lib/domain_driven/repository.rb
 - lib/domain_driven/service.rb
 - lib/domain_driven/version.rb
+- spec/domain_driven/block_active_record_spec.rb
 - spec/domain_driven/criteria_spec.rb
+- spec/domain_driven/entity_spec.rb
+- spec/domain_driven/model_spec.rb
+- spec/domain_driven/repository_spec.rb
+- spec/domain_driven/service_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/mwindholtz/domain_driven
 licenses:
@@ -173,7 +178,12 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Domain Driven provides Rails hooks for a Domain Driven Design
+summary: domain_driven allows Domain Driven Design (DDD) within RubyOnRails
 test_files:
+- spec/domain_driven/block_active_record_spec.rb
 - spec/domain_driven/criteria_spec.rb
+- spec/domain_driven/entity_spec.rb
+- spec/domain_driven/model_spec.rb
+- spec/domain_driven/repository_spec.rb
+- spec/domain_driven/service_spec.rb
 - spec/spec_helper.rb