pangea 0.0.36 → 0.0.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3adb572bc833133f8768acc6aa11107ba970f41326b866ce15be9eba50d1628e
-  data.tar.gz: 4b3328ff47c7a7c7c6319b958054560eb411e81560fc3b72cb1238f9477330a6
+  metadata.gz: 3f3e6f63447395733123799d775f0e399fffc41e1775e565a3f45ddfa2e54757
+  data.tar.gz: 8677e8ab34de7c145ba207cce558fa06d2d697a539c19fc90290ed7d5baf6e3b
 SHA512:
-  metadata.gz: 75556d3a15e44da52754dc608b0fff54559dd85db55c548b8da2fa435eea043e54288823a5d3ac041c3b70547fc18237a03dde25e04941dff74bbc6857cf77ce
-  data.tar.gz: 34f1de10c7e25404d227825789155812e03c762ac16d297afb714bcbafde8b74be94a4c81ba729c64c3e9d3c8cda0d556d4aeefefe5602b500cb7ab3dae0a008
+  metadata.gz: 7d028cb0f6d1d5471c74769fb5e63583d5078c82b86e35f4f28364ba3defc549311ad03a684498b443362b0eca6affb598e45b1d3ac127fe65fc4063922f1944
+  data.tar.gz: 9b11287e63adecb61e5a58d15d25de58105e03116f710618c1bb24a872844163b842cd36917aa3470beeebd3299f45bbca3ff508c81daf3404d3fe08ba7d4b7d

data/Gemfile

@@ -24,6 +24,7 @@ group :production do
     tty-color
     tty-box
     toml-rb
+    bundler
   ].each do |this_gem|
     gem this_gem
   end

data/Gemfile.lock

@@ -104,6 +104,7 @@ PLATFORMS
 DEPENDENCIES
   abstract-synthesizer
   aws-sdk-dynamodb
+  bundler
   keycutter
   rake
   rspec

data/lib/pangea/cli/subcommands/infra.rb

@@ -8,8 +8,8 @@ require %(pangea/errors/no_infra_target_error)
 require %(pangea/errors/incorrect_subcommand_error)
 require %(pangea/say/init)
 require %(pangea/modules)
-require %(terraform-synthesizer)
-require %(json)
+# require %(terraform-synthesizer)
+# require %(json)
 
 class InfraCommand < PangeaCommand
   include Constants
@@ -29,36 +29,47 @@ class InfraCommand < PangeaCommand
     desc %(target like ${namespace}.${site})
   end
 
-  def run(argv)
-    Say.terminal %(planning!)
-    parse(argv)
-
-    # grab a config synth
-    cfg_synth = Config.resolve_configurations
-
-    # reject empty configurations
+  def reject_empty_configurations
     if cfg_synth.empty?
       Say.terminal %(configuration empty, exiting...)
       exit
     end
+  end
 
-    Say.terminal JSON.pretty_generate(cfg_synth)
+  def help
+    <<~HELP
+      Usage: pangea infra command [OPTIONS] SUBCOMMAND
 
-    # preflight checks for the command execution
-    # check_run
-    # check_target(params[:target], cfg_synth)
+      Arguments:
+        SUBCOMMAND  subcommand for pangea infra
 
-    # targets = params[:target].split('.').map(&:to_sym)
-    # process_target(targets, cfg_synth)
+      Subcommands:
+        plan    plan infrastructure
+        apply   apply infrastructure
+        config  show run configuration
+    HELP
+  end
 
-    ###########################################################################
-    # modules
-    # modules can be fetched from git or local path
-    # modules can have a virtual environment to execute in
-    ###########################################################################
+  def cfg_synth
+    @cfg_synth ||= Config.resolve_configurations
+  end
 
-    namespaces = cfg_synth[:namespace].keys.map(&:to_sym)
+  def plan(argv)
+    Say.terminal %(planning!)
+    parse(argv)
+    process_modules
+  end
+
+  def config
+    Say.terminal JSON.pretty_generate(cfg_synth)
+  end
+
+  def common_run_checks
+    reject_empty_configurations
+  end
 
