automation_object 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c36cc7abfa4e9979ce44a0944d93226186e95322
+  data.tar.gz: 3c7a3f82d088f77f7fc8decb354eeafa5694632d
+SHA512:
+  metadata.gz: c2ece489fe81158e7aa27736e461042c8577180215b24cc0f01d0820e46e163b74b3a594dfb8b886fcdcede3426d84ea15ea7660826934d09311b33f7ae8bc68
+  data.tar.gz: 3fbbfa38f5f69f88e21eac36987a9b83f030f769bf211412d97dad5501a3ce6e4e1d65f661fdf731c0242579736134c510fe22565df2830eb19bd7f6ebc5bfb3

data/lib/automation_object/blue_print.rb

@@ -0,0 +1,106 @@
+module AutomationObject
+  class BluePrint < Hash
+    #Static
+    @@max_folder_depth = 10
+    @@base_directory = nil
+    @@validate_blueprint = false
+
+    def self.max_folder_depth
+      @@max_folder_depth
+    end
+
+    def self.max_folder_depth=(value)
+      @@max_folder_depth = value
+    end
+
+    def self.base_directory
+      @@base_directory
+    end
+
+    def self.base_directory=(value)
+      @@base_directory = value
+    end
+
+    def self.validate_blueprint
+      @@validate_blueprint
+    end
+
+    def self.validate_blueprint=(value)
+      @@validate_blueprint = value
+    end
+
+    #Instance
+    def initialize(path)
+      full_path = path
+      full_path = File.join(@@base_directory, path) if @@base_directory
+
+      unless File.directory?(full_path)
+        raise ArgumentError, "Blue prints directory doesn't exist: #{full_path}"
+      end
+
+      @configuration = Hash.new
+      self.merge_directory(full_path)
+
+      if @@validate_blueprint
+        BluePrintValidation::ValidationObject.new(self)
+      end
+
+      self.merge_views
+    end
+
+    def merge_directory(path, depth = 0)
+      raise ArgumentError, "Folder depth breached max depth of #{@@max_folder_depth}" if depth > @@max_folder_depth
+
+      unless File.directory?(path)
+        raise ArgumentError, "Blue print path doesn't exist: #{path}"
+      end
+
+      Dir.foreach(path) do |item|
+        next if item == '.' or item == '..'
+        next if item[0] == '.'
+
+        file_path = File.join(path, "#{item}")
+        if File.directory?(file_path)
+          depth = depth + 1
+          self.merge_directory("#{path}/#{item}", depth) #call this method again for the subdirectory
+          next
+        end
+
+        next unless self.is_yaml_file?(file_path)
+
+        file_configuration = YAML.load_file(file_path)
+        @configuration = @configuration.deep_merge(file_configuration) if file_configuration.class == Hash
+      end
+
+      @configuration.each { |key, value|
+        self[key] = value
+      }
+    end
+
+    def is_yaml_file?(file_path)
+      return (file_path.match(/\.ya?ml$/)) ? true : false
+    end
+
+    def merge_views
+      return unless self['screens'].is_a?(Hash)
+      return unless self['views'].is_a?(Hash)
+
+      self['screens'].each { |screen_name, screen_configuration|
+        next unless screen_configuration.is_a?(Hash)
+        next unless screen_configuration['included_views'].is_a?(Array)
+
+        screen_configuration['elements'] = Hash.new unless screen_configuration['elements'].class == Hash
+
+        screen_configuration['included_views'].each { |view|
+          next unless self['views'][view].is_a?(Hash)
+          self['views'][view]['elements'] = Hash.new unless self['views'][view]['elements'].is_a?(Hash)
+          screen_configuration = screen_configuration.deep_merge(self['views'][view])
+        }
+
+        self['screens'][screen_name] = screen_configuration
+      }
+
+      self.delete('views')
+    end
+  end
+end

data/lib/automation_object/blue_print_validation/base_validation.rb

@@ -0,0 +1,44 @@
+module AutomationObject
+  module BluePrintValidation
+    module BaseValidation
+      def validate_base
+        error_messages = Array.new
+
+        self.each { |base_key, base_value|
+          #Check if valid base keys
+          unless KeyValueConstants::BASE_PAIR_TYPES.keys.include?(base_key)
+            error_message = "Base level key (#{base_key}) is not a valid key, available base level keys ("
+            error_message << KeyValueConstants::BASE_PAIR_TYPES.keys.join(', ').to_s + ')'
+            error_messages.push(FormattedErrors::format_message(error_message))
+
+            next #skip if not a valid key since we are not going to check value
+          end
+
+          #Skip checking if nil, being nice
+          next if base_value == nil
+
+          unless base_value.is_a?(KeyValueConstants::BASE_PAIR_TYPES[base_key])
+            error_message = "Base level key (#{base_key}) has an invalid value type, expecting: ("
+            error_message << KeyValueConstants::BASE_PAIR_TYPES[base_key].to_s
+            error_message << "), got: (#{base_value.class.to_s})"
+            error_messages.push(FormattedErrors::format_message(error_message))
+
+            next #Skip any additional validation on this
+          end
+
+          case base_key
+            when 'default_screen'
+              unless self.screen_exists?(self[base_key])
+                error_message = "(#{base_key}) value has screen that does not exist (#{self[base_key]}), available screens ("
+                error_message << self.get_screens.join(', ').to_s
+                error_message << ')'
+                error_messages.push(FormattedErrors::format_message(error_message))
+              end
+          end
+        }
+
+        return error_messages
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print_validation/common_methods.rb

