Class: Minke::Generators::Processor

Inherits:
Object
  • Object
show all
Defined in:
lib/minke/generators/processor.rb

Overview

Process handles the creation of new projects from a generator template.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(variables, docker_runner, logger) ⇒ Processor

Returns a new instance of Processor.



15
16
17
18
19
 
# File 'lib/minke/generators/processor.rb', line 15

def initialize variables, docker_runner, logger
  @logger = logger
  @variables = variables
  @docker_runner = docker_runner
end

Class Method Details

.load_generators ⇒ Object 



7
8
9
10
11
12
13
 
# File 'lib/minke/generators/processor.rb', line 7

def self.load_generators
  Gem::Specification.find_all.each do |spec|
    if spec.metadata != nil && spec.metadata['entrypoint'] != nil
      require spec.metadata['entrypoint']
    end
  end
end

Instance Method Details

#build_image(docker_file) ⇒ Object 



44
45
46
47
48
49
 
# File 'lib/minke/generators/processor.rb', line 44

def build_image docker_file
  @logger.info "## Building custom docker image"

  image_name = @variables.application_name + "-buildimage"
  @docker_runner.build_image docker_file, image_name
end

#create_new_filename(template_location, original, output_folder, service_name) ⇒ Object 



110
111
112
113
114
115
116
 
# File 'lib/minke/generators/processor.rb', line 110

def create_new_filename template_location, original, output_folder, service_name
  new_filename = original.sub(template_location + '/', '')
  new_filename.sub!('.erb', '')
  new_filename.sub!('<%= application_name %>', service_name)

  output_folder + '/' + new_filename
end

#fetch_image(docker_image) ⇒ Object 



51
52
53
54
 
# File 'lib/minke/generators/processor.rb', line 51

def fetch_image docker_image
  @docker_runner.pull_image docker_image unless @docker_runner.find_image docker_image
  docker_image
end

#get_generator(generator) ⇒ Object 



124
125
126
127
128
129
130
131
 
# File 'lib/minke/generators/processor.rb', line 124

def get_generator generator
  config = Minke::Generators.get_registrations.select { |c| c.name == generator}.first
  if config == nil
    throw "Generator not installed please select from the above list of installed generators or install the required gem"
  end
  processor = Minke::Generators::ConfigProcessor.new @variables
  return processor.process config
end

#local_gems ⇒ Object 



120
121
122
 
# File 'lib/minke/generators/processor.rb', line 120

def local_gems
   Gem::Specification.sort_by{ |g| [g.name.downcase, g.version] }.group_by{ |g| g.name }
end

#process(generator_name, output_folder) ⇒ Object 



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/minke/generators/processor.rb', line 21

def process generator_name, output_folder
  generator = get_generator generator_name

  # process the files
  @logger.info '# Modifiying templates'
  @logger.debug "#{generator.template_location}"

  process_directory generator.template_location, '**/*', output_folder, @variables.application_name
  process_directory generator.template_location, '**/.*', output_folder, @variables.application_name

  # run generate command if present
  if generator.generate_settings != nil && generator.generate_settings.command != nil
    image = build_image generator.generate_settings.docker_file  unless generator.generate_settings.docker_file == nil
    image = fetch_image generator.generate_settings.docker_image unless generator.generate_settings.docker_image == nil

    run_command_in_container image, generator.generate_settings.command unless generator.generate_settings.command == nil
  end

  # write the shell script
  Minke::Generators::write_bash_script output_folder + "/_minke/minke"
  Minke::Generators::create_rvm_files output_folder + "/_minke/", @variables.application_name
end

#process_directory(template_location, folder, output_folder, service_name) ⇒ Object 



76
77
78
79
80
81
 
# File 'lib/minke/generators/processor.rb', line 76

def process_directory template_location, folder, output_folder, service_name
  Dir.glob("#{template_location}/#{folder}").each do |file_name|
    @logger.debug "## Processing #{file_name}"
    process_file template_location, file_name, output_folder, service_name
  end
end

#process_file(template_location, original, output_folder, service_name) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/minke/generators/processor.rb', line 83

def process_file template_location, original, output_folder, service_name
  new_filename = create_new_filename template_location, original, output_folder, service_name

  dirname = File.dirname(new_filename)
  unless File.directory?(dirname)
    FileUtils.mkdir_p(dirname)
  end

  if !File.directory?(original)
    if File.extname(original) == ".erb"
      render_erb original, new_filename
    elsif
      FileUtils.cp(original, new_filename)
    end
  end
end

#render_erb(original, new_filename) ⇒ Object 



100
101
102
103
104
105
106
107
108
 
# File 'lib/minke/generators/processor.rb', line 100

def render_erb original, new_filename
  b = binding
  b.local_variable_set(:application_name, @variables.application_name)
  b.local_variable_set(:namespace, @variables.namespace)
  b.local_variable_set(:src_root, @variables.src_root)

  renderer = ERB.new(File.read(original))
  File.open(new_filename, 'w') {|f| f.write renderer.result(b) }
end

#run_command_in_container(build_image, command) ⇒ Object 



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/minke/generators/processor.rb', line 56

def run_command_in_container build_image, command
  @logger.debug command
  begin
    args = {
      :image             => build_image, 
      :volumes           => ["#{File.expand_path(@variables.src_root)}:/src"],
      :working_directory => '/src', 
      :command           => command
    }


    container, success = @docker_runner.create_and_run_container args
    
    # throw exception if failed
    raise " #{command}" unless success
  ensure
    @docker_runner.delete_container container
  end
end