barkest_core 1.5.3.0

data/lib/barkest_core/extensions/application_configuration_extensions.rb

@@ -0,0 +1,38 @@
+# :enddoc:
+
+# alter the configuration class slightly.
+Rails::Application::Configuration.class_eval do
+
+  # redefine the 'database_configuration' method to provide defaults for test & development.
+  alias :barkest_core_original_database_configuration :database_configuration
+
+  def database_configuration
+    begin
+      barkest_core_original_database_configuration
+    rescue => e
+      # unless we are simply missing the 'database.yml' file, re-raise the error.
+      # Also raise the error if we are not in test or development.  The file
+      # really should be supplied for production.
+      raise e unless e.inspect.include?('No such file -') && (Rails.env.test? || Rails.env.development?)
+
+      default =
+      {
+          'adapter' => 'sqlite3',
+          'pool' => 5,
+          'timeout' => 5000
+      }
+
+      Rails.logger.warn "Providing default database configuration for #{Rails.env} environment." unless Rails.logger.nil?
+      puts "\nWARNING: Default database connection in use.\n" if Rails.env.test? || Rails.logger.nil?
+
+      # only provide defaults for development and test.
+      {
+          'test' => default.merge(database: 'db/test.sqlite3'),
+          'development' => default.merge(database: 'db/development.sqlite3')
+      }
+    end
+  end
+
+
+
+end

data/lib/barkest_core/extensions/application_extensions.rb

@@ -0,0 +1,50 @@
+# a minor extension for the application class.
+Rails::Application.class_eval do
+
+  ##
+  # Is the rails server running?
+  def running?
+    path = File.join(Rails.root, 'tmp/pids/server.pid')
+    pid = File.exist?(path) ? File.read(path).to_i : -1
+    server_running = true
+    begin
+      Process.getpgid pid
+    rescue Errno::ESRCH
+      server_running = false
+    end
+    server_running
+  end
+
+  ##
+  # Gets the application name.
+  #
+  # This should be overridden in your +application.rb+ file.
+  def app_name
+    'BarkerEST'
+  end
+
+  ##
+  # Gets the application version.
+  #
+  # This should be overridden in your +application.rb+ file.
+  def app_version
+    '0.0.1'
+  end
+
+  ##
+  # Gets the company responsible for the application.
+  #
+  # This should be overridden in your +application.rb+ file.
+  def app_company
+    'BarkerEST'
+  end
+
+  ##
+  # Gets the application name and version.
+  #
+  # This can be overridden in your +application.rb+ file if you want a different behavior.
+  def app_info
+    "#{app_name} v#{app_version}"
+  end
+
+end

data/lib/barkest_core/extensions/axlsx_extenstions.rb