@@ -0,0 +1,106 @@
+module AutomationObject
+  module BluePrintValidation
+    module CommonMethods
+      def get_screens
+        screens = Array.new
+        return screens unless self.has_key?('screens')
+        return screens unless self['screens'].class == Hash
+
+        screens = self['screens'].keys
+        return screens
+      end
+
+      def screen_exists?(screen_name)
+        return self.get_screens.include?(screen_name)
+      end
+
+      def view_has_modal?(view_name, modal_name)
+        return false unless self.view_exists?(view_name)
+
+        view_configuration = self['views'][view_name]
+        return self.get_modals(view_configuration).include?(modal_name)
+      end
+
+      def get_view_modals(view_name)
+        modals = Array.new
+        return modals unless self.has_key?('views')
+        return modals unless self['views'].class == Hash
+        return modals unless self['views'].has_key?(view_name)
+
+        view_configuration = self['views'][view_name]
+        return self.get_modals(view_configuration)
+      end
+
+      def screen_has_modal?(screen_name, modal_name)
+        return false unless self.screen_exists?(screen_name)
+
+        screen_configuration = self['screens'][screen_name]
+        return self.get_modals(screen_configuration).include?(modal_name)
+      end
+
+      def get_screen_modals(screen_name)
+        modals = Array.new
+        return modals unless self.has_key?('screens')
+        return modals unless self['screens'].class == Hash
+        return modals unless self['screens'].has_key?(screen_name)
+
+        screen_configuration = self['screens'][screen_name]
+        return self.get_modals(screen_configuration)
+      end
+
+      def get_modals(configuration)
+        modals = Array.new
+
+        return modals unless configuration.class == Hash
+        return modals unless configuration.has_key?('modals')
+        return modals unless configuration['modals'].class == Hash
+
+        modals = configuration['modals'].keys
+        return modals
+      end
+
+      def screen_has_live?(screen_name)
+        return false unless self.screen_exists?(screen_name)
+
+        screen_configuration = self['screens'][screen_name]
+        return false unless screen_configuration.class == Hash
+
+        if screen_configuration.has_key?('live?')
+          return true if screen_configuration['live?'].class == Hash
+          return false
+        end
+
+        #Check if has views
+        return false unless screen_configuration.has_key?('included_views')
+        return false unless screen_configuration['included_views'].class == Array
+
+        #No need to check if views doesn't exit
+        return false unless self.has_key?('views')
+        return false unless self['views'].class == Hash
+
+        screen_configuration['included_views'].each { |included_view|
+          return false unless self['views'].has_key?(included_view)
+          return false unless self['views'][included_view].class == Hash
+
+          view_configuration = self['views'][included_view]
+          return true if view_configuration.has_key?('live?') and view_configuration['live?'].class == Hash
+        }
+
+        return false
+      end
+
+      def view_exists?(view_name)
+        return self.get_views.include?(view_name)
+      end
+
+      def get_views
+        views = Array.new
+        return views unless self.has_key?('views')
+        return views unless self['views'].class == Hash
+
+        views = self['views'].keys
+        return views
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print_validation/element_validation.rb

