incline 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf198e645fba31e26e730a4fcf2deae2b72a8d92
-  data.tar.gz: 4c5782b14aa7db868e44ec418f0272aa6cbd026a
+  metadata.gz: '0254285858902e4313110fddc419672ac8ae267b'
+  data.tar.gz: f22408a384aa6aaf8ee1f36195a220d1677fb09c
 SHA512:
-  metadata.gz: e4422ca100423246a3eb80de970c1e6958379b14afc7294c07f4e739f66b3b5442414eae78781d5dc577c303baea32663bb5e3e6dc49f50095dd9afce86b3ed7
-  data.tar.gz: b84f5223ea71524f0f445a6a5cdf0aacb3d85d6e63b39397b30db8ea3ed4272c9994b98e949247a0167f4c0115e4367118b6bf02d52fb18217d795ceebf4fc11
+  metadata.gz: e8f26912a02f65f50705909925952a0478bed454cc32a3d5eff854a1186d030e72905370f3791fd40dae334c72fffad0d8cf2177e4077e8924cdc9b4028ae61a
+  data.tar.gz: 200de0b8b26cabf2303f94ee7df3d5aad0c3ec7c7a8745871df0825d3c16e6b4039da7115f50b70972310c661ba0b7ba50ee4a69d292b353cd1714301e3f63a9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    incline (0.1.7)
+    incline (0.1.8)
       ansi (~> 1.5.0)
       bcrypt
       bootstrap-sass
@@ -58,7 +58,7 @@ GEM
       tzinfo (~> 1.1)
     ansi (1.5.0)
     arel (6.0.4)
-    autoprefixer-rails (7.1.2.2)
+    autoprefixer-rails (7.1.2.3)
       execjs
     bcrypt (3.1.11)
     bootstrap-sass (3.3.7)
@@ -151,7 +151,7 @@ GEM
       sprockets (>= 2.8, < 4.0)
       sprockets-rails (>= 2.0, < 4.0)
       tilt (>= 1.1, < 3)
-    shells (0.1.9)
+    shells (0.1.10)
       net-ssh (~> 3.0.2)
       rubyserial (~> 0.4.0)
     spawnling (2.1.6)
@@ -165,7 +165,7 @@ GEM
     sqlite3 (1.3.13)
     thor (0.19.4)
     thread_safe (0.3.6)
-    tilt (2.0.7)
+    tilt (2.0.8)
     tiny_tds (1.3.0)
       mini_portile2 (~> 2.0)
     tzinfo (1.2.3)

data/app/controllers/incline/account_activations_controller.rb

@@ -8,7 +8,7 @@ module Incline
     def edit
       if logged_in?
         flash[:danger] = 'You cannot reactivate your account.'
-        redirect_to root_url
+        redirect_to main_app.root_url
       else
         user = User.find_by(email: params[:email].downcase)
         if user && !user.activated? && user.authenticated?(:activation, params[:id])
@@ -18,7 +18,7 @@ module Incline
           redirect_to user
         else
           flash[:danger] = 'Invalid activation link'
-          redirect_to root_url
+          redirect_to main_app.root_url
         end
       end
     end

data/app/controllers/incline/contact_controller.rb

@@ -17,7 +17,7 @@ module Incline
         @msg.remote_ip = request.remote_ip
         @msg.send_message
         flash[:success] = 'Your message has been sent.'
-        redirect_to root_url
+        redirect_to main_app.root_url
       else
         render 'new'
       end

data/app/controllers/incline/password_resets_controller.rb

@@ -40,7 +40,7 @@ module Incline
       end
 
       flash[:info] = 'An email with password reset information has been sent to you.'
-      redirect_to root_url
+      redirect_to main_app.root_url
     end
 
     ##
@@ -98,7 +98,7 @@ module Incline
 
     def valid_user
       unless @user && @user.enabled? && @user.activated? && @user.authenticated?(:reset, params[:id])
-        redirect_to root_url
+        redirect_to main_app.root_url
       end
     end
 

data/app/controllers/incline/sessions_controller.rb

@@ -29,7 +29,7 @@ module Incline
           redirect_back_or @user
         else
           flash[:safe_warning] = 'Your account has not yet been activated.<br/>Check your email for the activation link.'
-          redirect_to root_url
+          redirect_to main_app.root_url
         end
       else
         # deny login.
@@ -42,7 +42,7 @@ module Incline
     # DELETE /incline/logout
     def destroy
       log_out if logged_in?
-      redirect_to root_url
+      redirect_to main_app.root_url
     end
 
   end

data/app/controllers/incline/users_controller.rb

@@ -59,7 +59,7 @@ module Incline
             if inline_request?
               render 'show', formats: [ :json ]
             else
-              redirect_to root_url
+              redirect_to main_app.root_url
             end
             return
           end

data/exe/incline

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+# If installed as a gem, this won't do anything, however if we are
+# working from the source, this will ensure our lib path is searched
+# for require and include calls.
+git_path = File.expand_path('../../.git', __FILE__)
+if File.exist?(git_path)
+  $:.unshift File.expand_path('../../lib', __FILE__)
+end
+
+require 'incline/cli'
+Incline::CLI.new.execute(*ARGV)

data/lib/incline/cli/errors.rb

@@ -0,0 +1,8 @@
+module Incline
+  class CLI
+
+    class CliError < ::RuntimeError; end
+    class UsageError < CliError; end
+
+  end
+end

data/lib/incline/cli/helpers/yaml.rb

