cornucopia 0.1.12

data/lib/cornucopia/util/file_asset.rb

@@ -0,0 +1,46 @@
+module Cornucopia
+  module Util
+    class FileAsset
+      class << self
+        def asset(asset_name)
+          @@asset_list                    ||= {}
+          @@asset_list[asset_name.to_sym] = FileAsset.new(asset_name) unless @@asset_list[asset_name.to_sym]
+          @@asset_list[asset_name.to_sym]
+        end
+      end
+
+      def initialize(asset_name)
+        @asset_name = asset_name
+      end
+
+      def body=(asset_body)
+        @asset_body = asset_body
+      end
+
+      def source_file=(source_file_name)
+        # We read the file into memory in case the file moves or is temporary.
+        @asset_body = File.read(source_file_name)
+      end
+
+      def add_file(output_location)
+        unless (File.exists?(output_location))
+          create_file(output_location)
+        end
+      end
+
+      def create_file(output_location)
+        if @asset_body
+          File.open(output_location, "w+") do |write_file|
+            write_file << @asset_body
+          end
+        else
+          FileUtils.cp path, output_location
+        end
+      end
+
+      def path
+        File.absolute_path(File.join(File.dirname(__FILE__), "../source_files/", @asset_name))
+      end
+    end
+  end
+end

data/lib/cornucopia/util/generic_settings.rb

@@ -0,0 +1,37 @@
+module Cornucopia
+  module Util
+    # This is a stupid little settings class
+    # Basicaly, anything you send to it is put into a hash or returned from a hash.
+    class GenericSettings
+      def initialize
+        @settings_hash = {}
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        if self.respond_to?("super__#{method_sym}".to_sym)
+          super
+        else
+          if method_sym.to_s[-1] == "="
+            raise "wrong number of arguments (#{arguments.length} for 1)" if !arguments || arguments.length != 1
+            raise "block not accepted" if block
+
+            @settings_hash[method_sym.to_s[0..-2].to_sym] = arguments[0]
+          else
+            raise "too many arguments (#{arguments.length} for 0)" if arguments && arguments.length > 0
+            raise "block not accepted" if block
+            @settings_hash[method_sym]
+          end
+        end
+      end
+
+      def respond_to?(method_sym, include_private = false)
+        method_name = method_sym.to_s
+        if method_name[0.."super__".length - 1] == "super__"
+          super(method_sym["super__".length..-1].to_sym, include_private)
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/cornucopia/util/log_capture.rb

