turple 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ff3155ba3b5f42ba3db3cf7e997af756f5f3dfe7
+  data.tar.gz: 0f9f60ee592211502b89f85bebf79ed1636d902f
+SHA512:
+  metadata.gz: 143ed8335f2747128d212b9b970afdc7779e738f4759a1d0a87937e65db73a96eb6f62d4c33b53e5032e992843da165bcb23e17ec973213764a24cf5ff014e92
+  data.tar.gz: 69ef3ae91f5e8055d62b9e528c5cb8efab4027de22728fe18cc975f402368efe6ab58939db1f775bee71f6698039fee029d9f48ba9fdad7ae2f36fda6474603b

data/.gitignore

@@ -0,0 +1,3 @@
+.yardoc
+coverage
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+install: bundle install --without development
+script: bundle exec rspec
+rvm:
+  - 1.9.3-p551
+  - 2.1.5

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gem 'activesupport', '~> 4.1'
+gem 'cli_miami', '~> 0.0'
+gem 'colorize', '~> 0.7'
+gem 'coveralls', :require => false
+gem 'recursive-open-struct', '~> 0.5'
+gem 'thor', '~> 0.19'
+
+group :test do
+  gem 'guard', '~> 2.6'
+  gem 'guard-rspec', '~> 4.3', :require => false
+  gem 'rspec', '~> 3.1'
+  gem 'terminal-notifier-guard', '~> 1.5'
+end

data/Gemfile.lock

@@ -0,0 +1,105 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.0)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    cli_miami (0.0.6)
+      term-ansicolor (~> 1.3)
+    coderay (1.1.0)
+    colorize (0.7.5)
+    coveralls (0.7.1)
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      term-ansicolor
+      thor
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    ffi (1.9.6)
+    formatador (0.2.5)
+    guard (2.10.5)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-compat (1.2.0)
+    guard-rspec (4.5.0)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    hitimes (1.2.2)
+    i18n (0.7.0)
+    json (1.8.1)
+    listen (2.8.4)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    mime-types (2.4.3)
+    minitest (5.5.0)
+    multi_json (1.10.1)
+    nenv (0.1.1)
+    netrc (0.10.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    recursive-open-struct (0.5.0)
+    rest-client (1.7.2)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    slop (3.6.0)
+    term-ansicolor (1.3.0)
+      tins (~> 1.0)
+    terminal-notifier-guard (1.6.4)
+    thor (0.19.1)
+    thread_safe (0.3.4)
+    timers (4.0.1)
+      hitimes
+    tins (1.3.3)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 4.1)
+  cli_miami (~> 0.0)
+  colorize (~> 0.7)
+  coveralls
+  guard (~> 2.6)
+  guard-rspec (~> 4.3)
+  recursive-open-struct (~> 0.5)
+  rspec (~> 3.1)
+  terminal-notifier-guard (~> 1.5)
+  thor (~> 0.19)

data/Guardfile

