pups 1.0.3 → 1.1.0

data/lib/pups/replace_command.rb

@@ -1,43 +1,45 @@
-class Pups::ReplaceCommand < Pups::Command
-  attr_accessor :text, :from, :to, :filename, :direction, :global
+# frozen_string_literal: true
 
-  def self.from_hash(hash, params)
-    replacer = new(params)
-    replacer.from = guess_replace_type(hash["from"])
-    replacer.to = guess_replace_type(hash["to"])
-    replacer.text = File.read(hash["filename"])
-    replacer.filename = hash["filename"]
-    replacer.direction = hash["direction"].to_sym if hash["direction"]
-    replacer.global = hash["global"].to_s == "true"
-    replacer
-  end
+module Pups
+  class ReplaceCommand < Pups::Command
+    attr_accessor :text, :from, :to, :filename, :direction, :global
 
-  def self.guess_replace_type(item)
-    # evaling to get all the regex flags easily
-    item[0] == "/" ? eval(item) : item
-  end
+    def self.from_hash(hash, params)
+      replacer = new(params)
+      replacer.from = guess_replace_type(hash['from'])
+      replacer.to = guess_replace_type(hash['to'])
+      replacer.text = File.read(hash['filename'])
+      replacer.filename = hash['filename']
+      replacer.direction = hash['direction'].to_sym if hash['direction']
+      replacer.global = hash['global'].to_s == 'true'
+      replacer
+    end
 
-  def initialize(params)
-    @params = params
-  end
+    def self.guess_replace_type(item)
+      # evaling to get all the regex flags easily
+      item[0] == '/' ? eval(item) : item
+    end
 
-  def replaced_text
-    new_to = to
-    if String === to
-      new_to = interpolate_params(to)
+    def initialize(params)
+      @params = params
     end
-    if global
-      text.gsub(from,new_to)
-    elsif direction == :reverse
-      index = text.rindex(from)
-      text[0..index-1] << text[index..-1].sub(from,new_to)
-    else
-      text.sub(from,new_to)
+
+    def replaced_text
+      new_to = to
+      new_to = interpolate_params(to) if to.is_a?(String)
+      if global
+        text.gsub(from, new_to)
+      elsif direction == :reverse
+        index = text.rindex(from)
+        text[0..index - 1] << text[index..-1].sub(from, new_to)
+      else
+        text.sub(from, new_to)
+      end
     end
-  end
 
-  def run
-    Pups.log.info("Replacing #{from.to_s} with #{to.to_s} in #{filename}")
-    File.open(filename, "w"){|f| f.write replaced_text }
+    def run
+      Pups.log.info("Replacing #{from} with #{to} in #{filename}")
+      File.open(filename, 'w') { |f| f.write replaced_text }
+    end
   end
 end

data/lib/pups/runit.rb

@@ -1,40 +1,39 @@
-class Pups::Runit
+# frozen_string_literal: true
 
-  attr_accessor :env, :exec, :cd, :name
+module Pups
+  class Runit
+    attr_accessor :env, :exec, :cd, :name
 
+    def initialize(name)
+      @name = name
+    end
 
-  def initialize(name)
-    @name = name
-  end
-
-  def setup
-    `mkdir -p /etc/service/#{name}`
-    run = "/etc/service/#{name}/run"
-    File.open(run, "w") do |f|
-      f.write(run_script)
+    def setup
+      `mkdir -p /etc/service/#{name}`
+      run = "/etc/service/#{name}/run"
+      File.open(run, 'w') do |f|
+        f.write(run_script)
+      end
+      `chmod +x #{run}`
     end
-    `chmod +x #{run}`
-  end
 
-  def run_script
-"#!/bin/bash
+    def run_script
+      "#!/bin/bash
 exec 2>&1
 #{env_script}
 #{cd_script}
 #{exec}
 "
-  end
+    end
 
-  def cd_script
-    "cd #{@cd}" if @cd
-  end
+    def cd_script
+      "cd #{@cd}" if @cd
+    end
 