@@ -0,0 +1,198 @@
+module AutomationObject
+  module BluePrintValidation
+    module ElementValidation
+      def validate_elements
+        error_messages = Array.new
+
+        elements = self.get_elements
+
+        elements.each { |element|
+          #Set level string and get it out of the way
+          level_key_string = ''
+          if element[:view_name]
+            level_key_string = "(views/#{element[:view_name]}/elements)"
+          elsif element[:modal_name]
+            level_key_string = "(screens/#{element[:screen_name]}/modals/#{element[:modal_name]}/elements)"
+          else
+            level_key_string = "(screens/#{element[:screen_name]}/elements)"
+          end
+
+          unless element[:element_name].is_a?(String)
+            error_message = "#{level_key_string} level key (#{element[:element_name]}) is an invalid key type, expecting: ("
+            error_message << String.to_s
+            error_message << "), got: (#{element[:element_name].class.to_s})"
+            error_messages.push(FormattedErrors::format_message(error_message))
+          end
+
+          #Skip checking if nil, being nice
+          next if element[:configuration] == nil
+
+          unless element[:configuration].is_a?(Hash)
+            error_message = "#{level_key_string} level key (#{element[:element_name]}) is an invalid value type, expecting: ("
+            error_message << Hash.to_s
+            error_message << "), got: (#{element[:configuration].class.to_s})"
+            error_messages.push(FormattedErrors::format_message(error_message))
+
+            next #Skip any additional validation on this
+          end
+
+          element[:configuration].each { |sub_element_key, sub_element_value|
+            #Check if valid element keys
+            unless KeyValueConstants::ELEMENT_PAIR_TYPES.keys.include?(sub_element_key)
+              error_message = "#{level_key_string} level key (#{element[:element_name]}) sub key (#{sub_element_key}) "
+              error_message << 'is not a valid key, available (elements) sub level keys ('
+              error_message << KeyValueConstants::ELEMENT_PAIR_TYPES.keys.join(', ').to_s + ')'
+              error_messages.push(FormattedErrors::format_message(error_message))
+
+              next #skip if not a valid key since we are not going to check value
+            end
+
+            #Skip checking if nil, being nice
+            next if sub_element_value == nil
+
+            #Check sub element value
+            unless sub_element_value.is_a?(KeyValueConstants::ELEMENT_PAIR_TYPES[sub_element_key])
+              error_message = "#{level_key_string} level key (#{element[:element_name]}) sub key (#{sub_element_key}) "
+              error_message << 'has an invalid value type, expected: ('
+              error_message << KeyValueConstants::SCREEN_PAIR_TYPES[sub_element_key].to_s
+              error_message << "), got: (#{sub_element_value.class.to_s})"
+              error_messages.push(FormattedErrors::format_message(error_message))
+
+              next #Skip any additional validation on this
+            end
+
+            case sub_element_key
+              when 'define_elements_by'
+                valid_element_methods = KeyValueConstants::ELEMENT_KEYS + self.get_element_custom_methods(element[:configuration])
+
+                unless valid_element_methods.include?(sub_element_value)
+                  error_message = "#{level_key_string} level key (#{element[:element_name]}) sub key (#{sub_element_key}) "
+                  error_message << 'is not a valid element methods key. Available keys ('
+                  error_message << valid_element_methods.join(', ')
+                  error_message << ')'
+                  error_messages.push(FormattedErrors::format_message(error_message))
+                end
+              when 'custom_methods'
+                sub_element_value.each { |custom_method_name, custom_method_configuration|
+                  unless custom_method_name.is_a?(String)
+                    error_message = "#{level_key_string} level key (#{element[:element_name]}) custom_methods sub key (#{custom_method_name}) "
+                    error_message << 'is not a valid key type, expected: ('
+                    error_message << String.to_s
+                    error_message << "), got: (#{custom_method_name.class.to_s})"
+                    error_messages.push(FormattedErrors::format_message(error_message))
+                  end
+
+                  unless custom_method_configuration.is_a?(Hash)
+                    error_message = "#{level_key_string} level key (#{element[:element_name]}) custom_methods sub key (#{custom_method_name}) "
+                    error_message << 'is not a valid key value type, expected: ('
+                    error_message << Hash.to_s
+                    error_message << "), got: (#{custom_method_configuration.class.to_s})"
+                    error_messages.push(FormattedErrors::format_message(error_message))
+
+                    next
+                  end
+
+                  custom_method_configuration.each { |custom_method_key, custom_method_value|
+                    unless KeyValueConstants::ELEMENT_CUSTOM_METHOD_PAIR_TYPES.keys.include?(custom_method_key)
+                      error_message = "#{level_key_string} level key (#{element[:element_name]}) custom_methods (#{custom_method_name}) method sub key (#{custom_method_key}) "
+                      error_message << 'is not a valid key, available (custom_methods) sub level keys ('
+                      error_message << KeyValueConstants::ELEMENT_CUSTOM_METHOD_PAIR_TYPES.keys.join(', ').to_s + ')'
+                      error_messages.push(FormattedErrors::format_message(error_message))
+
+                      next #skip if not a valid key since we are not going to check value
+                    end
+
+                    #Skip checking if nil, being nice
+                    next if custom_method_value == nil
+
+                    unless custom_method_value.is_a?(KeyValueConstants::ELEMENT_CUSTOM_METHOD_PAIR_TYPES[custom_method_key])
+                      error_message = "#{level_key_string} level key (#{element[:element_name]}) custom_methods (#{custom_method_name}) method sub key (#{custom_method_key}) "
+                      error_message << 'has an invalid value type, expected: ('
+                      error_message << KeyValueConstants::ELEMENT_CUSTOM_METHOD_PAIR_TYPES[custom_method_key].to_s
+                      error_message << "), got: (#{custom_method_value.class.to_s})"
+                      error_messages.push(FormattedErrors::format_message(error_message))
+
+                      next #Skip any additional validation on this
+                    end
+
+                    case custom_method_key
+                      when 'element_method'
+                        unless KeyValueConstants::ELEMENT_KEYS.include?(custom_method_value)
+                          error_message = "#{level_key_string} level key (#{element[:element_name]}) custom_methods (#{custom_method_name}) sub key (#{custom_method_key}) "
+                          error_message << 'is not a valid elements method. Available element methods ('
+                          error_message << KeyValueConstants::ELEMENT_KEYS.join(', ')
+                          error_messages.push(FormattedErrors::format_message(error_message))
+                        end
+                    end
+                  }
+                }
+            end
+          }
+        }
+
+        return error_messages
+      end
+
+      def get_element_custom_methods(configuration)
+        custom_methods = Array.new
+        return custom_methods unless configuration.class == Hash
+        return custom_methods unless configuration.has_key?('custom_methods')
+        return custom_methods unless configuration['custom_methods'].class == Hash
+
+        custom_methods = configuration['custom_methods'].keys
+        return custom_methods
+      end
+
+      def get_elements
+        elements = Array.new
+
+        if self.has_key?('views') and self['views'].class == Hash
+          self['views'].each { |view_name, view_configuration|
+            next unless view_configuration.class == Hash
+            next unless view_configuration.has_key?('elements')
+            next unless view_configuration['elements'].class == Hash
+
+            view_configuration['elements'].each { |view_element_name, view_element_configuration|
+              element = {:view_name => view_name, :element_name => view_element_name,
+                         :configuration => view_element_configuration}
+              elements.push(element)
+            }
+          }
+        end
+
+        if self.has_key?('screens') and self['screens'].class == Hash
+          self['screens'].each { |screen_name, screen_configuration|
+            next unless screen_configuration.class == Hash
+
+            if screen_configuration.has_key?('elements') and screen_configuration['elements'].class == Hash
+              screen_configuration['elements'].each { |screen_element_name, screen_element_configuration|
+                element = {:screen_name => screen_name, :element_name => screen_element_name,
+                           :configuration => screen_element_configuration}
+                elements.push(element)
+              }
+            end
+
+            #Get elements from modals
+            next unless screen_configuration.class == Hash
+            next unless screen_configuration.has_key?('modals')
+            next unless screen_configuration['modals'].class == Hash
+
+            screen_configuration['modals'].each { |modal_name, modal_configuration|
+              next unless modal_configuration.class == Hash
+              next unless modal_configuration.has_key?('elements')
+              next unless modal_configuration['elements'].class == Hash
+
+              modal_configuration['elements'].each { |modal_element_name, modal_element_configuration|
+                element = {:screen_name => screen_name, :modal_name => modal_name,
+                           :element_name => modal_element_name, :configuration => modal_element_configuration}
+                elements.push(element)
+              }
+            }
+          }
+        end
+
+        return elements
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print_validation/formatted_errors.rb

