hecks-domain 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0e407c46ded01180a5c47b3b779aa5f193509002
+  data.tar.gz: d36411b8e9533bc8a42d4e9c845ab61329fd05a7
+SHA512:
+  metadata.gz: d89bcd8761dab08e36ca8cab1ea1d7e42cd63be5685d826bae3ca2b5d4e16ea007de15c00770111d900bf5bc69a9eb24c9e5517f77329a28c6b40588e1fd308f
+  data.tar.gz: 852174b857cdbd06b0f5d68ee75f54d756988250163052ce9247a12f41c2b3fe2016f985c8863422dac157405483ae010846a6bc8877b87875f4bf71d5c22265

data/lib/adapters/adapters.rb

@@ -0,0 +1,2 @@
+require_relative 'sql_database/sql_database'
+require_relative 'resource_server/resource_server'

data/lib/adapters/resource_server/cli/cli.rb

@@ -0,0 +1 @@
+require_relative 'generate_resource_server'

data/lib/adapters/resource_server/cli/generate_resource_server.rb

@@ -0,0 +1,25 @@
+module Hecks
+  module Domain
+    module Adapters
+      module ResourceServer
+        module CLI
+          class GenerateResourceServer < Thor::Group
+            include Thor::Actions
+
+            def self.source_root
+              File.dirname(__FILE__) + '/templates/'
+            end
+
+            def create_aggregate_folder
+              directory('resource_server', '.')
+            end
+
+            def domain
+              File.basename(Dir.getwd)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adapters/resource_server/cli/templates/resource_server/config.ru.tt

@@ -0,0 +1,8 @@
+require_relative "lib/<%= domain %>.rb"
+require 'hecks'
+
+run Hecks::Adapters::ResourceServer.new(
+  application_adapter: Hecks::Application.new(
+    domain: <%= domain.camelize %>
+  )
+)

data/lib/adapters/resource_server/resource_server.rb

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

data/lib/adapters/sql_database/cli/cli.rb

@@ -0,0 +1,3 @@
+require_relative 'generate_domain_migrations'
+require_relative 'generate_sql_database'
+require_relative 'migration_builder'

data/lib/adapters/sql_database/cli/generate_domain_migrations.rb

@@ -0,0 +1,33 @@
+module Hecks
+  module Domain
+    module Adapters
+      class SQLDatabase
+        module CLI
+          class GenerateDomainMigrations < Thor::Group
+            include Thor::Actions
+            attr_writer :migration_builder
+
+            def load_domain_spec
+              load('../../Domain')
+            end
+
+            def self.source_root
+              File.dirname(__FILE__) + '/templates/'
+            end
+
+            def create_migration_file
+              @migration_builder = MigrationBuilder.new(self, DOMAIN)
+              @migration_builder.call
+            end
+
+            private
+
+            def migration_builder
+              @migration_builder
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adapters/sql_database/cli/generate_sql_database.rb

@@ -0,0 +1,35 @@
+module Hecks
+  module Domain
+      module Adapters
+      class SQLDatabase
+        module CLI
+          class GenerateSQLDatabase < Thor::Group
+            include Thor::Actions
+
+            def self.source_root
+              File.dirname(__FILE__) + '/templates/'
+            end
+
+            def create_sql_database_folder
+              directory('sql_database', './adapters/sql_database')
+            end
+
+            def bundle
+              run 'bundle'
+            end
+
+            private
+
+            def class_name
+              @class_name
+            end
+
+            def domain_module_name
+              DOMAIN.name.camelize
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adapters/sql_database/cli/migration_builder.rb