@@ -0,0 +1,97 @@
+require ::File.expand_path('configuration', File.dirname(__FILE__))
+require ::File.expand_path('report_builder', File.dirname(__FILE__))
+
+module Cornucopia
+  module Util
+    class LogCapture
+      class << self
+        TAIL_BUF_LENGTH = 1 << 16
+
+        # This function will capture the logs and output them to the report
+        def capture_logs(report_table)
+          if report_table
+            if Object.const_defined?("Rails")
+              log_folder = Rails.root.to_s
+              if (log_folder =~ /\/features\/?$/ || log_folder =~ /\/spec\/?$/)
+                log_folder = File.join(log_folder, "../")
+              end
+
+              default_log_file = "log/#{Rails.env.to_s}.log"
+
+              output_log_file(report_table, File.join(log_folder, default_log_file))
+            else
+              log_folder = FileUtils.pwd
+            end
+
+            Cornucopia::Util::Configuration.user_log_files.each do |relative_log_file, options|
+              output_log_file(report_table, File.join(log_folder, relative_log_file), options)
+            end
+          else
+            Cornucopia::Util::ReportBuilder.current_report.within_section("Log Dump:") do |report|
+              report.within_table do |new_report_table|
+                Cornucopia::Util::LogCapture.capture_logs new_report_table
+              end
+            end
+          end
+        end
+
+        def highlight_log_output(log_text)
+          output_text = Cornucopia::Util::ReportBuilder.format_code_refs(log_text)
+          output_text = output_text.gsub(/^(Completed [^23].*)$/, "<span class=\"completed-error\">\\1<\/span>")
+          output_text = output_text.gsub(/^(Completed [23].*)$/, "<span class=\"completed-other\">\\1<\/span>")
+
+          output_text.html_safe
+        end
+
+        # A cheap and sleazy tail function, but it should work...
+        def output_log_file(report_table, log_file_name, options = {})
+          if File.exists?(log_file_name)
+            output_file = false
+
+            options.reverse_merge!({ num_lines: Cornucopia::Util::Configuration.num_lines })
+
+            num_lines  = options[:num_lines] || Cornucopia::Util::Configuration.num_lines
+            num_lines  = Cornucopia::Util::Configuration.num_lines if num_lines <= 0
+            log_buffer = ""
+            file_size  = File.size(log_file_name)
+
+            File.open(log_file_name) do |log_file|
+              seek_len = [file_size, TAIL_BUF_LENGTH].min
+              log_file.seek -seek_len, IO::SEEK_END
+
+              while (log_buffer.count("\n") <= num_lines)
+                log_buffer = log_file.read(seek_len) + log_buffer
+
+                file_size -= seek_len
+                seek_len  = [file_size, TAIL_BUF_LENGTH].min
+
+                break if seek_len <= 0
+
+                log_file.seek -seek_len - TAIL_BUF_LENGTH, IO::SEEK_CUR
+              end
+            end
+
+            if log_buffer
+              log_buffer = log_buffer.split("\n")
+              if (log_buffer.length > num_lines)
+                log_buffer = log_buffer[-num_lines..-1]
+              end
+
+              report_table.write_stats File.basename(log_file_name),
+                                       Cornucopia::Util::PrettyFormatter.format_string(
+                                           Cornucopia::Util::LogCapture.highlight_log_output(
+                                               "log_file - #{log_file_name}:#{file_size}\n#{log_buffer.join("\n")}"
+                                           )
+                                       ),
+                                       do_not_pretty_print: true
+
+              output_file = true
+            end
+
+            output_file
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cornucopia/util/pretty_formatter.rb

