hecks-domain 0.2.0 → 0.3.0

data/lib/cli/new.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module HecksDomain
-  module CLI
-    # Generate a new domain project
-    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

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,38 +0,0 @@
-module <%= domain_name.camelize %>
-  module Domain
-    module <%= name.camelize %>
-      class Repository
-        @collection = {}
-
-        def self.create attributes={}
-          id              = attributes[:id]
-          @collection[id] = <%= options[:head_name].camelize %>.new(attributes)
-          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 = {}
-        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/**/*"] + ['Domain']
-  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,61 +0,0 @@
-class HecksDomainBuilder
-  # A Domain Object attribute
-  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 domain_reference?
-      @string.include?('::')
-    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

data/lib/domain_builder/domain.rb

@@ -1,16 +0,0 @@
-class HecksDomainBuilder
-  # A domain
-  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

data/lib/domain_builder/domain_module.rb

@@ -1,32 +0,0 @@
-class HecksDomainBuilder
-  # A domain module
-  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
-
-    def find(name)
-      @objects.each do |object|
-        return object if object.name.downcase == name.downcase
-      end
-      return nil
-    end
-  end
-end

data/lib/domain_builder/domain_object.rb

@@ -1,44 +0,0 @@
-class HecksDomainBuilder
-  # A Domain Object
-  class DomainObject
-    attr_reader :name, :attributes
-
-    def initialize(name:)
-      @name = name
-    end
-
-    def attributes(*values)
-      return @attributes if @attributes
-      @attributes = values.map { |value| 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
-
-    def domain_references
-      @attributes.select(&:domain_reference?)
-    end
-
-    private
-
-    def type_with_domain_module(attribute)
-      type = 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

data/lib/domain_builder/head.rb

@@ -1,5 +0,0 @@
-class HecksDomainBuilder
-  # Points to the head object of a domain module
-  class Head < DomainObject
-  end
-end

data/lib/domain_builder/hecks-domain-builder.rb

@@ -1,37 +0,0 @@
-require_relative 'attribute'
-require_relative 'domain'
-require_relative 'domain_module'
-require_relative 'domain_object'
-require_relative 'value'
-require_relative 'head'
-require_relative 'reference'
-
-# Represents information about your domain
-class HecksDomainBuilder
-  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

data/lib/domain_builder/reference.rb

@@ -1,16 +0,0 @@
-class HecksDomainBuilder
-  # Represents a reference object
-  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

data/lib/domain_builder/value.rb

@@ -1,5 +0,0 @@
-class HecksDomainBuilder
-  # A Value object
-  class Value < DomainObject
-  end
-end

data/lib/hecks-domain.rb

@@ -1,4 +0,0 @@
-require 'thor'
-require_relative 'domain_builder/hecks-domain-builder'
-require_relative 'cli/cli'
-require 'active_support/inflector'