@@ -0,0 +1,51 @@
+module Hecks
+  module Domain
+    module Adapters
+      class SQLDatabase
+        module CLI
+          class MigrationBuilder
+            def initialize(generator, specification)
+              @generator = generator
+              @schema = Hecks::Adapters::SQLDatabase::Schema.factory(specification)
+            end
+
+            def call
+              generate_migrations
+              self
+            end
+
+            def table_name
+              @table.name
+            end
+
+            def columns
+              @table.columns
+            end
+
+            def tables
+              @schema.tables
+            end
+
+            private
+
+            attr_reader :generator
+
+            def file_name(index, object)
+              "#{index}_create_#{table_name}.rb"
+            end
+
+            def generate_migrations
+              tables.each.with_index(1) do |table, index|
+                @table = table
+                @generator.template(
+                  "migration.rb.tt",
+                  "db/migrate/" + file_name(index, table)
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adapters/sql_database/cli/templates/migration.rb.tt

@@ -0,0 +1,14 @@
+Sequel.migration do
+  up do
+    create_table(:<%= migration_builder.table_name %>) do
+      primary_key :id
+      <%- migration_builder.columns.each do |column| -%>
+      <%= column.type.camelcase %> :<%= column.name.to_sym %>, :null=>false
+      <%- end -%>
+    end
+  end
+
+  down do
+    drop_table(:<%= migration_builder.table_name %>)
+  end
+end

data/lib/adapters/sql_database/cli/templates/repository.rb.tt

@@ -0,0 +1,24 @@
+module <%= domain_module_name %>
+  module Adapters
+    class SQLDatabase
+      module Repositories
+        class <%= class_name %>
+          def self.create attributes = {}
+          end
+
+          def self.update id, attributes
+          end
+
+          def self.read id
+          end
+
+          def self.delete id
+          end
+
+          def self.delete_all
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adapters/sql_database/cli/templates/sql_database/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'hecks', path: '../../../../..'
+gem 'thor'
+gem 'pry'
+gem 'rspec'
+gem 'mysql2'
+gem 'sequel'
+gem 'simplecov'
+gem 'pizza_builder', path: '../../'

data/lib/adapters/sql_database/cli/templates/sql_database/Rakefile

@@ -0,0 +1,15 @@
+namespace :db do
+  desc "Run migrations"
+  task :migrate, [:version] do |t, args|
+    require "sequel"
+    Sequel.extension :migration
+    db = Sequel.connect(ENV.fetch("DATABASE_URL"))
+    if args[:version]
+      puts "Migrating to version #{args[:version]}"
+      Sequel::Migrator.run(db, "db/migrate", target: args[:version].to_i)
+    else
+      puts "Migrating to latest"
+      Sequel::Migrator.run(db, "db/migrate")
+    end
+  end
+end

data/lib/adapters/sql_database/commands/read/fetch_references.rb

@@ -0,0 +1,58 @@
+module Hecks
+  module Domain
+    module Adapters
+      class SQLDatabase
+        module Commands
+          class Read
+            class FetchReferences
+              attr_reader :reference_map
+              def initialize(read_command)
+                @head = read_command.head
+                @reference_map = {}
+                @entity = read_command.entity
+                @table = read_command.table
+                @id = read_command.id
+              end
+
+              def call
+                @head.references.each do |reference|
+                  fetch_reference(reference)
+                  fetch_references(reference)
+                end
+                self
+              end
+
+              private
+
+              def fetch_reference(reference)
+                return if reference.list?
+                column = Column.factory(reference)
+                value = DB[column.to_table_name].first(id: @entity[column.to_foreign_key])
+
+                @entity.delete(column.to_foreign_key)
+                value.delete(:id)
+                @reference_map[column.name.to_sym] = value
+              end
+
+              def fetch_references(reference)
+                return unless reference.list?
+
+                where_clause = {}
+                where_clause[@table.to_foreign_key.to_sym] = @id
+                column = Column.factory(reference)
+
+                @reference_map[column.name.to_sym] ||= []
+
+                DB[JoinTable(@table, reference).name.to_sym].where(where_clause).map do |record|
+                  value_object = DB[column.to_table_name].first(id: record[column.to_foreign_key])
+                  value_object.delete(:id)
+                  @reference_map[column.name.to_sym] << value_object
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

data/lib/cli/builder/aggregate_command_line_builder.rb

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

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

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

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

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

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

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

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

@@ -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,7 @@
+require 'thor'
+require 'hecks-adapters-sql-database'
+
+require_relative 'adapters/adapters'
+require_relative 'domain_builder/domain_builder'
+require_relative 'cli/cli'
+require 'active_support/inflector'

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: hecks-domain
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Chris Young
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hecks-adatpers-sql-database
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Make the Domain the center of your programming world
+email: chris@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/adapters/adapters.rb
+- lib/adapters/resource_server/cli/cli.rb
+- lib/adapters/resource_server/cli/generate_resource_server.rb
+- lib/adapters/resource_server/cli/templates/resource_server/config.ru.tt
+- lib/adapters/resource_server/resource_server.rb
+- lib/adapters/sql_database/cli/cli.rb
+- lib/adapters/sql_database/cli/generate_domain_migrations.rb
+- lib/adapters/sql_database/cli/generate_sql_database.rb
+- lib/adapters/sql_database/cli/migration_builder.rb
+- lib/adapters/sql_database/cli/templates/migration.rb.tt
+- lib/adapters/sql_database/cli/templates/repository.rb.tt
+- lib/adapters/sql_database/cli/templates/sql_database/Gemfile
+- lib/adapters/sql_database/cli/templates/sql_database/Rakefile
+- lib/adapters/sql_database/commands/read/fetch_references.rb
+- lib/adapters/sql_database/commands/update/delete_references.rb
+- lib/adapters/sql_database/commands/update/link_to_references.rb
+- lib/adapters/sql_database/sql_database.rb
+- lib/cli/builder/aggregate_command_line_builder.rb
+- lib/cli/builder/builder.rb
+- lib/cli/builder/reference_command_line_builder.rb
+- lib/cli/builder/value_object_command_line_builder.rb
+- lib/cli/cli.rb
+- lib/cli/command_builder.rb
+- lib/cli/domain_object/assignment_template.rb
+- lib/cli/domain_object/option_formatter.rb
+- lib/cli/generate_domain_object.rb
+- lib/cli/new.rb
+- lib/cli/templates/aggregate/lib/domain/%name%/%head_name%.rb.tt
+- lib/cli/templates/aggregate/lib/domain/%name%/%name%.rb.tt
+- lib/cli/templates/aggregate/lib/domain/%name%/repository.rb.tt
+- lib/cli/templates/domain/%name%.gemspec.tt
+- lib/cli/templates/domain/Version
+- lib/cli/templates/domain/lib/%name%.rb.tt
+- lib/cli/templates/domain/spec/spec_helper.rb.tt
+- lib/cli/templates/reference/lib/domain/%module_name%/%file_name%.rb.tt
+- lib/cli/templates/value_object/lib/domain/%module_name%/%name%.rb.tt
+- lib/domain_builder/attribute.rb
+- lib/domain_builder/domain.rb
+- lib/domain_builder/domain_builder.rb
+- lib/domain_builder/domain_module.rb
+- lib/domain_builder/domain_object.rb
+- lib/domain_builder/head.rb
+- lib/domain_builder/reference.rb
+- lib/domain_builder/value.rb
+- lib/hecks-domain.rb
+homepage: https://github.com/chrisyoung/hecks-domain
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: DDD and Hexagonal Code Generators
+test_files: []