hecks-domain 0.0.1 → 0.1.0

data/lib/hecks/domain/parser.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative 'parser/aggregate'
+require_relative 'parser/domain_object'
+require_relative 'parser/value_field'
+require_relative 'parser/entity_field'
+require_relative 'parser/list_field'
+require_relative 'parser/operation'
+require_relative 'parser/reference_field'
+require_relative 'parser/fields'
+
+class HecksDomain
+  class Parser
+    attr_reader :name, :aggregates, :spec_helper, :string_support,
+                :repository_helper, :factory_loader
+
+    def initialize(name, &block)
+      @name = name
+      @aggregates = []
+      @domain_version = nil
+      instance_eval(&block)
+    end
+
+    def summary(value)
+      @summary = value
+    end
+
+    def description(value)
+      @description = value
+    end
+
+    def version(value)
+      @version = value
+    end
+
+    def gemspec
+      {
+        summary: @summary,
+        description: @description,
+        version: @version,
+        authors: @authors,
+        email: @email,
+        homepage: @homepage
+      }
+    end
+
+    def authors(value)
+      @authors = value
+    end
+
+    def email(value)
+      @email = value
+    end
+
+    def homepage(value)
+      @homepage = value
+    end
+
+    def aggregate(name, &block)
+      @aggregates << Aggregate.new(name, self, &block)
+    end
+
+    def binding
+      super
+    end
+
+    def file_name
+      @file_name = folder_name + '.rb'
+    end
+
+    def folder_name
+      @folder_name = @name.to_s.underscore
+    end
+
+    def domain_version(value)
+      @domain_version = value
+    end
+
+    def for_each_domain_object
+      aggregates.each do |aggregate|
+        aggregate.domain_objects.each do |domain_object|
+          yield aggregate, domain_object
+        end
+      end
+    end
+
+    def for_each_operation
+      for_each_domain_object do |aggregate, domain_object|
+        domain_object.operations_get.each do |operation|
+          yield aggregate, domain_object, operation
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/support/string.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/hecks/domain/support.rb

@@ -0,0 +1 @@
+require_relative 'support/string'

data/lib/hecks/domain/templates/%domain_name%.gemspec.tt

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = '<%= domain_name %>'
+  s.version     = '<%= gemspec[:version] %>'
+  s.licenses    = ['MIT']
+  s.summary     = '<%= gemspec[:summary] %>'
+  s.description = '<%= gemspec[:description] %>'
+  s.authors     = <%= gemspec[:authors] %>
+  s.email       = '<%= gemspec[:email] %>'
+  s.files       = Dir['lib/**/*.rb', 'domain/**/*.rb', 'events/**/*.rb', 'Domainfile']
+  s.homepage    = '<%= gemspec[:homepage] %>'
+  s.metadata    = { 'hecks_domain' => 'true' }
+end

data/lib/hecks/domain/templates/%folder_name%/Domainfile.tt

@@ -0,0 +1,9 @@
+domain(:<%= domain_name %>) do
+  summary        '<FILL ME IN>'
+  description    '<FILL ME IN>'
+  version        '0.0.1'
+  authors        ['<FILL ME IN>']
+  email          '<FILL ME IN>'
+  homepage       'http://www.example.com'
+  domain_version '0.1.0'
+end

data/lib/hecks/domain/templates/%folder_name%/events/command_will_run.rb.tt

@@ -0,0 +1,11 @@
+module <%= domain_name %>
+  module Events
+    class CommandWillRun
+      attr_reader :root, :args, :command_to_run
+      def initialize(command)
+        @root = command.root
+        @command_to_run = command
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/%folder_name%/spec/spec_helper.rb.tt

@@ -0,0 +1 @@
+require_relative '../lib/<%= domain_name.underscore %>'

data/lib/hecks/domain/templates/entity/%aggregate_name%/%domain_object_name%/commands.rb.tt

@@ -0,0 +1,11 @@
+Dir[File.dirname(__FILE__) + '/commands/*.rb'].each {|file| require_relative file }
+module <%= @domain.name %>
+  module Domain
+    module <%= @aggregate.name %>
+      class <%= @domain_object.name %>
+        module Commands
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/entity/%aggregate_name%/%domain_object_name%/events.rb.tt

@@ -0,0 +1,11 @@
+Dir[File.dirname(__FILE__) + '/events/*.rb'].each { |file| require_relative file }
+module <%= domain.name %>
+  module Domain
+    module <%= aggregate.name %>
+      class <%= domain_object.name %>
+        module Events
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/entity/%aggregate_name%/%domain_object_name%/factories/build.rb.tt

