hecks 0.0.8

data/lib/application/commands/commands.rb

@@ -0,0 +1,5 @@
+require_relative 'update'
+require_relative 'create'
+require_relative 'delete'
+require_relative 'crud_handler'
+require_relative 'runner'

data/lib/application/commands/create.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module Hecks
+  module Adapters
+    class Application
+      module Commands
+        class Create
+          attr_accessor :args, :id, :errors, :repository, :domain_module
+
+          def initialize(args:, repository: , domain_module: )
+            @repository      = repository
+            @args            = args
+            @errors          = {}
+            @validator       = Validator
+            @domain_module   = domain_module
+          end
+
+          def call
+            validate
+            create
+            self
+          end
+
+          def to_h
+            { errors: errors, id: repository_result, args: args }
+          end
+
+          def name
+            self.class.to_s.split('::').last.underscore
+          end
+
+          def result
+            { id: id, success: !id.nil?, errors: errors, args: args }
+          end
+
+          private
+
+          attr_reader :repository_result
+
+          def create
+            return if @errors.count.positive?
+            @id = @repository_result = repository.create(args)
+          end
+
+          def validate
+            return if @validator.nil?
+            @errors = @validator.new(command: self).call.errors
+          end
+        end
+      end
+    end
+  end
+end

data/lib/application/commands/crud_handler.rb

@@ -0,0 +1,40 @@
+class CRUDHandler
+  attr_reader :module_name, :application
+
+  def initialize(module_name:, application:)
+    @module_name = module_name
+    @application = application
+  end
+
+  def create(attributes)
+    application.call(
+      module_name: module_name,
+      command_name: :create,
+      args: attributes
+    )
+  end
+
+  def read(id)
+    application.query(
+      module_name: module_name,
+      query_name: :find_by_id,
+      args: {id: id}
+    )
+  end
+
+  def update(id, attributes)
+    application.call(
+      module_name: module_name,
+      command_name: :update,
+      args: attributes.merge(id: id)
+    )
+  end
+
+  def delete(id)
+    application.call(
+      module_name: module_name,
+      command_name: :delete,
+      args: {id: id}
+    )
+  end
+end

data/lib/application/commands/delete.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module Hecks
+  module Adapters
+    class Application
+      module Commands
+        class Delete
+          attr_accessor :args, :errors, :repository
+
+          def initialize(args: nil, repository:, domain_module:)
+            @args            = args || chained_command.args
+            @repository      = repository
+            @errors          = { base: [] }
+          end
+
+          def call
+            delete
+            self
+          end
+
+          def name
+            self.class.to_s.split('::').last.underscore
+          end
+
+          def to_h
+            { errors: errors, args: args }
+          end
+
+          private
+
+          attr_accessor :command_result, :repository
+
+          def delete
+            @result = repository.delete(args[:id])
+            @errors[:base] << "cound not find #{args[:id]}" unless @result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/application/commands/runner.rb

@@ -0,0 +1,48 @@
+module Hecks
+  module Adapters
+    class Application
+      class Runner
+        attr_reader :module_name, :command
+
+        def initialize(command_name:, module_name:, args:, application:)
+          @command_name = command_name
+          @module_name = module_name
+          @args = args
+          @application = application
+          @domain_spec = application.domain_spec
+        end
+
+        def call()
+          fetch_command
+          run_command
+          broadcast
+          command
+        end
+
+        private
+
+        attr_reader :command_name, :args, :application, :domain_spec
+
+        def broadcast
+          application.events_port.send(command: command, module_name: module_name)
+        end
+
+        def fetch_command
+          @command = Commands.const_get(command_name.to_s.camelcase).new(
+            repository: application.database[module_name],
+            args:       args,
+            domain_module: fetch_module
+          )
+        end
+
+        def fetch_module
+          domain_spec.domain_modules[module_name.to_s.camelize.to_sym]
+        end
+
+        def run_command
+          @command = command.call
+        end
+      end
+    end
+  end
+end

