pangea 0.0.1

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

@@ -0,0 +1,206 @@
+require_relative %(./pangea)
+require_relative %(../../cli/constants)
+require_relative %(../../cli/config)
+require_relative %(../../errors/namespace_not_found_error)
+require_relative %(../../errors/site_not_found_error)
+require_relative %(../../errors/project_not_found_error)
+require_relative %(../../errors/no_infra_target_error)
+require_relative %(../../errors/incorrect_subcommand_error)
+require_relative %(../../say/init)
+
+require %(pangea/synthesizer/terraform)
+require %(json)
+
+class InfraCommand < StitchesCommand
+  include Constants
+  NAME = :infra
+
+  usage do
+    desc %(manage infrastructure)
+    program %(pangea)
+    command %(infra)
+  end
+
+  argument :subcommand do
+    desc %(the subcommand)
+  end
+
+  argument :target do
+    desc %(target like ${namespace}.${site}.${project})
+  end
+
+  def run(argv)
+    parse(argv)
+
+    # grab a config synth
+    cfg_synth = Config.resolve_configurations
+
+    # reject empty configurations
+    if cfg_synth.empty?
+      Say.terminal %(configuration empty, exiting...)
+      exit
+    end
+
+    # preflight checks for the command execution
+    check_run
+    check_target(params[:target], cfg_synth)
+
+    targets = params[:target].split('.').map(&:to_sym)
+    process_target(targets, cfg_synth)
+
+    # 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|
+              if File.exist?(File.join(
+                project[:src][:location].to_s,
+                %(src),
+                src_dir.to_s
+              ))
+                stitch_files = Dir.glob("#{File.join(
+                  project[:src][:location].to_s,
+                  %(src),
+                  src_dir.to_s
+                )}/**/*.rb")
+                stitch_files.each do |stitch_file|
+                  synth.synthesize(File.read(stitch_file))
+                end
+              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}
+  # ${namespace}.${site}.${project}
+  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/cli/subcommands/main.rb

@@ -0,0 +1,60 @@
+require_relative %(./pangea)
+require_relative %(./infra)
+require_relative %(./config)
+require_relative %(../version)
+
+###############################################################################
+# cli entrypoint
+###############################################################################
+
+class Command < PangeaCommand
+  usage do
+    desc %(manage crud apis declaratively)
+    program %(pangea)
+  end
+
+  argument :subcommand do
+    desc %(subcommand for pangea)
+    required
+  end
+
+  def help
+    <<~HELP
+      Usage: pangea command [OPTIONS] SUBCOMMAND
+
+      stitch together infrastructure
+
+      Arguments:
+        SUBCOMMAND  subcommand for pangea
+
+      Options:
+        -h, --help     Print usage
+        -v, --version  Print version
+
+      Subcommands:
+        infra   manage infrastructure
+        config  manage configuration
+    HELP
+  end
+
+  def run
+    argv = ARGV
+    parse(argv)
+
+    case params[:subcommand].to_s
+    when %(infra)
+      InfraCommand.new.run(argv)
+    when %(config)
+      ConfigCommand.new.run(argv)
+    else
+      if params[:version]
+        puts Pangea::Cli::VERSION
+      else
+        puts help
+      end
+      exit
+    end
+  end
+end
+
+# end cli entrypoint

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

@@ -0,0 +1,18 @@
+require %(tty-option)
+
+# shared command behavior for all commands in Stitches
+class StitchesCommand
+  include TTY::Option
+
+  flag :help do
+    short %(-h)
+    long %(--help)
+    desc %(Print usage)
+  end
+
+  flag :version do
+    short %(-v)
+    long %(--version)
+    desc %(Print version)
+  end
+end

data/lib/pangea/cli.rb

@@ -0,0 +1 @@
+require_relative %(./cli/subcommands/main)

data/lib/pangea/docker.rb