-  def env_script
-    if @env
-      @env.map do |k,v|
+    def env_script
+      @env&.map do |k, v|
         "export #{k}=#{v}"
-      end.join("\n")
+      end&.join("\n")
     end
   end
-
 end

data/lib/pups/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pups
-  VERSION = "1.0.3"
+  VERSION = '1.1.0'
 end

data/pups.gemspec

@@ -1,26 +1,31 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'pups/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "pups"
+  spec.name          = 'pups'
   spec.version       = Pups::VERSION
-  spec.authors       = ["Sam Saffron"]
-  spec.email         = ["sam.saffron@gmail.com"]
-  spec.description   = %q{Simple docker image creator}
-  spec.summary       = %q{Toolkit for orchestrating a composed docker image}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.authors       = ['Sam Saffron']
+  spec.email         = ['sam.saffron@gmail.com']
+  spec.description   = 'Simple docker image creator'
+  spec.summary       = 'Toolkit for orchestrating a composed docker image'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
-  spec.add_development_dependency "guard"
-  spec.add_development_dependency "guard-minitest"
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-minitest'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-discourse'
+  spec.add_development_dependency 'rubocop-minitest'
+  spec.add_development_dependency 'rubocop-rake'
 end

data/test/cli_test.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'tempfile'
+require 'stringio'
+
+module Pups
+  class CliTest < MiniTest::Test
+    def test_cli_option_parsing_stdin
+      options = Cli.parse_args(['--stdin'])
+      assert_equal(true, options[:stdin])
+    end
+
+    def test_cli_option_parsing_none
+      options = Cli.parse_args([])
+      assert_nil(options[:stdin])
+    end
+
+    def test_cli_read_config_from_file
+      # for testing output
+      f = Tempfile.new('test_output')
+      f.close
+
+      # for testing input
+      cf = Tempfile.new('test_config')
+      cf.puts <<~YAML
+      params:
+        run: #{f.path}
+      run:
+        - exec: echo hello world >> #{f.path}
+      YAML
+      cf.close
+
+      Cli.run([cf.path])
+      assert_equal('hello world', File.read(f.path).strip)
+    end
+
+    def test_cli_ignore_config_element
+      # for testing output
+      f = Tempfile.new('test_output')
+      f.close
+
+      # for testing input
+      cf = Tempfile.new('test_config')
+      cf.puts <<~YAML
+        env:
+          MY_IGNORED_VAR: a_word
+        params:
+          a_param_var: another_word
+        run:
+          - exec: echo repeating $MY_IGNORED_VAR and also $a_param_var >> #{f.path}
+      YAML
+      cf.close
+
+      Cli.run(["--ignore", "env,params", cf.path])
+      assert_equal('repeating and also', File.read(f.path).strip)
+    end
+
+    def test_cli_gen_docker_run_args_ignores_other_config
+      # When generating the docker run arguments it should ignore other template configuration
+      # like 'run' directives.
+
+      # for testing output
+      f = Tempfile.new("test_output")
+      f.close
+
+      # for testing input
+      cf = Tempfile.new("test_config")
+      cf.puts <<~YAML
+      env:
+        foo: 1
+        bar: 5
+        baz: 'hello_{{spam}}'
+      env_template:
+        spam: 'eggs'
+        config: my_app
+      params:
+        run: #{f.path}
+      run:
+        - exec: echo hello world >> #{f.path}
+      expose:
+        - "2222:22"
+        - "127.0.0.1:20080:80"
+        - 5555
+      volumes:
+        - volume:
+            host: /var/discourse/shared
+            guest: /shared
+        - volume:
+            host: /bar
+            guest: /baz
+      links:
+        - link:
+            name: postgres
+            alias: postgres
+        - link:
+            name: foo
+            alias: bar
+      labels:
+        monitor: "true"
+        app_name: "{{config}}_discourse"
+      YAML
+      cf.close
+
+      expected = []
+      expected << "--env foo=1 --env bar=5 --env baz=hello_eggs"
+      expected << "--publish 2222:22 --publish 127.0.0.1:20080:80 --expose 5555"
+      expected << "--volume /var/discourse/shared:/shared --volume /bar:/baz"
+      expected << "--link postgres:postgres --link foo:bar"
+      expected << "--label monitor=true --label app_name=my_app_discourse"
+      expected.sort!
+
+      assert_equal("", File.read(f.path).strip)
+      assert_output(expected.join(" ")) { Cli.run(["--gen-docker-run-args", cf.path]) }
+    end
+  end
+end

data/test/config_test.rb

@@ -1,55 +1,217 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'tempfile'
 
 module Pups
   class ConfigTest < MiniTest::Test
-
     def test_config_from_env
-      ENV["HELLO"] = "world"
+      ENV['HELLO'] = 'world'
       config = Config.new({})
-      assert_equal("world", config.params["$ENV_HELLO"])
+      assert_equal('world', config.params['$ENV_HELLO'])
     end
 
-    def test_integration
+    def test_env_param
+      ENV['FOO'] = 'BAR'
+      config = <<~YAML
+        env:
+          BAR: baz
+          hello: WORLD
+          one: 1
+      YAML
 
-      f = Tempfile.new("test")
-      f.close
+      config = Config.new(YAML.safe_load(config))
+      %w[BAR hello one].each { |e| ENV.delete(e) }
+      assert_equal('BAR', config.params['$ENV_FOO'])
+      assert_equal('baz', config.params['$ENV_BAR'])
+      assert_equal('WORLD', config.params['$ENV_hello'])
+      assert_equal('1', config.params['$ENV_one'])
+    end
+
+    def test_env_with_template
+      ENV['FOO'] = 'BAR'
+      config = <<~YAML
+        env:
+          greeting: "{{hello}}, {{planet}}!"
+          one: 1
+          other: "where are we on {{planet}}?"
+        env_template:
+          planet: pluto
+          hello: hola
+      YAML
+      config_hash = YAML.safe_load(config)
+
+      config = Config.new(config_hash)
+      %w[greeting one other].each { |e| ENV.delete(e) }
+      assert_equal('hola, pluto!', config.params['$ENV_greeting'])
+      assert_equal('1', config.params['$ENV_one'])
+      assert_equal('BAR', config.params['$ENV_FOO'])
+      assert_equal('where are we on pluto?', config.params['$ENV_other'])
+    end
+
+    def test_label_with_template
+      ENV["FOO"] = "BAR"
+      config = <<~YAML
+      env:
+        greeting: "{{hello}}, {{planet}}!"
+        one: 1
+        other: "where are we on {{planet}}?"
+      env_template:
+        planet: pluto
+        hello: hola
+        config: various
+      labels:
+        app_name: "{{config}}_discourse"
+      YAML
+      config_hash = YAML.load(config)
+
+      config = Config.new(config_hash)
+      %w[greeting one other].each { |e| ENV.delete(e) }
+      assert_equal("various_discourse", config.config['labels']['app_name'])
+    end
+
+    def test_env_with_ENV_templated_variable
+      ENV['env_template_config'] = 'my_application'
+      config = <<~YAML
+        env:
+          greeting: "{{hello}}, {{planet}}!"
+          one: 1
+          other: "building {{config}}"
+        env_template:
+          planet: pluto
+          hello: hola
+      YAML
+      config_hash = YAML.safe_load(config)
+
+      config = Config.new(config_hash)
+      %w[greeting one other].each { |e| ENV.delete(e) }
+      assert_equal('hola, pluto!', config.params['$ENV_greeting'])
+      assert_equal('1', config.params['$ENV_one'])
+      assert_equal('building my_application', config.params['$ENV_other'])
+      ENV["env_template_config"] = nil
+    end
 
-      config = <<YAML
-params:
-  run: #{f.path}
-run:
-  - exec: echo hello world >> #{f.path}
-YAML
+    def test_integration
+      f = Tempfile.new('test')
+      f.close
 
