confinicky 0.1.6 → 0.2.0

data/lib/confinicky/controllers/commands.rb

@@ -0,0 +1,182 @@
+module Confinicky
+
+  module Controllers
+
+    ##
+    # The command group controller allows you to manipulate the
+    # contents of a specific grouping of commands in a nice OO
+    # way.
+    class Commands
+
+      ##
+      # The path to the file on disk representing the model.
+      attr_reader :path
+
+      def initialize(file_type_key: :env)
+        @path = Confinicky::ConfigurationFile.path_for_key(key: file_type_key)
+        @shell_file = Confinicky::ShellFile.new(file_path: path)
+        @commands = []
+        @table_tite = "Commands"
+      end
+
+      ##
+      # Matches a given string against the names of the group's contents.
+      #
+      # ==== Attributes
+      #
+      # * +query+ - The string used to match a given command name.
+      #
+      # ==== Examples
+      #
+      #   # Find the PATH environment variable.
+      #   Exports.new.find("PATH")
+      #   # => {name: "PATH", value: "/Users/name/bin/"}
+      def find(query: nil)
+        match = @commands.find{|command| command[0] =~ /^#{query}/ }
+        {name: match[0], value: match[1]} unless match.nil?
+      end
+
+      ##
+      # Detects duplicate definitions.
+      def duplicates
+        duplicates = {}
+        @commands.each do |command|
+          duplicates[command[0]] = (duplicates[command[0]].nil?) ? 1 : duplicates[command[0]]+1
+        end
+        duplicates.delete_if { |key,value| value==1}.sort_by{|key,value| value}.reverse
+      end
+
+      ##
+      # Finds duplicate export statements and reduces them to the
+      # most recent statement.
+      def clean!
+        for duplicate in duplicates.map{|duplicate| duplicate[0]}
+          last_value = @commands.find_all{|c| c[0] =~ /^#{duplicate}/ }.last
+          @commands.delete_if{ |c| c[0] == duplicate}
+          @commands << [duplicate, last_value]
+        end
+      end
+
+      ##
+      # Parses an assignment such as "MY_VAR=1234" and injects it into
+      # the exports or updates an existing variable if possible.
+      #
+      # ==== Attributes
+      #
+      # * +assignment+ - The value which will be assigned to the command.
+      #
+      # ==== Examples
+      #
+      #   # Create or update an environment variable called MY_VAR.
+      #   Exports.new.set("MY_VAR=A short phrase.")
+      #
+      #   # Create or update an environment variable called MY_VAR.
+      #   Aliases.new.set("home=cd ~")
+      def set!(assignment)
+        assignment = assignment.split("=")
+        return false if assignment.length < 2
+        remove! assignment[0]
+        assignment[1] = "\'#{assignment[1]}\'" if assignment[1] =~ /\s/
+        @commands << assignment
+      end
+
+      ##
+      # Removes an environment variable if it exists.
+      def remove!(variable_name)
+        @commands.delete_if { |i| i[0] == variable_name }
+      end
+
+      ##
+      # Updates the actual shell file on disk.
+      def save!
+        @shell_file.write!
+      end
+
+      ##
+      # Creates a copy of the associated shell file.
+      def backup!
+        @shell_file.backup!
+      end
+
+      ##
+      # The total number of commands managed by the controller.
+      def length
+        @commands.length
+      end
+
+      ##
+      # Creates a table representation of the command data.
+      def to_table
+        make_table(title: @table_title, rows: @commands)
+      end
+
+      ##
+      # Returns a table for the contents of a specific variable when split
+      # by a specified separating string.
+      #
+      # ==== Attributes
+      #
+      # * +name+ - The name of the variable, alias, etc., to inspect.
+      # * +separator+ - A string used to split the value. Defaults to a ':'.
+      #
+      # ==== Examples
+      #
+      #   # Create or update an environment variable called MY_VAR.
+      #   Exports.inspect("PATH")
+      #   # +--------+-----------------------------------------------------------+
+      #   # |                           Values in PATH                           |
+      #   # +--------+-----------------------------------------------------------+
+      #   # | index  | value                                                     |
+      #   # +--------+-----------------------------------------------------------+
+      #   # | 1      | /Users/name/.rvm/gems/ruby-2.1.2/bin                      |
+      #   # | 2      | /Users/name/.rvm/gems/ruby-2.1.2@global/bin               |
+      #   # | 3      | /Users/name/.rvm/rubies/ruby-2.1.2/bin                    |
+      #   # +--------+-----------------------------------------------------------+
+      def inspect(name: nil, separator:":")
+        return nil if (match = find(query: name)).nil?
+        count = 0
+        rows = match[:value].split(separator).map{|partition| [count+=1, partition]}
+        make_table(title: "Values in #{name}", rows: rows, headings: ['index', 'value'])
+      end
+
+      private
+
+        ##
+        # Returns a terminal table with a specified title and contents.
+        #
+        # ==== Attributes
+        #
+        # * +title+ - A string to be printed out as the title.
+        # * +rows+ - An array of sub arrays +[[name, value],[name, value],...]+
+        # * +headings+ - An array of strings for heading titles +['Name', 'Value']+
+        #
+        # ==== Examples
+        #
+        #   # Create or update an environment variable called MY_VAR.
+        #   Exports.inspect("PATH")
+        #   # +--------+-----------------------------------------------------------+
+        #   # |                           [title]                                  |
+        #   # +--------+-----------------------------------------------------------+
+        #   # | Name   | Value                                                     |
+        #   # +--------+-----------------------------------------------------------+
+        #   # | PATH   | '/Users/name/.rvm/gems/ruby-2.1.2/bin:/Users/name/.rvm... |
+        #   # | FOO    | 3000                                                      |
+        #   # | BAR    | 'some other value'                                        |
+        #   # +--------+-----------------------------------------------------------+
+        def make_table(title: '', rows: [], headings: ['Name', 'Value'])
+          return nil if rows.length < 1
+          table = Terminal::Table.new(title: title, headings: headings) do |t|
+            for row in rows
+              if row[1].length > 100
+                t.add_row [row[0], row[1][0...100]+"..."]
+              else
+                t.add_row row
+              end
+            end
+          end
+          return table
+        end
+
+    end
+  end
+end

data/lib/confinicky/controllers/exports.rb

@@ -0,0 +1,35 @@
+module Confinicky
+  module Controllers
+
+    ##
+    # A subclass of the command group controller specifically
+    # for managing export statements.
+    class Exports < Commands
+
+      def initialize
+        super(file_type_key: :env)
+        @commands = @shell_file.exports
+        @table_title = "Environment Variables"
+      end
+
+      ##
+      # Updates the actual shell file on disk.
+      def save!
+        @shell_file.exports = @commands
+        @shell_file.write!
+      end
+
+      ##
+      # Finds duplicate export statements and replaces them with the actual
+      # value from the environment.
+      def clean!
+        for duplicate in duplicates.map{|duplicate| duplicate[0]}
+          @commands.delete_if{ |i| i[0] == duplicate}
+          @commands << [duplicate, ENV[duplicate]]
+        end
+      end
+
+    end
+
+  end
+end

data/lib/confinicky/parsers/command.rb

@@ -0,0 +1,98 @@
+module Confinicky
+
+  module Parsers
+
+    ##
+    # A simple class that parses a line of shell code to
+    # into a classified and attributed string.
+    class Command
+
+      EXPORT_COMMAND = 'export'
+      ALIAS_COMMAND = 'alias'
+
+      ##
+      # The name of the command.
+      attr_reader :name
+
+      ##
+      # The assigned value of the command.
+      attr_reader :value
+
+      ##
+      # Takes a line of code as a parameter and performs
+      # classification.
+      def initialize(line: nil)
+        @line = line
+        @current_command_type = EXPORT_COMMAND if export?
+        @current_command_type = ALIAS_COMMAND if alias?
+        process_attributes! unless line?
+      end
+
+      ##
+      # The command should be regarded as a general line of code that
+      # is of no interest if it doesn't match one of the supported
+      # command types.
+      def line?
+        !export? && !alias?
+      end
+
+      ##
+      # Returns true if the line of code matches an export command.
+      def export?
+        matches_command_type?(EXPORT_COMMAND) && has_expression?
+      end
+
+      ##
+      # Returns true if the line of code matches an alias command.
+      def alias?
+        matches_command_type?(ALIAS_COMMAND) && has_expression?
+      end
+
+      ##
+      # Returns an array containing the name / value pair for the command.
+      def values_array
+        [@name, @expression.value]
+      end
+
+      def open?
+        return false if line? || !has_expression?
+        @expression.open?
+      end
+
+      def closed?
+        !@expression.open?
+      end
+
+      def append(value)
+        @expression.append_value value
+      end
+
+      private
+
+        ##
+        # Returns true if the command matches the specified type.
+        def matches_command_type?(command_type)
+          raise "No command type was specified." if command_type.nil?
+          return !(@line =~ /\A#{command_type} /).nil?
+        end
+
+        ##
+        # Returns true if the command actually has an expression.
+        def has_expression?
+          return Confinicky::Parsers::Expression.new(statement: @line).valid?
+        end
+
+        ##
+        # Parses the commands name and assigned values into attributes.
+        def process_attributes!
+          if !@current_command_type.nil?
+            @expression = Confinicky::Parsers::Expression.new(statement: @line.gsub(/\A#{@current_command_type} /,""))
+            @name = @expression.name
+            @value = @expression.value
+          end
+        end
+
+    end
+
+  end
+end

data/lib/confinicky/parsers/expression.rb

@@ -0,0 +1,93 @@
+module Confinicky
+
+  module Parsers
+
+    ##
+    # A simple class that parses a basic assignment expression
+    class Expression
+
+      SINGLE_QUOTE_MATCHER = /'([^']+)'/
+      DOUBLE_QUOTE_MATCHER = /"([^"]+)"/
+
+      ##
+      # The name of the variable being assigned. (LHS)
+      attr_reader :name
+
+      ##
+      # Takes a line of code as a parameter and performs
+      # classification.
+      def initialize(statement: nil)
+        @statement = statement.split("=")
+        if valid?
+          @name = @statement[0]
+          @value = @statement[1]
+          @value.gsub!("\n","") unless open?
+        end
+      end
+
+      ##
+      # Ensures that the expression has an assigned value.
+      def valid?
+        @statement.length == 2 && !@statement[1].nil?
+      end
+
+      ##
+      # Determines whether or not both types of quotes are present.
+      def uses_both_quotes?
+        !(@value =~ /'/).nil? && !(@value =~ /"/).nil?
+      end
+
+      ##
+      # Determines if the expression is wrapped in double quotes.
+      def uses_double_quotes?
+        uses_both_quotes? && (@value =~ /'/) > (@value =~ /"/) || (@value =~ /"/) && (@value =~ /'/).nil?
+      end
+
+      ##
+      # Determines if the expression is wrapped in single quotes.
+      def uses_single_quotes?
+        !uses_double_quotes? && !(@value =~ /'/).nil?
+      end
+
+      ##
+      # Appends additional string content to the value stored in the
+      # parser.
+      def append_value(value)
+        @value += value
+      end
+
+      ##
+      # Determines if our statement is open ended. Meaning no closing quote
+      # for a provided opening quote.
+      def open?
+        !@value.nil? && (uses_double_quotes? || uses_single_quotes?) && extracted_value.nil?
+      end
+
+      ##
+      # The value which is being assigned to the variable in the expression (RHS)
+      def value
+        quote = uses_double_quotes? ? "\"" : "\'"
+        value = extracted_value
+        value =  "#{quote}#{value}#{quote}" if !value.nil? && value =~ /\s/ && value != "\n"
+        value
+      end
+
+      protected
+
+        ##
+        # Extracts the value from quotes if necessary. If the expression is
+        # has an opening quote without a corresponding closing quote the
+        # method will return nil.
+        def extracted_value
+          if uses_single_quotes? || uses_double_quotes?
+            matcher = uses_double_quotes? ? DOUBLE_QUOTE_MATCHER : SINGLE_QUOTE_MATCHER
+            matches = @value.scan(matcher)
+            return nil if matches.length < 1
+            return matches[0][0]
+          end
+          @value
+        end
+
+    end
+  end
+end

data/lib/confinicky/shell_file.rb

@@ -1,77 +1,54 @@
 require 'fileutils'
 
 module Confinicky
+
   ##
   # A model that loads and represents a shell file.
   class ShellFile
 
     ##
-    # The preserved lines of code from the shell file which confinicky
-    # will write back to the new shell file in the order they were received.
-    attr_reader :lines
+    # The alias commands stored in the shell file.
+    attr_accessor :aliases
 
-    attr_reader :exports
     ##
-    # References the actual file path from the shell configuration.
-    def self.file_path
-      ENV[Confinicky::FILE_PATH_VAR]
-    end
+    # A list of all exports in the shell file.
+    attr_accessor :exports
 
     ##
-    # Returns true if the file path has been configured in the environment.
-    def self.has_path?
-      self.file_path.nil?
-    end
-
-    ##
-    # Returns true if the file actually exists.
-    def self.exists?
-      File.exists? ENV[Confinicky::FILE_PATH_VAR]
-    end
+    # The preserved lines of code from the shell file which confinicky
+    # will write back to the new shell file in the order they were received.
+    attr_reader :lines
 
     ##
-    # Copies the current shell file to a temporary location.
-    def self.backup!
-      backup_name = Confinicky::ShellFile.file_path+Time.now.getutc.to_i.to_s+".bak.tmp"
-      FileUtils.cp(Confinicky::ShellFile.file_path, backup_name)
-      backup_name
-    end
+    # Returns the file path for the current instance of the shell file class.
+    attr_reader :file_path
 
     ##
     # Parses the configuration file if it exists.
-    def initialize(file_path: Confinicky::ShellFile.file_path)
+    def initialize(file_path: "")
       raise "Config file not found. Please set" if !File.exists?(@file_path = file_path)
       @exports = []
+      @aliases = []
       @lines = []
 
       file = File.new(@file_path, "r")
+      command = nil
 
       while (line = file.gets)
-        if line =~ /\Aexport /
-          export = line.gsub(/\Aexport /,"").split("=")
-          if export[1].nil?
-            @lines << line
-          else
-            @exports << [export[0], export[1].gsub(/\n/, "")]
-          end
+        if !command.nil? && command.open?
+          command.append line
         else
-          @lines << line
+          command = Confinicky::Parsers::Command.new(line: line)
         end
+
+        @lines << line if command.line?
+        @exports << command.values_array if command.export? and command.closed?
+        @aliases << command.values_array if command.alias? and command.closed?
       end
 
       file.close()
     end
 
-    ##
-    # Detects duplicate definitions.
-    def find_duplicates
-      duplicates = {}
-      @exports.each do |export|
-        duplicates[export[0]] = (duplicates[export[0]].nil?) ? 1 : duplicates[export[0]]+1
-      end
-      duplicates.delete_if { |key,value| value==1}.sort_by{|key,value| value}.reverse
-    end
-
     ##
     # Returns a list of all exports in alphanumeric order.
     def exports
@@ -79,31 +56,11 @@ module Confinicky
     end
 
     ##
-    # Finds duplicate export statements and replaces them with the actual
-    # value from the environment.
-    def clean!
-      for duplicate in find_duplicates.map{|duplicate| duplicate[0]}
-        @exports.delete_if{ |i| i[0] == duplicate}
-        @exports << [duplicate, ENV[duplicate]]
-      end
-      write!
-    end
-
-    ##
-    # Parses an assignment such as "MY_VAR=1234" and injects it into
-    # the exports or updates an existing variable if possible.
-    def set!(assignment)
-      assignment = assignment.split("=")
-      return false if assignment.length < 2
-      remove! assignment[0]
-      assignment[1] = "\'#{assignment[1]}\'" if assignment[1] =~ /\s/
-      @exports << assignment
-    end
-
-    ##
-    # Removes an environment variable if it exists.
-    def remove!(variable_name)
-      @exports.delete_if { |i| i[0] == variable_name }
+    # Copies the current shell file to a temporary location.
+    def backup!
+      backup_name = @file_path+Time.now.getutc.to_i.to_s+".bak.tmp"
+      FileUtils.cp(@file_path, backup_name)
+      backup_name
     end
 
     ##
@@ -113,14 +70,10 @@ module Confinicky
         for line in @lines
           f.write line
         end
-        f.puts @exports.map{|e| "export #{e.join("=")}"}.join("\n")
+        f.puts @exports.map{|e| "export #{e.join("=")}"}.join("\n") if !@exports.nil? and @exports.length > 0
+        f.puts @aliases.map{|a| "alias #{a.join("=")}"}.join("\n") if !@aliases.nil? and @aliases.length > 0
       end
-    end
-
-    ##
-    # Returns the file path for the current instance of the shell file class.
-    def file_path
-      @file_path
+      true
     end
 
   end

data/lib/confinicky/version.rb

@@ -4,8 +4,8 @@ module Confinicky
   # users of the gem can query it at run time.
   module Version
     MAJOR = 0
-    MINOR = 1
-    PATCH = 6
+    MINOR = 2
+    PATCH = 0
     BUILD = ''
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')

data/lib/confinicky.rb

@@ -1,3 +1,9 @@
 require 'confinicky/version'
 require 'confinicky/config'
-require 'confinicky/shell_file'
+require 'confinicky/configuration_file'
+require 'confinicky/shell_file'
+require 'confinicky/parsers/command'
+require 'confinicky/parsers/expression'
+require 'confinicky/controllers/commands'
+require 'confinicky/controllers/exports'
+require 'confinicky/controllers/aliases'

data/test/test_command_parser.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+class TestCommandParser < MiniTest::Test
+
+  def setup
+    @line = 'HOST="http://www.example.com"'
+    @alias = 'alias ..=\'cd ../\''
+    @export = 'export TEST=1234'
+    @no_expression = 'export DISPLAY'
+  end
+
+  def test_should_recognize_a_general_line
+    assert_equal true, Confinicky::Parsers::Command.new(line: @line).line?
+  end
+
+  def test_should_recognize_an_export
+    assert_equal true, Confinicky::Parsers::Command.new(line: @export).export?
+  end
+
+  def test_should_recognize_an_alias
+    assert_equal true, Confinicky::Parsers::Command.new(line: @alias).alias?
+  end
+
+  def test_should_not_report_a_line_as_an_export
+    assert_equal false, Confinicky::Parsers::Command.new(line: @line).export?
+  end
+
+  def test_should_not_report_a_line_as_an_alias
+    assert_equal false, Confinicky::Parsers::Command.new(line: @line).alias?
+  end
+
+  def test_should_not_report_an_export_as_a_line
+    assert_equal false, Confinicky::Parsers::Command.new(line: @export).line?
+  end
+
+  def test_should_not_report_an_alias_as_a_line
+    assert_equal false, Confinicky::Parsers::Command.new(line: @alias).line?
+  end
+
+  def test_should_recognize_any_line_without_an_expression_as_a_line
+    assert_equal true, Confinicky::Parsers::Command.new(line: @no_expression).line?
+  end
+
+end

data/test/test_controllers.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+require 'helper'
+
+class TestCommandGroups < MiniTest::Test
+
+  def setup
+    Confinicky::ConfigurationFile.force_config!({
+      files: {
+        aliases: "test/sample_bash_file.sh",
+        env: "test/sample_bash_file.sh"
+      }
+    })
+    @aliases = Confinicky::Controllers::Aliases.new
+    @exports = Confinicky::Controllers::Exports.new
+    @less='\'-i -N -w  -z-4 -g -e -M -X -F -R -P%t?f%f \
+:stdin .?pb%pb\%:?lbLine %lb:?bbByte %bb:-...\''
+  end
+
+  def test_clean_file
+    @exports.clean!
+    assert_equal 17, @exports.length
+  end
+
+  def test_shell_file_duplicates
+    assert_equal 1, @exports.duplicates.length
+  end
+
+  def test_add_var
+    @exports.set!("NEW_VAR=12345")
+    assert_equal 19, @exports.length
+  end
+
+  def test_add_alias
+    @aliases.set!("home=cd ~")
+    assert_equal 33, @aliases.length
+  end
+
+  def test_remove_var
+    @exports.remove!("PATH")
+    assert_equal 16, @exports.length
+  end
+
+  def test_remove_alias
+    @aliases.remove!("debug")
+    assert_equal 31, @aliases.length
+  end
+
+  def test_add_var_should_not_duplicate
+    @exports.set!("NEW_VAR=12345")
+    @exports.set!("NEW_VAR=123456")
+    assert_equal 19, @exports.length
+  end
+
+  def test_whitespace
+    @exports.set!("NEW_STRING=A String")
+    assert_equal "\'A String\'", @exports.find(query: "NEW_STRING")[:value]
+  end
+
+  def test_multiline_statements
+    assert_equal false, @exports.find(query: "LESS")[:value].nil?
+    assert_equal @less, @exports.find(query: "LESS")[:value]
+  end
+
+end