turple 0.0.8 → 0.0.9

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWE4MDY4OWIzYzdkNTdmOWE3MDg5MTM0ZTdhODljMDA1MDdmMjBiZA==
+    OTllNzk2ZWQ3MTY0NDcwNjk3YzczODY1OTVkNjg2ODNiMmMxZTdmZQ==
   data.tar.gz: !binary |-
-    NzQ4ZTdiMmUxNzY5ODQxMDJjNjJkYTMzMDgwNmNkNjNmZDg5MDQ5MA==
+    YjY5ZjM3NDMwZTZhNTkyMGVmYmFmNWRiZDAyZGViMTE3ZWZhOWQ2Mg==
 SHA512:
   metadata.gz: !binary |-
-    YTRkM2U0NmMwYjhmMzQ1OTQ0NDFhN2MwODQwNjRkYjFlMjgyYjIyYzVhOTI0
-    NzAyNTkwMjA2YjY4MzRhOTljNzczNmFkZGY5ZjAzZTVmZTgxN2JkMzdjOTNi
-    MjhmNDYyYzNlNTM5OWI5MjA0NjMwZmY5ZWI3MDA3MTEzNmUwMGQ=
+    N2MzMzIyZTc2NjJkYmI0MTkwZTgwY2Y0ZmM2MmU3NDYwZGMyODU5NDFhN2Rj
+    MDc2OWY0ZTI2MGNkZDQ2ZTNlMzAwODA2MjU3NTY0NmY4MDY0NzFjMTc4ZGY3
+    ODE2YTYzNjhiZjQ1OTM3MDAxMGM2MzE1YmYyNTlmMThmMTBhOTU=
   data.tar.gz: !binary |-
-    ZDA0MGZhYmZjZDRlODBlMGNiNjU0ODJmOGI0MTYwMjM4YTgxMjk0MjQyMjdl
-    MGE2YmE4NzgxNGZjNWI4ZDA1ODE5NDI5M2UwYTg3YjFlOWYwNDIyOGIxNWUx
-    MjA2MTI3NGIwYzZjYjg4NTQzYzYwM2FjNzk2ZTRjM2MyMWI2YWM=
+    ODAyZDIxN2FkNDkyNzZhMWEyNTRiZDg4ZmMyYjBhODQ2MmVhMjNiNzZhMGRi
+    YTNlMWYyMjFkMTA1MWE3ZjExOTlhMmYzZjZiYjVkMGRkZmQ4Y2VmYTM1MTNk
+    YmIzODVkZTNiNTRhNGNlMmEyMTk4NDZlMzhjMmY2NGQ4MzY4YjQ=

data/README.md

@@ -7,6 +7,22 @@ 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.
 
+### Install
+```sh
+gem install turple
+```
+
+Optionally you can create a `Turplefile` in your home directory *(~/Turplefile)* and include your own custom sources, and even common template data. This will prevent you from having to define your sources everytime you create a new project.
+
+```yaml
+sources:
+  my_remote_source: my_github_user/turple-templates
+  my_local_source: ~/Documents/turple-templates
+data:
+  developer:
+    name: Jane Doe
+```
+
 ### Usage
 
 I always make projects the same way. There are a bunch of tools for (supposedly) making this easier/faster, but I don't like any of them. They are either too opinionated or too limiting. This is what I like.
@@ -17,7 +33,7 @@ Turple is best used from a command line, but it can be used directly in ruby as
 
 ### 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.