-      Config.new(YAML.load(config)).run
-      assert_equal("hello world", File.read(f.path).strip)
+      config = <<~YAML
+        env:
+          PLANET: world
+        params:
+          run: #{f.path}
+          greeting: hello
+        run:
+          - exec: echo $greeting $PLANET >> #{f.path}
+      YAML
 
+      Config.new(YAML.safe_load(config)).run
+      ENV.delete('PLANET')
+      assert_equal('hello world', File.read(f.path).strip)
     ensure
       f.unlink
     end
 
     def test_hooks
-      yaml = <<YAML
-run:
-  - exec: 1
-  - exec:
-      hook: middle
-      cmd: 2
-  - exec: 3
-hooks:
-  after_middle:
-    - exec: 2.1
-  before_middle:
-    - exec: 1.9
-YAML
+      yaml = <<~YAML
+        run:
+          - exec: 1
+          - exec:
+              hook: middle
+              cmd: 2
+          - exec: 3
+        hooks:
+          after_middle:
+            - exec: 2.1
+          before_middle:
+            - exec: 1.9
+      YAML
 
       config = Config.load_config(yaml).config
-      assert_equal({ "exec" => 1.9 }, config["run"][1])
-      assert_equal({ "exec" => 2.1 }, config["run"][3])
+      assert_equal({ 'exec' => 1.9 }, config['run'][1])
+      assert_equal({ 'exec' => 2.1 }, config['run'][3])
+    end
+
+    def test_ignored_elements
+      f = Tempfile.new('test')
+      f.close
+
+      yaml = <<~YAML
+        env:
+          PLANET: world
+        params:
+          greeting: hello
+        run:
+          - exec: 1
+          - exec:
+              hook: middle
+              cmd: 2
+          - exec: 3
+          - exec: echo $greeting $PLANET >> #{f.path}
+        hooks:
+          after_middle:
+            - exec: 2.1
+          before_middle:
+            - exec: 1.9
+      YAML
 
+      conf = Config.load_config(yaml, %w[hooks params])
+      config = conf.config
+      assert_equal({ 'exec' => 1 }, config['run'][0])
+      assert_equal({ 'exec' => { 'hook' => 'middle', 'cmd' => 2 } }, config['run'][1])
+      assert_equal({ 'exec' => 3 }, config['run'][2])
+      assert_equal({ 'exec' => "echo $greeting $PLANET >> #{f.path}" }, config['run'][3])
 
+      # $greet from params will be an empty var as it was ignored
+      conf.run
+      ENV.delete('PLANET')
+      assert_equal('world', File.read(f.path).strip)
+    end
+
+    def test_generate_docker_run_arguments
+      yaml = <<~YAML
+      env:
+        foo: 1
+        bar: 2
+        baz: 'hello_{{spam}}'
+      env_template:
+        spam: 'eggs'
+        config: my_app
+      expose:
+        - "2222:22"
+        - "127.0.0.1:20080:80"
+        - 5555
+      volumes:
+        - volume:
+            host: /var/discourse/shared
+            guest: /shared
+        - volume:
+            host: /bar
+            guest: /baz
+      links:
+        - link:
+            name: postgres
+            alias: postgres
+        - link:
+            name: foo
+            alias: bar
+      labels:
+        monitor: "true"
+        app_name: "{{config}}_discourse"
+      YAML
+
+      config = Config.load_config(yaml)
+      args = config.generate_docker_run_arguments
+
+      expected = []
+      expected << "--env foo=1 --env bar=2 --env baz=hello_eggs"
+      expected << "--publish 2222:22 --publish 127.0.0.1:20080:80 --expose 5555"
+      expected << "--volume /var/discourse/shared:/shared --volume /bar:/baz"
+      expected << "--link postgres:postgres --link foo:bar"
+      expected << "--label monitor=true --label app_name=my_app_discourse"
+      expected.sort!
+
+      assert_equal(expected.join(" "), args)
     end
   end
 end
-