hecks-domain 0.1.0 → 0.1.2.rc

data/lib/cli/generate_domain_object.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+module Hecks
+  module Domain
+    module CLI
+      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'
+
+        def self.source_root
+          File.dirname(__FILE__) + '/templates'
+        end
+
+        def create_aggregate_folder
+          directory(options[:type].to_s, '.')
+        end
+
+        private
+
+        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 head_name
+          options[:head_name]
+        end
+
+        def name
+          options[:name]
+        end
+
+        def file_name
+          name.underscore
+        end
+
+        def attribute_names_without_id
+          attributes_without_id.map(&:name)
+        end
+
+        def module_name
+          options[:module_name]
+        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
+          options[:attributes] + ['id:integer']
+        end
+
+        def attributes_without_id
+          options[:attributes]
+        end
+      end
+    end
+  end
+end

data/lib/cli/new.rb

@@ -0,0 +1,50 @@
+# 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module <%= domain_name.camelize %>
+  module Domain
+    module <%= name.camelize %>
+      class <%= options[:head_name].camelize %>
+        attr_accessor <%= option_format('attribute_string', include_id: true) %>
+        def initialize(<%= option_format('param_names', include_id: true) %>)
+        <%= assignment_template(attributes) %>
+        end
+
+        def to_json
+          JSON.generate(<%= option_format('keys_and_values', include_id: true) %>)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module <%= domain_name.camelize %>
+  module Domain
+    module <%= name.camelize %>
+      def self.head
+        <%= options[:head_name].camelize %>
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module <%= domain_name.camelize %>
+  module Domain
+    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
+          Struct.new(:id).new(id)
+        end
+
+        def self.update id, attributes
+          entity = read id
+
+          return unless entity
+          attributes.each do |field, value|
+            entity.send("#{field}=", value)
+          end
+
+          entity
+        end
+
+        def self.read id
+          @collection[id]
+        end
+
+        def self.delete(id)
+          @collection.delete(id)
+        end
+
+        def self.delete_all
+          @collection = {}
+          @last_id    = 0
+        end
+      end
+    end
+  end
+end

data/lib/cli/templates/domain/%name%.gemspec.tt

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = '<%= name %>'
+  s.homepage    = ""
+  s.version     = File.read('Version').gsub("\n", '')
+  s.date        = '2016-09-12'
+  s.summary     = "Summary"
+  s.description = "Description"
+  s.authors     = ["Author"]
+  s.email       = 'email@example.com'
+  s.files       = Dir["lib/**/*"]
+  s.license     = 'MIT'
+end

data/lib/cli/templates/domain/Version

@@ -0,0 +1 @@
+0.0.0

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

@@ -0,0 +1,21 @@
+module <%= module_name %>
+  Dir[File.dirname(__FILE__) + "/domain/**/*.rb"].each {|file| require file}
+
+  def self.domain_modules
+    Domain.constants.map { |name| Domain.const_get(name)}
+  end
+
+  def self.repositories
+    domain_modules.map do |domain_module|
+      [module_name(domain_module), domain_module.const_get(:Repository)]
+    end.to_h
+  end
+
+  def self.module_name(domain_module)
+    domain_module.to_s.downcase.split("::").last.to_sym
+  end
+
+  def self.spec_path
+    File.dirname(__FILE__) + '/../Domain'
+  end
+end

data/lib/cli/templates/domain/spec/spec_helper.rb.tt

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require 'simplecov'
+SimpleCov.start
+require_relative '../lib/<%= name %>'

data/lib/cli/templates/reference/lib/domain/%module_name%/%file_name%.rb.tt

@@ -0,0 +1,25 @@
+module <%= domain_name.camelize %>
+  module Domain
+    module <%= module_name.camelize %>
+      class <%= name.camelize %>
+        attr_accessor :id, :referenced_entity
+
+        def self.factory(group_attributes)
+          return <%= name.camelize %>.new(group_attributes) unless group_attributes.is_a?(Array)
+          group_attributes.map do |attributes|
+            <%= name.camelize %>.new(attributes)
+          end
+        end
+
+        def initialize(id:)
+          @id = id
+          @referenced_entity = <%= options[:referenced_entity] %>
+        end
+
+        def to_json(config)
+          JSON.generate({id: @id, referenced_entity: @referenced_entity})
+        end
+      end
+    end
+  end
+end

data/lib/cli/templates/value_object/lib/domain/%module_name%/%name%.rb.tt

@@ -0,0 +1,24 @@
+module <%= domain_name.camelize %>
+  module Domain
+    module <%= module_name.camelize %>
+      class <%= name.camelize %>
+        attr_accessor <%= attributes_without_id_as_string %>
+
+        def self.factory(group_attributes)
+          return <%= name.camelize %>.new(group_attributes) unless group_attributes.is_a?(Array)
+          group_attributes.map do |attributes|
+            <%= name.camelize %>.new(attributes)
+          end
+        end
+
+        def initialize(<%= option_format('param_names') %>)
+          <%= assignment_template(attributes_without_id) %>
+        end
+
+        def to_json(config)
+          JSON.generate(<%= option_format('keys_and_values') %>)
+        end
+      end
+    end
+  end
+end

data/lib/domain_builder/attribute.rb