@@ -0,0 +1,157 @@
+require 'axlsx'
+require 'axlsx_rails'
+
+# :nodoc:
+module Axlsx
+
+  ##
+  # The Package class is used to manage the Excel file in memory.
+  class Package
+
+    ##
+    # Creates a simple workbook with one sheet.
+    #
+    # Predefines multiple styles that can be used to format cells.
+    # The +sheet+ and +styles+ are yielded to the provided block.
+    #
+    # See Axlsx::Workbook#predefined_styles for a list of predefined styles.
+    #
+    def simple(name = nil)
+      workbook.add_worksheet(name: name || 'Sheet 1') do |sheet|
+        yield sheet, workbook.predefined_styles if block_given?
+        sheet.add_row
+      end
+    end
+
+    alias :barkest_core_original_workbook :workbook
+
+    # :nodoc:
+    def workbook
+      @workbook ||= Workbook.new
+      @workbook.package = self
+      yield @workbook if block_given?
+      @workbook
+    end
+
+  end
+
+  ##
+  # The Workbook class is used to manage the Excel file in memory.
+  class Workbook
+
+    attr_accessor :package
+
+    ##
+    # Gets the predefined style list.
+    #
+    # The +predefined_styles+ hash contains :bold, :date, :float, :integer, :percent, :currency, :text, :wrapped, and :normal
+    # styles for you to use.
+    #
+    def predefined_styles
+      @predefined_styles ||=
+          begin
+            tmp = {}
+            styles do |s|
+              tmp = {
+                  bold:       s.add_style(b: true, alignment: { vertical: :top }),
+                  date:       s.add_style(format_code: 'mm/dd/yyyy', alignment: { vertical: :top }),
+                  float:      s.add_style(format_code: '#,##0.00', alignment: { vertical: :top }),
+                  integer:    s.add_style(format_code: '#,##0', alignment: { vertical: :top }),
+                  percent:    s.add_style(num_fmt: 9, alignment: { vertical: :top }),
+                  currency:   s.add_style(num_fmt: 7, alignment: { vertical: :top }),
+                  text:       s.add_style(format_code: '@', alignment: { vertical: :top }),
+                  wrapped:    s.add_style(alignment: { wrap_text: true, vertical: :top }),
+                  normal:     s.add_style(alignment: { vertical: :top })
+              }
+            end
+            tmp
+          end
+    end
+  end
+
+
+  # :nodoc:
+  class Cell
+
+    alias :barkest_core_original_cast_value :cast_value
+
+    # Fix the conversion of Date/Time values.
+    # :nodoc:
+    def cast_value(v)
+      return nil if v.nil?
+      if @type == :date
+        self.style = STYLE_DATE if self.style == 0
+        v
+      elsif (@type == :time && v.is_a?(Time)) || (@type == :time && v.respond_to?(:to_time))
+        self.style = STYLE_DATE if self.style == 0
+        # one simple little fix.  I DO NOT WANT TIME IN LOCAL TIME!
+        unless v.is_a?(Time)
+          v = v.respond_to?(:to_time) ? v.to_time : v
+        end
+        v
+      elsif @type == :float
+        v.to_f
+      elsif @type == :integer
+        v.to_i
+      elsif @type == :boolean
+        v ? 1 : 0
+      elsif @type == :iso_8601
+        #consumer is responsible for ensuring the iso_8601 format when specifying this type
+        v
+      else
+        @type = :string
+        # TODO find a better way to do this as it accounts for 30% of
+        # processing time in benchmarking...
+        Axlsx::trust_input ? v.to_s : ::CGI.escapeHTML(v.to_s)
+      end
+    end
+  end
+
+  ##
+  # The Worksheet class is used to manage the Excel file in memory.
+  class Worksheet
+
+    ##
+    # Adds a row to the worksheet with combined data.
+    #
+    # Currently we support specifying the +values+, +styles+, and +types+ using this method.
+    #
+    # The +row_data+ value should be an array of arrays.
+    # Each subarray represents a value in the row with up to three values specifying the +value+, +style+, and +type+.
+    # Value is the only item required.
+    #   [['Value 1', :bold, :string], ['Value 2'], ['Value 3', nil, :string]]
+    #
+    # In fact, if a subarray is replaced by a value, it is treated the same as an array only containing that value.
+    #   [['Value 1', :bold, :string], 'Value 2', ['Value 3', nil, :string]]
+    #
+    # The +keys+ parameter defines the location of the data elements within the sub arrays.
+    # The default would be [ :value, :style, :type ].  If your array happens to have additional data or data arranged
+    # in a different format, you can set this to anything you like to get the method to process your data
+    # appropriately.
+    #   keys = [ :ignored, :value, :ignored, :ignored, :style, :ignored, :type ]
+    #
+    # Styles can be specified as a symbol to use the predefined styles, or as a style object you created.
+    #
+    def add_combined_row(row_data, keys = [ :value, :style, :type ])
+      val_index = keys.index(:value) || keys.index('value')
+      style_index = keys.index(:style) || keys.index('style')
+      type_index = keys.index(:type) || keys.index('type')
+
+      raise ArgumentError.new('Missing :value key') unless val_index
+      values = row_data.map{|v| v.is_a?(Array) ? v[val_index] : v }
+      styles = style_index ? row_data.map{ |v| v.is_a?(Array) ? v[style_index] : nil } : []
+      types = type_index ? row_data.map{ |v| v.is_a?(Array) ? v[type_index] : nil } : []
+
+      # allows specifying the style as just a symbol.
+      styles.each_with_index do |style,index|
+        if style.is_a?(String) || style.is_a?(Symbol)
+          styles[index] = workbook.predefined_styles[style.to_sym]
+        end
+      end
+
+      add_row values, style: styles, types: types
+    end
+
+  end
+
+end

data/lib/barkest_core/extensions/fixture_set_extensions.rb

@@ -0,0 +1,107 @@
+require 'active_record/fixtures'
+
+# Add a few enhancements to FixtureSet that provide a method to define load and purge orders.
+ActiveRecord::FixtureSet.class_eval do
+
+  class << self
+    alias :barkest_core_original_create_fixtures :create_fixtures
+  end
+
+  ##
+  # Determines the fixtures that will be loaded first.
+  #
+  # Arguments can either be just table names or a hash of table names with indexes.
+  # If just table names, then the tables are inserted at the end of the list.
+  # If a hash, then the value is the index you want the table to appear in the load list.
+  #
+  # BarkestCore tables are pre-indexed to load before any other tables.
+  #
+  # Usage:
+  #   ActiveRecord::FixtureSet.load_first :table_1, :table_2
+  #   ActiveRecord::FixtureSet.load_first :table_1 => 0, :table_2 => 1
+  def self.load_first(*args)
+    priority_list = %w(access_groups users)
+
+    @load_first ||= priority_list
+
+    unless args.blank?
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          arg.each do |fix,order|
+            fix = fix.to_s
+            order += priority_list.length
+            if order >= @load_first.length
+              @load_first << fix unless @load_first.include?(fix)
+            else
+              @load_first.insert(order, fix) unless @load_first.include?(fix)
+            end
+          end
+        else
+          fix = arg.to_s
+          @load_first << fix unless @load_first.include?(fix)
+        end
+      end
+    end
+
+    @load_first
+  end
+
+  ##
+  # Determines the fixtures that will purged first.
+  #
+  # Arguments can either be just table names or a hash of table names with indexes.
+  # If just table names then the tables are inserted at the beginning of the list.
+  # If a hash, then the value is the index you want the table to appear in the purge list.
+  #
+  # BarkestCore tables are pre-indexed to be purged after any other tables added to this list.
+  #
+  # Usage:
+  #   ActiveRecord::FixtureSet.purge_first :table_1, :table_2
+  #   ActiveRecord::FixtureSet.purge_first :table_1 => 0, :table_2 => 1
+  def self.purge_first(*args)
+    priority_list = %w(ldap_access_groups access_group_user_members access_group_group_members user_login_histories users access_groups)
+
+    @purge_first ||= priority_list
+
+    unless args.blank?
+      args.reverse.each do |arg|
+        if arg.is_a?(Hash)
+          arg.each do |fix,order|
+            fix = fix.to_s
+            if order <= 0
+              @purge_first.insert(0, fix) unless @purge_first.include?(fix)
+            elsif order >= @purge_first.length - priority_list.length
+              @purge_first.insert(@purge_first.length - priority_list.length, fix) unless @purge_first.include?(fix)
+            else
+              @purge_first.insert(order, fix) unless @purge_first.include?(fix)
+            end
+          end
+        else
+          fix = arg.to_s
+          @purge_first.insert(0, fix) unless @purge_first.include?(fix)
+        end
+      end
+    end
+
+    @purge_first
+  end
+
+  # :nodoc:
+  def self.create_fixtures(fixtures_dir, fixture_set_names, *args)
+
+    # delete all fixtures that have been added to purge_first
+    purge_first.each do |fix|
+      fix = const_get(fix.singularize.camelcase)
+      if fix && fix.respond_to?(:delete_all)
+        fix.delete_all
+      end
+    end
+
+    reset_cache
+
+    # if we are adding any of the prioritized fixtures, make them go first, followed by any other fixtures.
+    fixture_set_names = load_first & fixture_set_names | fixture_set_names
+
+    barkest_core_original_create_fixtures fixtures_dir, fixture_set_names, *args
+  end
+end

