hecks 0.0.8 → 0.1.2

data/lib/adapters/adapters.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-require_relative 'memory_database/memory_database'
-require_relative 'resource_server/resource_server'
-require_relative 'events/events'
-require_relative 'logger/logger'
-require_relative 'validator/validator'

data/lib/adapters/events/events.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-module Hecks
-  module Adapters
-    class Events
-      def initialize(listeners: [])
-        @listeners = listeners
-      end
-
-      def send(module_name:, command:)
-        @command = command
-        @module_name = module_name
-        listeners.each do |listener|
-          next unless listener.respond_to?(event_name)
-          listener.public_send(event_name, command)
-        end
-      end
-
-      private
-
-      attr_reader :listeners, :command, :module_name
-
-      def event_name
-        "#{module_name}_#{command.name}".to_sym
-      end
-    end
-  end
-end

data/lib/adapters/logger/logger.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-module Hecks
-  module Adapters
-    class Logger
-      def initialize(output: [])
-        @output = output
-      end
-
-      def method_missing(name, *args, &block)
-        @output << {name: name, command: args.first.to_h.to_s}.to_s
-      end
-
-      def respond_to?(name)
-        true
-      end
-    end
-  end
-end

data/lib/adapters/memory_database/memory_database.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-module Hecks
-  module Adapters
-    class MemoryDatabase
-      def initialize(domain:)
-        @repositories = domain.repositories
-      end
-
-      def [](module_name)
-        @repositories[module_name]
-      end
-
-      def delete_all
-        @repositories.values.each(&:delete_all)
-      end
-    end
-  end
-end

data/lib/adapters/resource_server/methods.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require_relative 'methods/create'
-require_relative 'methods/read'
-require_relative 'methods/update'
-require_relative 'methods/delete'
-
-module Hecks
-  module Adapters
-    class ResourceServer
-      class Methods
-        attr_reader :create, :read, :update, :delete
-
-        def initialize(application_adapter:)
-          @create = Create.new(application_adapter: application_adapter)
-          @read   = Read.new(application_adapter: application_adapter)
-          @update = Update.new(application_adapter: application_adapter)
-          @delete = Delete.new(application_adapter: application_adapter)
-        end
-      end
-    end
-  end
-end

