hecks-domain 0.1.16.rc → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7ac35f924127c1f9983b3b9771813a454bf49ab
-  data.tar.gz: d1f2ce2bba8052d76d86ed132eb2aa999b65c035
+  metadata.gz: 36115f8f920445947e5b136b7e6ec72f6f6f697f
+  data.tar.gz: 38140ef2136f7e3a3e0f742effc121cacf288001
 SHA512:
-  metadata.gz: 1a697a9a0aa0183f9f220961c476f1e876c09db534d800e9c7d81fa714470f44b7d0309ff08af3b8b5975b4169ecaad9a8b78de082a99a4507eb5594c8643546
-  data.tar.gz: d20d3bd3b3bc4e1a4099a6743f4d13762469e97bdf704116296ff36b068708513dc3b30dafdf502a942a0d5cca37177bbfe237d4f07372b460aed6d1104da627
+  metadata.gz: af0c0408823a0d433eef1f7a84720b3256c6f85f5cc3765d9d4699e15f88af6df7d916bd2e49c409cf116e56fdfd27427814945075214d5d7f5771a5b5175b25
+  data.tar.gz: ae1950175278917b083ef1a72ecb77c0b3e760856cc213bf01925a2c3ac83fbd7aae31c3438b503b5d0add46d73241281d9ee82ba5be182c25e16fb2b206c43e

data/lib/cli/builder/aggregate_command_line_builder.rb

@@ -1,19 +1,18 @@
-module Hecks
-  module Domain
-    module CLI
-      class CommandBuilder
-        module AggregateCommandLineBuilder
-          def self.build(domain, runner)
-            domain.domain_modules.values.each do |domain_module|
-              runner.call(
-                [
-                  'generate domain_object',
-                  '-t', 'aggregate',
-                  '-n', domain_module.name,
-                  '--head_name', domain_module.head.name,
-                  '-a', domain_module.head.attribute_string
-                ])
-            end
+module HecksDomain
+  module CLI
+    class CommandBuilder
+      # Build an aggregate
+      module AggregateCommandLineBuilder
+        def self.build(domain, runner)
+          domain.domain_modules.values.each do |domain_module|
+            runner.call(
+              [
+                'generate domain_object',
+                '-t', 'aggregate',
+                '-n', domain_module.name,
+                '--head_name', domain_module.head.name,
+                '-a', domain_module.head.attribute_string
+              ])
           end
         end
       end

data/lib/cli/builder/reference_command_line_builder.rb

@@ -1,19 +1,18 @@
-module Hecks
-  module Domain
-    module CLI
-      class CommandBuilder
-        module ReferenceCommandLineBuilder
-          def self.build(domain, runner)
-            domain.domain_modules.values.each do |domain_module|
-              domain_module.references.each do |reference|
-                runner.call([
-                  'generate domain_object',
-                  '-t', 'reference',
-                  '-n', reference.name,
-                  '-m', domain_module.name,
-                  '-r', reference.referenced_entity
-                ])
-              end
+module HecksDomain
+  module CLI
+    class CommandBuilder
+      # Build a Reference object
+      module ReferenceCommandLineBuilder
+        def self.build(domain, runner)
+          domain.domain_modules.values.each do |domain_module|
+            domain_module.references.each do |reference|
+              runner.call([
+                'generate domain_object',
+                '-t', 'reference',
+                '-n', reference.name,
+                '-m', domain_module.name,
+                '-r', reference.referenced_entity
+              ])
             end
           end
         end

data/lib/cli/builder/value_object_command_line_builder.rb

@@ -1,19 +1,18 @@
-module Hecks
-  module Domain
-    module CLI
-      class CommandBuilder
-        module ValueObjectCommandLineBuilder
-          def self.build(domain, runner)
-            domain.domain_modules.values.each do |domain_module|
-              (domain_module.objects - [domain_module.head]).each do |value_object|
-                runner.call([
-                  'generate domain_object',
-                  '-t', 'value_object',
-                  '-n', value_object.name,
-                  '-m', domain_module.name,
-                  '-a', value_object.attribute_string
-                ])
-              end
+module HecksDomain
+  module CLI
+    class CommandBuilder
+      # Build a value object
+      module ValueObjectCommandLineBuilder
+        def self.build(domain, runner)
+          domain.domain_modules.values.each do |domain_module|
+            (domain_module.objects - [domain_module.head]).each do |value_object|
+              runner.call([
+                'generate domain_object',
+                '-t', 'value_object',
+                '-n', value_object.name,
+                '-m', domain_module.name,
+                '-a', value_object.attribute_string
+              ])
             end
           end
         end