+  def process_modules
+    namespaces = cfg_synth[:namespace].keys.map(&:to_sym)
     namespaces.each do |namespace_name|
       namespace     = cfg_synth[:namespace][namespace_name]
       context_names = namespace.keys.map(&:to_sym)
@@ -67,166 +78,207 @@ class InfraCommand < PangeaCommand
         context = namespace[cn]
         modules = context[:modules]
 
-        modules.each do |mod|
+        modules.each_key do |mod_key|
+          mod = modules[mod_key]
           PangeaModule.process(mod)
         end
       end
     end
-
-    ###########################################################################
-
-    # provide some kind of default exit of the command execution
-    exit
-  end
-
-  private
-
-  # process stage for target
-  def process_target(targets, cfg_synth)
-    namespaces    = cfg_synth[:namespace].keys.map(&:to_sym)
-    environments  = []
-
-    namespaces.each do |ns_name|
-      environments.concat(cfg_synth[:namespace][ns_name].keys.map(&:to_sym))
-    end
-
-    case targets.length.to_i
-      # only provided namespace
-    when 1
-      nil
-      # only provided namespace.site
-    when 2
-      nil
-      # only provided namespace.site.project
-    when 3
-      announce_preflight_info(targets, cfg_synth)
-      environments.each do |e_name|
-        projects = cfg_synth[:namespace][targets[0]][e_name][:projects]
-        projects.each do |project|
-          announce_project(project)
-
-          synth = TerraformSynthesizer.new
-          case project[:src][:type].to_sym
-          when :local
-            system %(mkdir -p #{CACHE_DIR}) unless Dir.exist?(CACHE_DIR)
-            PROJECT_SRC_DIRS.each do |src_dir|
-              next unless File.exist?(File.join(
-                                        project[:src][:location].to_s,
-                                        %(src),
-                                        src_dir.to_s
-                                      ))
-
-              synth_files = Dir.glob("#{File.join(
-                project[:src][:location].to_s,
-                %(src),
-                src_dir.to_s
-              )}/**/*.rb")
-              synth_files.each do |synth_file|
-                synth.synthesize(File.read(synth_file))
-              end
-            end
-
-            Say.terminal JSON.pretty_generate(synth.synthesis)
-
-            project_cache_dir = File.join(CACHE_DIR, project[:name].to_s)
-
-            system %(mkdir -p #{project_cache_dir}) unless Dir.exist?(project_cache_dir)
-            File.write(File.join(project_cache_dir, ARTIFACT_FILE), synth.synthesis.to_json)
-            system %(cd #{project_cache_dir} && terraform init)
-            system %(cd #{project_cache_dir} && terraform plan)
-
-          when :git
-            nil
-          end
-        end
-      end
-
-      # fetch project data
-      # projet_data = cfg_synth[:namespace][targets[0]]
-    end
-  end
-
-  def announce_project(project)
-    msg = []
-    msg << %(project: #{project[:name]})
-    msg << %(src:     #{project[:src]})
-    Say.terminal msg.map(&:strip).join(%(\n))
   end
 
-  def announce_preflight_info(targets, cfg_synth)
-    namespaces    = cfg_synth[:namespace].keys.map(&:to_sym)
-    environments  = []
+  def run(argv)
+    common_run_checks
 
-    namespaces.each do |ns_name|
-      environments.concat(cfg_synth[:namespace][ns_name].keys.map(&:to_sym))
+    if argv.length < 2
+      puts help
+      exit
     end
 
-    preflight_info = []
-    preflight_info << %(environments: #{environments})
-    preflight_info << %(\n)
-    preflight_info << %(namespace: #{targets[0]})
-    preflight_info << %(site:      #{targets[1]})
-    preflight_info << %(project:   #{targets[2]})
-
-    Say.terminal preflight_info.map(&:strip).join(%(\n))
-  end
+    config if argv[1].to_s.eql?(%(config))
+    plan(argv) if argv[1].to_s.eql?(%(plan))
+    apply(argv) if argv[1].to_s.eql?(%(apply))
 
-  # targets can be...
-  # ${namespace}
-  # ${namespace}.${site}
-  def check_target(target, config)
-    # raise NamespaceNotFoundError if target.nil?
+    # preflight checks for the command execution
+    # check_run
+    # check_target(params[:target], cfg_synth)
 
-    # targets       = target.split('.').map(&:to_sym)
-    # namespaces    = config[:namespace].keys.map(&:to_sym)
-    # runtype       = nil
-    # environments  = []
+    # targets = params[:target].split('.').map(&:to_sym)
+    # process_target(targets, cfg_synth)
 
-    # namespaces.each do |ns_name|
-    #   environments.concat(config[:namespace][ns_name].keys.map(&:to_sym))
-    # end
+    ###########################################################################
+    # modules
+    # modules can be fetched from git or local path
+    # modules can have a virtual environment to execute in
+    ###########################################################################
 
-    # raise NamespaceNotFoundError unless namespaces.include?(targets[0])
+    # namespaces = cfg_synth[:namespace].keys.map(&:to_sym)
 
-    # namespaces.each do |ns_name|
-    #   environments.each do |e_name|
-    #     sites = config[:namespace][ns_name][e_name][:sites] || []
-    #
-    #     next if sites.empty?
+    # namespaces.each do |namespace_name|
+    #   namespace     = cfg_synth[:namespace][namespace_name]
+    #   context_names = namespace.keys.map(&:to_sym)
     #
-    #     site_names = []
-    #     sites.each do |site|
-    #       site_names << site[:name]
-    #     end
-    #
-    #     raise SiteNotFoundError unless site_names.include?(targets[1].to_sym)
-    #
-    #     projects = config[:namespace][ns_name][e_name][:projects] || []
+    #   context_names.each do |cn|
+    #     context = namespace[cn]
+    #     modules = context[:modules]
     #
-    #     next if projects.empty?
-    #
-    #     project_names = []
-    #     projects.each do |project|
-    #       project_names << project[:name]
+    #     modules.each do |mod|
+    #       PangeaModule.process(mod)
     #     end
-    #
-    #     raise ProjectNotFoundError \
-    #     unless project_names
-    #            .include?(
-    #              targets[2].to_sym
-    #            )
     #   end
     # end
-  end
 
-  def check_run
-    raise IncorrectSubcommandError unless correct_subcommand?(
-      params[:subcommand]
-    )
-    raise NoInfraTargetError unless params[:target]
-  end
+    ###########################################################################
 
-  def correct_subcommand?(sbcmd)
-    NAME.to_s.eql?(sbcmd.to_s)
+    # provide some kind of default exit of the command execution
+    # exit
   end
+
+  # process stage for target
+  # def process_target(targets, cfg_synth)
+  #   namespaces    = cfg_synth[:namespace].keys.map(&:to_sym)
+  #   environments  = []
+  #
+  #   namespaces.each do |ns_name|
+  #     environments.concat(cfg_synth[:namespace][ns_name].keys.map(&:to_sym))
+  #   end
+  #
+  #   case targets.length.to_i
+  #     # only provided namespace
+  #   when 1
+  #     nil
+  #     # only provided namespace.site
+  #   when 2
+  #     nil
+  #     # only provided namespace.site.project
+  #   when 3
+  #     announce_preflight_info(targets, cfg_synth)
+  #     environments.each do |e_name|
+  #       projects = cfg_synth[:namespace][targets[0]][e_name][:projects]
+  #       projects.each do |project|
+  #         announce_project(project)
+  #
+  #         synth = TerraformSynthesizer.new
+  #         case project[:src][:type].to_sym
+  #         when :local
+  #           system %(mkdir -p #{CACHE_DIR}) unless Dir.exist?(CACHE_DIR)
+  #           PROJECT_SRC_DIRS.each do |src_dir|
+  #             next unless File.exist?(File.join(
+  #                                       project[:src][:location].to_s,
+  #                                       %(src),
+  #                                       src_dir.to_s
+  #                                     ))
+  #
+  #             synth_files = Dir.glob("#{File.join(
+  #               project[:src][:location].to_s,
+  #               %(src),
+  #               src_dir.to_s
+  #             )}/**/*.rb")
+  #             synth_files.each do |synth_file|
+  #               synth.synthesize(File.read(synth_file))
+  #             end
+  #           end
+  #
+  #           Say.terminal JSON.pretty_generate(synth.synthesis)
+  #
+  #           project_cache_dir = File.join(CACHE_DIR, project[:name].to_s)
+  #
+  #           system %(mkdir -p #{project_cache_dir}) unless Dir.exist?(project_cache_dir)
+  #           File.write(File.join(project_cache_dir, ARTIFACT_FILE), synth.synthesis.to_json)
+  #           system %(cd #{project_cache_dir} && terraform init)
+  #           system %(cd #{project_cache_dir} && terraform plan)
+  #
+  #         when :git
+  #           nil
+  #         end
+  #       end
+  #     end
+  #
+  #     # fetch project data
+  #     # projet_data = cfg_synth[:namespace][targets[0]]
+  #   end
+  # end
+
+  # def announce_project(project)
+  #   msg = []
+  #   msg << %(project: #{project[:name]})
+  #   msg << %(src:     #{project[:src]})
+  #   Say.terminal msg.map(&:strip).join(%(\n))
+  # end
+
+  # def announce_preflight_info(targets, cfg_synth)
+  #   namespaces    = cfg_synth[:namespace].keys.map(&:to_sym)
+  #   environments  = []
+  #
+  #   namespaces.each do |ns_name|
+  #     environments.concat(cfg_synth[:namespace][ns_name].keys.map(&:to_sym))
+  #   end
+  #
+  #   preflight_info = []
+  #   preflight_info << %(environments: #{environments})
+  #   preflight_info << %(\n)
+  #   preflight_info << %(namespace: #{targets[0]})
+  #   preflight_info << %(site:      #{targets[1]})
+  #   preflight_info << %(project:   #{targets[2]})
+  #
+  #   Say.terminal preflight_info.map(&:strip).join(%(\n))
+  # end
+
+  # targets can be...
+  # ${namespace}
+  # ${namespace}.${site}
+  # def check_target(target, config)
+  #   # raise NamespaceNotFoundError if target.nil?
+  #
+  #   # targets       = target.split('.').map(&:to_sym)
+  #   # namespaces    = config[:namespace].keys.map(&:to_sym)
+  #   # runtype       = nil
+  #   # environments  = []
+  #
+  #   # namespaces.each do |ns_name|
+  #   #   environments.concat(config[:namespace][ns_name].keys.map(&:to_sym))
+  #   # end
+  #
+  #   # raise NamespaceNotFoundError unless namespaces.include?(targets[0])
+  #
+  #   # namespaces.each do |ns_name|
+  #   #   environments.each do |e_name|
+  #   #     sites = config[:namespace][ns_name][e_name][:sites] || []
+  #   #
+  #   #     next if sites.empty?
+  #   #
+  #   #     site_names = []
+  #   #     sites.each do |site|
+  #   #       site_names << site[:name]
+  #   #     end
+  #   #
+  #   #     raise SiteNotFoundError unless site_names.include?(targets[1].to_sym)
+  #   #
+  #   #     projects = config[:namespace][ns_name][e_name][:projects] || []
+  #   #
+  #   #     next if projects.empty?
+  #   #
+  #   #     project_names = []
+  #   #     projects.each do |project|
+  #   #       project_names << project[:name]
+  #   #     end
+  #   #
+  #   #     raise ProjectNotFoundError \
+  #   #     unless project_names
+  #   #            .include?(
+  #   #              targets[2].to_sym
+  #   #            )
+  #   #   end
+  #   # end
+  # end
+
+  # def check_run
+  #   raise IncorrectSubcommandError unless correct_subcommand?(
+  #     params[:subcommand]
+  #   )
+  #   raise NoInfraTargetError unless params[:target]
+  # end
+
+  # def correct_subcommand?(sbcmd)
+  #   NAME.to_s.eql?(sbcmd.to_s)
+  # end
 end

data/lib/pangea/modules.rb

@@ -5,6 +5,9 @@
 # for terraform code.
 ###############################################################################
 
+require %(terraform-synthesizer)
+require %(bundler)
+
 module PangeaBase
   BASE_DIR = File.join(
     Dir.home,
@@ -28,12 +31,60 @@ module PangeaRbenv
   )
 
   class << self
+    def versions_dir
+      VERSIONS_DIR
+    end
+
     def rbenv_installed?
       `which rbenv`.strip != ''
     end
 
-    def rbenv_install(_version)
+    def rbenv_install(version, path)
       system %(mkdir -p #{VERSIONS_DIR}) unless Dir.exist?(VERSIONS_DIR)
+      if rbenv_installed? && !Dir.exist?(File.join(path.to_s))
+        system [BIN, %(install), version.to_s, path.to_s].join(%( ))
+      end
+    end
+  end
+end
+
+module PangeaRubyBuild
+  include PangeaBase
+  BIN = %(ruby-build).freeze
+  RUBY_BUILD_DIR = File.join(
+    BASE_DIR,
+    %(rbenv)
+  )
+  class << self
+    def ruby_build_installed?
+      `which rbenv`.strip != ''
+    end
+
+    def ruby_build(version, path)
+      system %(mkdir -p #{PangeaRbenv.versions_dir}) unless Dir.exist?(PangeaRbenv.versions_dir)
+      system [BIN, version.to_s, path.to_s].join(%( )) if ruby_build_installed? && !Dir.exist?(File.join(path.to_s))
+    end
+
+    def gem_install(gem, ruby_version, gem_version, gemset_path)
+      gem_path = File.join(gemset_path, %(lib), %(ruby), %(gems), ruby_version.to_s, %(gems), %(#{gem}-#{gem_version}))
+      unless Dir.exist?(gem_path)
+        gembin = File.join(gemset_path, %(bin), %(gem))
+        system [gembin, %(install), gem.to_s.strip, %(-v), gem_version.to_s].join(%( ))
+      end
+    end
+
+    def bundle_install(mpath, gemset_path)
+      @bundlebin = File.join(gemset_path, %(bin), %(bundle))
+      bundlehint = File.join(gemset_path, %(bundle_hint))
+      unless File.exist?(bundlehint)
+        cmd = [
+          # %(cd #{mpath} &&),
+          %(BUNDLE_GEMFILE=#{File.join(mpath, %(Gemfile))}), @bundlebin,
+          %(install)
+        ].join(%( ))
+        system cmd
+        system [%(touch), bundlehint].join(%( ))
+      end
     end
   end
 end
@@ -51,15 +102,33 @@ module PangeaModule
     %(rubies)
   )
 
-  # SECTIONS = %i[
-  #   lib
-  #   src
-  # ].freeze
-
   class << self
+    def symbolize(hash)
+      JSON[JSON[hash], symbolize_names: true]
+    end
+
+    def terraform_synth
+      @terraform_synth ||= TerraformSynthesizer.new
+    end
+
     # entrypoint for module processing
     def process(mod)
-      exit 1 unless mod.fetch(:sandboxed, false)
+      mod = symbolize(mod)
+      if mod.fetch(:sandboxed)
+
+        name = mod.fetch(:name)
+
+        raise ArgumentError, %(name cannot be nil) if name.nil?
+
+        # understanding that module entrypoint loading
+        # will work with #{context}-#{name}
+        context       = mod.fetch(:context, %(pangea-component))
+        require_name  = %(#{context}-#{name})
+
+        require require_name
+        puts    render
+        puts    %(end)
+      end
     end
   end
 end

data/lib/pangea/version.rb

@@ -1,3 +1,3 @@
 module Pangea
-  VERSION = %(0.0.36).freeze
+  VERSION = %(0.0.38).freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pangea
 version: !ruby/object:Gem::Version
-  version: 0.0.36
+  version: 0.0.38
 platform: ruby
 authors:
 - drzthslnt@gmail.com
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-21 00:00:00.000000000 Z
+date: 2023-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec