hecks 0.0.8

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

@@ -0,0 +1,18 @@
+module Hecks
+  class Builder
+    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

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

@@ -0,0 +1,19 @@
+module Hecks
+  class Builder
+    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

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

@@ -0,0 +1,19 @@
+module Hecks
+  class Builder
+    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

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

@@ -0,0 +1,17 @@
+class GenerateResourceServer < Thor::Group; end
+
+class GeneratePackage
+  include Thor::Actions
+
+  def self.source_root
+    File.dirname(__FILE__) + '/templates/'
+  end
+
+  def create_package
+    directory('package', './packages/lambda')
+  end
+
+  def domain
+    File.basename(Dir.getwd)
+  end
+end

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

@@ -0,0 +1,92 @@
+class GenerateBinaryPackage < Thor::Group
+  include Thor::Actions
+
+  HOST          = "http://d6r77u77i8pq3.cloudfront.net/releases"
+  OSX_BINARY    = "traveling-ruby-20150715-2.2.2-osx.tar.gz"
+  LINUX_BINARY  = 'traveling-ruby-20150715-2.2.2-linux-x86_64.tar.gz'
+  BUILD_DIR     = 'packages/binary/build'
+  RESOURCES_DIR = BUILD_DIR + '/resources'
+  OSX_DIR       = BUILD_DIR + '/osx'
+  OSX_LIB_DIR   = OSX_DIR + '/lib'
+  OSX_APP_DIR   = OSX_LIB_DIR + '/app'
+  LINUX_DIR     = BUILD_DIR + '/linux-x86_64'
+  LINUX_LIB_DIR = LINUX_DIR + 'lib'
+  LINUX_APP_DIR = LINUX_LIB_DIR + '/app'
+
+  def self.source_root
+    File.dirname(__FILE__) + '/templates'
+  end
+
+  def create_package_folder
+    run("rm -rf packages/binary")
+    directory('binary_package', './packages/binary')
+  end
+
+  def domain_name
+    Dir.pwd.split('/').last
+  end
+
+  def build
+    package(OSX_APP_DIR, OSX_LIB_DIR, OSX_BINARY, OSX_DIR)
+    package(LINUX_APP_DIR, LINUX_LIB_DIR, LINUX_BINARY, LINUX_DIR)
+  end
+
+  private
+
+  def package(app_dir, lib_dir, binary, package_dir)
+    empty_directory(app_dir)
+    empty_directory(lib_dir + '/ruby')
+    download(binary, lib_dir)
+    copy_resources(app_dir, package_dir)
+    bundle_with_ruby_2_2_2(app_dir)
+    reduce_package_size(app_dir)
+  end
+
+  def reduce_package_size(app_dir)
+    files = %w(test tests spec features benchmark README* CHANGE* Change*
+      COPYING* LICENSE* MIT-LICENSE* TODO *.txt *.md *.rdoc doc docs example
+      examples sample doc-api
+    )
+    files.each do |file|
+      run("rm -rf #{app_dir}/vendor/ruby/*/gems/*/#{file}")
+    end
+
+    run("rm -rf #{app_dir}/vendor/*/*/cache/*")
+    %w(.gitignore .travis.yml).each do |file|
+      run("rm -rf #{app_dir}/vendor/ruby/*/gems/*/#{file}")
+    end
+
+    %w(MAKEfile */Makefile */tmp).each do |file|
+      run("rm -f #{app_dir}/vendor/ruby/*/gems/*/ext/#{file}")
+    end
+
+    %w(*.c *.cpp *.h *.rl *extconf.rb *.java *.class *.md).each do |file|
+      run("find #{app_dir}/vendor/ruby -name '#{file}' | xargs rm -f")
+    end
+
+    %w(*.0 *.so *.bundle).each do |file|
+      run("find #{app_dir}/vendor/ruby/*/gems -name '#{file}' | xargs rm -f")
+    end
+  end
+
+  def copy_resources(app_dir, package_dir)
+    run("cp #{RESOURCES_DIR}/Gemfile #{app_dir}")
+    run("cp -rf #{RESOURCES_DIR}/bundle #{app_dir}/.bundle")
+    run("cp -rf #{RESOURCES_DIR}/#{domain_name}.rb #{app_dir}/#{domain_name}.rb")
+    run("cp -rf #{RESOURCES_DIR}/wrapper #{package_dir}/#{domain_name}")
+    run("cd #{package_dir} && chmod 744 #{domain_name}")
+  end
+
+  def download(binary, lib_dir)
+    run("cd #{RESOURCES_DIR} && curl -O #{HOST}/#{binary}")
+    run("tar -xzf #{RESOURCES_DIR}/#{binary} -C #{lib_dir}/ruby")
+  end
+
+  def bundle_with_ruby_2_2_2(app_dir)
+    run("cp -rf #{RESOURCES_DIR}/Dockerfile #{app_dir}")
+    run("cp #{domain_name}-0.0.0.gem #{app_dir}" )
+    run("cd #{app_dir} && docker build -t #{domain_name} --no-cache .")
+    container = `docker create pizza_builder:latest`.gsub("\n", '')
+    run("docker cp #{container}:/usr/src/app/vendor #{app_dir}")
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class GenerateDomainObject < Thor::Group; end
+
+require_relative "generate_domain_object/assignment_template"
+require_relative "generate_domain_object/option_formatter"
+
+class GenerateDomainObject
+  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::DomainBuilder::Attribute.new(attribute).name }.join ', '
+  end
+
+  def attributes
+    options[:attributes] + ['id:value']
+  end
+
+  def attributes_without_id
+    options[:attributes]
+  end
+end

data/lib/cli/commands/generate/generate_domain_object/assignment_template.rb

@@ -0,0 +1,36 @@
+class GenerateDomainObject
+  class AssignmentTemplate
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def render
+      attributes.map do |attribute|
+        @attribute = Hecks::DomainBuilder::Attribute.new(attribute)
+        do_assignment
+      end.join("\n")
+    end
+
+    private
+
+    attr_reader :attributes, :attribute
+
+    def do_assignment
+      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

data/lib/cli/commands/generate/generate_domain_object/option_formatter.rb

@@ -0,0 +1,30 @@
+class GenerateDomainObject
+  class OptionFormatter
+    def initialize(attributes)
+      @attributes = attributes.map do |attribute|
+        Hecks::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::DomainBuilder::Attribute.new('id:value')]
+      else
+        @attributes
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+class GenerateLambdaPackage < Thor::Group
+  include Thor::Actions
+
+  def self.source_root
+    File.dirname(__FILE__) + '/templates'
+  end
+
+  def create_package_folder
+    directory('lambda_package', './packages/lambda')
+  end
+
+  def domain_name
+    Dir.pwd.split('/').last
+  end
+
+  def create_function
+    run("rm -rf packages/lambda/#{domain_name}")
+    run("cp -r packages/binary/build/osx packages/lambda/#{domain_name}")
+  end
+end

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

@@ -0,0 +1,17 @@
+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
+
+  private
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Hecks
+  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]
+      Hecks::Builder.new(
+        hecks_file: File.read('HECKS'),
+        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

data/lib/cli/commands/generate/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/commands/generate/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/commands/generate/templates/aggregate/lib/domain/%name%/repository.rb.tt

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