data/lib/cli/command_builder.rb

@@ -1,58 +1,63 @@
 # frozen_string_literal: true
 require 'pathname'
 
-module Hecks
-  module Domain
-    module CLI
-      class CommandBuilder
-        def initialize(name:, dry_run: false)
-          @name   = name
-          @domain = DOMAIN
-          @dry_run = dry_run
-          @runner = CommandRunner.new(domain, name, dry_run)
-        end
+if ENV['HECKS_DOMAIN_PATH']
+  load(ENV['HECKS_DOMAIN_PATH'])
+else
+  load('Domain') if File.exist?('Domain')
+end
 
-        def call
-          delete_tmpfile
-          puts "\n"
-          generate :domain
-          generate :modules
-          generate :value_objects
-          generate :references
-          execute_tmpfile && return unless @dry_run
-          print_tmpfile
-        end
+module HecksDomain
+  module CLI
+    # Class for generating domain objects
+    class CommandBuilder
+      def initialize(name:, dry_run: false)
+        @name   = name
+        @domain = DOMAIN
+        @dry_run = dry_run
+        @runner = HecksCLI::CommandRunner.new(domain, name, dry_run)
+      end
 
-        private
+      def call
+        delete_tmpfile
+        puts "\n"
+        generate :domain
+        generate :modules
+        generate :value_objects
+        generate :references
+        execute_tmpfile && return unless @dry_run
+        print_tmpfile
+      end
 
-        attr_reader :runner, :name, :domain
+      private
 
-        def print_tmpfile
-          puts File.read('tmp/hecks')
-        end
+      attr_reader :runner, :name, :domain
 
-        def delete_tmpfile
-          return unless Pathname('tmp/hecks').exist?
-          FileUtils.rm('tmp/hecks')
-        end
+      def print_tmpfile
+        puts File.read('tmp/hecks')
+      end
 
-        def execute_tmpfile
-          exec('bash -x tmp/hecks')
-        end
+      def delete_tmpfile
+        return unless Pathname('tmp/hecks').exist?
+        FileUtils.rm('tmp/hecks')
+      end
+
+      def execute_tmpfile
+        exec('bash -x tmp/hecks')
+      end
 
-        def generate(command)
-          case command
-          when :references
-            ReferenceCommandLineBuilder.build(domain, runner)
-          when :domain
-            runner.call(['new', '-n', name])
-          when :modules
-            AggregateCommandLineBuilder.build(domain, runner)
-          when :value_objects
-            ValueObjectCommandLineBuilder.build(domain, runner)
-          else
-            raise "unrecognized command: #{command}"
-          end
+      def generate(command)
+        case command
+        when :references
+          ReferenceCommandLineBuilder.build(domain, runner)
+        when :domain
+          runner.call(['new', '-n', name])
+        when :modules
+          AggregateCommandLineBuilder.build(domain, runner)
+        when :value_objects
+          ValueObjectCommandLineBuilder.build(domain, runner)
+        else
+          raise "unrecognized command: #{command}"
         end
       end
     end

data/lib/cli/domain_object/assignment_template.rb

@@ -1,41 +1,40 @@
-module Hecks
-  module Domain
-    module CLI
-      class GenerateDomainObject
-        class AssignmentTemplate
-          def initialize(attributes)
-            @attributes = attributes
-          end
+module HecksDomain
+  module CLI
+    # Helpful methods for supporting object creation
+    class GenerateDomainObject
+      class AssignmentTemplate
+        def initialize(attributes)
+          @attributes = attributes
+        end
 
-          def render
-            attributes.map do |attribute|
-              @attribute = Hecks::Domain::DomainBuilder::Attribute.new(attribute)
-              do_assignment
-            end.join("\n")
-          end
+        def render
+          attributes.map do |attribute|
+            @attribute = HecksDomainBuilder::Attribute.new(attribute)
+            do_assignment
+          end.join("\n")
+        end
 
-          private
+        private
 
-          attr_reader :attributes, :attribute
+        attr_reader :attributes, :attribute
 
-          def do_assignment
-            return value_assignment if Hecks::Domain::DomainBuilder::Types.values.include?(@attribute.type)
-            return value_assignment if @attribute.type == 'Value'
-            return reference_factory_assignment if attribute.domain_module
-            return factory_assignment
-          end
+        def do_assignment
+          return value_assignment if HecksDomainBuilder::Types.values.include?(@attribute.type)
+          return value_assignment if @attribute.type == 'Value'
+          return reference_factory_assignment if attribute.domain_module
+          return factory_assignment
+        end
 
