cloud_powers 0.2.7.23 → 1.0.0

data/lib/cloud_powers/helpers.rb

@@ -0,0 +1,58 @@
+require 'logger'
+require 'syslog/logger'
+require 'cloud_powers/helpers/lang_help'
+require 'cloud_powers/helpers/logic_help'
+require 'cloud_powers/helpers/path_help'
+
+module Smash
+  module CloudPowers
+    module Helpers
+      # methods to help change convert between different cases, like the
+      # <tt>from_json</tt> and <tt>to_camel</tt> and other help with Ruby
+      include Smash::CloudPowers::LangHelp
+      # methods to help awareness, dynamic code and other such fun
+      include Smash::CloudPowers::LogicHelp
+      # methods to help find locations of files and directories.  This provides
+      # common locations for code to reference.
+      include Smash::CloudPowers::PathHelp
+
+      # creates a default logger
+      #
+      # Parameters
+      # * log_to +String+ (optional) - location to send logging information to; default is STDOUT
+      #
+      # Returns
+      # +Logger+
+      #
+      # Notes
+      # * TODO: at least make this have overridable defaults
+      def create_logger(log_to = STDOUT)
+        logger = Logger.new(log_to)
+        logger.datetime_format = '%Y-%m-%d %H:%M:%S'
+        logger
+      end
+
+      # Gets the path from the environment and sets @log_file using the path
+      #
+      # Returns
+      # @log_file +String+
+      #
+      # Notes
+      # * See +#zfind()+
+      def log_file
+        @log_file ||= zfind('LOG_FILE')
+      end
+
+      # Returns An instance of Logger, cached as @logger@log_file path <String>
+      #
+      # Returns
+      # +Logger+
+      #
+      # Notes
+      # * See +#create_logger+
+      def logger
+        @logger ||= create_logger
+      end
+    end
+  end
+end

data/lib/cloud_powers/helpers/lang_help.rb