+Turple requires a path to a template, and an optional destination. If no destination is passed, it will put everything in a `turple` folder in your current working directory.
 
 ```sh
 turple --template /path/to/template --destination my_new_project_name
@@ -26,18 +42,23 @@ turple --template /path/to/template --destination my_new_project_name
 turple -t /path/to/template -d 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 necessary data.
-
-### Turplefile
-
-`Turplefile` files are yaml formatted files that provided various information to turple. Assuming our template requires a single piece of information called `foo`, our destination Turplefile could look something like this.
+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 put a `Turplefile` into your destination directory with the necessary data. Assuming our template requires a single piece of information called `foo`, our destination Turplefile could look something like this.
 
 ```yaml
 data:
   foo: bar
 ```
 
-Turple templates also have a Turplefile
+### Turplefile
+
+`Turplefile` files are yaml formatted files that provided various information to turple.  Turple checks in multiple locations for a Turplefile.
+
+* Home Directory *(~/Turplefile)*
+  * Define your own custom defaults...  Set your sources, preferred template configuration, and even common template data *(e.g. developer.name)*
+* Template
+  * Templates require a Turplefile with a configuration *(esp if different from the turple defaults)* and an optional data map for use with the wizard.
+* Destination
+  * This file can have preset data (good for bypassing the wizard)
 
 ### Turple Templates
 

data/lib/turple.rb

@@ -18,6 +18,7 @@ class Turple
 
   # Turple user configuration defaults
   @@turpleobject = {
+    :interactive => false,
     :template => '',
     :data => {},
     :data_map => {},
@@ -100,7 +101,8 @@ class Turple
   # allows helper accessors for turpleobject
   #
   def self.method_missing method
-    self.turpleobject[method] || super
+    value = self.turpleobject[method]
+    defined?(value) ? value : super
   end
 
   # Read yaml turplefile and add contents to the turpleobject
@@ -129,34 +131,43 @@ class Turple
 private
 
   def initialize template_path, data_hash = {}, configuration_hash = {}
-    # create sources
-    # load home & template turplefile first for possible additional sources
+    # load home turplefile
     Turple.load_turplefile File.join(File.expand_path('~'), 'Turplefile')
-    Turple.load_turplefile File.join(File.expand_path(template_path), 'Turplefile')
+
+    # create sources
     Turple.sources.each do |source_name, source_path|
       Turple::Source.new source_name, source_path
     end
 
-    # find the destination and load it's optional Turplefile
-    configuration_hash = Turple.configuration.deep_merge configuration_hash
-    @destination_path = configuration_hash[:destination]
-    Turple.load_turplefile File.join(File.expand_path(@destination_path), 'Turplefile')
+    # update turpleobject with initialized arguments
+    Turple.turpleobject = {
+      :template => template_path,
+      :data => data_hash,
+      :configuration => configuration_hash
+    }
+
+    # initialize template after sources are created
+    @template = Turple::Template.new template_path, Turple.interactive
+
+    # set destination and load Turplefile
+    @destination_path = File.expand_path Turple.configuration[:destination]
+    Turple.load_turplefile File.join(@destination_path, 'Turplefile')
 
     # collect data
     data_hash = Turple.data.deep_merge data_hash
     data_map_hash = Turple.data_map
+    configuration_hash = Turple.configuration.deep_merge configuration_hash
 
-    if configuration_hash[:cli]
+    if Turple.interactive
       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]
+    output_summary if Turple.interactive
   end
 
   def output_summary

data/lib/turple/cli.rb

@@ -5,17 +5,14 @@ class Turple::Cli < Thor
   option :template, :type => :string, :aliases => ['-t'], :desc => 'Path to, or name of, a turple template.'
   option :destination, :type => :string, :aliases => ['-d'], :desc => 'Path to save interpolated template to.'
   def ate
-    # update turpleobject object with cli options
-    Turple.turpleobject = {
-      template: options['template'] || Turple.template,
-      configuration: {
-        cli: true,
-        destination: options['destination'] || Turple.configuration[:destination],
-      }
-    }
+    # enable interactive mode
+    Turple.turpleobject = { :interactive => true }
+
+    # dont pass a nil destination
+    configuration_hash = options['destination'] ? { :destination => options['destination'] } : {}
 
     # initialize turple
-    Turple.ate Turple.template
+    Turple.ate options['template'], {}, configuration_hash
   end
 
   default_task :ate

data/lib/turple/data.rb

@@ -18,10 +18,8 @@ private
       prompt_for_data missing_data
     end
 
-    # add provided data to turpleobject
-    Turple.turpleobject = {
-      :data => @provided_data
-    }
+    # update turpleobject with complete data
+    Turple.turpleobject = { :data => @provided_data }
   end
 
   # populate missing data map values to match required data

data/lib/turple/interpolate.rb

@@ -11,7 +11,7 @@ private
     @template = template
     @data = data.data
     @destination = destination
-    @configuration = template.configuration.to_hash
+    @configuration = Turple.configuration
     @tmp_dir = Dir.mktmpdir
     @project_name = File.basename @destination
 

data/lib/turple/template.rb

@@ -9,41 +9,82 @@ class Turple::Template
 
 private
 
-  def initialize path, configuration
-    @configuration = configuration
-
-    # validate configuration and path
-    valid_configuration?
-    unless valid_path? path
-      if @configuration[:cli]
-        prompt_for_path
+  def initialize template, interactive = false
+    path = get_template_path template
+
+    # validate and set path before configuration
+    if valid_path? path
+      @path = path
+    else
+      if interactive
+        until @path
+          prompt_for_path
+        end
       else
         raise S.ay "Invalid Template Path `#{path}`", :error
       end
     end
 