-          def reference_factory_assignment
-            "@#{attribute.name} = #{attribute.type}Reference.factory(#{attribute.name})"
-          end
+        def reference_factory_assignment
+          "@#{attribute.name} = #{attribute.type}Reference.factory(#{attribute.name})"
+        end
 
-          def factory_assignment
-            "@#{attribute.name} = #{attribute.type}.factory(#{attribute.name})"
-          end
+        def factory_assignment
+          "@#{attribute.name} = #{attribute.type}.factory(#{attribute.name})"
+        end
 
-          def value_assignment
-            "@#{attribute.name} = #{attribute.name}"
-          end
+        def value_assignment
+          "@#{attribute.name} = #{attribute.name}"
         end
       end
     end

data/lib/cli/domain_object/option_formatter.rb

@@ -1,33 +1,32 @@
-module Hecks
-  module Domain
-    module CLI
-      class GenerateDomainObject
-        class OptionFormatter
-          def initialize(attributes)
-            @attributes = attributes.map do |attribute|
-              Hecks::Domain::DomainBuilder::Attribute.new(attribute)
-            end
+module HecksDomain
+  module CLI
+    class GenerateDomainObject
+      # Generates options in templates
+      class OptionFormatter
+        def initialize(attributes)
+          @attributes = attributes.map do |attribute|
+            HecksDomainBuilder::Attribute.new(attribute)
           end
+        end
 
-          def call(format, include_id: false)
-            case format
-            when 'keys_and_values'
-              attributes(include_id).map { |attribute| (attribute.name + ': ' + attribute.name) }.join(', ')
-            when 'attribute_string'
-              attributes(include_id).map { |attribute| ':' + attribute.name }.join ', '
-            when 'param_names'
-              attributes(include_id).map { |attribute| attribute.name + ':' }.join ', '
-            end
+        def call(format, include_id: false)
+          case format
+          when 'keys_and_values'
+            attributes(include_id).map { |attribute| (attribute.name + ': ' + attribute.name) }.join(', ')
+          when 'attribute_string'
+            attributes(include_id).map { |attribute| ':' + attribute.name }.join ', '
+          when 'param_names'
+            attributes(include_id).map { |attribute| attribute.name + ':' }.join ', '
           end
+        end
 
-          private
+        private
 
-          def attributes(include_id)
-            if include_id
-              @attributes + [Hecks::Domain::DomainBuilder::Attribute.new('id:value')]
-            else
-              @attributes
-            end
+        def attributes(include_id)
+          if include_id
+            @attributes + [HecksDomainBuilder::Attribute.new('id:value')]
+          else
+            @attributes
           end
         end
       end

data/lib/cli/generate_domain_object.rb

@@ -1,70 +1,69 @@
 # frozen_string_literal: true
-module Hecks
-  module Domain
-    module CLI
-      class GenerateDomainObject < Thor::Group
-        include Thor::Actions
+module HecksDomain
+  module CLI
+    # Generate a domain object
+    class GenerateDomainObject < Thor::Group
+      include Thor::Actions
 
-        class_option :head_name,   aliases: '-h', desc: 'the name of the aggregate head'
-        class_option :attributes,  aliases: '-a', type: :array, desc: 'attributes for the aggregate head'
-        class_option :name,        aliases: '-n', desc: 'attributes for the aggregate head'
-        class_option :type,        aliases: '-t', desc: 'The type of domain object you want to create'
-        class_option :module_name, aliases: '-m', desc: 'Domain Module'
-        class_option :referenced_entity, aliases: '-r', desc: 'Referenced Entity'
+      class_option :head_name,   aliases: '-h', desc: 'the name of the aggregate head'
+      class_option :attributes,  aliases: '-a', type: :array, desc: 'attributes for the aggregate head'
+      class_option :name,        aliases: '-n', desc: 'attributes for the aggregate head'
+      class_option :type,        aliases: '-t', desc: 'The type of domain object you want to create'
+      class_option :module_name, aliases: '-m', desc: 'Domain Module'
+      class_option :referenced_entity, aliases: '-r', desc: 'Referenced Entity'
 
-        def self.source_root
-          File.dirname(__FILE__) + '/templates'
-        end
+      def self.source_root
+        File.dirname(__FILE__) + '/templates'
+      end
 
-        def create_aggregate_folder
-          directory(options[:type].to_s, '.')
-        end
+      def create_aggregate_folder
+        directory(options[:type].to_s, '.')
+      end
 
-        private
+      private
 
-        def assignment_template(attributes)
-          AssignmentTemplate.new(attributes).render
-        end
+      def assignment_template(attributes)
+        AssignmentTemplate.new(attributes).render
+      end
 