@@ -0,0 +1,288 @@
+module Smash
+  module CloudPowers
+    module LangHelp
+
+      # Allows you to modify all keys, including nested, with a block that you pass.
+      # If no block is passed, a copy is returned.
+      #
+      # Parameters
+      # * params +Hash+|+Array+ - hash to be modified
+      # * +block+ (optional) - a block to be used to modify each key should
+      #   modify the key and return that value so it can be used in the copy
+      #
+      # Returns
+      # +Hash+|+Array+ - a copy of the given Array or Hash, with all Hash keys modified
+      #
+      # Example
+      #   hash = { 'foo' => 'v1', 'bar' => { fleep: { 'florp' => 'yo' } } }
+      #   modify_keys_with(hash) { |key| key.to_sym }
+      #   # => { foo: 'v1', bar: { fleep: { florp: 'yo' } } }
+      #
+      # Notes
+      #   * see `#modify_keys_with()` for handling first-level keys
+      #   * see `#pass_the_buck()` for the way nested structures are handled
+      #   * case for different types taken from _MultiXML_ (multi_xml.rb)
+      #   * TODO: look at optimization
+      def deep_modify_keys_with(params)
+        case params
+        when Hash
+          params.inject({}) do |carry, (k, v)|
+            carry.tap do |h|
+              if block_given?
+                key = yield k
+
+                value = if v.kind_of?(Hash)
+                    deep_modify_keys_with(v) { |new_key| Proc.new.call(new_key) }
+                  else
+                    v
+                  end
+
+                h[key] = value
+              else
+                h[k] = v
+              end
+            end
+          end
+        when Array
+          params.map{ |value| symbolize_keys(value) }
+        else
+          params
+        end
+      end
+
+      # Search through a +Hash+ without knowing if the key is a +String+ or
+      # +Symbol+.  A +String+ modification that _normalizes_ each value to compare
+      # is used that is case insensitive.  It only leaves word characters, not
+      # including underscore.  After the value is found, if it exists and can
+      # be found, the +Hash+, minus that value, is returns in an +Array+ with
+      # the element you were searching for
+      #
+      # Parameters
+      # * key +String+|+Symbol+ - the key you are searching for
+      # * hash +Hash+ - the +Hash+ to search through and return a modified copy
+      #   from
+      def find_and_remove(key, hash)
+        candidate_keys = hash.select do |k,v|
+          to_pascal(key).casecmp(to_pascal(k)) == 0
+        end.keys
+
+        interesting_value = hash.delete(candidate_keys.first)
+        [interesting_value, hash]
+      end
+
+      # Join the message and backtrace into a String with line breaks
+      #
+      # Parameters
+      # * error +Exception+
+      #
+      # Returns
+      # +String+
+      def format_error_message(error)
+        begin
+          [error.message, error.backtrace.join("\n")].join("\n")
+        rescue Exception
+          # if the formatting won't work, return the original exception
+          error
+        end
+      end
+
+      # Change valid JSON into a hash
+      #
+      # Parameter
+      # * var +String+
+      #
+      # Returns
+      # +Hash+ or +nil+ - +nil+ is returned if the JSON is invalid
+      def from_json(var)
+        begin
+          JSON.parse(var)
+        rescue JSON::ParserError, TypeError
+          nil
+        end
+      end
+
+      # Allows you to modify all first-level keys with a block that you pass.
+      # If no block is passed, a copy is returned.
+      #
+      # Parameters
+      # * params +Hash+|+Array+
+      # * block (optional) - should modify the key and return that value so it can be used in the copy
+      #
+      # Returns
+      # +Hash+|+Array+ - a copy of the given Array or Hash, with all Hash keys modified
+      #
+      # Example
+      #   hash = { 'foo' => 'v1', 'bar' => { fleep: { 'florp' => 'yo' } } }
+      #   modify_keys_with(hash) { |k| k.to_sym }
+      #   # => { :foo => 'v1', :bar => { fleep: { 'florp' => 'yo' } } }
+      #
+      # Notes
+      # * see +#deep_modify_keys_with()+ for handling nested keys
+      # * case for different types taken from _MultiXML_ (multi_xml.rb)
+      def modify_keys_with(params)
+        params.inject({}) do |carry, (k, v)|
+          carry.tap do |h|
+            key = block_given? ? (yield k) : k
+            h[key] = v
+          end
+        end
+      end
+
+      # Change strings into camelCase
+      #
+      # Parameters
+      # * var +String+
+      #
+      # Returns
+      # +String+
+      def to_camel(var)
+        var = var.to_s unless var.kind_of? String
+        step_one = to_snake(var)
+        step_two = to_pascal(step_one)
+        step_two[0, 1].downcase + step_two[1..-1]
+      end
+
+      # Change strings into a hyphen delimited phrase
+      #
+      # Parameters
+      # * var +String+
+      #
+      # Returns
+      # +String+
+      def to_hyph(var)
+        var = var.to_s unless var.kind_of? String
+
+        var.gsub(/:{2}|\//, '-').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          gsub(/\s+/, '-').
+          tr("_", "-").
+          gsub(/^\W/, '').
+          downcase
+      end
+
+      # Assure your arguments are a +Hash+
+      #
+      # Parameters
+      # * start_point +Object+ - Best to start with a +Hash+, then a 2-D Array,
+      #   then something +Enumerable+ that is at least Ordered
+      #
+      # Returns
+      # +Hash+
+      #
+      # Notes
+      # * If a +Hash+ is given, a copy is returned
+      # * If an +Array+ is given,
+      # * And if the +Array+ is a properly formatted, 2-D +Array+, <tt>to_h</tt>
+      #   is called
+      # * Else <tt>Hash[<default_key argument>, <the thing we're trying to turn into a hash>]</tt>
+      def to_basic_hash(start_point, default_key: 'key')
+        case start_point
+        when Hash
+          start_point
+        when Enumerable
+          two_dimensional_elements = start_point.select do |value|
+            value.respond_to? :each
+          end
+
+          if two_dimensional_elements.count - start_point.count
+            start_point.to_h
+          else
+            Hash[default_key, start_point]
+          end
+        else
+          Hash[default_key, start_point]
+        end
+      end
+
+      # Change strings into an i-var format
+      #
+      # Parameters
+      # * var +String+
+      #
+      # Returns
+      # +String+
+      def to_i_var(var)
+        var = var.to_s unless var.kind_of? String
+        /^\W*@\w+/ =~ var ? to_snake(var) : "@#{to_snake(var)}"
+      end
+
+      # Change strings into PascalCase
+      #
+      # Parameters
+      # * var +String+
+      #
+      # Returns
+      # +String+
+      def to_pascal(var)
+        var = var.to_s unless var.kind_of? String
+        var.gsub(/^(.{1})|\W.{1}|\_.{1}/) { |s| s.gsub(/[^a-z0-9]+/i, '').capitalize }
+      end
+
+      # Change strings into a ruby_file_name with extension
+      #
+      # Parameters
+      # * var +String+
+      #
+      # Returns
+      # +String+
+      #
+      # Notes
+      # * given_string.rb
+      # * includes ruby file extension
+      # * see #to_snake()
+      def to_ruby_file_name(name)
+        return name if /\w+\.rb$/ =~ name
+        "#{to_snake(name)}.rb"
+      end
+
+      # Change strings into PascalCase
+      #
+      # Parameters
+      # * var +String+
+      #
+      # Returns
+      # +String+
+      #
+      # Notes
+      # * given_string
+      # * will not have file extensions
+      # * see #to_ruby_file_name()
+      def to_snake(var)
+        var = var.to_s unless var.kind_of? String
+
+        var.gsub(/:{2}|\//, '_').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          gsub(/\s+/, '_').
+          tr("-", "_").
+          downcase
+      end
+
+      # Predicate method to check if a String is parsable, as JSON
+      #
+      # Parameters
+      # * json +String+
+      #
+      # Returns
+      # +Boolean+
+      #
+      # Notes
+      # * See <tt>from_json</tt>
+      def valid_json?(json)
+        !!from_json(json)
+      end
+
+      # Predicate method to check if a String is a valid URL
+      #
+      # Parameters
+      # * url +String+
+      #
+      # Returns
+      # +Boolean+
+      def valid_url?(url)
+        url =~ /\A#{URI::regexp}\z/
+      end
+    end
+  end
+end

data/lib/cloud_powers/helpers/logic_help.rb

@@ -0,0 +1,152 @@
+module Smash
+  module CloudPowers
+    module LogicHelp
+      # Sets an Array of instance variables, individually to a value that a
+      # user given block returns.
+      #
+      # Parameters
+      #
+      # * keys +Array+
+      # * * each object will be used as the name for the instance variable that
+      #     your block returns
+      # +block+ (optional)
+      #   * this block is called for each object in the Array and is used as the value
+      #   for the instance variable that is being named and created for each key
+      # Returns +Array+ - each object will either be the result of
+      # <tt>#instance_variable_set(key, value)</tt> => +value+
+      #     or instance_variable_get(key)
+      # Example
+      #   keys = ['foo', 'bar', 'yo']
+      #
+      #   attr_map!(keys) { |key| sleep 1; "#{key}:#{Time.now.to_i}" }
+      #   # => ['foo:1475434058', 'bar:1475434059', 'yo:1475434060']
+      #
+      #   puts @bar
+      #   # => 'bar:1475434059'
+      def attr_map(attributes)
+        attributes = [attributes, nil] unless attributes.respond_to? :map
+
+        attributes.inject(self) do |this, (attribute, before_value)|
+          first_place, second_place = yield attribute, before_value if block_given?
+
+          results = if second_place.nil?
+            [attribute, first_place]
+          else
+            [first_place, second_place]
+          end
+
+          this.instance_variable_set(to_i_var(results.first), results.last)
+          this
+        end
+      end
+
+      # Does its best job at guessing where this method was called from, in terms
+      # of where it is located on the file system.  It helps track down where a
+      # project root is etc.
+      #
+      # Returns
+      # +String+
+      #
+      # Notes
+      # * Uses +$0+ to figure out what the current file is
+      def called_from
+        File.expand_path(File.dirname($0))
+      end
+
+      # Create an <tt>attr_accessor</tt> feeling getter and setter for an instance
+      # variable.  The method doesn't create a getter or setter if it is already
+      # defined.
+      #
+      # Parameters
+      # * base_name +String+ - the name, without the '@' symbol
+      #     # ok
+      #     add_instance_attr_accessor('my_variable_name', my_value)
+      #     => <your_instance @my_variable_name=my_value, ...>
+      #     # not ok
+      #     add_instance_attr_accessor('@#!!)', my_value)
+      #     => <your_instance> <i>no new instance variable found</i>
+      # * value +Object+ - the actual instance variable that matches the +base_name+
+      #
+      # Returns
+      # * the value of the instance variable that matches the +base_name+ (first) argument
+      #
+      # Notes
+      # * if a matching getter or setter method can be found, this method won't
+      #   stomp on it.  nothing happens, in that case
+      # * if an appropriately named instance variable can't be found, the getter
+      #   method will return nil until you set it again.
+      # * <b>it is the responsibility of you and me to make sure our variable names
+      #   are valid, i.e. proper Ruby instance variable names
+      def instance_attr_accessor(base_name)
+        i_var_name = to_i_var(base_name)
+        getter_signature = to_snake(base_name)
+        setter_signature = "#{getter_signature}="
+
+        unless respond_to? getter_signature
+          define_singleton_method(getter_signature) do
+            instance_variable_get(i_var_name)
+          end
+        end
+
+        unless respond_to? setter_signature
+          define_singleton_method(setter_signature) do |argument|
+            instance_variable_set(i_var_name, argument)
+          end
+        end
+      end
+
+      # Lets you retry a piece of logic with 1 second sleep in between attempts
+      # until another bit of logic does what it's supposed to, kind of like
+      # continuing to poll something and doing something when a package is ready
+      # to be taken and processed.
+      #
+      # Parameters
+      # * allowed_attempts +Number+|+Infinity(default)+ - The number of times
+      #   the loop should be allowed to...well, loop, before a failed retry occurs.
+      # * &test +Block+ - A predicate method or block of code that is callable
+      #   is used to test if the block being retried is successful yet.
+      # * []
+      #
+      # Example
+      #   check_stuff = lambda { |params| return true }
+      #   smart_retry(3, check_stuff(params)) { do_stuff_that_needs_to_be_checked }
+      def smart_retry(test, allowed_attempts = Float::INFINITY)
+        result = yield if block_given?
+        tries = 1
+        until test.call(result) || tries >= allowed_attempts
+          result = yield if block_given?
+          tries += 1
+          sleep 1
+        end
+      end
+
+      # This method provides a default overrideable message body for things like
+      # basic status updates.
+      #
+      # Parameters
+      # * instanceId +Hash+
+      #
+      # Notes
+      # * camel casing is used on the keys because most other languages prefer
+      #   that and it's not a huge problem in ruby.  Besides, there's some other
+      #   handy methods in this module to get you through those issues, like
+      #   +#to_snake()+ and or +#modify_keys_with()+
+      def update_message_body(opts = {})
+        # TODO: Better implementation of merging message bodies and config needed
+        unless opts.kind_of? Hash
+          update = opts.to_s
+          opts = {}
+          opts[:extraInfo] = { message: update }
+        end
+        updated_extra_info = opts.delete(:extraInfo) || {}
+
+        {
+          instanceId:       @instance_id || 'none-aquired',
+          type:             'status-update',
+          content:          'running',
+          extraInfo:        updated_extra_info
+        }.merge(opts)
+      end
+    end
+  end
+end