-    # set data variables after validating path and configuration
+    # with a valid path, load the turplefile
+    Turple.load_turplefile File.join(@path, 'Turplefile')
+
+    # validate configuration after path is validated and template Turplefile is loaded
+    valid_configuration? Turple.configuration
+
+    # set variables after validating path
+    @name = File.basename @path
     @required_data = scan_for_data @path
-    @name = Turple.turpleobject[:name] || File.basename(@path)
+  end
+
+  # Look for a template path with a user provided template name or path
+  #
+  # @param template [String] template name, source && template name, or system path
+  # @return [String] valid template path or nil if none is found
+  #
+  def get_template_path template
+    return nil unless template
+
+    # with source included in template path...
+    if template.include? SOURCE_TEMPLATE_SPLITTER
+      # split source from template
+      source_template = template.split SOURCE_TEMPLATE_SPLITTER
+
+      # create new source
+      begin
+        source = Turple::Source.new source_template[1], source_template[0]
+      rescue
+        return nil
+      end
+
+      # look up template path from new source
+      source.template_paths[source_template[1]]
+
+    # if just the template name/path is passed...
+    else
+      # check for template name in existing sources or treat it as a local path
+      Turple::Source.find_template_path(template) || File.expand_path(template) || nil
+    end
   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
+    configuration = Turple.configuration
     required_data = {}
 
     Find.find template_path do |path|
       if File.file?(path)
 
         # process file paths
-        path_regex = Regexp.new @configuration[:path_regex]
+        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 = 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
@@ -51,12 +92,12 @@ private
         end
 
         # process file contents
-        content_regex = Regexp.new @configuration[:content_regex]
-        if path =~ /\.#{Regexp.escape(@configuration[:file_ext])}$/
+        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 = 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
@@ -67,94 +108,73 @@ private
 
     # 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
+      S.ay 'No Required Data - Nothing found to interpolate.  Make sure your configuration matches your template.', :error
+      exit
     end
 
     return required_data
   end
 
-  # check that the path is a valid template
-  # @return [Boolean]
-  #
-  def valid_path? potential_path
-    # with source included in template path...
-    new_path = if potential_path.include? SOURCE_TEMPLATE_SPLITTER
-      # split source from template
-      source_template = potential_path.split SOURCE_TEMPLATE_SPLITTER
-
-      # create new source
-      begin
-        Turple::Source.new source_template[1], source_template[0]
-      rescue
-        return false
-      end
-
-      # look up template path from new source
-      Turple::Source.find_template_path source_template[1], source_template[1]
-
-    # if just the template name/path is passed...
-    else
-      # check for template name in existing sources or treat it as a local path
-      Turple::Source.find_template_path(potential_path) || File.expand_path(potential_path)
-    end
-
-    # set path var if new path is a valid template
-    if !new_path.nil? && File.directory?(new_path) && File.file?(File.join(new_path, 'Turplefile'))
-      @path = new_path
-      return true
-    else
-      return false
-    end
-  end
-
   # prompt the user for a template path until a vaid one is entered
   # @return [String] valid template path
   #
   def prompt_for_path
-    until @path
-      A.sk 'Enter a path to a Turple Template', :preset => :prompt, :readline => true do |response|
-        valid_path? response
-      end
+    A.sk 'Enter a path to a Turple Template', :preset => :prompt, :readline => true do |response|
+      path = get_template_path response
+      @path = path if valid_path? path
     end
+  end
 
-    return @path
+  # Check that a path is a valid template
+  #
+  # @param path [String] file system path to a proposed template directory
+  # @return [Boolean]
+  #
+  def valid_path? path
+    !path.nil? && File.directory?(path) && File.file?(File.join(path, 'Turplefile'))
   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
+  # @param [Hash] a configuration hash
+  # @return [Boolean] true or exit
+  #
+  def valid_configuration? configuration
+    begin
+      # 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
+      # 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[: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
+      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[: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
+      # 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
+      return true
+    rescue
+      exit
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turple
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Ryan Brewster