@@ -0,0 +1,743 @@
+module Incline
+  module CliHelpers
+
+    ##
+    # Adds YAML text helper methods.
+    #
+    # Does not parse YAML files, but does allow for updating raw text files to be YAML compliant.
+    module Yaml
+
+      class YamlError < ::Incline::CLI::CliError; end
+
+      ##
+      # Helper class to process the YAML file contents easily.
+      class YamlContents
+
+        ##
+        # Creates a new YAML contents.
+        def initialize(content)
+          @content = content.to_s.gsub("\r\n", "\n").strip + "\n"
+        end
+
+        ##
+        # Returns the YAML contents.
+        def to_s
+          @content
+        end
+
+        ##
+        # Adds a key to the YAML contents if it is missing.
+        # Does nothing to the key if it exists.
+        #
+        #   add_key [ "default", "name" ], "george"
+        #
+        # The 'key' should be an array defining the path.
+        #
+        # Value can be nil, a string, a symbol, a number, or a boolean.
+        #
+        # The 'make_safe_value' option can be used to provide an explicit text value.
+        # This can be useful if you want to add a specific value, like an ERB command.
+        #
+        #   add_key [ "default", "name" ], "<%= ENV[\"DEFAULT_USER\"] %>", false
+        #
+        # You can also use a hash for the value to specify advanced options.
+        # Currently only three advanced options are recognized.
+        #
+        # The first option, :value, simply sets the value.  If this is the only
+        # hash key provided, then the value supplied is treated as if it was the original
+        # value.  In other words, only setting :value is the same as not using a hash and
+        # just passing in the value, so the value must be nil, a string, a symbol, a number,
+        # or a boolean.
+        #
+        # The second option, :safe, works the opposite of the 'make_safe_value' parameter.
+        # If :safe is a non-false value, then it is like 'make_safe_value' is set to false.
+        # If :safe is a false value, then it is like 'make_safe_value' is set to true.
+        # The :safe value can be set to true and the :value option can set the value, or
+        # the :safe value can be set to the value directly since all strings are non-false.
+        #
+        # The third option, :before_section, tells add_key to insert the section before the
+        # named section (if the new section doesn't exist).  This can be useful if the named
+        # section is going to be referencing the key you are adding.  Otherwise, when a
+        # section needs to be added, it gets added to the end of the file.
+        #
+        # Returns the contents object.
+        def add_key(key, value, make_safe_value = true)
+
+          # ensure the parent structure exists!
+          if key.count > 1
+            add_key(key[0...-1], nil)
+          else
+            # If the base key already exists, no need to look further.
+            return self if @content =~ /^#{key.first}:/
+
+            unless @content[0] == '#'
+              @content = "# File modified by Incline v#{Incline::VERSION}.\n" + @content
+            end
+          end
+
+          val_name = key.last
+
+          # construct a regular expression to find the parent group and value.
+          rex_str = '^('
+          rex_prefix = /\A./
+          key.each_with_index do |attr,level|
+            lev = (level < 1 ? '' : ('\\s\\s' * (level)))
+            if lev != ''
+              rex_str += '(?:' + lev + '[^\\n]*\\n)*'
+            end
+            if level == key.count - 1
+              if level == 0
+                # At level 0 we cheat and use a very simple regular expression to confirm the section exists.
+                rex_str = "^#{attr}:"
+                # If it doesn't exists, the prefix regex will usually want to put the new section at the end of the
+                # file.  However if the :before_section option is set, and the other section exists, then we
+                # want to ensure that we are putting the new section before it.
+                #
+                # Down below we take care to reverse the replacement string when key.count == 1.
+                rex_prefix =
+                  if value.is_a?(::Hash) && value[:before_section] && @content =~ /^#{value[:before_section]}:/
+                    /(^#{value[:before_section]}:)/
+                  else
+                    /(\z)/   # match the end of the contents.
+                  end
+              else
+                rex_str += ')'
+                rex_prefix = Regexp.new(rex_str)
+                rex_str += '(' + lev + attr + ':.*\\n)'
+              end
+            else
+              rex_str += lev + attr + ':.*\\n'
+            end
+          end
+
+          rex = Regexp.new(rex_str)
+
+          if @content =~ rex
+            # all good.
+          elsif @content =~ rex_prefix
+            if make_safe_value
+              value = safe_value(value)
+              value = add_value_offset(key, value)
+            elsif value.is_a?(::Hash)
+              value = value[:value]
+            end
+            value = '' if value =~ /\A\s*\z/
+            # Should be true thanks to first step in this method.
+            # Capture 1 would be the parent group.
+            # When key.count == 1 then we want to put our new value before capture 1.
+            # Otherwise we put our new value after capture 1.
+            rep = if key.count == 1
+                    "\n#{val_name}:#{value}\n\\1"
+                  else
+                    "\\1#{'  ' * (key.count - 1)}#{val_name}:#{value}\n"
+                  end
+
+            @content.gsub! rex_prefix, rep
+          else
+            raise ::Incline::CliHelpers::Yaml::YamlError, "Failed to create parent group for '#{key.join('/')}'."
+          end
+
+          self
+        end
+
+
+        ##
+        # Adds a key to the YAML contents if it is missing.
+        # Does nothing to the key if it exists.
+        #
+        #   add_key_with_comment [ "default", "name" ], "george", "this is the name of the default user"
+        #
+        # The 'key' should be an array defining the path.
+        # If the 'comment' is blank (nil or ''), then it will not modify the comment.
+        # Use a whitespace string (' ') to indicate that you want a blank comment added.
+        #
+        # Value can be nil, a string, a symbol, a number, or a boolean.
+        # Value can also be a hash according to #add_key.
+        #
+        # Returns the contents object.
+        def add_key_with_comment(key, value, comment)
+          if comment.to_s == ''
+            add_key key, value
+          else
+            add_key key, value_with_comment(key, value, comment), false
+          end
+        end
+
+        ##
+        # Sets a key in the YAML contents.
+        # Adds the key if it is missing, replaces it if it already exists.
+        #
+        #   set_key [ "default", "name" ], "george"
+        #
+        # The 'key' should be an array defining the path.
+        #
+        # Value can be nil, a string, a symbol, a number, or a boolean.
+        # Value can also be a hash according to #add_key.
+        #
+        # The 'make_safe_value' option can be used to provide an explicit text value.
+        # This can be useful if you want to add a specific value, like an ERB command.
+        #
+        #   set_key [ "default", "name" ], "<%= ENV[\"DEFAULT_USER\"] %>", false
+        #
+        # Returns the contents object.
+        def set_key(key, value, make_safe_value = true)
+
+          # construct a regular expression to find the value and not confuse it with any other value in the file.
+          rex_str = '^('
+          key.each_with_index do |attr,level|
+            lev = (level < 1 ? '' : ('\\s\\s' * (level)))
+            if lev != ''
+              rex_str += '(?:' + lev + '.*\\n)*'
+            end
+            if level == key.count - 1
+              rex_str += lev + attr + ':)\\s*([^#\\n]*)?(#[^\\n]*)?\\n'
+            else
+              rex_str += lev + attr + ':.*\\n'
+            end
+          end
+
+          rex = Regexp.new(rex_str)
+
+          if @content =~ rex
+            if make_safe_value
+              value = safe_value(value)
+              value = add_value_offset(key, value)
+            elsif value.is_a?(::Hash)
+              value = value[:value]
+            end
+            value = '' if value =~ /\A\s*\z/
+            # Capture 1 is everything before the value.
+            # Capture 2 is going to be just the value.
+            # Capture 3 is the comment (if any).  This allows us to propagate comments if we change a value.
+            if $2 != value
+              rep = "\\1#{value}\\3\n"
+              @content.gsub! rex, rep
+            end
+
+            self
+          else
+            add_key(key, value, make_safe_value)
+          end
+        end
+
+        ##
+        # Sets a key in the YAML contents.
+        # Adds the key if it is missing, replaces it if it already exists.
+        #
+        #   set_key_with_comment [ "default", "name" ], "george", "this is the name of the default user"
+        #
+        # The 'key' should be an array defining the path.
+        # If the 'comment' is blank (nil or ''), then it will not modify the comment.
+        # Use a whitespace string (' ') to indicate that you want a blank comment added.
+        #
+        # Value can be nil, a string, a symbol, a number, or a boolean.
+        # Value can also be a hash according to #add_key.
+        #
+        # Returns the contents object.
+        def set_key_with_comment(key, value, comment)
+          if comment.to_s == ''
+            set_key key, value
+          else
+            set_key key, value_with_comment(key, value, comment), false
+          end
+        end
+
+        ##
+        # Removes the specified key from the contents.
+        #
+        # Returns an array containing the contents of the key.
+        # The first element will be for the key itself.  If the
+        # key had child keys, then they will also be included in
+        # the array.
+        #
+        # The returned array will contain hashes for each removed
+        # key.
+        #
+        #     data = remove_key %w(pet dog)
+        #
+        #     [
+        #       {
+        #         :key => [ "pet", "dog" ],
+        #         :value => "",
+        #         :safe => true,
+        #         :comment => "This list has the family dogs."
+        #       },
+        #       {
+        #         :key => [ "pet", "dog", "sadie" ],
+        #         :value => "",
+        #         :safe => true,
+        #         :comment => ""
+        #       },
+        #       {
+        #         :key => [ "pet", "dog", "sadie", "breed" ],
+        #         :value => "boxer",
+        #         :safe => true,
+        #         :comment => ""
+        #       },
+        #       {
+        #         :key => [ "pet", "dog", "sadie", "dob" ],
+        #         :value => "\"2016-06-01\"",
+        #         :safe => true,
+        #         :comment => "Estimated date of birth since she was a rescue."
+        #       }
+        #     ]
+        #
+        # The returned hashes can be fired right back into #add_key.
+        #
+        #     data.each do |item|
+        #       add_key_with_comment item[:key], item, item[:comment]
+        #     end
+        #
+        # This method can be used to move a section within the file.
+        #
+        #     # remove the 'familes' section from the file.
+        #     section = remove_key [ "families" ]
+        #     item = section.delete(section.first)
+        #
+        #     # add the 'familes' section back in before the 'pets' section.
+        #     add_key_with_comment item[:key], { before_section: "pets" }.merge(item), item[:comment]
+        #
+        #     # add the data back into the 'familes' section.
+        #     section.each do |item|
+        #       add_key_with_comment item[:key], item, item[:comment]
+        #     end
+        #
+        def remove_key(key)
+          rex_str = '(^'
+          key.each_with_index do |attr,level|
+            lev = (level < 1 ? '' : ('\\s\\s' * level))
+            if lev != ''
+              rex_str += '(?:' + lev + '.*\\n)*'
+            end
+            if level == key.count - 1
+              if level == 0
+                rex_str = '(^)(' + attr + ':[^\\n]*\\n(?:\\s\\s[^\\n]*\\n)*)'
+              else
+                rex_str += ')(' + lev + attr + ':[^\\n]*\\n(?:' + lev + '\\s\\s[^\\n]*\\n)*)'
+              end
+            else
+              rex_str += lev + attr + ':[^\\n]*\\n'
+            end
+          end
+
+          # match result 1 is the parent key structure leading up to the key to be extracted.
+          # match result 2 is the key with all child elements to be extracted.
+
+          rex = Regexp.new(rex_str)
+
+          if @content =~ rex
+
+            # cache the key contents
+            key_content = $2
+
+            # remove the key from the main contents.
+            @content.gsub!(rex, "\\1")
+
+            # and separate into lines.
+            lines = extract_to_array(key_content)
+
+            ret = []
+
+            base_key = key.length == 1 ? [] : key[0...-1]
+
+            last_line = nil
+
+            lines.each do |line|
+              level = line[:level]
+              if level > 0 && line[:key]
+                # go from base 1 to base 0
+                level -= 1
+
+                # make sure the base key is the right length for the current key.
+                while level > base_key.length
+                  base_key.push '?' # hopefully this never occurs.
+                end
+                while level < base_key.length
+                  base_key.pop
+                end
+
+                # add our key to the base key.
+                # if the next key is below it, this ensures the parent structure is correct.
+                # if the next key is higher or at the same level the above loops should make it correct.
+                base_key << line[:key]
+
+                last_line = {
+                    key: base_key,
+                    value: line[:value].to_s,
+                    comment: line[:comment],
+                    safe: true
+                }
+
+                ret << last_line
+              elsif level > 0 && line[:comment]
+                if last_line && last_line[:key].length == level
+                  if last_line[:comment]
+                    last_line[:comment] += "\n" + line[:comment]
+                  else
+                    last_line[:comment] = "\n" + line[:comment]
+                  end
+                end
+              end
+            end
+
+            ret
+          else
+            []
+          end
+        end
+
+        ##
+        # Realigns the file.
+        #
+        # All values and comments will line up at each level when complete.
+        def realign!
+          lines = extract_to_array(@content)
+
+          # reset the offsets.
+          value_offsets.clear
+          comment_offsets.clear
+
+          # get value offsets.
+          lines.each do |line|
+            level = line[:level]
+            if level > 0 && line[:key]
+              key_len = line[:key].length + 2   # include the colon and a space
+              if key_len > level_value_offset(level)
+                set_level_value_offset level, key_len
+              end
+            end
+          end
+
+          # get comment offsets.
+          lines.each do |line|
+            level = line[:level]
+            if level > 0 && line[:value]
+              voff = level_value_offset(level)
+              val_len = line[:value] ? line[:value].length : 0
+              coff = voff + val_len + 1         # add a space after the value.
+              if coff > level_comment_offset(level)
+                set_level_comment_offset level, coff
+              end
+            end
+          end
+
+          # convert the lines back into strings with proper spacing.
+          lines = lines.map do |line|
+            level = line[:level]
+            if level > 0
+              if line[:key]
+                # a key: value line.
+                key = line[:key] + ':'
+                key = key.ljust(level_value_offset(level), ' ') unless line[:value].to_s == '' && line[:comment].to_s == ''
+                val = line[:value].to_s
+                val = val.ljust(level_comment_offset(level) - level_value_offset(level), ' ') unless line[:comment].to_s == ''
+                comment = line[:comment] ? "# #{line[:comment]}" : ''
+                ('  ' * (level - 1)) + key + val + comment
+              else
+                # just a comment line.
+                ('  ' * (level - 1)) +
+                    (' ' * level_comment_offset(level)) +
+                    "# #{line[:comment]}"
+              end
+            else
+              line[:value]  # return the original value
+            end
+          end
+
+          @content = lines.join("\n") + "\n"
+        end
+
+        ##
+        # Gets the value offset for the specified level.
+        #
+        # The offset is based on the beginning of the level in question.
+        # There will always be at least one whitespace before the value.
+        # For instance an offset of 10 for level 2 would be like this:
+        #
+        #   one:
+        #     two:      value
+        #     some_long_name: value
+        #   # 0123456789^
+        #
+        def level_value_offset(level)
+          value_offsets[level] || 0
+        end
+
+        ##
+        # Sets the value offset for the specified level.
+        #
+        # The offset is based on the beginning of the level in question.
+        # There will always be at least one whitespace before the value.
+        # For instance an offset of 10 for level 2 would be like this:
+        #
+        #   one:
+        #     two:      value
+        #     some_long_name: value
+        #   # 0123456789^
+        #
+        def set_level_value_offset(level, offset)
+          value_offsets[level] = offset
+        end
+
+        ##
+        # Gets the comment offset for the specified level.
+        #
+        # The offset is based on the beginning of the level in question.
+        # There will always be at least one whitespace before the value
+        # and at least one whitespace between the value and a comment.
+        # For instance an offset of 15 for level 2 would be like this:
+        #
+        #   one:
+        #     two: value     # comment
+        #     some_long_name: value # comment
+        #   # 012345678901234^
+        #
+        def level_comment_offset(level)
+          comment_offsets[level] || 0
+        end
+
+        ##
+        # Sets the comment offset for the specified level.
+        #
+        # The offset is based on the beginning of the level in question.
+        # There will always be at least one whitespace before the value
+        # and at least one whitespace between the value and a comment.
+        # For instance an offset of 15 for level 2 would be like this:
+        #
+        #   one:
+        #     two: value     # comment
+        #     some_long_name: value # comment
+        #   # 012345678901234^
+        #
+        def set_level_comment_offset(level, offset)
+          comment_offsets[level] = offset
+        end
+
+        ##
+        # Allows comparing the contents against a regular expression.
+        def =~(regexp)
+          @content =~ regexp
+        end
+
+        private
+
+        def extract_to_array(data)
+          # match 1 = lead white
+          # ([ \t]*)
+          # match 2 = key name
+          # (\S+):
+          # match 3 = value with leading whitespace
+          # ((?:[ \t]*(?:"(?:[^"]*(?:(?:\\{1}|\\{3}|\\{5}|\\{7}|\\{9})")?)*"|'(?:[^']*(?:(?:\\{1}|\\{3}|\\{5}|\\{7}|\\{9})')?)*'|[^\s#"']+))*)
+          # ignore white between value and comment (if any).
+          # [ \t]*
+          # match 4 = comment (if any).
+          # (?:#([^\n]*))?
+          line_regex = /\A([ \t]*)(\S+):((?:[ \t]*(?:"(?:[^"]*(?:(?:\\{1}|\\{3}|\\{5}|\\{7}|\\{9})")?)*"|'(?:[^']*(?:(?:\\{1}|\\{3}|\\{5}|\\{7}|\\{9})')?)*'|[^\s#"']+))*)[ \t]*(?:#([^\n]*))?\z/
+          last_level = 0
+          data.split("\n").map do |raw_line|
+            # assuming the file is valid any lines not matching the regex should be comments or blank.
+            match = line_regex.match(raw_line)
+            if match    # a key: value line
+              last_level = (match[1].length / 2).to_i + 1 # one level per 2 spaces.
+              {
+                  level: last_level,
+                  key: match[2].strip,
+                  value: match[3] ? match[3].strip : nil,
+                  comment: match[4] ? match[4].lstrip : nil
+              }
+            elsif raw_line =~ /\A(\s*)#(.*)\z/    # a comment
+              whitespace = $1
+              raw_line = $2
+              level =
+                  if whitespace.length >= (last_level * 2)
+                    last_level
+                  else
+                    (whitespace.length / 2).to_i + 1
+                  end
+              raw_line = raw_line[1..-1] if raw_line[0] == ' '
+              {
+                  level: level,
+                  comment: raw_line
+              }
+            else
+              {
+                  level: 0,
+                  value: raw_line
+              }
+            end
+          end
+        end
+
+        def value_with_comment(key, value, comment)
+          vh = value.is_a?(::Hash) ? value : { safe: false, value: value, before_section: nil }
+          unless vh[:safe]
+            vh[:value] = add_comment(key, add_value_offset(key, safe_value(vh[:value])), comment)
+            vh[:safe] = true
+          end
+          vh
+        end
+
+        def add_value_offset(key, safe_value)
+          key_len = key.last.to_s.length + 1 # add one for the colon.
+          voff = level_value_offset(key.count) - key_len
+          voff = 1 if voff < 1
+
+          (' ' * voff) + safe_value
+        end
+
+        def add_comment(key, safe_value, comment)
+          key_len = key.last.to_s.length + 1 # add one for the colon.
+          coff = level_comment_offset(key.count) - key_len - safe_value.length
+          coff = 1 if coff < 1
+          coff_total = ((key.count - 1) * 2) + value.length + coff
+
+          safe_value + (' ' * coff) + '# ' + comment.to_s.gsub("\r\n", "\n").gsub("\n", "\n#{' ' * coff_total}# ")
+        end
+
+        def value_offsets
+          @value_offsets ||= [ ]
+        end
+
+        def comment_offsets
+          @comment_offsets ||= [ ]
+        end
+
+        # always returns a string, even for safe values.
+        def safe_value(value)
+          # Allows the user to specify the value as a hash option without marking it as safe.
+          if value.is_a?(::Hash) && value[:value] && !value[:safe]
+            value = value[:value]
+          end
+
+          if value.is_a?(::Hash) && value[:safe]
+            # If the user specifies a safe value, return it as-is.
+            (value[:value] || value[:safe]).to_s
+          elsif value.nil?
+            # If the value is nil, return an empty string.
+            ''
+          else
+            # Otherwise process the value to make it YAML compliant.
+            unless value.is_a?(::String) || value.is_a?(::Symbol) || value.is_a?(::Numeric) || value.is_a?(::TrueClass) || value.is_a?(::FalseClass)
+              raise ArgumentError, "'value' must be a value type (string, symbol, number, boolean)"
+            end
+
+            if value.is_a?(::String)
+              if value =~ /\A\s*\z/m  ||                # Empty or filled with whitespace
+                  value =~ /\A\s/m    ||                # Starts with whitespace
+                  value =~ /\s\z/m    ||                # Ends with whitespace
+                  value =~ /\A[+-]?\d+(\.\d*)?\z/ ||    # Contains a probable number
+                  value =~ /\A0(b[01]*|x[0-9a-f]*)\z/i  # Another probable number in binary or hex format.
+                value.inspect
+              elsif value =~ /\A([0-9]*[a-z]|[a-z])([a-z0-9_ .,=-]*[a-z0-9_])*\z/i
+                value
+              else
+                value.inspect
+              end
+            else
+              value.inspect
+            end
+          end
+
+        end
+
+      end
+
+      protected
+
+      ##
+      # Repairs a YAML file, creating it if necessary.
+      #
+      # The optional parameters define what all will be done by this method before yielding to a supplied block.
+      # The contents of the YAML file are yielded to the block and the block should return the modified contents.
+      #
+      #     repair_yaml "config/database.yml" do |contents|
+      #       contents.add_key [ "test", "database" ], "db/test.sqlite3"
+      #     end
+      #
+      # If 'env_ref_set' is set to a non-empty value, then it defines the anchor providing default values
+      # for the environment sections.  The default value is 'default'.
+      #
+      # If 'ensure_default' is set, then a 'default' section with a 'default' anchor will be created at the
+      # beginning of the file unless a 'default' section already exists in the file.
+      # The default value is 'true'.
+      #
+      # If 'ensure_env' is set, then the environment sections will be created if missing.  This ensures that
+      # a 'development', 'test', and 'production' section all exist. The default value is 'true'.
+      #
+      # If 'realign' is set, then the entire file will be processed.  All values will be aligned at each
+      # level and so will all comments.  The default is 'true'.
+      #
+      # The default options on an empty file will generate a 'default' section before yielding and then
+      # fill in the environment sections after the block returns.
+      #
+      #     default: &default
+      #
+      #     development:
+      #       <<: *default
+      #
+      #     test:
+      #       <<: *default
+      #
+      #     production:
+      #       <<: *default
+      #
+      def repair_yaml(filename, env_ref_sect = 'default', ensure_default = true, ensure_env = true, realign = true) # :doc:
+        dirty = false
+        stat = :updated
+
+        # ensure the file exists.
+        unless File.exist?(filename)
+          File.write filename, "# File created by Incline v#{Incline::VERSION}.\n"
+          stat = :created
+          dirty = true
+        end
+
+        orig_contents = File.read(filename)
+
+        contents = YamlContents.new(orig_contents)
+
+        if ensure_default
+          contents.set_key %w(default), '&default', false
+        end
+
+        yield contents if block_given?
+
+        if ensure_env
+          %w(development test production).each do |sect|
+            contents.add_key [ sect ], nil
+          end
+        end
+
+        # Potential bug, and I'm not even sure if it would be or not.
+        # But since we use relatively simple regular expressions to perform the set action,
+        # the << "key" can only exist once and would be overridden.
+        # That means that a section would not be able to include multiple anchors.
+        # Like I said before, I'm not sure if that would actually be a bug or not.
+        #
+        # Luckily, the YAML files aren't meant to be overly complex so this shouldn't show
+        # up regularly if at all.
+        unless env_ref_sect.to_s.strip == ''
+          %w(development test production).each do |sect|
+            contents.set_key [ sect, '<<' ], '*' + env_ref_sect
+          end
+        end
+
+        contents.realign! if realign
+
+        unless dirty
+          dirty = (orig_contents != contents.to_s)
+        end
+
+        if dirty
+          File.write filename, contents.to_s
+          say_status stat, filename, :green
+        else
+          say_status :unchanged, filename, :blue
+        end
+      end
+
+
+
+    end
+  end
+end

data/lib/incline/cli/usage.rb

@@ -0,0 +1,77 @@
+
+module Incline
+  class CLI
+
+    ##
+    # Defines the 'usage' command for the CLI.
+    class Usage
+
+      ##
+      # Creates a new 'usage' command for the CLI.
+      def initialize
+
+      end
+
+      ##
+      # Shows usage information for the application.
+      def run
+
+        commands = Incline::CLI::valid_commands.sort{|a,b| a[0] <=> b[0]}
+
+        msg = ANSI.ansi(:bold) { "Usage: #{$PROGRAM_NAME} command <arguments>" }
+        msg += "\nValid Commands:\n"
+
+        commands.each do |(name,klass,params)|
+          comment = get_run_comment(klass)
+          comment = "(No description)" if comment.to_s.strip == ''
+          comment = '    ' + comment.gsub("\n", "\n    ")
+          msg += "  #{name}"
+          pend = ''
+          params.each do |t,p|
+            msg += ' '
+            if t == :req
+              msg += p.to_s
+            elsif t == :opt
+              msg += '[' + p.to_s
+              pend += ']'
+            else
+              msg += '<...>'
+            end
+          end
+          msg += "\n" + comment + "\n"
+        end
+
+        STDOUT.print msg
+        msg
+      end
+
+      private
+
+      def get_run_comment(klass)
+        meth = klass.instance_method(:run)
+        return '' unless meth
+        file,line_num = meth.source_location
+        return '' unless file && line_num
+        return '' unless File.exist?(file)
+
+        source_lines = File.read(file).gsub("\r\n", "\n").split("\n")
+
+        comments = []
+
+        # line_num is 1 based so we need to subtract 1 to get the line with the method definition
+        # then we subtract 1 again to get the first line before the method definition.
+        line_num -= 2
+
+        while line_num >= 0 && source_lines[line_num] =~ /\A(?:\s*)(?:#(?:\s(.*))?)?\z/
+          line = $1.to_s
+          comments << line
+          line_num -= 1
+        end
+
+        comments.reverse.join("\n")
+      end
+
+    end
+
+  end
+end

data/lib/incline/cli/version.rb

@@ -0,0 +1,23 @@
+
+module Incline
+  class CLI
+
+    ##
+    # Defines the 'version' command for the CLI.
+    class Version
+
+      ##
+      # Creates a new 'version' command for the CLI.
+      def initialize
+
+      end
+
+      ##
+      # Shows the version of the Incline library.
+      def run
+        STDOUT.puts "Incline v#{Incline::VERSION}"
+      end
+
+    end
+  end
+end

data/lib/incline/cli.rb

@@ -0,0 +1,120 @@
+require 'ansi/code'
+require 'incline/version'
+require 'incline/cli/errors'
+
+require 'incline/cli/helpers/yaml'
+
+require 'incline/cli/version'
+require 'incline/cli/usage'
+
+
+module Incline
+  class CLI
+
+
+    def initialize
+
+    end
+
+    def execute(*args)
+      begin
+        if args.empty? || %w(usage help /? -? -help --help).include?(args.first)
+          process_command(:usage)
+        else
+          process_command(*args)
+        end
+      rescue UsageError => err
+        STDERR.puts err.message
+        process_command(:usage)
+      rescue CliError => err
+        STDERR.puts ANSI.code(:red) { 'ERROR:' }
+        STDERR.puts err.message
+      rescue RuntimeError => err
+        STDERR.puts ANSI.code(:red) { 'FATAL ERROR:' }
+        STDERR.puts err.inspect
+      end
+    end
+
+    def process_command(command, *args)
+      command = command.to_sym
+      cmd_info = self.class.command_list.find{|c| c[:method] == command}
+      if cmd_info
+        args = args.dup
+        args = []
+        cmd_info[:new_params].each do |(type,name)|
+          if type == :rest
+            args += args
+            break
+          elsif type == :req
+            if args.empty?
+              raise UsageError, "Missing required parameter '#{name}' for command '#{command}'."
+            end
+            args << args.delete_at(0)
+          elsif type == :opt
+            if args.empty?
+              break
+            else
+              args << args.delete_at(0)
+            end
+          else
+            raise UsageError, "Unknown parameter type '#{type}' for command '#{command}'."
+          end
+        end
+        cmd_object = cmd_info[:klass].new(*args)
+        cmd_object.send(:run)
+      else
+        raise UsageError, "Unknown command '#{command}'."
+      end
+    end
+
+    def self.valid_commands
+      command_list.map do |cmd_info|
+        [ cmd_info[:method], cmd_info[:klass], cmd_info[:new_params] ]
+      end
+    end
+
+    private
+
+    def self.command_list
+      @command_list ||=
+          begin
+            constants.map do |c|
+              klass = const_get c
+              # class must have a :new class method and a :run instance method.
+              if klass.instance_methods.include?(:run) && klass.methods.include?(:new)
+                m = klass.method(:new)
+                new_params = m.parameters.select{ |p| p[1] && (p[0] == :req || p[0] == :opt || p[0] == :rest) }.freeze
+                m = klass.instance_method(:run)
+                run_params = m.parameters.select{ |p| p[1] && (p[0] == :req || p[0] == :opt || p[0] == :rest) }.freeze
+                if run_params.count == 0
+                  {
+                      name: c.to_s,
+                      method: c.to_s.gsub(/(.)([A-Z])/,"\\1_\\2").downcase.to_sym,
+                      new_params: new_params,
+                      klass: klass,
+                      valid: true
+                  }
+                else
+                  {
+                      name: c.to_s,
+                      valid: false,
+                      failure_reason: 'Method :run expects parameters.'
+                  }
+                end
+              else
+                {
+                    name: c,
+                    valid: false,
+                    failure_reason: 'Missing :new or :run.'
+                }
+              end
+            end.select do |c|
+              c[:valid]
+            end
+          end
+    end
+
+
+
+  end
+end

data/lib/incline/extensions/action_controller_base.rb

@@ -318,7 +318,7 @@ module Incline::Extensions
       rescue ::Incline::NotAuthorized => err
 
         flash[:danger] = err.message
-        redirect_to root_url and return false
+        redirect_to main_app.root_url and return false
       end
       true
 

data/lib/incline/extensions/test_case.rb

@@ -216,11 +216,17 @@ module Incline::Extensions
     end
 
     ##
-    # Make sure main_app is available and working correctly.
+    # Make sure main_app is available and working correctly in tests.
     def main_app
       Rails.application.class.routes.url_helpers
     end
-
+    
+    ##
+    # Make sure incline is available and working correctly in tests.
+    def incline
+      Incline::Engine.routes.url_helpers
+    end
+    
     ##
     # Determines if a user is logged into the test session
     def is_logged_in?

data/lib/incline/version.rb

@@ -1,3 +1,3 @@
 module Incline
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/test/cli/yaml_contents_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+require 'incline/cli'
+
+class YamlContentsTest < ActiveSupport::TestCase
+
+  ALIGNED_YAML = <<-YAML
+default: &default
+  alpha:    # comment for alpha
+  bravo:    # comment for bravo
+one:     &one
+  charlie:  # comment for charlie
+    item_1: :simple                                            # Level 3 remains aligned in all sections.
+two:     &two
+  delta:
+    item_1: "This is a \\"string\\" with a '#' character in it." # A nice long string on level 3.
+    item_2: true                                               # Just true.
+                                                               # This comment is aligned with the comment above.
+three:   &three
+  echo:
+    item_1: <%= Rails.application.secrets["db"]["password"] %> # Ironically, the same length as the string above.
+  YAML
+
+  TOP_OF_FILE = "# Top of file.\n"
+
+  SIMPLE_ADD_KEY_RESULT = <<-YAML.strip
+# Top of file.
+
+default:
+  one:
+    alpha: true
+  YAML
+
+  SIMPLE_REPLACE_RESULT = <<-YAML.strip
+# Top of file.
+
+default:
+  one:
+    alpha: false
+  YAML
+
+  MULTIPLE_ADD_RESULT = <<-YAML.strip
+# Top of file.
+
+one:
+  alpha: 1
+  delta: 4
+
+two:
+  bravo: 2
+  echo: 5
+
+three:
+  charlie: 3
+  foxtrot: 6
+  YAML
+
+  test 'does not modify unnecessarily on realign' do
+    contents = Incline::CliHelpers::Yaml::YamlContents.new(ALIGNED_YAML)
+    contents.realign!
+    assert_equal ALIGNED_YAML, contents.to_s
+  end
+
+  test 'should insert as appropriate' do
+    contents = Incline::CliHelpers::Yaml::YamlContents.new(TOP_OF_FILE)
+    contents.add_key %w(default one alpha), true
+    assert_equal SIMPLE_ADD_KEY_RESULT, contents.to_s.strip
+  end
+
+  test 'should replace as appropriate' do
+    contents = Incline::CliHelpers::Yaml::YamlContents.new(SIMPLE_ADD_KEY_RESULT)
+    contents.set_key %w(default one alpha), false
+    assert_equal SIMPLE_REPLACE_RESULT, contents.to_s.strip
+  end
+
+  test 'multiple add works as expected' do
+    contents = Incline::CliHelpers::Yaml::YamlContents.new(TOP_OF_FILE)
+
+    contents.add_key %w(one alpha), 1
+    contents.add_key %w(two bravo), 2
+    contents.add_key %w(three charlie), 3
+    contents.add_key %w(one delta), 4
+    contents.add_key %w(two echo), 5
+    contents.add_key %w(three foxtrot), 6
+
+    assert_equal MULTIPLE_ADD_RESULT, contents.to_s.strip
+  end
+
+end

data/test/controllers/incline/welcome_controller_test.rb

@@ -1,13 +1,13 @@
 require 'test_helper'
 
 class WelcomeControllerTest < ActionDispatch::IntegrationTest
-
+  
+  # 2017-08-03: root path should be changeable by actual app. remove jumbotron check and instead do some link checks that should always be present.
   test 'should get root_path' do
     get root_path
     assert_response :success
     assert_select 'title', full_title
-    assert_select 'div.jumbotron'
-    assert_select 'a[href=?]', root_path, count: 2
+    assert_select 'a[href=?]', main_app.root_path, count: 2
     assert_select 'a[href=?]', incline.login_path, count: 1
     assert_select 'a[href=?]', incline.contact_path, count: 1
   end

data/test/dummy/app/controllers/dummy_controller.rb

@@ -0,0 +1,10 @@
+
+class DummyController < ApplicationController
+  
+  allow_anon true
+  
+  def hello
+    
+  end
+  
+end

data/test/dummy/app/views/dummy/hello.html.erb

@@ -0,0 +1 @@
+<h1>Congrats, this is the DUMMY root.</h1>

data/test/dummy/config/routes.rb

@@ -2,5 +2,7 @@ Rails.application.routes.draw do
 
   mount Incline::Engine => "/incline"
 
-  root 'incline/welcome#home'
+  # need to ensure that custom root paths work.
+  root 'dummy#hello'
+  # root 'incline/welcome#home'
 end

data/test/integration/incline/users_signup_test.rb

@@ -131,12 +131,12 @@ module Incline
       assert_not is_logged_in?
 
       # invalid activation token
-      get incline.edit_account_activation_url('invalid-token', email: user.email)
+      get incline.edit_account_activation_path('invalid-token', email: user.email)
       assert_not is_logged_in?
       assert_not user.reload.activated?
 
       # valid activation token
-      get incline.edit_account_activation_url(token, email: user.email)
+      get incline.edit_account_activation_path(token, email: user.email)
       assert user.reload.activated?
       follow_redirect!
       assert_template 'incline/users/show'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: incline
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Beau Barker
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-17 00:00:00.000000000 Z
+date: 2017-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -378,6 +378,7 @@ files:
 - db/migrate/20170622195742_add_non_standard_to_action_security.rb
 - db/migrate/20170622230422_add_visible_to_action_security.rb
 - db/seeds.rb
+- exe/incline
 - exe/new_incline_app
 - lib/generators/incline/install_generator.rb
 - lib/generators/incline/templates/_app_menu_anon.html.erb
@@ -393,6 +394,11 @@ files:
 - lib/generators/incline/templates/incline_version.rb
 - lib/incline.rb
 - lib/incline/auth_engine_base.rb
+- lib/incline/cli.rb
+- lib/incline/cli/errors.rb
+- lib/incline/cli/helpers/yaml.rb
+- lib/incline/cli/usage.rb
+- lib/incline/cli/version.rb
 - lib/incline/data_tables_request.rb
 - lib/incline/date_time_formats.rb
 - lib/incline/engine.rb
@@ -446,6 +452,7 @@ files:
 - lib/templates/jbuilder/scaffold/index.json.jbuilder
 - lib/templates/jbuilder/scaffold/show.json.jbuilder
 - lib/templates/rails/scaffold_controller/controller.rb
+- test/cli/yaml_contents_test.rb
 - test/controllers/incline/access_groups_controller_test.rb
 - test/controllers/incline/access_test_controller_test.rb
 - test/controllers/incline/contact_controller_test.rb
@@ -458,10 +465,12 @@ files:
 - test/dummy/app/assets/stylesheets/application.css
 - test/dummy/app/controllers/application_controller.rb
 - test/dummy/app/controllers/concerns/.keep
+- test/dummy/app/controllers/dummy_controller.rb
 - test/dummy/app/helpers/application_helper.rb
 - test/dummy/app/mailers/.keep
 - test/dummy/app/models/.keep
 - test/dummy/app/models/concerns/.keep
+- test/dummy/app/views/dummy/hello.html.erb
 - test/dummy/app/views/layouts/application.html.erb
 - test/dummy/app/views/layouts/incline/_app_menu_anon.html.erb
 - test/dummy/app/views/layouts/incline/_app_menu_authenticated.html.erb