hecks-application 0.1.16.rc → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e835d560fad82657aced9156d3b9d73c3089d7a0
-  data.tar.gz: 77a0909656ab8e840583cf33e312f0f9386ecfd0
+  metadata.gz: 5ea1241067264baa88f4ba4e89d1dcaf09fad09e
+  data.tar.gz: af63582186c185435e111912570f8eb23a8c6b06
 SHA512:
-  metadata.gz: '019ef6624b3e1bbe7eb2c5d3806f258e9497a6219a501caf3604d1b9a3a20373fafabb27c6a5f18bcf91a04cb1f2361e7845ccbf0d45b433a2c630d5bb6358ea'
-  data.tar.gz: '056639fa7558ec83222497faf09348c433b240e83a26121b170cdaeae42fec9aa0b69588b8db74a1e4acfceec2be9379542282bd7c95fe4287b704c9b5b6ddf4'
+  metadata.gz: d8c0a05ecae96f05662a2aad3e7b39b149df2bbbd20f927955a33821122c6e4d79281a854e3849903126afb2310fec9b076c202935360e1f47481163f36894db
+  data.tar.gz: fc16e2f199eb5199d7de6c5f9cd3b4b410f045d3d3a2e12b239f094b0e48952149d0da02c00201b1bcc253c7fcb9f8896e9865684bc55d80cde57b3054e4a1b1

data/lib/command_runner.rb

@@ -0,0 +1,55 @@
+require 'digest'
+
+class HecksApplication
+  # Run an application command, with validations and broacast lifecycle events
+  class CommandRunner
+    attr_reader :module_name, :command
+
+    def initialize(command_name:, module_name:, args:, application:, async: false)
+      @command_name = command_name
+      @module_name  = module_name
+      @args         = args
+      @application  = application
+      @domain_spec  = application.domain_spec
+      @async        = async
+    end
+
+    def call()
+      fetch_command
+      run_command
+      broadcast
+      command
+    end
+
+    private
+
+    attr_reader :command_name, :args, :application, :domain_spec, :async
+
+    def broadcast
+      application.events_port.send(command: command, module_name: module_name)
+    end
+
+    def fetch_command
+      args.merge!(id: SecureRandom.uuid) if command_name == :create
+      @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
+      if async
+        Thread::new { command.call }
+      else
+        command.call
+      end
+
+      command
+    end
+  end
+end

data/lib/commands/commands.rb

@@ -2,4 +2,3 @@ require_relative 'update'
 require_relative 'create'
 require_relative 'delete'
 require_relative 'crud_handler'
-require_relative 'runner'

data/lib/commands/create.rb

@@ -1,49 +1,49 @@
 # frozen_string_literal: true
-module Hecks
-  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       = Hecks::Adapters::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).id
-        end
-
-        def validate
-          return if @validator.nil?
-          @errors = @validator.new(command: self).call.errors
-        end
+class HecksApplication
+  module Commands
+    # Create a resource
+    class Create
+      attr_accessor :args, :result, :errors, :repository, :domain_module, :id
+
+      def initialize(args:, repository:, domain_module:, validator: HecksApplication::Validator)
+        @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 = args[:id]
+        repository.create(args)
+      end
+
+      def validate
+        return if @validator.nil?
+        @errors = @validator.new(command: self).call.errors
       end
     end
   end

data/lib/commands/crud_handler.rb

@@ -1,45 +1,45 @@
-module Hecks
-  class Application
-    module Commands
-      class CRUDHandler
-        attr_reader :module_name, :application
+class HecksApplication
+  module Commands
+    # Map resourceful methods to the domain
+    class CRUDHandler
+      attr_reader :module_name, :application, :validator
 
-        def initialize(module_name:, application:)
-          @module_name = module_name
-          @application = application
-        end
+      def initialize(module_name:, application:, validator:)
+        @module_name = module_name
+        @application = application
+        @validator = validator
+      end
 
-        def create(attributes)
-          application.call(
-            module_name: module_name,
-            command_name: :create,
-            args: attributes
-          )
-        end
+      def create(args)
+        application.call(
+          module_name:  module_name,
+          command_name: :create,
+          args:         args
+        )
+      end
 
-        def read(id)
-          application.query(
-            module_name: module_name,
-            query_name: :find_by_id,
-            args: { id: id }
-          )
-        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 update(attributes)
+        application.call(
+          module_name:  module_name,
+          command_name: :update,
+          args:         attributes
+        )
+      end
 
-        def delete(id)
-          application.call(
-            module_name: module_name,
-            command_name: :delete,
-            args: { id: id }
-          )
-        end
+      def delete(id)
+        application.call(
+          module_name:  module_name,
+          command_name: :delete,
+          args:         { id: id }
+        )
       end
     end
   end

data/lib/commands/delete.rb

@@ -1,37 +1,40 @@
 # frozen_string_literal: true