@@ -0,0 +1,60 @@
+module Hecks
+  module Domain
+    class DomainBuilder
+      class Attribute
+        attr_writer :type
+        attr_reader :object_name
+
+        def initialize(string)
+          @string = string
+          @object_name = object_name
+        end
+
+        def list?
+          @string.include?("[")
+        end
+
+        def name
+          @string.split(":").first
+        end
+
+        def type
+          return @type if @type
+          @string.split(":").last.delete("[").delete("]").camelize
+        end
+
+        def domain_module
+          return unless @string.include?("::")
+          @string.split("::").first.split(":").last.camelize
+        end
+
+        def copy(new_values={})
+          result = self.class.new(@string)
+          result.type = new_values[:type] if new_values[:type]
+          result
+        end
+
+        def reference?
+          !primitive? && !list?
+        end
+
+        def referenced_object
+          return unless reference?
+          return @string.split("::").last if @string.include?("::")
+          @string.split(":").last
+        end
+
+        def primitive?
+          ['String', 'Integer', 'Currency'].include?(type)
+        end
+
+        def ==(other)
+          return false if other.name != name
+          return false if other.type != type
+          return false if other.domain_module != domain_module
+          return true
+        end
+      end
+    end
+  end
+end

data/lib/domain_builder/domain.rb

@@ -0,0 +1,19 @@
+module Hecks
+  module Domain
+    class DomainBuilder
+      class Domain
+        attr_reader :domain_modules, :name
+        def initialize(name:)
+          @name = name
+          @domain_modules = {}
+        end
+
+        def module(name, &block)
+          result = DomainModule.new(name: name)
+          @domain_modules[name.to_sym] = result
+          yield(result)
+        end
+      end
+    end
+  end
+end

data/lib/domain_builder/domain_builder.rb

@@ -0,0 +1,37 @@
+require_relative 'attribute'
+require_relative 'domain'
+require_relative 'domain_module'
+require_relative 'domain_object'
+require_relative 'value'
+require_relative 'head'
+require_relative 'reference'
+
+module Hecks
+  module Domain
+    class DomainBuilder
+      Types = { string: 'String', integer: 'Integer', currency: 'Currency'}
+
+      attr_accessor :domain, :specification, :name
+
+      def initialize(domain_name:, &block)
+        @name = domain_name
+        @domain = Domain.new(name: domain_name)
+        block.yield(@domain)
+        self
+      end
+
+      def domain_modules
+        @domain.domain_modules
+      end
+
+      def [](module_name)
+        domain_modules[module_name]
+      end
+
+
+      def self.build(domain_name, &block)
+        new(domain_name: domain_name, &block)
+      end
+    end
+  end
+end

data/lib/domain_builder/domain_module.rb

@@ -0,0 +1,28 @@
+module Hecks
+  module Domain
+    class DomainBuilder
+      class DomainModule
+        attr_reader :objects, :name, :references
+
+        def initialize(name:)
+          @name = name
+          @objects = []
+          @references = []
+        end
+
+        def head(name=nil)
+          return (@objects << Head.new(name: name)).last if name
+          objects.find{ |o| o.is_a?(Head) }
+        end
+
+        def value(name)
+          (@objects << Value.new(name: name)).last
+        end
+
+        def reference(name)
+          (@references << Reference.new(name)).last
+        end
+      end
+    end
+  end
+end

data/lib/domain_builder/domain_object.rb

@@ -0,0 +1,43 @@
+module Hecks
+  module Domain
+    class DomainBuilder
+      class DomainObject
+        attr_reader :name, :attributes
+
+        def initialize(name:)
+          @name = name
+        end
+
+        def attributes(*values)
+          return @attributes if @attributes
+          @attributes = values.map { |value| Hecks::Domain::DomainBuilder::Attribute.new(value) }
+        end
+
+        def attribute_hash
+          attributes.map do |attribute|
+            [attribute.name.to_sym, type_with_domain_module(attribute)]
+          end.to_h
+        end
+
+        def attribute_string
+          attributes.map do |attribute|
+            [attribute.name, type_with_domain_module(attribute)].join(':')
+          end
+        end
+
+        def references
+          @attributes.reject(&:primitive?)
+        end
+
+        private
+
+        def type_with_domain_module(attribute)
+          type = DomainBuilder::Types.values.include?(attribute.type) ? "Value" : attribute.type
+          type = '[' + type + ']' if attribute.list?
+          return type unless attribute.domain_module
+          [attribute.domain_module, type].join("::")
+        end
+      end
+    end
+  end
+end

data/lib/domain_builder/head.rb

@@ -0,0 +1,8 @@
+module Hecks
+  module Domain
+    class DomainBuilder
+      class Head < DomainObject
+      end
+    end
+  end
+end

data/lib/domain_builder/reference.rb

@@ -0,0 +1,19 @@
+module Hecks
+  module Domain
+    class DomainBuilder
+      class Reference
+        def initialize(reference)
+          @reference = reference
+        end
+
+        def referenced_entity
+          @reference.split("::").map(&:camelcase).join("::")
+        end
+
+        def name
+          @reference.split("::").last.camelcase + "Reference"
+        end
+      end
+    end
+  end
+end

data/lib/domain_builder/value.rb

@@ -0,0 +1,8 @@
+module Hecks
+  module Domain
+    class DomainBuilder
+      class Value < DomainObject
+      end
+    end
+  end
+end

data/lib/hecks-domain.rb

@@ -0,0 +1,6 @@
+require 'thor'
+
+require_relative 'adapters/adapters'
+require_relative 'domain_builder/domain_builder'
+require_relative 'cli/cli'
+require 'active_support/inflector'