@@ -0,0 +1,37 @@
+module <%= @domain.name %>
+  module Domain
+    module <%= @aggregate.name%>
+      class <%= @domain_object.name %>
+        module Factories
+          # Recursively build domain objects.  Used in the domain as the primary
+          # factory. The results of #build can be passed to any other build
+          # factory in the domain. Takes a hash, or a list of hashes.  If a list
+          # is given, it will return a list of the instantiated objects
+          class Build
+            def self.factory(args=nil)
+              return args if args.nil?
+              return args unless args.is_a?(Hash)
+
+              [args].flatten.map do |domain_object_args|
+                new_domain_object(domain_object_args)
+              end.tap do |result|
+                return result.first unless args.is_a?(Array)
+              end
+            end
+
+            def self.new_domain_object(args)
+              <%= @domain_object.name %>.new(
+                args.merge(
+<% @domain_object.fields.each do |field| -%>
+<% next unless (field.respond_to?(:module_name) && field.module_name) -%>
+                  <%= field.name.to_s%>: <%= field.module_name.is_a?(Hash) ? 'Domain::' + field.module_name.to_a.join('::').to_s : field.module_name.to_s %>.build(args[:<%= field.name.to_s%>]<%= ' || []' if field.is_a?(HecksDomain::Parser::ListField) %>),
+<% end -%>
+                )
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/entity/%aggregate_name%/%domain_object_name%/factories.rb.tt

@@ -0,0 +1,11 @@
+Dir[File.dirname(__FILE__) + '/factories/*.rb'].each {|file| require_relative file }
+module <%= domain.name %>
+  module Domain
+    module <%= aggregate.name %>
+      class <%= domain_object.name %>
+        module Factories
+        end
+      end
+    end
+  end
+  end

data/lib/hecks/domain/templates/entity/%aggregate_name%/%domain_object_name%/invariants.rb.tt

@@ -0,0 +1,11 @@
+Dir[File.dirname(__FILE__) + '/invariants/*.rb'].each {|file| require_relative file }
+module <%= domain.name %>
+  module Domain
+    module <%= aggregate.name %>
+      class <%= domain_object.name %>
+        module Invariants
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/entity/%aggregate_name%/%domain_object_name%/queries.rb.tt

@@ -0,0 +1,11 @@
+Dir[File.dirname(__FILE__) + '/queries/*.rb'].each { |file| require_relative file }
+module <%= domain.name %>
+  module Domain
+    module <%= aggregate.name %>
+      class <%= domain_object.name %>
+        module Queries
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/entity/%aggregate_name%/%domain_object_name%/repository.rb.tt

@@ -0,0 +1,68 @@
+
+module <%= domain.name %>
+  module Domain
+    module <%= aggregate.name %>
+      class <%= domain_object.name %>
+        class Repository
+          include Singleton
+          def self.save(object)
+            instance.save(object)
+          end
+
+          def self.fetch(<%= domain_object_name %>)
+            instance.fetch(<%= domain_object_name %>)
+          end
+
+          def initialize
+            @objects = {}
+          end
+
+          def self.create(<%= domain_object_name %>)
+            instance.create(<%= domain_object_name %>)
+          end
+
+          def self.all
+            instance.all
+          end
+
+          def self.destroy(<%= domain_object_name %>)
+            instance.destroy(<%= domain_object_name %>)
+          end
+
+          def all
+            @objects.values
+          end
+
+          def destroy(<%= domain_object_name %>)
+            @objects.delete(<%= domain_object_name %>.id)
+          end
+
+          def create(<%= domain_object_name %>)
+            klass = self.class.const_get(
+              self.class.to_s.gsub('::Repository', '')
+            )
+            domain_object = klass.build(<%= domain_object_name %>)
+            domain_object.tap(&:save)
+          end
+
+          def fetch(fetchable)
+            return @objects[fetchable.id] if fetchable.respond_to?(:id)
+
+            @objects[fetchable]
+          end
+
+          def save(<%= domain_object_name %>)
+            domain_object = <%= domain_object_name %>
+            @objects[<%= domain_object_name %>.hash] = domain_object
+
+            <%= domain_object_name %>.instance_eval do
+              @id = <%= domain_object_name %>.hash
+            end
+
+            <%= domain_object_name %>
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/entity/%aggregate_name%/%domain_object_name%/subscribers.rb.tt

@@ -0,0 +1,11 @@
+Dir[File.dirname(__FILE__) + '/subscribers/*.rb'].each { |file| require_relative file }
+module <%= @domain.name %>
+  module Domain
+    module <%= aggregate.name %>
+      class <%= domain_object.name %>
+        module Subscribers
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/entity/%aggregate_name%/%domain_object_name%.rb.tt

@@ -0,0 +1,34 @@
+module <%= domain.name %>
+  module Domain
+    module <%= aggregate.name %>
+      class <%= domain_object.name %>
+        <%= 'include Support::Root' if domain_object.is_a?(HecksDomain::Parser::Root) %>
+        include Support::DomainObject
+
+        attr_reader <%= domain_object.public_accessors %>
+
+        def initialize(<%= domain_object.initializer_attributes %>)
+<% domain_object.fields.each do |field| -%>
+          <%= "@#{field.name} = #{field.initial_state}" %>
+<% end -%>
+        end
+<% domain_object.boolean_accessors.each do |field| -%>
+
+        def <%= field.name %>?
+          @<%= field.name %>
+        end
+<% end -%>
+<% domain_object.list_accessors.each do |field| -%>
+
+        def <%= field.name %>
+          @<%= field.name %>.clone.freeze
+        end
+<% end -%>
+
+        private
+
+        attr_writer <%= domain_object.private_accessors %>
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/%domain_name%.rb.tt

@@ -0,0 +1,9 @@
+require_relative 'support'
+Dir[File.dirname(__FILE__) + "/../events/*.rb"].each { |file| require_relative file }
+<% domain.aggregates.each do |aggregate| -%>
+require_relative '../domain/<%= aggregate.folder_name %>/root'
+<% end -%>
+
+module <%= domain.name %>
+  class InvariantViolationError < StandardError; end
+end

data/lib/hecks/domain/templates/lib/support/commands/command_loader.rb

@@ -0,0 +1,18 @@
+class Support
+  module Commands
+    module CommandLoader
+      def self.included(base)
+        return unless base.constants.include?(:Commands)
+        base::Commands.constants.each do |constant|
+          base.class_eval "
+            def #{constant.to_s.underscore}!(*args, &block)
+              Support::Commands::CommandRunner.run(
+                Commands::#{constant}.new(self, *args), &block
+              )
+            end
+          "
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/commands/command_runner.rb

@@ -0,0 +1,17 @@
+class Support
+  module Commands
+    module CommandRunner
+      def self.run(command, &block)
+        Events::DomainEventPublisher.emit(
+          const_get(command.class.to_s.split('::')[0])::
+            Events::CommandWillRun.new(command)
+        )
+
+        command.call
+        command.root.test_invariants(command)
+        Events::DomainEventPublisher.emit(command, &block)
+        command
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/commands.rb

@@ -0,0 +1,2 @@
+require_relative 'commands/command_runner'
+require_relative 'commands/command_loader'

data/lib/hecks/domain/templates/lib/support/domain_object.rb

@@ -0,0 +1,25 @@
+class Support
+  module DomainObject
+    TYPES = %w[services invariants factories].freeze
+
+    LOADERS = [
+      Support::Factories::FactoryLoader, Support::Invariants::InvariantLoader
+    ].freeze
+
+    def self.included(base)
+      path = [
+        '../../domain',
+        base.to_s.split('::')[-2].underscore.downcase,
+        base.to_s.split('::')[-1].underscore.downcase
+      ].join('/')
+
+      TYPES.each do |name|
+        Dir[File.dirname(__FILE__) + "/#{path}/" + name + '/*.rb'].each do |file|
+          require_relative file
+        end
+      end
+
+      LOADERS.each { |loader| base.include(loader) }
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/events/domain_event.rb

@@ -0,0 +1,14 @@
+class Support
+  module Events
+    class DomainEvent
+      attr_reader :type, :name, :command, :args, :root
+      def initialize(command)
+        @command = command
+        @root = @command.root
+        @type = @command.class
+        @name = @type.to_s.underscore
+        @args = command.args
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/events/domain_event_publisher.rb

@@ -0,0 +1,34 @@
+class Support
+  module Events
+    class DomainEventPublisher
+      include Singleton
+      attr_reader :subscribers
+      def initialize
+        @subscribers = []
+      end
+
+      def self.emit(command, &block)
+        instance.emit(DomainEvent.new(command), &block)
+      end
+
+      def self.subscribe(subscriber)
+        instance.subscribers << subscriber
+      end
+
+      def self.cancel_subscription(subscriber)
+        instance.subscribers.delete(subscriber)
+      end
+
+      def emit(domain_event, &block)
+        yield domain_event if block
+        @subscribers.each do |subscriber|
+          next unless subscriber.domain_event == '*' ||
+                      subscriber.domain_event == domain_event.type
+
+          subscriber.notify(domain_event)
+        end
+      end
+    end
+  end
+end
+

data/lib/hecks/domain/templates/lib/support/events.rb

@@ -0,0 +1,14 @@
+require_relative 'events/domain_event_publisher'
+require_relative 'events/domain_event'
+
+class Support
+  module Events
+    def self.subscribe(subscriber)
+      DomainEventPublisher.subscribe(subscriber)
+    end
+
+    def self.cancel_subscription(subscriber)
+      DomainEventPublisher.cancel_subscription(subscriber)
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/factories/factory_loader.rb

@@ -0,0 +1,21 @@
+class Support
+  module Factories
+    module FactoryLoader
+      def self.included(base)
+        return unless base.constants.include?(:Factories)
+        base::Factories.constants.each do |constant|
+          base.class_eval "
+            def #{constant.to_s.underscore}(*args)
+              #{base}::Factories::#{constant}.factory(self, *args)
+            end
+          "
+          base.instance_eval "
+            def #{constant.to_s.underscore}(*args)
+              #{base}::Factories::#{constant}.factory(*args)
+            end
+          "
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/factories.rb

@@ -0,0 +1 @@
+require_relative 'factories/factory_loader'

data/lib/hecks/domain/templates/lib/support/invariants/invariant_loader.rb

@@ -0,0 +1,24 @@
+class Support
+  module Invariants
+    module InvariantLoader
+      def self.included(base)
+        return unless base.constants.include?(:Invariants)
+        base::Invariants.constants.each do |invariant|
+          base.include base::Invariants.const_get(invariant)
+        end
+      end
+
+      def test_invariants(command = nil)
+        return unless self.class.constants.include?(:Invariants)
+        self.class::Invariants.constants.each do |invariant|
+          invariant_class = self.class::Invariants.const_get(invariant)
+          invariant_class.instance_methods(false).each do |method|
+            raise "invariant methods must be prepended with \"invariant_test\".  Try:\n" +
+            "#{invariant_class}#invariant_test_#{method.to_s}" unless method.to_s =~ /^invariant.*/
+            send(method, command)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/queries/query_loader.rb

@@ -0,0 +1,18 @@
+class Support
+  module Queries
+    module QueryLoader
+      def self.included(base)
+        return unless base.constants.include?(:Queries)
+        base::Queries.constants.each do |constant|
+          raise "Query name `#{constant}` not valid.  Query classes must start with 'Find'" unless constant.to_s.underscore =~ /^find_.*/
+          
+          base.class_eval "
+            def #{constant.to_s.underscore}(*args, &block)
+              Queries::#{constant}.query(self, *args)
+            end
+          "
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/queries.rb

@@ -0,0 +1 @@
+require_relative 'queries/query_loader'

data/lib/hecks/domain/templates/lib/support/repositories/repository_loader.rb

@@ -0,0 +1,32 @@
+class Support
+  module Repositories
+    module RepositoryLoader
+      def self.included(base)
+        base.class_eval do
+          def save
+            test_invariants
+            self.class::Repository.save(self)
+          end
+
+          def destroy
+            self.class::Repository.destroy(self)
+          end
+        end
+
+        base.instance_eval do
+          def create(domain_object = nil)
+            self::Repository.create(domain_object).tap(&:test_invariants)
+          end
+
+          def fetch(fetchable)
+            self::Repository.fetch(fetchable)
+          end
+
+          def all
+            self::Repository.all
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/root.rb

@@ -0,0 +1,27 @@
+class Support
+  module Root
+    TYPES = %w[commands services invariants queries events subscribers].freeze
+
+    LOADERS = [
+      Support::Commands::CommandLoader, Support::Queries::QueryLoader,
+      Support::Repositories::RepositoryLoader
+    ].freeze
+
+    def self.included(base)
+      path = [
+        '../../domain',
+        base.to_s.split('::')[-2].underscore.downcase,
+        base.to_s.split('::')[-1].underscore.downcase
+      ].join('/')
+
+      require_relative path + '/repository'
+
+      TYPES.each do |name|
+        Dir[File.dirname(__FILE__) + "/#{path}/" + name + '/*.rb']
+          .each { |file| require_relative file }
+      end
+
+      LOADERS.each { |loader| base.include(loader) }
+    end
+  end
+end

data/lib/hecks/domain/templates/lib/support/support/string.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/hecks/domain/templates/lib/support.rb

@@ -0,0 +1,11 @@
+require 'singleton'
+require_relative 'support/repositories/repository_loader'
+require_relative 'support/support/string'
+require_relative 'support/events'
+require_relative 'support/commands'
+require_relative 'support/queries'
+require_relative 'support/factories'
+require_relative 'support/invariants/invariant_loader'
+require_relative 'support/queries/query_loader'
+require_relative 'support/root'
+require_relative 'support/domain_object'