@@ -0,0 +1,91 @@
+module Shell
+  class << self
+    def run(bin, cmd)
+      final = []
+      final << bin
+      final.concat(cmd)
+      system final.join(%( ))
+    end
+  end
+end
+
+module Compose
+  BIN = ENV[%(COMPOSE_BIN)] || %(docker-compose).freeze
+
+  class << self
+    def run(cmd)
+      Shell.run(BIN, cmd)
+    end
+  end
+end
+
+module Docker
+  BIN = ENV[%(DOCKER_BIN)] || %(docker).freeze
+
+  class << self
+    def run(cmd)
+      Shell.run(BIN, cmd)
+    end
+
+    def build(image)
+      cmd = []
+      cmd << %(build)
+      cmd << %(-t)
+      cmd << %(#{image}:latest)
+      cmd << %(.)
+      run cmd
+    end
+
+    def tag(image)
+      sha = `git rev-parse --short HEAD`
+      cmd = []
+      cmd << %(tag)
+      cmd << %(#{image}:latest)
+      cmd << %(#{image}:#{sha})
+      run cmd
+    end
+
+    def create(name, image)
+      cmd = []
+      cmd << %(create)
+      cmd << %(-it)
+      cmd << %(--name #{name})
+      cmd << image
+      cmd << %(/bin/bash)
+      run cmd
+    end
+
+    def start(name)
+      cmd = []
+      cmd << %(start)
+      cmd << %(-i -a)
+      cmd << name
+    end
+  end
+end
+
+class Image
+  def initialize(name)
+    @name = name
+  end
+
+  def build
+    Docker.build(@name)
+    Docker.tag(@name)
+  end
+end
+
+class Container
+  def initialize(name, image)
+    @name   = name
+    @image  = image
+  end
+
+  def create
+    Docker.create(@name, @image)
+  end
+
+  def start
+    Docker.start(@name)
+  end
+end

data/lib/pangea/errors/incorrect_subcommand_error.rb

@@ -0,0 +1,2 @@
+class IncorrectSubcommandError < StandardError
+end

data/lib/pangea/errors/namespace_not_found_error.rb

@@ -0,0 +1,2 @@
+class NamespaceNotFoundError < StandardError
+end

data/lib/pangea/errors/no_infra_target_error.rb

@@ -0,0 +1,2 @@
+class NoInfraTargetError < StandardError
+end

data/lib/pangea/errors/project_not_found_error.rb

@@ -0,0 +1,2 @@
+class ProjectNotFoundError < StandardError
+end

data/lib/pangea/errors/site_not_found_error.rb

@@ -0,0 +1,2 @@
+class SiteNotFoundError < StandardError
+end

data/lib/pangea/extractors/README.md

@@ -0,0 +1,3 @@
+# extractors
+
+take a synthesis and return appropriate hash of namespaces

data/lib/pangea/log/init.rb

@@ -0,0 +1,2 @@
+module Log
+end

data/lib/pangea/say/init.rb

@@ -0,0 +1,27 @@
+require %(tty-color)
+require %(tty-box)
+
+module Say
+  class << self
+    def terminal(msg)
+      spec = {
+        width: 80,
+        style: {
+          fg: :yellow,
+          bg: :blue,
+          border: { fg: :green, bg: :black }
+        },
+        align: :right,
+        border: :thick
+        # padding: 0,
+        # height: 1
+      }
+
+      box = TTY::Box.frame(**spec)
+
+      puts box + "\n"
+      puts msg.strip
+      puts "\n" + box
+    end
+  end
+end

data/lib/pangea/shell/README.md

@@ -0,0 +1 @@
+# localize calling out to the shell

data/lib/pangea/shell/terraform.rb

@@ -0,0 +1,21 @@
+module Shell
+  module Terraform
+    BIN = ENV[%(TERRAFORM_BIN)] || %(terraform).freeze
+
+    class << self
+      def run(terraform_cmd)
+        cmd = []
+        cmd << %(cd)
+        cmd << Dir.pwd
+        cmd << %(&&)
+        cmd << BIN
+        cmd << terraform_cmd
+        system cmd.join(%( ))
+      end
+
+      def plan
+        run(%(plan))
+      end
+    end
+  end
+end

data/lib/pangea/structures/README.md

@@ -0,0 +1,3 @@
+# structures
+
+The principle structures driving the pangea cli

data/lib/pangea/structures/abstract.rb

@@ -0,0 +1,2 @@
+class AbstractStitchesStructure
+end

data/lib/pangea/structures/namespace.rb

@@ -0,0 +1,4 @@
+require_relative './abstract'
+
+class Namespace < AbstractStitchesStructure
+end

data/lib/pangea/structures/project.rb

@@ -0,0 +1,4 @@
+require_relative './abstract'
+
+class Project < AbstractStitchesStructure
+end

data/lib/pangea/structures/site.rb

@@ -0,0 +1,4 @@
+require_relative './abstract'
+
+class Site < AbstractStitchesStructure
+end

data/lib/pangea/synthesizer/config.rb

@@ -0,0 +1,39 @@
+require_relative %(../cli/constants)
+require %(pangea/synthesizer/abstract)
+require %(toml-rb)
+require %(json)
+require %(yaml)
+
+###############################################################################
+# read files merge config data and provide a single configuation structure
+###############################################################################
+
+class ConfigSynthesizer < AbstractSynthesizer
+  include Constants
+
+  def synthesize(content, ext)
+    case ext.to_s
+    when %(yaml), %(yml)
+      translation[:template] = YAML.safe_load(content)
+    when %(toml)
+      translation[:template] = TomlRB.parse(content)
+    when %(json)
+      translation[:template] = JSON.parse(content)
+    when %(rb)
+      if block_given?
+        yield
+      else
+        instance_eval(content)
+      end
+    end
+  end
+
+  def method_missing(method_name, *args, &block)
+    abstract_method_missing(
+      method_name,
+      %i[namespace],
+      *args,
+      &block
+    )
+  end
+end

data/lib/pangea/version.rb

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

data/pangea.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+lib = File.expand_path(%(lib), __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require_relative %(./lib/pangea/version)
+
+Gem::Specification.new do |spec|
+  spec.name                  = %(pangea)
+  spec.version               = Pangea::VERSION
+  spec.authors               = [%(drzthslnt@gmail.com)]
+  spec.email                 = [%(drzthslnt@gmail.com)]
+  spec.description           = %(control rest apis declaratively with ruby)
+  spec.summary               = %(control rest apis declaratively with ruby)
+  spec.homepage              = %(https://github.com/drzln/#{spec.name})
+  spec.license               = %(MIT)
+  spec.files                 = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  spec.require_paths         = [%(lib)]
+  spec.executables           = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.required_ruby_version = %(>= #{`cat .ruby-version`})
+
+  %i[
+    rubocop-rspec
+    rubocop-rake
+    solargraph
+    keycutter
+    rubocop
+    rspec
+    rake
+    yard
+  ].each do |gem|
+    spec.add_development_dependency(gem)
+  end
+
+  %i[terraform-synthesizer tty-option].each do |gem|
+    spec.add_runtime_dependency(gem)
+  end
+
+  spec.metadata[%(rubygems_mfa_required)] = %(true)
+end

data/spec/cli/config_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require %(pangea/cli/config)
+
+describe Config do
+  context %(#resolve_configuration) do
+    defaults = { ignore_default_paths: true }
+    it %(empty when paths ignored) do
+      expect(
+        Config.resolve_configurations(**defaults.merge(
+          { extra_paths: [] }
+        ))
+      ).to be_empty
+    end
+  end
+end

data/spec/synthesizer/config_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require %(pangea/synthesizer/config)
+
+# describe ConfigSynthesizer do
+#   context %(main) do
+#     let(:synth) do
+#       described_class.new
+#     end
+#
+#     it %(should compile small declaration and be hash) do
+#       synth.synthesize do
+#         namespace :nietztche, :thus_spoke_zarathustra do
+#           superman(%(came from krypton))
+#           overman(%(came from austria))
+#         end
+#       end
+#       expect(synth.synthesis).to be_kind_of(Hash)
+#     end
+#
+#     it %(should raise an argument error with more than one arg per field) do
+#       expect do
+#         synth.synthesize do
+#           namespace :socrates, :the_republic do
+#             things(%(may), %(not), %(be), %(what), %(you), %(think))
+#           end
+#         end
+#       end.to raise_error(TooManyFieldValuesError)
+#     end
+#
+#     it %(should have expected keys) do
+#       synth.synthesize do
+#         namespace :kafka, :metamorphasis do
+#           change :inevitable
+#         end
+#       end
+#       expect(
+#         synth.synthesis[:namespace][:kafka][:metamorphasis][:change]
+#       ).to be(:inevitable)
+#     end
+#   end
+# end