data/lib/application/commands/update.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Hecks
+  module Adapters
+    class Application
+      module Commands
+        class Update
+          attr_accessor :args, :errors, :id, :repository
+
+          def initialize(args: nil, repository: Repository, domain_module:)
+            @repository      = repository
+            @args            = args
+            @errors          = []
+            @id              = @args.delete(:id)
+          end
+
+          def name
+            self.class.to_s.split('::').last.underscore
+          end
+
+          def call
+            update
+            self
+          end
+
+          def to_h
+            { id: id, args: args }
+          end
+
+          private
+
+          attr_reader :repository_result
+
+          def update
+            return if @errors.count.positive?
+            @repository_result = repository.update(id, args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/application/queries/find_by_id.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Hecks
+  module Adapters
+    class Application
+      module Queries
+        class FindById
+          def initialize(repository:)
+            @repository = repository
+          end
+
+          def call(params)
+            return unless params.keys == [:id]
+            @repository.read(params[:id])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/application/queries/queries.rb

@@ -0,0 +1,2 @@
+require_relative 'find_by_id'
+require_relative 'query_runner'

data/lib/application/queries/query_runner.rb

@@ -0,0 +1,28 @@
+module Hecks
+  module Adapters
+    class Application
+      class QueryRunner
+        def initialize(query_name:, application:, module_name:, args:)
+          @query_name = query_name
+          @application = application
+          @module_name = module_name
+          @args = args
+        end
+
+        def call()
+          fetch.new(repository: repository).call(@args)
+        end
+
+        private
+
+        def fetch
+          Queries.const_get(@query_name.to_s.camelcase)
+        end
+
+        def repository
+          @application.database[@module_name]
+        end
+      end
+    end
+  end
+end

data/lib/cli/cli.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'active_support/inflector'
+require_relative 'command_runner'
+require_relative 'commands'
+
+module Hecks
+  class CLI < Thor
+    package_name 'hecks'
+
+    desc 'generate', 'generate'
+    subcommand('generate', Generate)
+
+    desc 'package', 'package'
+    subcommand('package', Package) if File.file?('HECKS')
+
+    long_desc      'Generate a domain'
+    method_option  :dryrun,
+                   aliases:  '-d',
+                   type:     :boolean,
+                   desc:     'Output commands without running'
+
+    register(New, 'new', 'new', 'Create a new Domain') if File.file?('HECKS')
+  end
+end

data/lib/cli/command_runner.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+class CommandRunner
+  def initialize(hexagon, name, dry_run = false)
+    @hexagon = hexagon
+    @dry_run = dry_run
+    @name    = name
+  end
+
+  def call(command)
+    output = full_command(command)
+    unless File.directory?('tmp')
+      FileUtils.mkdir('tmp')
+    end
+    File.open('tmp/hecks', 'a') { |file| file.write(output + "\n")  }
+    return if dry_run
+  end
+
+  private
+
+  attr_reader :hexagon, :dry_run, :name
+
+  def full_command(command)
+    (['hecks'] + command).join(' ')
+  end
+end

data/lib/cli/commands.rb

@@ -0,0 +1,5 @@
+require_relative 'commands/test' if File.file?('hecks.gemspec')
+require_relative 'commands/generate'
+require_relative 'commands/build' if File.file?('hecks.gemspec')
+require_relative 'commands/console' if File.file?('HECKS')
+require_relative 'commands/package'

data/lib/cli/commands/build.rb

@@ -0,0 +1,10 @@
+module Hecks
+  class CLI < Thor
+    desc 'build','build and install the hecks gem'
+
+    def build
+      exec(['gem build hecks',
+      'gem install hecks'].join("&&"))
+    end
+  end
+end

data/lib/cli/commands/console.rb

@@ -0,0 +1,8 @@
+module Hecks
+  class CLI < Thor
+    desc 'console','REPL with domain helpers'
+    def console
+      exec 'hecks_console'
+    end
+  end
+end

data/lib/cli/commands/generate.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require_relative 'generate/new'
+require_relative 'generate/generate_domain_object'
+require_relative 'generate/generate_resource_server'
+require_relative 'generate/builder'
+
+
+class Generate < Thor
+  desc          'domain_objects', 'generate domain objects'
+  method_option :type,
+                aliases:  '-t',
+                required: true,
+                desc:     'The type of the domain object you want to generate',
+                banner:   '[OBJECT_TYPE]',
+                enum:     %w(entity value_object aggregate reference)
+  register(GenerateDomainObject,
+                'domain_object',
+                'domain_object',
+                'Generate Domain Objects') if File.file?('HECKS')
+
+  desc           'resource_server', 'generate resource_server'
+  register(GenerateResourceServer,
+                 'resource_server',
+                 'resource_server',
+                 'Generate A Resource Server for a domain') if File.file?('HECKS')
+end

data/lib/cli/commands/generate/builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'json'
+
+require_relative 'builder/value_object_command_line_builder'
+require_relative 'builder/aggregate_command_line_builder'
+require_relative 'builder/reference_command_line_builder'
+
+module Hecks
+  class Builder
+    def initialize(hecks_file:, name:, dry_run: false)
+      @name   = name
+      @domain = eval(hecks_file).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