-        def option_format(format, include_id: false)
-          OptionFormatter.new(options[:attributes]).call(format, include_id: include_id)
-        end
+      def option_format(format, include_id: false)
+        OptionFormatter.new(options[:attributes]).call(format, include_id: include_id)
+      end
 
-        def head_name
-          options[:head_name]
-        end
+      def head_name
+        options[:head_name]
+      end
 
-        def name
-          options[:name]
-        end
+      def name
+        options[:name]
+      end
 
-        def file_name
-          name.underscore
-        end
+      def file_name
+        name.underscore
+      end
 
-        def attribute_names_without_id
-          attributes_without_id.map(&:name)
-        end
+      def attribute_names_without_id
+        attributes_without_id.map(&:name)
+      end
 
-        def module_name
-          options[:module_name]
-        end
+      def module_name
+        options[:module_name]
+      end
 
-        def domain_name
-          Dir.pwd.split('/').last
-        end
+      def domain_name
+        Dir.pwd.split('/').last
+      end
 
-        def attributes_without_id_as_string
-          attributes_without_id.map { |attribute| ':' + Hecks::Domain::DomainBuilder::Attribute.new(attribute).name }.join ', '
-        end
+      def attributes_without_id_as_string
+        attributes_without_id.map { |attribute| ':' + HecksDomainBuilder::Attribute.new(attribute).name }.join ', '
+      end
 
-        def attributes
-          options[:attributes] + ['id:integer']
-        end
+      def attributes
+        options[:attributes] + ['id:integer']
+      end
 
-        def attributes_without_id
-          options[:attributes]
-        end
+      def attributes_without_id
+        options[:attributes]
       end
     end
   end

data/lib/cli/new.rb

@@ -1,49 +1,48 @@
 # frozen_string_literal: true
-load('Domain') if File.exist?('Domain')
-module Hecks
-  module Domain
-    module CLI
-      class New < Thor::Group
-        namespace :hecks
-        include Thor::Actions
-
-        class_option :nobuilder, aliases: '-n', desc: 'load schema from builder'
-        class_option :dry_run, aliases: '-d', desc: 'Use when specifying a schema file to output the commands, without running them'
-
-        def self.source_root
-          File.dirname(__FILE__)
-        end
-
-        def load_from_builder
-          return if options[:nobuilder]
-          CommandBuilder.new(
-            name:    File.basename(Dir.getwd),
-            dry_run: !options[:dry_run].nil?
-          ).call
-        end
-
-        def create_hexagon_folder
-          return unless options[:nobuilder]
-          directory('templates/domain', ".")
-        end
-
-        private
-
-        def name
-          File.basename(Dir.getwd)
-        end
-
-        def module_name
-          name.camelize
-        end
-
-        def domain_module_name
-          domain_name.camelize
-        end
-
-        def condensed_module_name
-          name.delete('_')
-        end
+
+module HecksDomain
+  module CLI
+    # Generate a new domain project
+    class New < Thor::Group
+      namespace :hecks
+      include Thor::Actions
+
+      class_option :nobuilder, aliases: '-n', desc: 'load schema from builder'
+      class_option :dry_run, aliases: '-d', desc: 'Use when specifying a schema file to output the commands, without running them'
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      def load_from_builder
+        return if options[:nobuilder]
+        CommandBuilder.new(
+          name:    File.basename(Dir.getwd),
+          dry_run: !options[:dry_run].nil?
+        ).call
+      end
+
+      def create_hexagon_folder
+        return unless options[:nobuilder]
+        directory('templates/domain', ".")
+      end
+
+      private
+
+      def name
+        File.basename(Dir.getwd)
+      end
+
+      def module_name
+        name.camelize
+      end
+
+      def domain_module_name
+        domain_name.camelize
+      end
+
+      def condensed_module_name
+        name.delete('_')
       end
     end
   end

data/lib/cli/templates/aggregate/lib/domain/%name%/repository.rb.tt

@@ -3,12 +3,10 @@ module <%= domain_name.camelize %>
     module <%= name.camelize %>
       class Repository
         @collection = {}
-        @last_id    = 0
 
         def self.create attributes={}
-          id              = @last_id + 1
-          @collection[id] = <%= options[:head_name].camelize %>.new(attributes.merge(id: id))
-          @last_id        = id
+          id              = attributes[:id]
+          @collection[id] = <%= options[:head_name].camelize %>.new(attributes)
           Struct.new(:id).new(id)
         end
 
@@ -33,7 +31,6 @@ module <%= domain_name.camelize %>
 
         def self.delete_all
           @collection = {}
-          @last_id    = 0
         end
       end
     end