pigtail 0.0.1.17

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e8aed587afcec2ae4c4778dc261d31d2d5bd7911
+  data.tar.gz: c6d47a99d9667856abe45601996e9bd52b93969b
+SHA512:
+  metadata.gz: 08fcd3f2eda95c5a1cf9f18b533c141da150533b365ced6d12c33effaeae0b1cf564fdce9986d4f7d8c842e5488b086862c14e250105e5f8a86f7940672d6d91
+  data.tar.gz: d5d9ff35417313aaeb7cd2e5fc68c5559ab9b666616b1a70ab0ff48bafccb5a2d2c73aaf0437e1d7dcef10b49156646c367f1c9238ce0e9659ed79facc9a3f69

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Declare your gem's dependencies in pigtail.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use a debugger
+# gem 'byebug', group: [:development, :test]
+

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Nab Inno
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+Pigtail is a Ruby gem that provides a clear syntax for writing configurations.
+
+### Installation
+
+```sh
+$ gem install pigtail
+```
+
+Or with Bundler in your Gemfile.
+
+```ruby
+gem 'pigtail'
+```
+
+### Getting started
+
+```sh
+$ cd /apps/my-great-project
+$ pigtailize .
+```
+
+This will create an initial `config/pigtail.rb` file for you.
+
+### Example config/pigtail.rb file
+
+Pigtail ships with three pre-defined config types: command, runner, and rake. You can define your own with `config_type`.
+
+```ruby
+config_type :sports, <<-YAML
+global:
+  - category: :task
+    place: :place
+    log: :log
+    feeds:
+      - http://www.example.com/ski_1.rss
+      - http://www.example.com/ski_2.rss
+YAML
+set :log, "/path/to/my/sports.log"
+
+to "foo/bar" do
+  sports "ski", {
+    place: "/japan/nagano"
+  }
+end
+```
+
+Would configure `global: foo` to "/bar/buzz". `:task` is always replaced with the first argument, and any additional hash arguments are replaced with the options passed in or by variables that have been defined with `set`.
+
+### The `pigtail` command
+
+```sh
+$ cd /apps/my-great-project
+$ pigtail
+```
+
+This will simply show you your `config/pigtail.rb` file converted to cron syntax. It does not read or write your crontab file. Run `pigtail --help` for a complete list of options.
+
+### Acknowledgement
+
+Pigtail is based heavily on Whenever.
+
+### Epilogue
+
+```
+A whale!
+Down it goes, and more, and more
+Up goes its tail!
+
+-Buson Yosa
+```
+
+----
+
+Compatible with Ruby 1.8.7-2.2.0, JRuby, and Rubinius. [![Build Status](https://secure.travis-ci.org/nabinno/pigtail.png)](http://travis-ci.org/nabinno/pigtail)
+
+---
+
+Copyright &copy; 2015 Nab Inno

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn("warning: Could not load bundler: #{e}")
+  warn("         Some rake tasks will not be defined")
+else
+  Bundler::GemHelper.install_tasks
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs      << 'lib' << 'test'
+  test.pattern   = 'test/{functional,unit}/**/*_test.rb'
+  test.verbose   = true
+end
+
+task :default => :test

data/bin/pigtail

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'pigtail'
+require 'pigtail/version'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: pigtail [options]"
+  opts.on('-w', '--write-plagger-configs [identifier]', 'Default: full path to pigtail_config.rb file') do |identifier|
+     options[:write] = true
+     options[:identifier] = identifier if identifier
+  end
+  opts.on('-s', '--set [variables]', 'Example: --set \'environment=staging&path=/my/sweet/path\'') do |set|
+    options[:set] = set if set
+  end
+  opts.on('-f', '--load-file [pigtail file]', 'Default: config/pigtail_config.rb') do |file|
+    options[:file] = file if file
+  end
+  opts.on('-v', '--version') { puts "Pigtail v#{Pigtail::VERSION}"; exit(0) }
+end.parse!
+
+Pigtail::CommandLine.execute(options)

data/bin/pigtailize

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'fileutils'
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [path]"
+
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    warn e.message
+    puts opts
+    exit 1
+  end
+end
+
+unless ARGV.empty?
+  if !File.exists?(ARGV.first)
+    abort "`#{ARGV.first}' does not exist."
+  elsif !File.directory?(ARGV.first)
+    abort "`#{ARGV.first}' is not a directory."
+  elsif ARGV.length > 1
+    abort "Too many arguments; please specify only the directory to pigtailize."
+  end
+end
+
+content = <<-FILE
+# Use this file to easily define all of your configs.
+
+# Example:
+#
+# config_type :sports, <<-YAML
+# global:
+#   - category: :task
+#     place: :place
+#     log: :log
+#     feeds:
+#       - http://www.example.com/ski_1.rss
+#       - http://www.example.com/ski_2.rss
+# YAML
+# set :log, "/path/to/my/sports.log"
+#
+# to "foo/bar" do
+#   sports "ski", {
+#     place: "/japan/nagano"
+#   }
+# end
+
+# Learn more: http://github.com/nabinno/pigtail
+FILE
+
+file = 'config/pigtail.rb'
+base = ARGV.empty? ? '.' : ARGV.shift
+
+file = File.join(base, file)
+if File.exists?(file)
+  warn "[skip] `#{file}' already exists"
+elsif File.exists?(file.downcase)
+  warn "[skip] `#{file.downcase}' exists, which could conflict with `#{file}'"
+elsif !File.exists?(File.dirname(file))
+  warn "[skip] directory `#{File.dirname(file)}' does not exist"
+else
+  puts "[add] writing `#{file}'"
+  File.open(file, "w") { |f| f.write(content) }
+end
+
+puts "[done] pigtailize!"

data/lib/pigtail/command_line.rb

@@ -0,0 +1,135 @@
+require 'fileutils'
+
+module Pigtail
+  class CommandLine
+
+    def self.execute(options={})
+      new(options).run
+    end
+
+    def initialize(options={})
+      @options                = options
+      @options[:file]       ||= 'config/pigtail.rb'
+      @options[:identifier] ||= default_identifier
+      # @options[:cut]        ||= 0
+
+      if !File.exists?(@options[:file]) && @options[:clear].nil?
+        warn("[fail] Can't find file: #{@options[:file]}")
+        exit(1)
+      end
+
+      # if [@options[:update], @options[:write], @options[:clear]].compact.length > 1
+      #   warn("[fail] Can only update, write or clear. Choose one.")
+      #   exit(1)
+      # end
+
+      # unless @options[:cut].to_s =~ /[0-9]*/
+      #   warn("[fail] Can't cut negative lines from the pigtail_config #{options[:cut]}")
+      #   exit(1)
+      # end
+      # @options[:cut] = @options[:cut].to_i
+    end
+
+    def run
+      # if @options[:update] || @options[:clear]
+      #   write_pigtail_config(updated_pigtail_config)
+      # elsif @options[:write]
+      if @options[:write]
+        write_pigtail_config(pigtail_configs)
+      else
+        puts Pigtail.configs(@options)
+        puts "## [message] Above is your pigtail_config file converted to config syntax; your pigtail_config file was not updated."
+        puts "## [message] Run `pigtail --help' for more options."
+        exit(0)
+      end
+    end
+
+  protected
+
+    def default_identifier
+      File.expand_path(@options[:file])
+    end
+
+    def pigtail_configs
+      # return '' if @options[:clear]
+      Pigtail.configs(@options)
+    end
+
+    # def read_pigtail_config
+    #   return @current_pigtail_config if @current_pigtail_config
+    #   @current_pigtail_config = ""
+    #   # @current_pigtail_config = pigtail_configs.nil? ? '' : prepare(pigtail_configs)
+    # end
+
+    def write_pigtail_config(contents)
+      contents.each do |content|
+        content_path      = content[:path]
+        content_configure = content[:configure]
+        system("mkdir -p " + File.dirname(content_path))
+        IO.popen("cat >" + content_path, 'r+') do |io|
+          configure = ([comment_open, content_configure, comment_close].compact.join("\n") + "\n")
+          io.write(configure)
+          io.close_write
+        end
+
+        success = $?.exitstatus.zero?
+
+        if success
+          action = 'written' if @options[:write]
+          # action = 'updated' if @options[:update]
+          puts "[write] pigtail file #{action} to #{content_path}"
+        else
+          warn "[fail] Couldn't write pigtail to #{content_path}; try running `pigtail' with no options to ensure your config file is valid."
+        end
+      end
+    end
+
+    # def updated_pigtail_config
+    #   # Check for unopened or unclosed identifier blocks
+    #   if (read_pigtail_config =~ Regexp.new("^#{comment_open}\s*$") &&
+    #       (read_pigtail_config =~ Regexp.new("^#{comment_close}\s*$")).nil?)
+    #     warn "[fail] Unclosed indentifier; Your pigtail_config file contains '#{comment_open}', but no '#{comment_close}'"
+    #     exit(1)
+    #   elsif ((read_pigtail_config =~ Regexp.new("^#{comment_open}\s*$")).nil? &&
+    #          read_pigtail_config =~ Regexp.new("^#{comment_close}\s*$"))
+    #     warn "[fail] Unopened indentifier; Your pigtail_config file contains '#{comment_close}', but no '#{comment_open}'"
+    #     exit(1)
+    #   end
+    #
+    #   # If an existing identier block is found, replace it with the new pigtail config entries
+    #   if (read_pigtail_config =~ Regexp.new("^#{comment_open}\s*$") &&
+    #       read_pigtail_config =~ Regexp.new("^#{comment_close}\s*$"))
+    #     # If the existing pigtail_config file contains backslashes they get lost going through gsub.
+    #     # .gsub('\\', '\\\\\\') preserves them. Go figure.
+    #     read_pigtail_config.gsub(Regexp.new("^#{comment_open}\s*$.+^#{comment_close}\s*$", Regexp::MULTILINE),
+    #                              pigtail_configs[:configure].chomp.gsub('\\', '\\\\\\'))
+    #   else # Otherwise, append the new pigtail config entries after any existing ones
+    #     [read_pigtail_config, pigtail_configs].join("\n\n")
+    #   end.gsub(/\n{3,}/, "\n\n") # More than two newlines becomes just two.
+    # end
+
+    # def prepare(contents)
+    #   # Strip n lines from the top of the file as specified by the :cut option.
+    #   # Use split with a -1 limit option to ensure the join is able to rebuild
+    #   # the file with all of the original seperators in-tact.
+    #   stripped_contents = contents.split($/,-1)[@options[:cut]..-1].join($/)
+    #
+    #   # Some pigtail config implementations require all non-comment lines to be newline-
+    #   # terminated. (issue #95) Strip all newlines and replace with the default
+    #   # platform record seperator ($/)
+    #   stripped_contents.gsub!(/\s+$/, $/)
+    # end
+
+    def comment_base
+      "Pigtail generated configures for: #{@options[:identifier]}"
+    end
+
+    def comment_open
+      "# Begin #{comment_base}"
+    end
+
+    def comment_close
+      "# End #{comment_base}"
+    end
+  end
+end

data/lib/pigtail/config.rb

@@ -0,0 +1,47 @@
+# require 'shellwords'
+
+module Pigtail
+  class Config
+
+    def initialize(options = {})
+      @options = options
+      @template                         = options.delete(:template)
+      @config_template                  = options.delete(:config_template) || ":config"
+      # @options[:environment_variable] ||= "RAILS_ENV"
+      # @options[:environment]          ||= :production
+      # @options[:path]                   = Shellwords.shellescape(@options[:path] || Pigtail.path)
+    end
+
+    def output
+      config = process_template(@template, @options)
+      out = process_template(@config_template, @options.merge(:config => config))
+      out.gsub(/%/, '\%')
+    end
+
+  protected
+
+    def process_template(template, options)
+      template.to_s.gsub(/:\w+/) do |key|
+        before_and_after = [$`[-1..-1], $'[0..0]]
+        option = options[key.sub(':', '').to_sym] || key
+
+        if before_and_after.all? { |c| c == "'" }
+          escape_single_quotes(option)
+        elsif before_and_after.all? { |c| c == '"' }
+          escape_double_quotes(option)
+        else
+          option
+        end
+      end
+      # end.gsub(/\s+/m, " ").strip
+    end
+
+    def escape_single_quotes(str)
+      str.gsub(/'/) { "'\\''" }
+    end
+
+    def escape_double_quotes(str)
+      str.gsub(/"/) { '\"' }
+    end
+  end
+end

data/lib/pigtail/configs.rb

@@ -0,0 +1,132 @@
+module Pigtail
+  class Configs
+
+    def initialize(options)
+      @configs, @set_variables, @pre_set_variables = {}, {}, {}, {}
+
+      if options.is_a? String
+        options = { :string => options }
+      end
+
+      pre_set(options[:set])
+
+      # setup_file     = File.expand_path('../setup.rb', __FILE__)
+      # setup          = File.read(setup_file)
+      pigtail_config =
+        if options[:string]
+          options[:string]
+        elsif options[:file]
+          File.read(options[:file])
+        end
+
+      # instance_eval(setup, setup_file)
+      instance_eval(pigtail_config, options[:file] || '<eval>')
+    end
+
+    def set(variable, value)
+      variable = variable.to_sym
+      return if @pre_set_variables[variable]
+
+      instance_variable_set("@#{variable}".to_sym, value)
+      self.class.send(:attr_reader, variable.to_sym)
+      @set_variables[variable] = value
+    end
+
+    def to(path, options = {})
+      @current_path_scope = path
+      @options = options
+      yield
+    end
+
+    def config_type(name, template)
+      singleton_class_shim.class_eval do
+        define_method(name) do |task, *args|
+          options = { :task => task, :template => template }
+          options.merge!(args[0]) if args[0].is_a? Hash
+
+          @configs[@current_path_scope] ||= []
+          @configs[@current_path_scope] << Pigtail::Config.new(@options.merge(@set_variables).merge(options))
+        end
+      end
+    end
+
+    def generate_configs_output
+      output_configs
+    end
+
+  private
+
+    # The Object#singleton_class method only became available in MRI 1.9.2, so
+    # we need this to maintain 1.8 compatibility. Once 1.8 support is dropped,
+    # this can be removed
+    def singleton_class_shim
+      if self.respond_to?(:singleton_class)
+        singleton_class
+      else
+        class << self; self; end
+      end
+    end
+
+    #
+    # Takes a string like: "variable1=something&variable2=somethingelse"
+    # and breaks it into variable/value pairs. Used for setting variables at runtime from the command line.
+    # Only works for setting values as strings.
+    #
+    def pre_set(variable_string = nil)
+      return if variable_string.nil? || variable_string == ""
+
+      pairs = variable_string.split('&')
+      pairs.each do |pair|
+        next unless pair.index('=')
+        variable, value = *pair.split('=')
+        unless variable.nil? || variable == "" || value.nil? || value == ""
+          variable = variable.strip.to_sym
+          set(variable, value.strip)
+          @pre_set_variables[variable] = value
+        end
+      end
+    end
+
+    #
+    # Takes the standard config output that Pigtail generates and finds
+    # similar entries that can be combined. For example: If a configure should run
+    # at "/foo/bar" and "/foo/baz", instead of creating two configures this method combines
+    # them into one that runs at the 2nd, 3rd and 4th directory.
+    #
+    def combine(entries)
+      entries.map! { |entry| entry.split(/ +/, 6) }
+      0.upto(4) do |f|
+        (entries.length-1).downto(1) do |i|
+          next if entries[i][f] == '*'
+          comparison = entries[i][0...f] + entries[i][f+1..-1]
+          (i-1).downto(0) do |j|
+            next if entries[j][f] == '*'
+            if comparison == entries[j][0...f] + entries[j][f+1..-1]
+              entries[j][f] += ',' + entries[i][f]
+              entries.delete_at(i)
+              break
+            end
+          end
+        end
+      end
+
+      entries.map { |entry| entry.join(' ') }
+    end
+
+    def output_configs
+      return if @configs.empty?
+
+      @output_configs = []
+
+      @configs.each do |paths, configs|
+        configs.each do |config|
+          Pigtail::Output::Config.output(paths, config) do |pigtail_config|
+            @output_configs << pigtail_config
+          end
+        end
+      end
+
+      return @output_configs
+    end
+  end
+end

data/lib/pigtail/output_config.rb

@@ -0,0 +1,32 @@
+module Pigtail
+  module Output
+    class Config
+      attr_accessor :path, :configure
+
+      def initialize(path = nil, configure = nil)
+        @path      = path
+        @configure = configure
+      end
+
+      def self.enumerate(item)
+        if item and item.is_a?(String)
+          items = item.split(',')
+        else
+          items = item
+          items = [items] unless items and items.respond_to?(:each)
+        end
+        items
+      end
+
+      def self.output(paths, config)
+        enumerate(paths).each do |path|
+          yield new(path, config.output).output
+        end
+      end
+
+      def output
+        { path: @path, configure: @configure }
+      end
+    end
+  end
+end

data/lib/pigtail/setup.rb

@@ -0,0 +1,11 @@
+# Environment variable defaults to RAILS_ENV
+set :environment_variable, "RAILS_ENV"
+# Environment defaults to production
+set :environment, "production"
+# Path defaults to the directory `pigtail` was run from
+set :path, Pigtail.path
+
+# All configs are wrapped in this template.
+set :config_template, ":config"
+
+config_type :command, ":task"

data/lib/pigtail/version.rb

@@ -0,0 +1,3 @@
+module Pigtail
+  VERSION = '0.0.1.17'
+end

data/lib/pigtail.rb

@@ -0,0 +1,15 @@
+require 'pigtail/configs'
+require 'pigtail/config'
+require 'pigtail/command_line'
+require 'pigtail/output_config'
+require 'pigtail/version'
+
+module Pigtail
+  def self.configs(options)
+    Pigtail::Configs.new(options).generate_configs_output
+  end
+
+  def self.path
+    Dir.pwd
+  end
+end

data/pigtail.gemspec

@@ -0,0 +1,24 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require "pigtail/version"
+
+Gem::Specification.new do |s|
+  s.name          = "pigtail"
+  s.version       = Pigtail::VERSION
+  s.authors       = ["Nab Inno"]
+  s.email         = ["nab@blahfe.com"]
+  s.homepage      = "https://github.com/nabinno/pigtail"
+  s.summary       = %q{Configs in ruby.}
+  s.description   = %q{Clean ruby syntax for writing and deploying configs.}
+  s.license       = "MIT"
+
+  s.files         = Dir["{bin,lib,test}/**/*",
+                        "Gemfile", "MIT-LICENSE", "README.md", "Rakefile", "pigtail.gemspec"]
+  s.test_files    = Dir["test/{functional,unit}/*"]
+  s.executables   = Dir["bin/*"].map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "bundler", "~> 1.9"
+  s.add_development_dependency 'mocha', '~> 0.9', '>= 0.9.5'
+  s.add_development_dependency 'rake', '~> 0'
+end

data/test/functional/#setup_test.rb#

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+class OutputDefinedConfigTest < Pigtail::TestCase
+  test "defined config with a :task" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after"
+      to "/foo/bar" do
+        some_config "during"
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after" }], output)
+  end
+
+  test "defined config with a :task and some options" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after :option1 :option2"
+      to "/foo/bar" do
+        some_config "during", :option1 => 'happy', :option2 => 'birthday'
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after happy birthday" }], output)
+  end
+
+  test "defined config with a :task and an option where the option is set globally" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after :option1"
+      set :option1, 'happy'
+      to "/foo/bar" do
+        some_config "during"
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after happy" }], output)
+  end
+
+  test "defined config with a :task and an option where the option is set globally and locally" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after :option1"
+      set :option1, 'global'
+      to "/foo/bar" do
+        some_config "during", :option1 => 'local'
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after local" }], output)
+  end
+
+  test "defined config with a :task and an option that is not set" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after :option1"
+      to "/foo/bar" do
+        some_config "during", :option2 => 'happy'
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after :option1" }], output)
+  end
+
+  test "defined config that uses a :path where none is explicitly set" do
+    Pigtail.stubs(:path).returns('/my/path')
+
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "cd :path && :task"
+      to "/foo/bar" do
+        some_config 'blahblah'
+      end
+    file
+
+    assert_equal([{ path: foobar_directory, configure: %( cd /my/path && blahblah) }], output)
+  end
+end

data/test/functional/command_line_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class CommandLineWriteTest < Pigtail::TestCase
+  setup do
+    File.expects(:exists?).with('config/pigtail.rb').returns(true)
+    @command    = Pigtail::CommandLine.new({ :write => true, :identifier => 'My identifier' })
+    @configures = { path: "#{foobar_directory}", configure: "/my/command" }
+    Pigtail.expects(:configs).returns(@configures)
+  end
+  should "output the pigtail config with identifier blocks" do
+    output = @configures[:configure]
+    assert_equal output, @command.send(:pigtail_configs)[:configure]
+  end
+  should "write the crontab when run" do
+    @command.expects(:write_pigtail_config).returns(true)
+    assert @command.run
+  end
+end
+
+class ConfigTypeWithSetOptionTest < Pigtail::TestCase
+  setup do
+    @output = Pigtail.configs :string => \
+    <<-file
+      yaml = <<-YAML
+- global:
+    env: :env
+    path: /foo/baz
+      YAML
+      config_type :yaml, yaml
+      to "/foo/bar" do
+        yaml "", { env: "ENV" }
+      end
+    file
+  end
+  should "output the runner using the override environment" do
+    assert_equal([{ path: foobar_directory, configure: %(- global:\n    env: ENV\n    path: /foo/baz\n) }], @output)
+  end
+end

data/test/functional/setup_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+class OutputDefinedConfigTest < Pigtail::TestCase
+  test "defined config with a :task" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after"
+      to "/foo/bar" do
+        some_config "during"
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after" }], output)
+  end
+
+  test "defined config with a :task and some options" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after :option1 :option2"
+      to "/foo/bar" do
+        some_config "during", :option1 => 'happy', :option2 => 'birthday'
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after happy birthday" }], output)
+  end
+
+  test "defined config with a :task and an option where the option is set globally" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after :option1"
+      set :option1, 'happy'
+      to "/foo/bar" do
+        some_config "during"
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after happy" }], output)
+  end
+
+  test "defined config with a :task and an option where the option is set globally and locally" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after :option1"
+      set :option1, 'global'
+      to "/foo/bar" do
+        some_config "during", :option1 => 'local'
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after local" }], output)
+  end
+
+  test "defined config with a :task and an option that is not set" do
+    output = Pigtail.configs \
+    <<-file
+      set :config_template, nil
+      config_type :some_config, "before :task after :option1"
+      to "/foo/bar" do
+        some_config "during", :option2 => 'happy'
+      end
+    file
+
+    assert_equal([{ path: "/foo/bar", configure: "before during after :option1" }], output)
+  end
+end

data/test/pigtail_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class PigtailTest < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, Pigtail
+  end
+end

data/test/test_case.rb

@@ -0,0 +1,39 @@
+module Pigtail
+  begin
+    require 'minitest/autorun'
+    begin
+      # 2.0.0
+      class TestCase < MiniTest::Test; end
+    rescue NameError
+      # 1.9.3
+      class TestCase < MiniTest::Unit::TestCase; end
+    end
+  rescue LoadError
+    # 1.8.7
+    require 'test/unit'
+    class TestCase < Test::Unit::TestCase
+      def default_test; end
+    end
+  end
+
+  class TestCase
+    class << self
+      def setup(&block)
+        define_method(:setup) do
+          super()
+          instance_eval(&block)
+        end
+      end
+
+      def test(name, &block)
+        define_method("test_#{name}".to_sym, &block)
+      end
+      alias should test
+    end
+
+    def assert_no_match(regexp, string)
+      message = "<#{regexp}> expected to not match\n<#{string}>"
+      assert regexp !~ string, message
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'pigtail'
+require 'test_case'
+require 'mocha/setup'
+
+module Pigtail::TestHelpers
+  protected
+    def new_config(options={})
+      Pigtail::Config.new(options)
+    end
+
+    def foobar_directory
+      "/foo/bar"
+    end
+end
+
+Pigtail::TestCase.send(:include, Pigtail::TestHelpers)

data/test/unit/config_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+class ConfigTest < Pigtail::TestCase
+  should "substitute the :task when #output is called" do
+    config = new_config(:template => ":task", :task => 'abc123')
+    assert_equal 'abc123', config.output
+  end
+
+  should "substitute the :path when #output is called" do
+    assert_equal 'foo', new_config(:template => ':path', :path => 'foo').output
+  end
+
+  should "not substitute parameters for which no value is set" do
+    assert_equal 'Hello :world', new_config(:template => ':matching :world', :matching => 'Hello').output
+  end
+
+  should "escape percent signs" do
+    config = new_config(
+      :template => "before :foo after",
+      :foo => "percent -> % <- percent"
+    )
+    assert_equal %q(before percent -> \% <- percent after), config.output
+  end
+
+  should "assume percent signs are not already escaped" do
+    config = new_config(
+      :template => "before :foo after",
+      :foo => %q(percent preceded by a backslash -> \% <-)
+    )
+    assert_equal %q(before percent preceded by a backslash -> \\\% <- after), config.output
+  end
+end
+
+class ConfigWithQuotesTest < Pigtail::TestCase
+  should "output the :task if it's in single quotes" do
+    config = new_config(:template => "':task'", :task => 'abc123')
+    assert_equal %q('abc123'), config.output
+  end
+
+  should "output the :task if it's in double quotes" do
+    config = new_config(:template => '":task"', :task => 'abc123')
+    assert_equal %q("abc123"), config.output
+  end
+
+  should "output escaped single quotes in when it's wrapped in them" do
+    config = new_config(
+      :template => "before ':foo' after",
+      :foo => "quote -> ' <- quote"
+    )
+    assert_equal %q(before 'quote -> '\'' <- quote' after), config.output
+  end
+
+  should "output escaped double quotes when it's wrapped in them" do
+    config = new_config(
+      :template => 'before ":foo" after',
+      :foo => 'quote -> " <- quote'
+    )
+    assert_equal %q(before "quote -> \" <- quote" after), config.output
+  end
+end
+
+class ConfigWithConfigTemplateTest < Pigtail::TestCase
+  should "use the config template" do
+    config = new_config(:template => ':task', :task => 'abc123', :config_template => 'left :config right')
+    assert_equal 'left abc123 right', config.output
+  end
+
+  should "reuse parameter in the config template" do
+    config = new_config(:template => ':path :task', :path => 'path', :task => "abc123", :config_template => ':path left :config right')
+    assert_equal 'path left path abc123 right', config.output
+  end
+
+  should "escape single quotes" do
+    config = new_config(:template => "before ':task' after", :task => "quote -> ' <- quote", :config_template => "left ':config' right")
+    assert_equal %q(left 'before '\''quote -> '\\''\\'\\'''\\'' <- quote'\'' after' right), config.output
+  end
+
+  should "escape double quotes" do
+    config = new_config(:template => 'before ":task" after', :task => 'quote -> " <- quote', :config_template => 'left ":config" right')
+    assert_equal %q(left "before \"quote -> \\\" <- quote\" after" right), config.output
+  end
+end

data/test/unit/output_config_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class OutputConfigOtherTest < Pigtail::TestCase
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: pigtail
+version: !ruby/object:Gem::Version
+  version: 0.0.1.17
+platform: ruby
+authors:
+- Nab Inno
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Clean ruby syntax for writing and deploying configs.
+email:
+- nab@blahfe.com
+executables:
+- pigtail
+- pigtailize
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/pigtail
+- bin/pigtailize
+- lib/pigtail.rb
+- lib/pigtail/command_line.rb
+- lib/pigtail/config.rb
+- lib/pigtail/configs.rb
+- lib/pigtail/output_config.rb
+- lib/pigtail/setup.rb
+- lib/pigtail/version.rb
+- pigtail.gemspec
+- test/functional/#setup_test.rb#
+- test/functional/command_line_test.rb
+- test/functional/setup_test.rb
+- test/pigtail_test.rb
+- test/test_case.rb
+- test/test_helper.rb
+- test/unit/config_test.rb
+- test/unit/output_config_test.rb
+homepage: https://github.com/nabinno/pigtail
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Configs in ruby.
+test_files:
+- test/functional/command_line_test.rb
+- test/functional/#setup_test.rb#
+- test/functional/setup_test.rb
+- test/unit/output_config_test.rb
+- test/unit/config_test.rb