hecks-domain 0.0.1 → 0.1.0

data/lib/adapters/sql_database/commands/update/delete_references.rb

@@ -1,45 +0,0 @@
-module Hecks
-  module Domain
-    module Adapters
-      class SQLDatabase
-        module Commands
-          class Update
-            class DeleteReferences
-              attr_reader :attributes
-
-              def initialize(table:, attributes:, reference:)
-                @table = table
-                @attributes = attributes
-                @reference = reference
-                @where_clause = {}
-                @dataset = DB[JoinTable.new(@table, @reference).name.to_sym]
-              end
-
-              def call
-                build_where_clause
-                delete_references
-                remove_references_from_attributes
-                self
-              end
-
-              private
-
-              def build_where_clause
-                DB[JoinTable.new(@table, @reference).name.to_sym]
-              end
-
-              def remove_references_from_attributes
-                @attributes.delete(@reference.name.to_sym)
-              end
-
-              def delete_references
-                return unless @reference.list?
-                @dataset.where(@where_clause).delete
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/adapters/sql_database/commands/update/link_to_references.rb

@@ -1,45 +0,0 @@
-module Hecks
-  module Domain
-    module Adapters
-      class SQLDatabase
-        module Commands
-          class Update
-            class LinkToReferences
-              attr_reader :reference_ids
-              def initialize(reference:, table:, reference_ids:, attributes:)
-                @reference = reference
-                @reference_ids = reference_ids
-                @table = table
-                @attributes = attributes
-                @column = Column.factory(@reference)
-                @record = {}
-              end
-
-              def call
-                make_linking_records
-                make_foreign_keys
-                self
-              end
-
-              private
-
-              def make_linking_records
-                return unless @reference.list?
-                @reference_ids[@reference.name.to_sym].each do |value|
-                  @record[@column.to_foreign_key] = value
-                  @record[@table.to_foreign_key] = @attributes[:id]
-                  DB[JoinTable.new(@table, @reference).name.to_sym].insert(@record)
-                end
-              end
-
-              def make_foreign_keys
-                return if @reference.list?
-                @attributes[@column.to_foreign_key] = @reference_ids[@reference.name]
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/adapters/sql_database/sql_database.rb

@@ -1 +0,0 @@
-require_relative 'cli/cli'

data/lib/cli/builder/aggregate_command_line_builder.rb

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

data/lib/cli/builder/builder.rb

@@ -1,3 +0,0 @@
-require_relative 'value_object_command_line_builder'
-require_relative 'aggregate_command_line_builder'
-require_relative 'reference_command_line_builder'

data/lib/cli/builder/reference_command_line_builder.rb

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

data/lib/cli/builder/value_object_command_line_builder.rb

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

data/lib/cli/cli.rb

@@ -1,8 +0,0 @@
-require 'json'
-
-require_relative 'generate_domain_object'
-require_relative 'new'
-require_relative 'builder/builder'
-require_relative 'command_builder'
-require_relative "domain_object/assignment_template"
-require_relative "domain_object/option_formatter"

data/lib/cli/command_builder.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-        def call
-          delete_tmpfile
-          puts "\n"
-          generate :domain
-          generate :modules
-          generate :value_objects
-          generate :references
-          execute_tmpfile && return unless @dry_run
-          print_tmpfile
-        end
-
-        private
-
-        attr_reader :runner, :name, :domain
-
-        def print_tmpfile
-          puts File.read('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
-        end
-      end
-    end
-  end
-end

data/lib/cli/domain_object/assignment_template.rb

@@ -1,43 +0,0 @@
-module Hecks
-  module Domain
-    module CLI
-      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
-
-          private
-
-          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 reference_factory_assignment
-            "@#{attribute.name} = #{attribute.type}Reference.factory(#{attribute.name})"
-          end
-
-          def factory_assignment
-            "@#{attribute.name} = #{attribute.type}.factory(#{attribute.name})"
-          end
-
-          def value_assignment
-            "@#{attribute.name} = #{attribute.name}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cli/domain_object/option_formatter.rb

@@ -1,36 +0,0 @@
-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
-          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
-
-          def attributes(include_id)
-            if include_id
-              @attributes + [Hecks::Domain::DomainBuilder::Attribute.new('id:value')]
-            else
-              @attributes
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cli/generate_domain_object.rb

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

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

@@ -1,16 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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

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

@@ -1,21 +0,0 @@
-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

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

@@ -1,25 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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