@@ -0,0 +1,580 @@
+module Cornucopia
+  module Util
+    class PrettyFormatter
+      class << self
+        def format_string(unknown_string)
+          PrettyFormatter.new(unknown_string).pretty_print
+        end
+      end
+
+      def initialize(unknown_string)
+        @unknown_string  = unknown_string
+        @print_html_safe = @unknown_string.html_safe?
+      end
+
+      def pretty_print
+        search_pos = 0
+
+        do_pretty_print     = @unknown_string =~ /Parameters:[ \t]*\{.*?\}/
+        formatted_class_pos = class_pos = -1
+        while !do_pretty_print && class_pos && class_pos == formatted_class_pos
+          search_pos += formatted_class_pos + 1
+
+          if @print_html_safe
+            class_pos           = @unknown_string[search_pos..-1] =~ /\#\&lt;[^ \t\n]+/
+            formatted_class_pos = (@unknown_string[search_pos..-1] =~ /\#\&lt;[^ \t\n]+[ \t]*\n/)
+          else
+            class_pos           = @unknown_string[search_pos..-1] =~ /\#\<[^ \t\n]+/
+            formatted_class_pos = (@unknown_string[search_pos..-1] =~ /\#\<[^ \t\n]+[ \t]*\n/)
+          end
+
+          do_pretty_print ||= (class_pos && class_pos != formatted_class_pos)
+        end
+
+        if do_pretty_print
+          @indent_level       = 0
+          @current_state      = :unknown
+          @state_stack        = [:unknown]
+          @current_pos        = 0
+          @start_pos          = 0
+          @unknown_string_len = @unknown_string.length
+          @formatted_string   = ""
+
+          while @current_pos < @unknown_string_len
+            case @current_state
+              when :unknown
+                search_pos          = @current_pos
+                params_pos          = @unknown_string[search_pos..-1] =~ /Parameters:[ \t]*\{.*?\}/
+                params_pos          += search_pos if params_pos
+                formatted_class_pos = class_pos = -1
+                while (class_pos && class_pos == formatted_class_pos)
+                  search_pos += formatted_class_pos + 1
+
+                  if @print_html_safe
+                    class_pos           = @unknown_string[search_pos..-1] =~ /\#\&lt;[^ \t\n]+/
+                    formatted_class_pos = (@unknown_string[search_pos..-1] =~ /\#\&lt;[^ \t\n]+[ \t]*\n/)
+                  else
+                    class_pos           = @unknown_string[search_pos..-1] =~ /\#\<[^ \t\n]+/
+                    formatted_class_pos = (@unknown_string[search_pos..-1] =~ /\#\<[^ \t\n]+[ \t]*\n/)
+                  end
+                end
+                class_pos           += search_pos if class_pos
+                formatted_class_pos += search_pos if formatted_class_pos
+
+                if class_pos &&
+                    class_pos != formatted_class_pos &&
+                    (!params_pos || class_pos < params_pos)
+                  @current_pos = class_pos
+
+                  if @start_pos < @current_pos || @start_pos > 0
+                    output_line(@unknown_string[@start_pos..@current_pos - 1])
+                  else
+                    @indent_level -= 1
+                    @state_stack << :bottom_level
+                  end
+
+                  start_class
+                else
+                  if params_pos
+                    @current_pos = params_pos
+                    @state_stack << :parameters
+
+                    if @start_pos < @current_pos || @start_pos > 0
+                      output_line(@unknown_string[@start_pos..@current_pos - 1])
+                    else
+                      @state_stack << :bottom_level
+                      @indent_level -= 1
+                    end
+
+                    @formatted_string.rstrip!
+                    @state_stack << :parameters_name
+                    @current_state = :value
+                    @start_pos     = @current_pos
+                    @indent_level  += 1
+                  else
+                    output_end
+                  end
+                end
+
+              when :value_end
+                case @state_stack[-1]
+                  when :unknown
+                    @current_state = :unknown
+
+                  when :parameters
+                    if @current_pos + 1 < @unknown_string_len
+                      @formatted_string << "\n"
+                    end
+                    @indent_level -= 1
+                    @state_stack.pop
+                    @current_state = :unknown
+
+                  when :parameters_name
+                    group_value_end :parameters_start, "}"
+
+                  when :class_name
+                    group_value_end :variable,
+                                    ">",
+                                    end_append_text:     @indent_level == 0 ? "\n" : "",
+                                    append_text:         " ",
+                                    group_end_same_line: true,
+                                    add_value:           true
+                    @indent_level += 1
+
+                  when :variable
+                    if (position_matches_string(@current_pos - 1, ":") &&
+                        ((!@print_html_safe &&
+                            0 == (@unknown_string[@current_pos..-1] =~ /^[ \t\r\n]*({.*?}|\#<.*?>|\[.*?\]|\".*?\"|[^\n,\"]+)[ \t\r\n]*[,\>]/)) ||
+                            (@print_html_safe &&
+                                0 == (@unknown_string[@current_pos..-1] =~ /^[ \t\r\n]*({.*?}|\#&lt\;.*?&gt\;|\[.*?\]|&quot\;.*?&quot\;|[^\n,\"]+)[ \t\r\n]*(,|&gt\;)/))
+                        ))
+                      @state_stack.pop
+                      @state_stack << :group_implied
+                      @state_stack << :hash_key_symbol_post
+                    elsif (!position_matches_string(@current_pos - 1, ":") &&
+                        ((!@print_html_safe &&
+                            0 == (@unknown_string[@current_pos..-1] =~ /^[ \t\r\n]*=>[ \t\r\n]*({.*?}|\#<.*?>|\[.*?\]|\".*?\"|[^\n,\"]+)[ \t\r\n]*[,\>]/)) ||
+                            (@print_html_safe &&
+                                0 == (@unknown_string[@current_pos..-1] =~ /^[ \t\r\n]*=&gt\;[ \t\r\n]*({.*?}|\#&lt\;.*?&gt\;|\[.*?\]|&quot\;.*?&quot\;|[^\n,\"&]+)[ \t\r\n]*(,|&gt\;)/))
+                        ))
+                      @state_stack.pop
+                      @state_stack << :group_implied
+                      @state_stack << :hash_key_string
+                    else
+                      group_value_end :variable_equal,
+                                      ">",
+                                      append_text:         " ",
+                                      group_end_same_line: !@variable_set,
+                                      end_append_text:     @indent_level == 0 ? "\n" : ""
+                    end
+
+                  when :variable_value
+                    group_value_end :variable_comma, ">",
+                                    same_line:       true,
+                                    end_append_text: @indent_level == 0 ? "\n" : ""
+
+                  when :hash_key_symbol_post
+                    group_value_end :hash_value,
+                                    @state_stack[-2] == :group_implied ? ">" : "}",
+                                    append_text: " ",
+                                    add_value:   true
+
+                  when :hash_key, :hash_key_symbol, :hash_key_string
+                    group_value_end :hash_rocket,
+                                    @state_stack[-2] == :group_implied ? ">" : "}",
+                                    append_text: " "
+
+                  when :hash_value
+                    group_value_end :hash_comma,
+                                    @state_stack[-1] == :group_implied ? ">" : "}",
+                                    same_line: true
+
+                  when :array
+                    group_value_end :array_comma, "]"
+                end
+
+                @current_pos -= 1
+
+              when :hash_rocket
+                if @unknown_string[@current_pos] == ","
+                  group_separator ",",
+                                  :hash_value,
+                                  @state_stack[-2] == :group_implied ? ">" : "}",
+                                  append_text: " "
+                else
+                  group_separator "=>",
+                                  :hash_value,
+                                  @state_stack[-2] == :group_implied ? ">" : "}",
+                                  append_text: " "
+                end
+
+              when :variable_equal
+                @variable_set = true
+                if @unknown_string[@current_pos] == ","
+                  group_separator ",",
+                                  :variable_value, ">",
+                                  end_append_text: @indent_level == 0 ? "\n" : ""
+                else
+                  group_separator "=",
+                                  :variable_value, ">",
+                                  end_append_text: @indent_level == 0 ? "\n" : "",
+                                  append_text:     " "
+                end
+
+              when :variable_comma
+                group_separator ",",
+                                :variable, ">",
+                                end_append_text: @indent_level == 0 ? "\n" : ""
+
+              when :array_comma
+                group_separator ",", :array, "]"
+
+              when :hash_comma
+                group_separator ",",
+                                :hash_key,
+                                @state_stack[-1] == :group_implied ? ">" : "}"
+                if @state_stack[-1] == :group_implied
+                  @state_stack.pop
+                end
+
+              when :parameters_start
+                start_grouping :hash_key
+
+              when :whitespace
+                case @unknown_string[@current_pos]
+                  when " ", "\r", "\n", "\t"
+                    @start_pos = @current_pos + 1
+
+                  else
+                    @start_pos     = @current_pos # probably redundant, but better safe than sorry...
+                    @current_pos   -= 1
+                    @current_state = @state_stack.pop
+                end
+
+              when :string
+                if position_matches_string(@current_pos, "\\")
+                  @current_pos += 1
+                elsif position_matches_string(@current_pos, "\"")
+                  @current_pos += translate_value("\"").length
+                  value_end
+                end
+
+              when :value
+                case @unknown_string[@current_pos]
+                  when "{"
+                    if @start_pos == @current_pos
+                      start_grouping :hash_key
+                    else
+                      output_end
+                    end
+
+                  when "["
+                    if @start_pos == @current_pos
+                      start_grouping :array
+                    else
+                      output_end
+                    end
+
+                  when "\""
+                    if position_matches_string(@current_pos, "\"")
+                      start_quote
+                    end
+
+                  when "#"
+                    if @start_pos == @current_pos &&
+                        @current_pos < @unknown_string_len - 2 &&
+                        position_matches_string(@current_pos + 1, "<")
+                      start_class
+                    end
+
+                  when "="
+                    case @state_stack[-1]
+                      when :variable,
+                          :hash_key,
+                          :hash_key_string,
+                          :hash_key_symbol,
+                          :hash_key_symbol_post
+                        value_end
+                    end
+
+                  when ":"
+                    case @state_stack[-1]
+                      when :hash_key
+                        if @current_pos == @start_pos
+                          @state_stack.pop
+                          @state_stack << :hash_key_symbol
+                        else
+                          @state_stack.pop
+                          @state_stack << :hash_key_symbol_post
+
+                          @current_pos += 1
+                          value_end
+                        end
+
+                      when :parameters_name
+                        @current_pos += 1
+                        value_end
+
+                      when :variable
+                        unless @current_pos == @start_pos
+                          @current_pos += 1
+                          value_end
+                        end
+                    end
+
+                  when "&", ">"
+                    if position_matches_string(@current_pos, ">")
+                      case @state_stack[-1]
+                        when :class_name,
+                            :variable,
+                            :variable_equal,
+                            :variable_value,
+                            :variable_comma
+                          value_end
+                        when :hash_key,
+                            :hash_key_symbol_post,
+                            :hash_key_symbol,
+                            :hash_key_string,
+                            :hash_rocket,
+                            :hash_value,
+                            :hash_comma
+                          if @state_stack[-2] == :group_implied
+                            value_end
+                          end
+                      end
+                    elsif position_matches_string(@current_pos, "\"")
+                      start_quote
+                    end
+
+                  when "}"
+                    case @state_stack[-1]
+                      when :hash_key,
+                          :hash_key_symbol_post,
+                          :hash_key_symbol,
+                          :hash_key_string,
+                          :hash_rocket,
+                          :hash_value,
+                          :hash_comma
+                        value_end
+                    end
+
+                  when "]"
+                    case @state_stack[-1]
+                      when :array,
+                          :array_comma
+                        value_end
+                    end
+
+                  when ","
+                    case @state_stack[-1]
+                      when :hash_value,
+                          :array,
+                          :variable_value,
+                          #unexpected, probably error states...
+                          :variable,
+                          :variable_equal,
+                          :hash_key,
+                          :hash_key_string,
+                          :hash_key_symbol,
+                          :hash_key_symbol_post,
+                          :hash_rocket,
+                          :hash_comma,
+                          :variable_comma,
+                          :array_comma
+                        value_end
+                    end
+
+                  when " ", "\r", "\n", "\t"
+                    case @state_stack[-1]
+                      when :variable_value,
+                          :array,
+                          :hash_value
+                        @current_pos += 1
+                        @current_pos -= 1
+
+                      else
+                        value_end
+                    end
+                end
+            end
+
+            @current_pos += 1
+          end
+
+          if @start_pos < @current_pos
+            output_end
+          end
+
+          @formatted_string.rstrip!
+          @formatted_string = @formatted_string.html_safe if @print_html_safe
+          @formatted_string
+        else
+          @unknown_string
+        end
+      end
+
+      def start_quote
+        if @start_pos == @current_pos
+          if @state_stack[-1] == :hash_key && @start_pos == @current_pos
+            @state_stack.pop
+            @state_stack << :hash_key_string
+          end
+
+          @current_state = :string
+          @current_pos   += translate_value("\"").length - 1
+        else
+          # This is almost certainly an error.  End it now...
+          output_end
+        end
+      end
+
+      def group_value_end(next_state, group_end_char, options = {})
+        @state_stack.pop
+
+        if position_matches_string @current_pos, group_end_char
+          output_line(@unknown_string[@start_pos..@current_pos - 1], options.merge(strip_output: true))
+          @start_pos = @current_pos
+
+          safe_end = translate_value(group_end_char)
+          end_grouping safe_end, options
+          @current_pos += 1
+        else
+          output_line(@unknown_string[@start_pos..@current_pos - 1], options.merge(strip_output: true))
+
+          if options[:append_text]
+            @formatted_string << options[:append_text]
+          end
+
+          @state_stack << next_state
+          @state_stack << :value if options[:add_value]
+          @start_pos     = @current_pos
+          @current_state = :whitespace
+        end
+      end
+
+      def value_end
+        @current_state = :value_end
+        @current_pos   -= 1
+      end
+
+      def group_separator(separator_value, next_state, group_end_char, options = {})
+        if position_matches_string(@current_pos, separator_value)
+          safe_separator = translate_value(separator_value)
+
+          @formatted_string << @unknown_string[@start_pos..(@current_pos + safe_separator.length - 1)]
+          @formatted_string.rstrip!
+
+          if options[:append_text]
+            @formatted_string << options[:append_text]
+          end
+
+          @start_pos   = @current_pos + safe_separator.length
+          @current_pos += safe_separator.length - 1
+          @state_stack << next_state
+          @state_stack << :value
+          @current_state = :whitespace
+
+        elsif position_matches_string(@current_pos, group_end_char)
+          end_grouping translate_value(group_end_char), options
+
+        else
+          # Some kind of error, exit out
+          output_end
+        end
+      end
+
+      def end_grouping(safe_end, options = {})
+        @indent_level -= 1
+
+        if options[:group_end_same_line]
+          @formatted_string.strip!
+          @formatted_string << @unknown_string[@start_pos..@current_pos + safe_end.length - 1]
+        else
+          output_line(@unknown_string[@start_pos..@current_pos + safe_end.length - 1])
+
+          if options[:end_append_text]
+            @formatted_string << options[:end_append_text]
+          end
+        end
+
+        @indent_level -= 1
+        if @state_stack[-1] == :bottom_level ||
+            (@state_stack[-1] == :group_implied && @state_stack[-2] == :bottom_level)
+          if @state_stack[-1] == :bottom_level
+            @state_stack.pop
+          else
+            @state_stack.pop
+            @state_stack.pop
+            @state_stack << :group_implied
+          end
+
+          @indent_level += 1
+        end
+
+        @current_pos   += safe_end.length - 1
+        @start_pos     = @current_pos + 1
+        @current_state = :value_end
+      end
+
+      def start_grouping group_type
+        if @state_stack[-1] == :array
+          @state_stack << :bottom_level
+        else
+          @indent_level += 1
+        end
+
+        output_line(@unknown_string[@start_pos..@current_pos])
+        @indent_level += 1
+        @start_pos    = @current_pos + 1
+        @state_stack << group_type
+        @state_stack << :value
+        @current_state = :whitespace
+      end
+
+      def start_class
+        if @state_stack[-1] == :array
+          @state_stack << :bottom_level
+          @indent_level -= 1
+        end
+        @indent_level += 1
+
+        @start_pos = @current_pos
+
+        @variable_set = false
+        @state_stack << :class_name
+
+        @current_pos   += 1
+        @current_state = :value
+
+        @formatted_string.rstrip!
+      end
+
+      def output_end
+        unless @start_pos >= @unknown_string_len
+          @formatted_string << "\n" unless @formatted_string[-1] == "\n"
+          @formatted_string << @unknown_string[@start_pos..-1]
+        end
+
+        @current_pos = @unknown_string_len
+        @start_pos   = @unknown_string_len
+      end
+
+      def translate_value(value)
+        safe_string = value
+
+        if @print_html_safe
+          safe_string = "".html_safe
+          safe_string << value
+        end
+
+        safe_string
+      end
+
+      def position_matches_string(test_position, test_string)
+        safe_string = translate_value(test_string)
+
+        test_position <= @unknown_string_len - safe_string.length &&
+            @unknown_string[test_position..(test_position + safe_string.length - 1)] == safe_string
+      end
+
+      def output_line(text, options = {})
+        unless text.blank?
+          unless options[:same_line]
+            if (@formatted_string[-1] == " ")
+              @formatted_string.rstrip!
+            end
+
+            @formatted_string << "\n" unless @formatted_string.length == 0 || @formatted_string[-1] == "\n"
+            @formatted_string << " " * (2 * @indent_level)
+          end
+
+          @formatted_string << text
+
+          if options[:strip_output]
+            @formatted_string.rstrip!
+          end
+        end
+      end
+    end
+  end
+end