@@ -0,0 +1,5 @@
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/lib/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -0,0 +1,138 @@
+[![Gem Version](https://badge.fury.io/rb/turple.svg)](http://badge.fury.io/rb/turple)
+[![Build Status](https://travis-ci.org/brewster1134/turple.svg?branch=master)](https://travis-ci.org/brewster1134/turple)
+[![Coverage Status](https://coveralls.io/repos/brewster1134/turple/badge.png)](https://coveralls.io/r/brewster1134/turple)
+
+# Turple
+Quick project templating, with optional cli wizard support
+
+Turple can take a custom template and use it to bootstrap projects structures you commonly use instead of **copy/pasting** an old project and **find/replacing** to make it a new project.
+
+### Usage
+
+I always make projects the same way.  There are a bunch of tools for making this faster, but i didnt like any of them.  This is what i like.
+
+Turple takes any kind of template format you want, a bunch of data, and in*turple*ates it.
+
+Turple is best used from a command line, but it can be used directly in ruby as well.  **CLI FIRST...**
+
+### CLI
+
+Turple requires a path to a template, and an optional destination.  If no destination is passed, it will put everything in a `turple` folder from your current working directory.
+
+```sh
+turple --template /path/to/template --destination my_new_project_name
+```
+
+Turple will scan the template, determine what data is needed to process it, and prompt you for any missing data.  If you wanted to run turple without the wizard, just throw a `Turplefile` into your destination directory with the nececssary data (even the template if you want)
+
+### Turplefile
+
+`Turplefile` files are yaml formatted files that provided various information to turple.  Assuming our template requires a single peice of information called `foo`, our destination Turplefile would look something like this.
+
+```yaml
+template: /path/to/template
+data:
+  foo: bar
+```
+
+Turple templates also have a Turplefile
+
+### Turple Templates
+
+A turple template is simply a directory containing a Turplefile, and any amount of custom folders and files your project template needs.  The Turplefile inside a template has different data than a destination file.  It has instructions on how to prompt a user for data, and the configuration details on how the template is built.  _This example uses the default turple configuration._
+
+### Configuration
+
+```yaml
+name: Foo Project Template
+configuration:
+  file_ext: turple
+  path_regex: '\[([A-Z_\.]+)\]'
+  path_separator: .
+  content_regex: '<>([a-z_\.]+)<>'
+  content_separator: .
+data_map:
+  foo: What is the foo called?
+```
+
+* `name` is just a friendly name for the template.  its optional. we can use the template directory name for that.
+* `configuration` has some very important details. (again, these are the defaults, so if your template does not have a custom configuration, it uses these values)
+  * `file_ext` is the file extension turple looks for to tell it there is content inside the file that needs processed
+  * `path_regex` this is a string representing a regex match to variable names
+  * `path_separator` this is a string representing a character(s) to seperate variables strung togehter
+  * `content_regex` & `content_separator` are the same as with a path, but to match file contents rather than a path.
+* `data_map` is a hash that matches the same structure as the data required for a template, but instead provides the details to prompt a user in case a peice of required data is missing.
+
+## Example Template
+
+Say you design a template using teh turple default configuration, and you create a file structure like so...
+```
+foo_template
+  |__ my_[FOO.BAR]_dir
+  |   |
+  |   |__ my_[FOO.BAZ]_file.txt.turple
+  |
+  |__ Turplefile
+```
+
+and say your `my_[FOO.BAZ]_file.txt.turple` file contains the following
+```
+This <>foo.baz<> file is in the <>foo.bar<> folder.
+```
+
+With a simple Turplefile containing...
+```
+name: Foo Template
+data_map:
+  foo:
+    bar: What is the foo bar?
+    baz: What is the foo baz?
+```
+
+* Notice how the path variables match the `path_regex`
+* Notice how the separator of the path variables match the `path_separator`
+* Notice how the content variables match the `content_regex`
+* Notice how the separator of the content variables match the `content_separator`
+
+**Let's run Turple!**
+```sh
+Saving to: /your/current/directory/turple
+There is some missing data. You will be prompted to enter each value.
+What is the foo bar?
+>>> # enter your value here
+What is the foo baz?
+>>> # enter your value here
+================================================================================
+                              !TURPLE SUCCESS!
+================================================================================
+Turpleated `Foo Template` to a new project `turple`
+Paths Turpleated: 2
+   Turpleated in: 1.1ms
+================================================================================
+```
+
+### Ruby
+You can run turple directly in ruby if needed as well.  _This example matches the template from the above example._
+
+```ruby
+require 'turple'
+
+Turple.ate '~/Code/templates/mini_ruby_project', {
+  :foo => {
+    :bar => 'foobar',
+    :baz => 'foobaz'
+  }
+}, {
+  :destination => '/path/to/your/new/project',
+}
+```
+
+most notably the passing of the destination in the 3rd argument _(the configuration hash)_
+
+### Development & Testing
+```shell
+gem install yuyi
+yuyi -m https://raw.githubusercontent.com/brewster1134/turple/master/yuyi_menu
+bundle install
+bundle exec guard
+```

data/bin/turple

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'turple'
+
+Turple::Cli.start ARGV

data/lib/turple.rb

@@ -0,0 +1,145 @@
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/keys'
+require 'cli_miami'
+require 'yaml'
+
+class Turple
+  # classes
+  require 'turple/cli'
+  require 'turple/data'
+  require 'turple/interpolate'
+  require 'turple/template'
+
+  # Create CLI Miami presets
+  @@line_size = 80
+  CliMiami.set_preset :error, {
+    :color => :red,
+    :style => :bold
+  }
+  CliMiami.set_preset :prompt, {
+    :color => :blue,
+    :style => :bright
+  }
+  CliMiami.set_preset :header, CliMiami.presets[:prompt].merge({
+    :justify => :center,
+    :padding => @@line_size
+  })
+  CliMiami.set_preset :key, CliMiami.presets[:prompt].merge({
+    :justify => :rjust,
+    :padding => @@line_size / 2,
+    :preset => :prompt,
+    :newline => false
+  })
+  CliMiami.set_preset :value, {
+    :indent => 1
+  }
+
+  # Allows Turple.ate vs Turple.new
+  class << self
+    alias_method :ate, :new
+  end
+
+  @@turpleobject = {
+    :template => '',
+    :data => {},
+    :data_map => {},
+    :configuration => {
+      # default regex for file names to interpolate content of
+      # matches files with an extension of `.turple`
+      # (e.g. foo.txt.turple)
+      :file_ext => 'turple',
+
+      # default regex for path interpolation
+      # make sure to include the path_separator
+      # matches capitalized, dot-notated keys surrounded with single brackets
+      # (e.g. [FOO.BAR])
+      :path_regex => '\[([A-Z_\.]+)\]',
+
+      # default separator for attributes in the path
+      # the separator must exist in the path_regex capture group
+      # (e.g. [FOO.BAR])
+      :path_separator => '.',
+
+      # default regex for content interpolation
+      # make sure to include the content_separator
+      # matches lowercase, dot-notated keys surrounded with `<>`
+      # (e.g. <>foo.bar<>)
+      :content_regex => '<>([a-z_\.]+)<>',
+
+      # default separator for attributes in file contents
+      # the separator must exist in the content_regex capture group
+      # (e.g. <>foo.bar<>)
+      :content_separator => '.'
+    }
+  }
+
+  # Get loaded turplefiles contents
+  # @return [Hash]
+  #
+  def self.turpleobject; @@turpleobject; end
+
+  # allows helper accessors for turpleobject
+  #
+  def self.method_missing method
+    self.turpleobject[method] || super
+  end
+
+  # Read yaml turplefile and add contents to the turpleobject
+  #
+  # @param file [String] relative/absolute path to a turplefile
+  # @return [Hash]
+  #
+  def self.load_turplefile turplefile_path
+    # return false if file doesnt exist
+    turplefile_path = File.expand_path turplefile_path
+    return false unless File.exists? turplefile_path
+
+    self.turpleobject = YAML.load File.read turplefile_path
+  end
+
+  # Add additional data to the collective turplefile
+  # @param hash [Hash] any hash of data to be merged into existing turplefile data
+  # @return [Hash] merged turplefile data with symbolized keys
+  def self.turpleobject= hash
+    @@turpleobject.deep_merge! hash.deep_symbolize_keys
+  end
+
+private
+
+  def initialize template_path, data_hash, configuration_hash
+    template_path = File.expand_path template_path
+    data_hash = Turple.data.deep_merge data_hash
+    data_map_hash = Turple.data_map
+    configuration_hash = Turple.configuration.deep_merge configuration_hash
+    @destination_path = configuration_hash[:destination]
+
+    if configuration_hash[:cli]
+      S.ay 'Saving to: ', :preset => :prompt, :newline => false
+      S.ay @destination_path
+    end
+
+    # Initialize components
+    @template = Turple::Template.new template_path, configuration_hash
+    @data = Turple::Data.new @template.required_data, data_hash, data_map_hash
+    @interpolate = Turple::Interpolate.new @template, @data, @destination_path
+
+    output_summary if configuration_hash[:cli]
+  end
+
+  def output_summary
+    S.ay '=' * @@line_size, :prompt
+    S.ay '!TURPLE SUCCESS!', :preset => :header
+    S.ay '=' * @@line_size, :prompt
+
+    S.ay 'Turpleated ', :newline => false, :indent => 2
+    S.ay @template.name, :newline => false, :preset => :prompt
+    S.ay ' to a new project ', :newline => false
+    S.ay @interpolate.project_name, :preset => :prompt
+
+    S.ay 'Paths Turpleated:', :key
+    S.ay Dir[File.join(@destination_path, '**/*')].count.to_s, :value
+    S.ay 'Turpleated in:', :key
+    S.ay (@interpolate.time * 1000).round(1).to_s + 'ms', :value
+    S.ay '=' * @@line_size, :prompt
+  end
+end

data/lib/turple/cli.rb

@@ -0,0 +1,28 @@
+require 'cli_miami'
+require 'thor'
+
+class Turple::Cli < Thor
+  desc 'ate', 'Interpolate your template!'
+  option :template, :type => :string, :desc => 'Path to a turple template.'
+  option :destination, :type => :string, :default => File.join(Dir.pwd, 'turple'), :desc => 'Path to save interpolated template to.'
+  def ate
+    destination = File.expand_path options['destination']
+
+    # load destination turplefile if it exists
+    Turple.load_turplefile File.join(destination, 'Turplefile')
+
+    # update turpleobject object with cli options
+    Turple.turpleobject = {
+      template: (options['template'] || Turple.template rescue nil),
+      configuration: {
+        destination: destination,
+        cli: true
+      }
+    }
+
+    # initialize turple
+    Turple.ate Turple.template, Turple.data, Turple.configuration
+  end
+
+  default_task :ate
+end

data/lib/turple/data.rb

@@ -0,0 +1,118 @@
+require 'cli_miami'
+require 'recursive-open-struct'
+
+class Turple::Data
+  def data; RecursiveOpenStruct.new @provided_data; end
+
+private
+
+  def initialize required_data, provided_data, data_map
+    @provided_data = provided_data
+
+    data_map = build_data_map required_data, Turple.data_map.deep_merge(data_map)
+    missing_data = get_missing_data required_data, @provided_data, data_map
+
+    # if there is missing data, prompt user to enter it in
+    unless missing_data.empty?
+      S.ay 'There is some missing data. You will be prompted to enter each value.', :color => :white, :bgcolor => :blue
+      prompt_for_data missing_data
+    end
+
+    # add provided data to turpleobject
+    Turple.turpleobject = {
+      :data => @provided_data
+    }
+  end
+
+  # populate missing data map values to match required data
+  # uses a collection of the parent keys as the value
+  #
+  # @param required_data [Hash] hash of required data
+  # @param data_map [Hash] hash of existing data map
+  #
+  # @return [Hash] complete data map hash
+  #
+  def build_data_map required_data, data_map
+    build_data_map_keys(required_data).deep_merge data_map
+  end
+
+  # create a new hash with the values replaced with an array of parent keys
+  #
+  # @param hash [Hash] hash to process
+  # @param keys [Array] initial array of keys (used internally for recursive functionlity)
+  #
+  # @return [Hash] mirrored hash with array of parent keys instead of the intial value
+  #
+  def build_data_map_keys hash, keys = []
+    # go through each key-value pair
+    hash.each do |key, val|
+      # if the value is a Hash, recurse and add the key to the array of parents
+      if val.is_a? Hash
+        build_data_map_keys(val, keys.push(key))
+        # remove last parent when we're done with this pair
+        keys.pop
+      else
+        # if the value is not a Hash, set the value to parents + current key
+        hash[key] = keys + [key]
+      end
+    end
+  end
+
+  # remove provided data from required data
+  # create a new hash with data map values
+  #
+  # @param required_data [Hash] hash of all the data neccessary to interpolate a template
+  # @param provided_data [Hash] hash of all the data collected from turplefile
+  # @param data_map [Hash] hash of descriptions of required data
+  #
+  # @return [Hash] hash of missing data with data map descriptions (or nested keys)
+  #
+  def get_missing_data required_data, provided_data, data_map
+    required_data.keys.inject({}) do |diff, k|
+      # if the hashes dont match on a particular key...
+      if required_data[k] != provided_data[k]
+        if required_data[k].is_a?(Hash) && provided_data[k].is_a?(Hash)
+          diff[k] = get_missing_data(required_data[k], provided_data[k], data_map[k])
+        else
+          # set the key to false if it doesnt exist in the 2nd hash
+          unless provided_data[k]
+            # if data map value exists, use it
+            diff[k] = data_map[k]
+          end
+        end
+      end
+      diff.delete k if diff[k].nil? || diff[k].empty?
+      diff
+    end
+  end
+
+  # merges user-input missing data into the provided data
+  #
+  # @param missing_data [Hash] hash of missing data
+  #
+  # @return [Hash] complete provided data hash
+  #
+  def prompt_for_data missing_data
+    @provided_data.deep_merge! prompt_for_data_keys(missing_data)
+  end
+
+  # loop through the missing data hash and prompt user to enter said data
+  #
+  # @param missing_data [Hash] hash of missing data
+  #
+  # @return [Hash] complete missing data hash
+  #
+  def prompt_for_data_keys missing_data
+    missing_data.each do |key, value|
+      if value.is_a? Hash
+        missing_data[key] = prompt_for_data_keys value
+      else
+        value = value.join(' | ') if value.is_a? Array
+        A.sk value, :prompt do |response|
+          missing_data[key] = response
+        end
+      end
+    end
+    missing_data
+  end
+end

data/lib/turple/interpolate.rb

@@ -0,0 +1,160 @@
+require 'active_support/core_ext/hash/keys'
+require 'date'
+require 'yaml'
+
+class Turple::Interpolate
+  attr_reader :destination, :time, :project_name
+
+private
+
+  def initialize template, data, destination
+    @template = template.path
+    @data = data.data
+    @destination = destination
+    @configuration = template.configuration
+    @tmp_dir = Dir.mktmpdir
+    @project_name = File.basename @destination
+
+    # make sure the destination exists
+    FileUtils.mkdir_p @destination
+
+    start_timer = Time.now
+
+    # copy the template to tmp, and set the new path to process
+    create_tmp_project!
+
+    # interpolate directory and copy to destination
+    process_template! @tmp_project
+
+    # save a turplefile to the destination
+    create_turplefile!
+
+    end_timer = Time.now
+    @time = end_timer - start_timer
+  end
+
+  # Copy template to tmp dir and get the new path
+  #
+  def create_tmp_project!
+    FileUtils.cp_r @template, @tmp_dir
+
+    @tmp_project = File.join(@tmp_dir, File.basename(@template))
+  end
+
+  # Collect paths to interpolate
+  # Only process files and empty directories
+  #
+  # @param template_path [String] valid path to a root template directory
+  #
+  def process_template! template_path
+    Find.find template_path do |path|
+      # don't process root dir
+      next if path == template_path
+
+      # if path is a file...
+      # or path is an empty directory
+      if File.file?(path) || Dir.entries(path).size <= 2
+        process_path! path
+      end
+    end
+  end
+
+  # Interpolate a path
+  #
+  # @param path [String] a valid path of a template asset
+  #
+  def process_path! path
+    # start the new_path out matching the original path
+    new_path = path.dup
+
+    # interpolate file contents
+    file_ext_regex = /\.#{Regexp.escape(@configuration[:file_ext])}$/
+    if path =~ file_ext_regex
+      process_contents! path
+    end
+
+    # interpolate path
+    path_regex = Regexp.new @configuration[:path_regex]
+    if path =~ path_regex
+      new_path = path.gsub path_regex do
+        # Extract interpolated values into symbols
+        methods = $1.downcase.split(@configuration[:path_separator]).map(&:to_sym)
+
+        # Call each method on the data
+        methods.inject(@data){ |data, method| data.send(method.to_sym) }
+      end
+    end
+
+    # Remove the turple file extension from the file name
+    new_path.sub! file_ext_regex, ''
+
+    # replace the tmp dir path, with the destination path
+    new_path.sub! @tmp_project, @destination
+
+    copy_path! path, new_path
+  end
+
+  # Open a file, interpolate its contents, and overwrite it with the new contents
+  #
+  # @param file_path [String]  valid path to a file with contents needing interpolated
+  # @return [File]
+  #
+  def process_contents! file_path
+    contents = File.read file_path
+    new_contents = process_string! contents
+
+    # Overwrite the original file with the processed file
+    File.open file_path, 'w' do |f|
+      f.write new_contents
+    end
+  end
+
+  def process_string! string
+    content_regex = Regexp.new @configuration[:content_regex]
+    string.gsub content_regex do
+      # Extract interpolated values into symbols
+      methods = $1.downcase.split(@configuration[:content_separator]).map(&:to_sym)
+
+      # Call each method on data
+      methods.inject(@data){ |data, method| data.send(method.to_sym) }
+    end
+  end
+
+  # Copies a modified path asset to the destination
+  #
+  # @param path [String] path to the asset in the tmp directory
+  # @param new_path [String] path to the new asset to create/copy
+  #
+  def copy_path! path, new_path
+    # if path is an empty directory, just create the directory
+    if File.directory? path
+      FileUtils.mkdir_p new_path
+
+    # if path is a file, make sure its directory exists and copy the file to it
+    elsif File.file? path
+      FileUtils.mkdir_p File.dirname(new_path)
+      FileUtils.cp_r path, new_path
+    end
+  end
+
+  # Saves the complete turplefile data to the newly created project
+  #
+  # @return [File]
+  #
+  def create_turplefile!
+    # get new template name based on the first directory of the destination
+    turplefile_path = File.join(@destination, 'Turplefile')
+    turplefile_object = Turple.turpleobject.deep_merge({
+      template: @template,
+      :created_on => Date.today.to_s
+    })
+
+    # convert object to yaml
+    turplefile_contents = turplefile_object.deep_stringify_keys.to_yaml
+
+    # Overwrite the original file if it exists with the processed file
+    File.open turplefile_path, 'w' do |f|
+      f.write turplefile_contents
+    end
+  end
+end

data/lib/turple/template.rb

@@ -0,0 +1,136 @@
+require 'active_support/core_ext/hash/deep_merge'
+require 'cli_miami'
+require 'find'
+
+class Turple::Template
+  attr_accessor :path, :required_data, :configuration, :name
+
+private
+
+  def initialize path, configuration
+    @path = path
+    @configuration = configuration
+
+    # validate template path
+    unless valid_path?
+      if @configuration[:cli]
+        prompt_for_path
+      else
+        raise S.ay "Invalid Path `#{@path}`", :error
+      end
+    end
+
+    # load template turplefile after validating path
+    Turple.load_turplefile File.join(@path, 'Turplefile')
+
+    # validate configuration after loading turplefile
+    valid_configuration?
+
+    # set data variables after validating path and configuration
+    @required_data = scan_for_data @path
+    @name = Turple.turpleobject[:name] || File.basename(@path)
+  end
+
+  # Scan a path and determine the required data needed to interpolate it
+  # @param template_path [String] path to a template file
+  # @return [Hash] a hash of all the data needed
+  #
+  def scan_for_data template_path
+    required_data = {}
+
+    Find.find template_path do |path|
+      if File.file?(path)
+
+        # process file paths
+        path_regex = Regexp.new @configuration[:path_regex]
+        if path =~ path_regex
+          capture_groups = path.scan(path_regex).flatten
+
+          capture_groups.each do |group|
+            group_attributes = group.split(@configuration[:path_separator])
+            group_attributes_hash = group_attributes.reverse.inject(true) { |value, key| { key.downcase.to_sym => value } }
+
+            required_data.deep_merge! group_attributes_hash
+          end
+        end
+
+        # process file contents
+        content_regex = Regexp.new @configuration[:content_regex]
+        if path =~ /\.#{Regexp.escape(@configuration[:file_ext])}$/
+          capture_groups = File.read(path).scan(content_regex).flatten
+
+          capture_groups.each do |group|
+            group_attributes = group.split(@configuration[:content_separator])
+            group_attributes_hash = group_attributes.reverse.inject(true) { |value, key| { key.downcase.to_sym => value } }
+
+            required_data.deep_merge! group_attributes_hash
+          end
+        end
+      end
+    end
+
+    # check that the template requires data
+    if required_data.empty?
+      raise S.ay 'No Required Data - Nothing found to interpolate.  Make sure your configuration matches your template.', :error
+    end
+
+    return required_data
+  end
+
+  # check that the path is a valid template
+  # @return [Boolean]
+  #
+  def valid_path?
+    File.exists?(@path) && File.exists?(File.join(@path, 'Turplefile'))
+  end
+
+  # prompt the user for a template path until a vaid one is entered
+  # @return [String] valid template path
+  #
+  def prompt_for_path
+    until valid_path?
+      A.sk 'Enter a path to a Turple Template', :preset => :prompt, :readline => true do |response|
+        @path = File.expand_path response
+      end
+    end
+    @path
+  end
+
+  # check the configuration is valid
+  # @return [Boolean]
+  #
+  def valid_configuration?
+    # check that a configuration exists
+    if @configuration.empty?
+      raise S.ay 'No Configuration Found', :error
+    end
+
+    # check that a configuration values are valid
+    #
+    # make sure the string is a valid extension with no period's in it
+    if !@configuration[:file_ext].is_a?(String) ||
+        @configuration[:file_ext] =~ /\./
+      raise S.ay "`file_ext` is invalid.  See README for requirements.", :error
+    end
+
+    if !@configuration[:path_separator].is_a?(String)
+      raise S.ay "`path_separator` is invalid.  See README for requirements.", :error
+    end
+
+    if !@configuration[:content_separator].is_a?(String)
+      raise S.ay "`content_separator` is invalid.  See README for requirements.", :error
+    end
+
+    # make sure it contains the path separator in the capture group
+    if !(@configuration[:path_regex] =~ /\(.*#{Regexp.escape(@configuration[:path_separator])}.*\)/)
+      raise S.ay "`path_regex` invalid.  See README for requirements.", :error
+    end
+
+    # make sure it contains the path separator in the capture group
+    if !(@configuration[:content_regex] =~ /\(.*#{Regexp.escape(@configuration[:content_separator])}.*\)/)
+      raise S.ay "`content_regex` invalid.  See README for requirements.", :error
+    end
+
+    return true
+  end
+end

data/yuyi_menu

@@ -0,0 +1,8 @@
+sources:
+  yuyi: https://github.com/brewster1134/Yuyi-Rolls/archive/master.zip
+rolls:
+  bundler:
+  ruby:
+    versions:
+      - 2.1.2
+  ruby_gems:

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: turple
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan Brewster
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: cli_miami
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: recursive-open-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier-guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: 
+email: brewster1134@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- README.md
+- bin/turple
+- lib/turple.rb
+- lib/turple/cli.rb
+- lib/turple/data.rb
+- lib/turple/interpolate.rb
+- lib/turple/template.rb
+- yuyi_menu
+homepage: https://github.com/brewster1134/turple
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Quick Project Templating
+test_files: []
+has_rdoc: