terraspace-bundler 0.1.0 → 0.2.0

data/lib/terraspace_bundler/mod/locked.rb

@@ -1,48 +0,0 @@
-class TerraspaceBundler::Mod
-  class Locked
-    include TB::Util::Registry
-
-    attr_reader :name, :path, :source, :version
-    def initialize(name, info)
-      @name, @info = name.to_s, info
-
-      @path = @info[:path]
-      @version = @info[:version]
-    end
-
-    def source
-      @info[:source]
-    end
-
-    def org
-      obtain_org(source)
-    end
-
-    def repo
-      s = registry?(source) ? registry_github : source
-      File.basename(s)
-    end
-
-    def full_repo
-      "#{org}/#{repo}"
-    end
-
-    def to_mod
-      # copy all props in Terrafile.lock
-      options = @info.clone
-      # add org
-      options.merge!(org: @org)
-
-      data = {
-        args: @name,
-        options: options,
-      }
-      TB::Mod.new(data) # no need for global, info in the lockfile is enough
-    end
-
-    def export
-      export = Export.new(self)
-      export.run
-    end
-  end
-end

data/lib/terraspace_bundler/mod/sync.rb

@@ -1,53 +0,0 @@
-class TerraspaceBundler::Mod
-  class Sync
-    extend Memoist
-    include TB::Helper::Git
-    include TB::Logging
-    include TB::Mod::TmpPaths
-
-    attr_reader :sha
-    def initialize(mod, url)
-      @mod, @url = mod, url
-    end
-
-    def run
-      setup_tmp
-      org_path = "#{cache_root}/#{@mod.org}"
-      FileUtils.mkdir_p(org_path)
-      Dir.chdir(org_path) do
-        name = File.basename(@url).sub('.git','')
-        unless File.exist?(name)
-          sh "git clone #{@url}"
-        end
-
-        Dir.chdir(name) do
-          git "pull"
-          git "submodule update --init"
-          stage(name)
-        end
-      end
-    end
-
-    def stage(name)
-      copy_to_stage(name)
-      switch_to_specific_version(name)
-    end
-
-    def switch_to_specific_version(name)
-      stage_path = stage_path("#{@mod.org}/#{name}")
-      logger.debug "Within: #{stage_path}"
-      Dir.chdir(stage_path) do
-        git "checkout #{@mod.checkout_version}" if @mod.checkout_version
-        @sha = git("rev-parse HEAD").strip
-      end
-    end
-
-    def copy_to_stage(name)
-      cache_path = cache_path("#{@mod.org}/#{name}")
-      stage_path = stage_path("#{@mod.org}/#{name}")
-      FileUtils.rm_rf(stage_path)
-      FileUtils.mkdir_p(File.dirname(stage_path))
-      FileUtils.cp_r(cache_path, stage_path)
-    end
-  end
-end

data/lib/terraspace_bundler/setup.rb

@@ -1,20 +0,0 @@
-module TerraspaceBundler
-  class Setup
-    def initialize(options={})
-      @options = options
-    end
-
-    def setup!
-      # Run the DSL to possibly override the config defaults
-      meta = Dsl.new.run
-      export_path = meta[:global][:export_path]
-      TB.config.export_path = export_path if export_path
-
-      # cli --terrafile option
-      if @options[:terrafile]
-        TB.config.terrafile = @options[:terrafile]
-        TB.config.lockfile = "#{@options[:terrafile]}.lock"
-      end
-    end
-  end
-end

data/lib/terraspace_bundler/updater.rb

@@ -1,49 +0,0 @@
-module TerraspaceBundler
-  class Updater
-    include Logging
-
-    def initialize(options={})
-      @options = options
-      @mod_name = @options[:mod]
-    end
-
-    def run(without_install: false)
-      Setup.new(@options).setup!
-      puts "Bundling modules from #{TB.config.terrafile}..."
-
-      if update_one?
-        update_one
-      else
-        update_all
-      end
-      unless without_install
-        Installer.new(@options.merge(download: false)).run
-      end
-    end
-
-    def update_one?
-      @mod_name && File.exist?(TB.config.lockfile)
-    end
-
-    def update_one
-      meta = Dsl.new.run
-      mods = meta[:mods].map { |data| Mod.new(data, meta[:global]) }
-      mod = mods.find { |m| m.name == @mod_name }
-      unless mod
-        logger.error "No module #{@mod_name} found in your Terrafile"
-        exit 1
-      end
-      mod.sync
-      Lockfile.new.update_one(mod)
-    end
-
-    def update_all
-      meta = Dsl.new.run
-      mods = meta[:mods].map { |data| Mod.new(data, meta[:global]) }
-      mods.each do |mod|
-        mod.sync
-      end
-      Lockfile.new(mods).create
-    end
-  end
-end

data/lib/terraspace_bundler/updater/lockfile.rb

@@ -1,48 +0,0 @@
-require "yaml"
-
-class TerraspaceBundler::Updater
-  class Lockfile
-    include TB::Logging
-
-    def initialize(mods=[])
-      @mods = mods
-    end
-
-    def create
-      data = {}
-      @mods.each do |mod|
-        data.merge!(item(mod))
-      end
-      write(data)
-    end
-
-    def item(mod)
-      props = {
-        path: mod.path,
-        sha: mod.sha,
-        source: mod.source,
-        url: mod.url,
-        version: mod.version,
-      }
-      props.delete_if { |k,v| v.nil? }
-      { mod.name => props }
-    end
-
-    def update_one(mod)
-      data = YAML.load_file(lockfile)
-      data.merge!(item(mod))
-      write(data, ": #{mod.name}")
-    end
-
-    def write(data, message="")
-      content = YAML.dump(data.deep_stringify_keys)
-      action = File.exist?(lockfile) ? "Updated" : "Created"
-      IO.write(lockfile, content)
-      logger.info "#{action} #{lockfile}#{message}"
-    end
-
-    def lockfile
-      TB.config.lockfile
-    end
-  end
-end

data/lib/terraspace_bundler/util/registry.rb

@@ -1,24 +0,0 @@
-module TerraspaceBundler::Util
-  module Registry
-    extend Memoist
-
-    def registry?(url)
-      !url.nil? && url.split('/').size == 3
-    end
-
-    def registry_github
-      TB::Mod::Registry.new(self).to_github
-    end
-    memoize :registry_github
-
-    def obtain_org(source_option, global_org=nil)
-      source = registry?(source_option) ? registry_github : source_option
-      parts = source.split('/') # IE: git@github.com:boltopspro/terraform-google-vm
-      if parts.size == 1
-        global_org
-      else
-        parts[-2..-2].first
-      end
-    end
-  end
-end

data/spec/terraform_bundler/installer_spec.rb

@@ -1,16 +0,0 @@
-describe TB::Installer do
-  let(:installer) { described_class.new }
-
-  context "installer" do
-    # hacky sanity check
-    it "run" do
-      FileUtils.rm_f("tmp/Terrafile.lock")
-      FileUtils.mkdir_p("tmp")
-      Dir.chdir("tmp")
-      TB.config.terrafile = "spec/fixtures/Terrafile"
-      installer.run
-      file_exist = File.exist?("Terrafile.lock")
-      expect(file_exist).to be true
-    end
-  end
-end