@@ -0,0 +1,41 @@
+module AutomationObject
+  module BluePrintValidation
+    class FormattedErrors
+      MESSAGE_COLOR = :red
+      SPECIFIC_VALUE_COLOR = :blue
+
+      def self.array_to_message(error_messages)
+        error_messages.each_with_index { |raw_message, index|
+          error_messages[index] = (((index+1).to_s + '. ').colorize(MESSAGE_COLOR) + raw_message)
+          error_messages[index] = "\n" + error_messages[index] if index == 0
+        }
+
+        formatted_message = error_messages.join("\n ----- \n")
+        formatted_message << "\n ----- \n"
+        return formatted_message
+      end
+
+      def self.format_message(error_message)
+        specific_values = error_message.scan(/\([^\)]+\)/)
+        replaced_string = error_message.gsub(/\([^\)]+\)/, '######')
+        message_array = replaced_string.split('######')
+
+        return error_message.colorize(MESSAGE_COLOR) if specific_values.length == 0
+
+        formatted_message = ''
+        message_array.each_with_index { |message, index|
+          formatted_message << message.colorize(MESSAGE_COLOR)
+
+          next if specific_values[index] == nil
+          stripped_specific_value = specific_values[index].gsub(/\(/, '').gsub(/\)/, '')
+          final_specific_value = '('.colorize(MESSAGE_COLOR)
+          final_specific_value << stripped_specific_value.colorize(SPECIFIC_VALUE_COLOR)
+          final_specific_value << ')'.colorize(MESSAGE_COLOR)
+          formatted_message << final_specific_value
+        }
+
+        return formatted_message
+      end
+    end
+  end
+end