data/lib/barkest_core/extensions/generator_extensions.rb

@@ -0,0 +1,271 @@
+require 'io/console'
+require 'rails/generators'
+
+Rails::Generators::Base.class_eval do
+
+  protected
+
+  def erb_read(file)
+    ERB.new(File.read(file), 0).result
+  end
+
+  def tell(message, color = nil)
+    open = ''
+    close = ''
+    if color
+      open = "\033[0"
+      close = "\033[0m"
+      open += case color.to_sym
+                when :black
+                  ';30'
+                when :dark_grey, :dark_gray
+                  ';30;1'
+                when :red, :dark_red
+                  ';31'
+                when :bright_red
+                  ';31;1'
+                when :green, :dark_green
+                  ';32'
+                when :bright_green
+                  ';32;1'
+                when :gold, :dark_yellow
+                  ';33'
+                when :yellow
+                  ';33;1'
+                when :dark_blue
+                  ';34'
+                when :blue
+                  ';34;1'
+                when :dark_magenta, :violet, :purple
+                  ';35'
+                when :magenta, :pink
+                  ';35;1'
+                when :dark_cyan, :teal
+                  ';36'
+                when :cyan, :aqua
+                  ';36;1'
+                when :light_gray, :gray, :light_grey, :grey
+                  ';37'
+                when :white
+                  ';37;1'
+                when :bold
+                  ';1'
+                else
+                  ''
+              end + 'm'
+
+    end
+
+    puts open + message + close unless options.quiet?
+  end
+
+  def ask_for_bool(question, default = false)
+    return default if options.quiet?
+
+    print "#{trimq(question)} [#{default ? 'Y/n' : 'y/N'}]? "
+
+    if options.force?
+      puts default ? 'Y' : 'N'
+      return default
+    end
+
+    answer = STDIN.gets.strip.upcase[0]
+
+    return default if answer.blank?
+
+    answer == 'Y'
+  end
+
+  def ask_for_string(question, default = '', valid = nil)
+    return default if options.quiet?
+
+    loop do
+      print "#{trimq(question)} [#{default}] (. to clear)? "
+
+      if options.force?
+        puts default.to_s
+        return default
+      end
+
+      answer = STDIN.gets.strip
+
+      return '' if answer == '.'
+      return default if answer.blank?
+
+      if valid && valid.respond_to?(:call)
+        return answer if valid.call(answer)
+      elsif valid && valid.respond_to?(:include?)
+        return answer if valid.include?(answer)
+      else
+        return answer
+      end
+
+      puts "Entered value (#{answer}) is invalid."
+      unless valid.respond_to?(:call)
+        puts "Valid values are #{valid.inspect}."
+      end
+    end
+
+  end
+
+  def ask_for_int(question, default = 0, valid = nil)
+    return default if options.quiet?
+
+    loop do
+      print "#{question} [#{default}]? "
+
+      if options.force?
+        puts default.to_s
+        return default
+      end
+
+      answer = STDIN.gets.strip
+
+      return default if answer.blank?
+
+      answer = answer.to_i
+
+      if valid && valid.respond_to?(:call)
+        return answer if valid.call(answer)
+      elsif valid && valid.respond_to?(:include?)
+        return answer if valid.include?(answer)
+      else
+        return answer
+      end
+
+      puts "Entered value (#{answer}) is invalid."
+      unless valid.respond_to?(:call)
+        puts "Valid values are #{valid.inspect}."
+      end
+    end
+  end
+
+  def ask_for_secret(question, default = '')
+    return default if options.quiet?
+
+    print "#{question} [enter to keep, . to clear]: "
+
+    if options.force?
+      puts ''
+      return default
+    end
+
+    loop do
+      answer1 = STDIN.noecho(&:gets).strip
+      puts ''
+
+      return '' if answer1 == '.'
+      return default if answer1.blank?
+
+      print 'Enter again to confirm: '
+      answer2 = STDIN.noecho(&:gets).strip
+      puts ''
+
+      return answer1 if answer2 == answer1
+
+      puts 'Confirmation does not match!'
+      print 'Please try again: '
+    end
+  end
+
+  def configure_the(what, config_file, attributes, hash_key, defaults, *optional_levels)
+    tell '=' * 79
+    if ask_for_bool("Would you like to configure #{what.pluralize}?", true)
+      current_config = File.exist?(config_file) ? YAML.load_file(config_file) : {}
+      levels = ([''] + (optional_levels || [])).uniq
+      levels.each do |level|
+        if level.blank? || ask_for_bool("Would you like to configure a #{level} #{what.singularize} configuration?", false)
+          current_config[level] ||= {} unless level.blank?
+
+          env_list = %w(test development production)
+
+          unless level.blank?
+            level,_,envs = level.partition('[')
+            unless envs.blank?
+              env_list = envs.partition(']').first.strip.split(' ')
+            end
+          end
+
+          last_env = nil
+          env_list.each do |env|
+            tell "Configure the '#{level.blank? ? '' : (level + ':')}#{env}' environment."
+            tell '-' * 79
+
+            cur_env = level.blank? ? env : "#{level}_#{env}"
+
+            current = (current_config[cur_env] || {}).dup
+
+            if current.blank? || ask_for_bool("Do you want to make changes to the '#{cur_env}' environment?", false)
+              if last_env
+                if ask_for_bool("Would you like to use the configuration from the '#{last_env}' environment to start?", false)
+                  current = (current_config[last_env] || {}).dup
+                end
+              end
+              current = input_attributes(current, attributes, defaults, hash_key)
+            end
+
+            current_config[cur_env] = current
+
+            tell '-' * 79
+
+            last_env = cur_env
+          end
+        end
+      end
+
+      perform "> creating '#{config_file}'..." do
+        File.write config_file, current_config.to_yaml
+      end
+    end
+  end
+
+  def perform(message, &block)
+    tell message + (options.pretend? ? ' [pretend]' : ''), :teal
+    block.call unless options.pretend?
+  end
+
+  def input_attributes(target_hash, attribute_list, defaults, hash_key = nil)
+    attribute_list.each do |data|
+      if data.is_a?(Hash)
+        if hash_key && target_hash[hash_key] && data[target_hash[hash_key]].is_a?(Array)
+          target_hash = input_attributes(target_hash, data[target_hash[hash_key]], defaults, hash_key)
+        end
+      elsif data.is_a?(Array)
+        field,asker,valid,label,default_override = data
+        label ||= field
+        def_val = if target_hash[field].nil?
+                    if default_override.nil?
+                      defaults[field]
+                    else
+                      default_override
+                    end
+                  else
+                    target_hash[field]
+                  end
+
+        answer = if valid
+                   send(asker, label, def_val, valid)
+                 else
+                   send(asker, label, def_val)
+                 end
+
+        target_hash[field] = answer
+      end
+    end
+    target_hash
+  end
+
+
+  private
+
+  def trimq(question)
+    question = question.to_s.strip
+    if question[-1] == '?' || question[-1] == ':'
+      question = question[0...-1]
+    end
+    question
+  end
+
+
+
+end