mjacobus / koine-profiler

    class Entries

      extend Forwardable

      def_delegators :storage, :size

      def_delegators :to_a, :each

      def initialize(groups = [])

        @storage = Hash.new

        groups.each { |group| append_group(group) }

      end

      def append(name, time)

        group = find_by_name(name) || create_group(name)

        append_to_group(group, name, time)

      end

      def find_by_name(name)

        storage[name.to_s]

      end

      def elapsed_time

        storage.inject(0) do |total, (_key, group)|

          total + group.elapsed_time

        end

      end

      def sort_by(&_block)

        sorted = storage.sort_by { |item| yield(item[1]) }.map {|_key, group| group }

        create(sorted)

      end

      def reverse

        create(storage.to_a.reverse.map { |_key, group| group })

      end

      def slowest

        sort_by(&:elapsed_time).reverse

      end

      def to_a

        storage.values

      end

      def limit(number)

        create(to_a.slice(0, number.to_i))

      end

      def ==(other)

        storage.to_a == other.storage.to_a

      end

      private

      def create(groups = [])

        self.class.new(groups)

      end

      def create_group(name)

        append_group(EntryGroup.new(name))

      end

      def append_group(group)

        storage[group.name] = group

      end

      def append_to_group(group, name, time)

        group.append(Entry.new(name, time))

      end

      protected

      attr_reader :storage

    end