data/lib/adapters/resource_server/methods/create.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-module Hecks
-  module Adapters
-    class ResourceServer < Sinatra::Base
-      class Methods
-        class Create
-          attr_reader :result
-
-          def initialize(application_adapter:)
-            @application_adapter = application_adapter
-          end
-
-          def call(body:, module_name:)
-            @body        = body.read
-            @module_name = module_name.to_sym
-            run_command
-            build_json
-            self
-          end
-
-          def status
-            return 500 if command_result.errors.count.positive?
-            200
-          end
-
-          private
-
-          attr_reader :application_adapter, :body, :module_name, :command_result
-
-          def build_json
-            @result = JSON.generate(command_result.to_h)
-          end
-
-          def run_command
-            @command_result = application_adapter.call(
-              module_name: module_name,
-              command_name: :create,
-              args:        params
-            )
-          end
-
-          def params
-            JSON.parse(body, symbolize_names: true)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/adapters/resource_server/methods/delete.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-module Hecks
-  module Adapters
-    class ResourceServer < Sinatra::Base
-      class Methods
-        class Delete
-          attr_reader :result
-
-          def initialize(application_adapter:)
-            @application_adapter = application_adapter
-          end
-
-          def call(id:, module_name:)
-            @id          = id.to_i
-            @module_name = module_name.to_sym
-            run_command
-            convert_to_json
-            self
-          end
-
-          def status
-            return 500 if command_result.errors.count.positive?
-            200
-          end
-
-          private
-
-          attr_reader :application_adapter, :module_name, :id, :command_result
-
-          def convert_to_json
-            @result = JSON.generate(command_result.to_h)
-          end
-
-          def run_command
-            @command_result = application_adapter.call(
-              module_name: module_name,
-              command_name: :delete,
-              args: { id: id }
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/adapters/resource_server/methods/read.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-module Hecks
-  module Adapters
-    class ResourceServer < Sinatra::Base
-      class Methods
-        class Read
-          attr_reader :result, :status
-          def initialize(application_adapter:)
-            @application_adapter = application_adapter
-          end
-
-          def call(id:, module_name:)
-            @id          = id.to_i
-            @module_name = module_name.to_sym
-            run_query
-            convert_to_json
-            self
-          end
-
-          def status
-            return 404 if command_result.nil?
-            200
-          end
-
-          private
-
-          attr_reader :application_adapter, :id, :module_name, :command_result
-
-          def convert_to_json
-            @result = command_result.to_json
-          end
-
-          def run_query
-            @command_result = application_adapter.query(
-              query_name:  :find_by_id,
-              module_name: module_name,
-              args:        { id: id }
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/adapters/resource_server/methods/update.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-module Hecks
-  module Adapters
-    class ResourceServer < Sinatra::Base
-      class Methods
-        class Update
-          attr_reader :result
-
-          def initialize(application_adapter:)
-            @application_adapter = application_adapter
-          end
-
-          def call(id:, body:, module_name:)
-            @id          = id.to_i
-            @body        = body.read
-            @module_name = module_name.to_sym
-            run_command
-            convert_to_json
-            self
-          end
-
-          def status
-            return 500 if command_result.errors.count.positive?
-            200
-          end
-
-          private
-
-          attr_accessor :application_adapter, :id, :body, :module_name, :command_result
-
-          def convert_to_json
-            @result = JSON.generate(command_result.to_h)
-          end
-
-          def run_command
-            @command_result = application_adapter.call(
-              module_name:  module_name,
-              command_name: :update,
-              args:         params
-            )
-          end
-
-          def params
-            JSON.parse(body, symbolize_names: true).merge(id: id)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/adapters/resource_server/resource_server.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require 'sinatra'
-require 'json'
-require_relative 'methods'
-
-module Hecks
-  module Adapters
-    class ResourceServer < Sinatra::Base
-      configure do
-        set :raise_errors, true
-        set :show_exceptions, false
-      end
-
-      def initialize(app: nil, application_adapter:)
-        super(app)
-        @methods = Methods.new(application_adapter: application_adapter)
-      end
-
-      get '/:module_name/:id' do |module_name, id|
-        command = methods.read.call(id: id, module_name: module_name)
-        body command.result
-        status command.status
-      end
-
-      post '/:module_name' do |module_name|
-        command = methods.create.call(body: request.body, module_name: module_name)
-        status command.status
-        body   command.result
-      end
-
-      put '/:module_name/:id' do |module_name, id|
-        command = methods.update.call(
-          id:          id,
-          body:        request.body,
-          module_name: module_name
-        )
-        status command.status
-        body   command.result
-      end
-
-      delete '/:module_name/:id' do |module_name, id|
-        command = methods.delete.call(id: id, module_name: module_name)
-        status command.status
-        body   command.result
-      end
-
-      private
-
-      attr_reader :methods
-    end
-  end
-end

data/lib/adapters/validator/validator.rb

@@ -1,33 +0,0 @@
-module Hecks
-  module Adapters
-    class Validator
-      attr_reader :errors
-
-      def initialize(command:)
-        @args = command.args
-        @head_spec = command.domain_module.head
-        @errors = {}
-      end
-
-      def call
-        validate
-        return self
-      end
-
-      private
-
-      attr_reader :args, :head_spec
-
-      def validate
-        (missing_attributes).each do |missing_attribute|
-          errors[missing_attribute] = []
-          errors[missing_attribute] << "missing"
-        end
-      end
-
-      def missing_attributes
-        head_spec.attribute_hash.keys - args.keys
-      end
-    end
-  end
-end

data/lib/application/application.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-require_relative 'commands/commands'
-require_relative 'queries/queries'
-
-module Hecks
-  module Adapters
-    class Application
-      attr_reader :database, :domain_spec, :events_port
-      def initialize(database: nil, listeners: [], domain:)
-        load(domain.spec_path)
-        @domain      = domain
-        @database    = database.new(domain: @domain) if @database
-        @events_port = Adapters::Events.new(listeners: listeners)
-        @domain_spec = Hecks.specification
-      end
-
-      def call(command_name:, module_name:, args: {})
-        Runner.new(
-          command_name: command_name,
-          module_name:  module_name,
-          args:         args,
-          application:  self
-        ).call
-      end
-
-      def [](module_name)
-        CRUDHandler.new(module_name: module_name, application: self)
-      end
-
-      def query(query_name:, module_name:, args: {})
-        QueryRunner.new(
-          module_name: module_name,
-          query_name:  query_name,
-          args:        args,
-          application: self
-        ).call
-      end
-
-      def database
-        return MemoryDatabase.new(domain: @domain) unless @database
-        @database
-      end
-    end
-  end
-end

data/lib/application/commands/commands.rb

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

data/lib/application/commands/create.rb

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