-module Hecks
-  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
+class HecksApplication
+  module Commands
+    # Delete a resource.
+    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
+
+      def result
+        { id: args[:id], 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

data/lib/commands/update.rb

@@ -1,38 +1,41 @@
 # frozen_string_literal: true
-module Hecks
-  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
+class HecksApplication
+  module Commands
+    # Update a resource
+    class Update
+      attr_accessor :args, :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 result
+        { success: errors.empty?, errors: errors, args: args }
+      end
+
+      def to_h
+        { id: id, args: args }
+      end
+
+      private
+
+      attr_reader :repository_result, :id, :errors
+
+      def update
+        return if @errors.count.positive?
+        @repository_result = repository.update(id, args)
       end
     end
   end

data/lib/events.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Send lifecycle events to listeners
+class HecksEvents
+  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

data/lib/hecks-application.rb

@@ -1,49 +1,57 @@
 # frozen_string_literal: true
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'hecks-memory-database'
+require 'hecks-domain'
+
 require_relative 'commands/commands'
+require_relative 'command_runner'
 require_relative 'queries/queries'
-require 'hecks-domain'
+require_relative 'events'
+require_relative 'logger'
+require_relative 'validator'
 
-module Hecks
-  def self.version
-    path = "#{File.dirname(__FILE__)}/Version"
-    File.read(path).gsub("\n", '')
+# The Applicaiton port.  Adapters usually talk to the domain through
+# HecksApplication
+class HecksApplication
+  attr_reader :database, :domain_spec, :events_port, :validator
+  def initialize(database: nil, listeners: [], domain:, validator: HecksApplication::Validator)
+    load(domain.spec_path)
+    @domain      = domain
+    @database    = database
+    @events_port = HecksEvents.new(listeners: listeners)
+    @domain_spec = DOMAIN
+    @validator   = validator
   end
 
-  class Application
-    attr_reader :database, :domain_spec, :events_port
-    def initialize(database: nil, listeners: [], domain:)
-      load(domain.spec_path)
-      @domain      = domain
-      @database    = database
-      @events_port = Adapters::Events.new(listeners: listeners)
-      @domain_spec = DOMAIN
-    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 call(command_name:, module_name:, args: {})
+    CommandRunner.new(
+      command_name: command_name,
+      module_name:  module_name,
+      args:         args,
+      application:  self
+    ).call
+  end
 
-    def [](module_name)
-      Commands::CRUDHandler.new(module_name: module_name, application: self)
-    end
+  def [](module_name)
+    Commands::CRUDHandler.new(
+      module_name: module_name,
+      application: self,
+      validator:   validator
+    )
+  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 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 @database.new(domain: @domain) if @database
-      return Hecks::Adapters::MemoryDatabase.new(domain: @domain)
-    end
+  def database
+    return @database.new(domain: @domain) if @database
+    return HecksAdapters::MemoryDatabase.new(domain: @domain)
   end
 end

data/lib/logger.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Simple logger
+class HecksLogger
+  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

data/lib/queries/find_by_id.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
-module Hecks
-  class Application
-    module Queries
-      class FindById
-        def initialize(repository:)
-          @repository = repository
-        end
+class HecksApplication
+  module Queries
+    # Find a resource by id
+    class FindById
+      def initialize(repository:)
+        @repository = repository
+      end
 
-        def call(params)
-          return unless params.keys == [:id]
-          @repository.read(params[:id])
-        end
+      def call(params)
+        return unless params.keys == [:id]
+        @repository.read(params[:id])
       end
     end
   end

data/lib/queries/query_runner.rb

@@ -1,26 +1,26 @@
-module Hecks
-  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
+class HecksApplication
 
-      def call()
-        fetch.new(repository: repository).call(@args)
-      end
+  # Call queries by name
+  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
+    private
 
-      def fetch
-        Queries.const_get(@query_name.to_s.camelcase)
-      end
+    def fetch
+      Queries.const_get(@query_name.to_s.camelcase)
+    end
 
-      def repository
-        @application.database[@module_name]
-      end
+    def repository
+      @application.database[@module_name]
     end
   end
 end

data/lib/validator.rb

@@ -0,0 +1,32 @@
+class HecksApplication
+  # Looks for the presence of required fields.
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hecks-application
 version: !ruby/object:Gem::Version
-  version: 0.1.16.rc
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Young
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-15 00:00:00.000000000 Z
+date: 2017-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hecks-domain
@@ -16,31 +16,47 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.16.rc
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.16.rc
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: hecks-memory-database
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 description: Hecks Application
 email: chris@example.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/Version
+- lib/command_runner.rb
 - lib/commands/commands.rb
 - lib/commands/create.rb
 - lib/commands/crud_handler.rb
 - lib/commands/delete.rb
-- lib/commands/runner.rb
 - lib/commands/update.rb
+- lib/events.rb
 - lib/hecks-application.rb
+- lib/logger.rb
 - lib/queries/find_by_id.rb
 - lib/queries/queries.rb
 - lib/queries/query_runner.rb
+- lib/validator.rb
 homepage: https://github.com/chrisyoung/hecks-application
 licenses:
 - MIT
@@ -56,14 +72,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
-summary: Hecks::Application understands things and acts as an interface to Domains
-  built with Hecks::Domain
+summary: HecksApplication acts as an interface to Domains built with HecksDomain
 test_files: []

data/lib/Version

@@ -1 +0,0 @@
-0.1.16.rc

data/lib/commands/runner.rb

@@ -1,46 +0,0 @@
-module Hecks
-  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