danger-dangermattic 1.2.2 → 1.2.3

data/spec/fixtures/android_unit_test_checker/src/main/java/com/dayoneapp/dayone/main/settings/integrations/connect/AppIntegrationModule.kt

@@ -0,0 +1,29 @@
+package com.dayoneapp.dayone.main.settings.integrations.connect
+
+import com.dayoneapp.dayone.main.settings.integrations.IntegrationAppId
+import com.dayoneapp.dayone.main.settings.integrations.strava.StravaAppIntegrationHandler
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Qualifier
+import javax.inject.Singleton
+import kotlin.jvm.JvmWildcard
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class AppIntegrationHandlers
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object AppIntegrationModule {
+    @Provides
+    @Singleton
+    @AppIntegrationHandlers
+    fun provideAppIntegrationHandlers(
+        stravaAppIntegrationHandler: StravaAppIntegrationHandler,
+    ): Map<IntegrationAppId, @JvmWildcard AppIntegrationHandler> =
+        mapOf(
+            IntegrationAppId.STRAVA to stravaAppIntegrationHandler,
+        )
+}

data/spec/fixtures/android_unit_test_checker/src/main/java/com/dayoneapp/dayone/main/streaks/StreaksViewModel.kt

@@ -0,0 +1,377 @@
+package com.dayoneapp.dayone.main.streaks
+
+import android.content.Context
+import android.graphics.Bitmap
+import androidx.annotation.ColorRes
+import androidx.annotation.VisibleForTesting
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.dayoneapp.dayone.di.DatabaseThreadDispatcher
+import com.dayoneapp.dayone.domain.JournalRepository
+import com.dayoneapp.dayone.domain.SelectedJournalsProvider
+import com.dayoneapp.dayone.domain.StreakRepository
+import com.dayoneapp.dayone.domain.UserRepository
+import com.dayoneapp.dayone.domain.analytics.AnalyticsTracker
+import com.dayoneapp.dayone.domain.analytics.InitialContent
+import com.dayoneapp.dayone.domain.entry.EntryRepository
+import com.dayoneapp.dayone.main.editor.EditorLauncher
+import com.dayoneapp.dayone.main.editor.MainActivityLauncher
+import com.dayoneapp.dayone.main.navigation.ActivityEventHandler
+import com.dayoneapp.dayone.main.navigation.Navigator
+import com.dayoneapp.dayone.main.sharedjournals.events.OpenJournalOnTimeline
+import com.dayoneapp.dayone.utils.DOStreakCalculator
+import com.dayoneapp.dayone.utils.TimeProvider
+import com.dayoneapp.dayone.utils.UtilsWrapper
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import java.io.File
+import java.time.DayOfWeek
+import java.time.LocalDate
+import java.util.Calendar
+import javax.inject.Inject
+
+@HiltViewModel
+class StreaksViewModel
+    @Inject
+    constructor(
+        @DatabaseThreadDispatcher private val databaseDispatcher: CoroutineDispatcher,
+        private val entryRepository: EntryRepository,
+        private val journalRepository: JournalRepository,
+        private val streakRepository: StreakRepository,
+        private val streaksCalculator: DOStreakCalculator,
+        private val timeProvider: TimeProvider,
+        private val userRepository: UserRepository,
+        private val navigator: Navigator,
+        private val selectedJournalsProvider: SelectedJournalsProvider,
+        private val utilsWrapper: UtilsWrapper,
+        private val analyticsTracker: AnalyticsTracker,
+        private val mainActivityLauncher: MainActivityLauncher,
+        private val editorLauncher: EditorLauncher,
+        private val activityEventHandler: ActivityEventHandler,
+    ) : ViewModel() {
+        val uiState =
+            combine(
+                entryRepository.liveEntryCount().distinctUntilChanged(),
+                entryRepository.liveEntryCountForDate().distinctUntilChanged(),
+                journalRepository
+                    .getAllJournalsLive(false)
+                    .map { journals ->
+                        journals.map { journal -> journal.isHideStreaksEnabled }
+                    }.distinctUntilChanged(),
+            ) { _, _, _ ->
+                val streakDays = streaksCalculator.calculateStreakWithSharedJournals()
+                val journals = getStreakJournals()
+                val streakWeekDays = getStreakWeekDays()
+
+                UiState.Streaks(
+                    streakDays = streakDays,
+                    streakWeekDays = streakWeekDays,
+                    journals = journals,
+                )
+            }.stateIn(viewModelScope, SharingStarted.Lazily, UiState.Loading)
+
+        private val _journalOptionsState = MutableStateFlow<JournalOptionsState?>(null)
+        val journalOptionsState = _journalOptionsState.asStateFlow()
+
+        private val dayOfWeekList: DaysOfWeekList = DaysOfWeekList(timeProvider.getFirstDayOfWeek())
+
+        fun shareStreaks(
+            bitmap: Bitmap,
+            context: Context,
+        ) {
+            viewModelScope.launch(databaseDispatcher) {
+                analyticsTracker.trackButtonTapped("streakView_share")
+                val streaksFile: File = utilsWrapper.saveBitmapToFile(context, bitmap, "streaks_file")
+                utilsWrapper.shareImage(context, streaksFile.absolutePath)
+            }
+        }
+
+        fun close() {
+            viewModelScope.launch {
+                analyticsTracker.trackButtonTapped("streakView_close")
+                navigator.goBack()
+            }
+        }
+
+        fun showJournalOptions(
+            journalId: Int,
+            journalName: String,
+        ) {
+            viewModelScope.launch {
+                analyticsTracker.trackButtonTapped("streakView_journal")
+                _journalOptionsState.value = JournalOptionsState(journalId, journalName)
+            }
+        }
+
+        fun openJournal(journalId: Int) {
+            viewModelScope.launch {
+                _journalOptionsState.value = null
+
+                analyticsTracker.trackButtonTapped("streakView_journalMenu_openJournal")
+
+                activityEventHandler.sendEvent(
+                    OpenJournalOnTimeline(
+                        journalId = journalId,
+                        selectedJournalsProvider = selectedJournalsProvider,
+                        mainActivityLauncher = mainActivityLauncher,
+                    ),
+                )
+            }
+        }
+
+        fun createEntry(journalId: Int) {
+            viewModelScope.launch {
+                _journalOptionsState.value = null
+
+                analyticsTracker.trackButtonTapped("streakView_journalMenu_createEntry")
+
+                val newEntry =
+                    entryRepository.createNewEntry(
+                        journalId = journalId,
+                    )
+                val newEntryInformation =
+                    EditorLauncher.NewEntryInformation(
+                        AnalyticsTracker.NewEntrySource.STREAKS,
+                        InitialContent.BLANK,
+                    )
+                editorLauncher.editNewEntry(
+                    entry = newEntry,
+                    newEntryInformation = newEntryInformation,
+                    navigateTo = navigator::navigateTo,
+                )
+            }
+        }
+
+        fun closeJournalOptions() {
+            _journalOptionsState.value = null
+        }
+
+        private suspend fun getStreakWeekDays(): List<StreakWeekDay> {
+            val week = mutableListOf<StreakWeekDay>()
+            // First day of the week can vary based on the user's locale. Generally, SUNDAY is the default in countries
+            // influenced by the US, MONDAY is standard in most of Europe and Asia, and SATURDAY can be common in some
+            // Middle Eastern countries due to the weekend structure.
+            val firstDayOfWeek = timeProvider.getFirstDayOfWeek()
+            if (firstDayOfWeek == Calendar.SATURDAY) {
+                week.add(getStreakWeekDay(DayOfWeek.SATURDAY))
+            }
+            if (firstDayOfWeek == Calendar.SUNDAY || firstDayOfWeek == Calendar.SATURDAY) {
+                week.add(getStreakWeekDay(DayOfWeek.SUNDAY))
+            }
+            week.add(getStreakWeekDay(DayOfWeek.MONDAY))
+            week.add(getStreakWeekDay(DayOfWeek.TUESDAY))
+            week.add(getStreakWeekDay(DayOfWeek.WEDNESDAY))
+            week.add(getStreakWeekDay(DayOfWeek.THURSDAY))
+            week.add(getStreakWeekDay(DayOfWeek.FRIDAY))
+            if (firstDayOfWeek != Calendar.SATURDAY) {
+                week.add(getStreakWeekDay(DayOfWeek.SATURDAY))
+            }
+            if (firstDayOfWeek != Calendar.SUNDAY && firstDayOfWeek != Calendar.SATURDAY) {
+                week.add(getStreakWeekDay(DayOfWeek.SUNDAY))
+            }
+
+            return week
+        }
+
+        @VisibleForTesting
+        suspend fun getStreakWeekDay(dayOfWeek: DayOfWeek): StreakWeekDay {
+            val currentDate = timeProvider.currentLocalDate()
+            val daysToDayOfWeek =
+                dayOfWeekList.daysToPreviousDay(
+                    currentDay = currentDate.dayOfWeek,
+                    previousDay = dayOfWeek,
+                )
+            // Go to the previous date based on [dateOfWeek] and current date.
+            val currentDateForDayOfWeek = currentDate.minusDays(daysToDayOfWeek.daysToPreviousDay.toLong())
+            // From that date, go back DAYS_MINUS_WEEK * 7 days to cover DAYS_MINUS_WEEK (18) instances of the [dayOfWeek].
+            // For example,if [dayOfWeek] is MONDAY and current date is 2024-10-8 (a TUESDAY), then [daysToDayOfWeek] is 1
+            // and [currentDateForDayOfWeek] is 2024-10-7 and since becomes 2024-6-7 which represents the 18th MONDAY from
+            // the current date.
+            val previousWeeks = if (daysToDayOfWeek.wasInPreviousWeek) DAYS_MINUS_WEEK - 1 else DAYS_MINUS_WEEK
+            val since = currentDateForDayOfWeek.minusDays(previousWeeks * 7)
+            // Generates a sequences of dates that represents the [dayOfWeek] for the previous 18 weeks. For the previous
+            // example, represent dates for each MONDAY from 2024-6-7 to 2024-10-7.
+            val dateRange: Sequence<LocalDate> =
+                generateSequence(since) { date ->
+                    if (date < currentDateForDayOfWeek) date.plusDays(7) else null
+                }
+            // We query all the dates with entries since 2024-6-7 and check if the [dayOfWeek] for each week has an entry.
+            val userId = userRepository.getUser()?.id
+            val datesWithEntries = streakRepository.getDatesThatHaveEntriesSince(since, userId)
+            val days =
+                dateRange
+                    .map { date ->
+                        DayJournaled(datesWithEntries.contains(date))
+                    }.toMutableList()
+                    .also {
+                        if (daysToDayOfWeek.wasInPreviousWeek) {
+                            it.add(DayJournaled(null))
+                        }
+                    }
+
+            return StreakWeekDay(dayOfWeek = dayOfWeek, days = days)
+        }
+
+        @VisibleForTesting
+        suspend fun getStreakJournals(): List<StreakJournal> {
+            val currentDate = timeProvider.currentLocalDate()
+            val since = currentDate.minusDays(DAYS_MINUS_JOURNAL)
+            val dateRange: Sequence<LocalDate> =
+                generateSequence(since) { date ->
+                    if (date < currentDate) date.plusDays(1) else null
+                }
+            return journalRepository
+                .getAllJournals(includeHidden = true)
+                .filter {
+                    !it.isHideFromStreakEnabledNonNull() && !it.isPlaceholderForEncryptedJournalNonNull()
+                }.sortedBy { it.sortOrder ?: 0 }
+                .map { journal ->
+                    val datesWithEntries =
+                        if (journal.isShared == true) {
+                            streakRepository.getDatesThatHaveEntriesSinceForSharedJournal(
+                                journalId = journal.id,
+                                since = since,
+                                userId = userRepository.getUser()?.id ?: "",
+                            )
+                        } else {
+                            streakRepository.getDatesThatHaveEntriesSinceForJournal(journalId = journal.id, since = since)
+                        }
+                    val days =
+                        dateRange
+                            .map { date ->
+                                DayJournaled(datesWithEntries.contains(date))
+                            }.toList()
+                    val entriesToday =
+                        if (journal.isShared == true) {
+                            streakRepository.getNumEntriesForSharedJournalOnDate(
+                                journalId = journal.id,
+                                date = currentDate,
+                                userId = userRepository.getUser()?.id ?: "",
+                            )
+                        } else {
+                            streakRepository.getNumEntriesOnDate(journalId = journal.id, date = currentDate)
+                        }
+
+                    StreakJournal(
+                        journalId = journal.id,
+                        journalName = journal.name ?: "",
+                        entriesToday = entriesToday,
+                        color = journal.journalColor.backgroundColorRes,
+                        days = days,
+                    )
+                }
+        }
+
+        companion object {
+            private const val DAYS_MINUS_JOURNAL = 18L
+            private const val DAYS_MINUS_WEEK = 17L
+        }
+
+        sealed interface UiState {
+            data object Loading : UiState
+
+            data class Streaks(
+                val streakDays: Int,
+                val streakWeekDays: List<StreakWeekDay>,
+                val journals: List<StreakJournal>,
+            ) : UiState
+        }
+
+        class JournalOptionsState(
+            val journalId: Int,
+            val journalName: String,
+        )
+    }
+
+data class StreakWeekDay(
+    val dayOfWeek: DayOfWeek,
+    val days: List<DayJournaled>,
+)
+
+@JvmInline
+value class DayJournaled(
+    val isFilled: Boolean?,
+)
+
+data class StreakJournal(
+    val journalId: Int,
+    val journalName: String,
+    val entriesToday: Int,
+    @ColorRes
+    val color: Int,
+    val days: List<DayJournaled>,
+)
+
+private class DaysOfWeekList(
+    private val firstDayOfWeek: Int,
+) {
+    private val days =
+        buildList {
+            if (firstDayOfWeek == Calendar.SATURDAY) {
+                add(DayOfWeek.SATURDAY)
+            }
+            if (firstDayOfWeek == Calendar.SUNDAY || firstDayOfWeek == Calendar.SATURDAY) {
+                add(DayOfWeek.SUNDAY)
+            }
+            add(DayOfWeek.MONDAY)
+            add(DayOfWeek.TUESDAY)
+            add(DayOfWeek.WEDNESDAY)
+            add(DayOfWeek.THURSDAY)
+            add(DayOfWeek.FRIDAY)
+            if (firstDayOfWeek != Calendar.SATURDAY) {
+                add(DayOfWeek.SATURDAY)
+            }
+            if (firstDayOfWeek != Calendar.SUNDAY && firstDayOfWeek != Calendar.SATURDAY) {
+                add(DayOfWeek.SUNDAY)
+            }
+        }
+
+    /**
+     * Return the number of days between the current day of the week and the previous day of the week.
+     *
+     * Example: If the current day of the week is MONDAY and the previous day of the week is FRIDAY, then it would
+     * return 3 because we have to go through SUNDAY, SATURDAY to FRIDAY.
+     *
+     * @param currentDay The current day of the week.
+     * @param previousDay The previous day of the week.
+     * @return Number of days between the current day of the week and the previous day of the week.
+     */
+    fun daysToPreviousDay(
+        currentDay: DayOfWeek,
+        previousDay: DayOfWeek,
+    ): PreviousDays {
+        if (currentDay == previousDay) {
+            return PreviousDays(0, false)
+        }
+        var indexCurrentDay = days.indexOf(currentDay)
+        var daysToPreviousDay = 0
+        var wasInPreviousWeek = false
+        while (true) {
+            indexCurrentDay -= 1
+            if (indexCurrentDay < 0) {
+                wasInPreviousWeek = true
+                indexCurrentDay = days.size - 1
+            }
+            daysToPreviousDay += 1
+
+            if (days[indexCurrentDay] == previousDay) {
+                break
+            }
+        }
+
+        return PreviousDays(daysToPreviousDay, wasInPreviousWeek)
+    }
+
+    class PreviousDays(
+        val daysToPreviousDay: Int,
+        val wasInPreviousWeek: Boolean,
+    )
+}

data/spec/fixtures/android_unit_test_checker/src/main/java/com/dayoneapp/dayone/mediastorage/MediaStorageConfiguration.kt

@@ -0,0 +1,31 @@
+package com.dayoneapp.mediastorage
+
+import android.graphics.Bitmap
+
+@JvmInline
+value class CompressQuality(
+    val value: Int,
+) {
+    init {
+        require(value in 1..100) { }
+    }
+}
+
+class MediaStorageConfiguration(
+    val mediaPath: String,
+    val externalImagesPath: String,
+    val externalVideosPath: String,
+    val externalAudiosPath: String,
+    val externalDocumentsPath: String,
+    val avatarsPath: String,
+    val thumbnailsConfiguration: ThumbnailsConfiguration,
+)
+
+class ThumbnailsConfiguration(
+    val thumbnailsPath: String,
+    val height: Int,
+    val width: Int,
+    val extension: String,
+    val compression: Bitmap.CompressFormat,
+    val quality: CompressQuality,
+)

data/spec/fixtures/android_unit_test_checker/src/main/java/com/dayoneapp/dayone/utils/AccountType.kt

@@ -0,0 +1,15 @@
+package com.dayoneapp.dayone.utils
+
+enum class AccountType(
+    val key: String,
+) {
+    DAY_ONE("Day One"),
+    GOOGLE("Google"),
+    APPLE("Apple ID"),
+    ;
+
+    companion object {
+        @JvmStatic
+        fun fromString(key: String): AccountType = values().find { it.key == key }!!
+    }
+}

data/spec/fixtures/android_unit_test_checker/src/main/java/com/dayoneapp/dayone/utils/usecase/SelectPhotoUseCase.kt

@@ -0,0 +1,76 @@
+package com.dayoneapp.dayone.utils.usecase
+
+import android.content.Context
+import android.content.Intent
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.contract.ActivityResultContracts.GetContent
+import androidx.activity.result.contract.ActivityResultContracts.GetMultipleContents
+import androidx.fragment.app.Fragment
+import com.dayoneapp.dayone.utils.UriWrapper
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import javax.inject.Inject
+
+class SelectPhotoUseCase
+    @Inject
+    constructor() {
+        private lateinit var getContent: ActivityResultLauncher<String>
+        private val _mediaUris = MutableSharedFlow<List<UriWrapper>>(extraBufferCapacity = 5)
+        val mediaUris = _mediaUris.asSharedFlow()
+
+        fun onCreate(
+            fragment: Fragment,
+            singlePhoto: Boolean = false,
+        ) {
+            getContent =
+                if (singlePhoto) {
+                    fragment.registerForActivityResult(GetSingleImage()) { uri ->
+                        uri?.let {
+                            _mediaUris.tryEmit(listOf(UriWrapper(it)))
+                        }
+                    }
+                } else {
+                    fragment.registerForActivityResult(GetMultipleImages()) { uris ->
+                        _mediaUris.tryEmit(uris.map { UriWrapper(it) })
+                    }
+                }
+        }
+
+        fun selectPhotos() {
+            getContent.launch("image/*")
+        }
+
+        private class GetMultipleImages : GetMultipleContents() {
+            // Required to remove a lint error due to this method no longer calling super.createIntent()
+            @Suppress("MissingSuperCall")
+            override fun createIntent(
+                context: Context,
+                input: String,
+            ): Intent =
+                Intent(
+                    Intent.ACTION_PICK,
+                    android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+                ).setType(input)
+                    .putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+                    .apply {
+                        putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("image/jpeg", "image/png", "image/jpg"))
+                    }
+        }
+
+        private class GetSingleImage : GetContent() {
+            // Required to remove a lint error due to this method no longer calling super.createIntent()
+            @Suppress("MissingSuperCall")
+            override fun createIntent(
+                context: Context,
+                input: String,
+            ): Intent =
+                Intent(
+                    Intent.ACTION_PICK,
+                    android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+                ).setType(input)
+                    .apply {
+                        putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("image/jpeg", "image/png", "image/jpg"))
+                    }
+        }
+    }
+    

data/spec/pr_size_checker_spec.rb

@@ -72,19 +72,19 @@ module Danger
             end
 
             context 'when fail on error is false and a custom message is given' do
-              include_examples 'reporting diff size custom warnings or errors', false, 'this is my custom warning message'
+              it_behaves_like 'reporting diff size custom warnings or errors', false, 'this is my custom warning message'
             end
 
             context 'when fail on error is false' do
-              include_examples 'reporting diff size custom warnings or errors', false
+              it_behaves_like 'reporting diff size custom warnings or errors', false
             end
 
             context 'when fail on error is true' do
-              include_examples 'reporting diff size custom warnings or errors', true
+              it_behaves_like 'reporting diff size custom warnings or errors', true
             end
 
             context 'when a custom error message is given and fail on error is true' do
-              include_examples 'reporting diff size custom warnings or errors', true, 'this is my custom error message'
+              it_behaves_like 'reporting diff size custom warnings or errors', true, 'this is my custom error message'
             end
           end
         end
@@ -163,18 +163,18 @@ module Danger
         end
 
         context 'with the entire diff' do
-          include_examples 'using the default diff size counter, without a file selector', :all
-          include_examples 'using a file selector to filter and count the changes in a diff', :all, [422, 520, 1541]
+          it_behaves_like 'using the default diff size counter, without a file selector', :all
+          it_behaves_like 'using a file selector to filter and count the changes in a diff', :all, [422, 520, 1541]
         end
 
         context 'with the insertions in the diff' do
-          include_examples 'using the default diff size counter, without a file selector', :insertions
-          include_examples 'using a file selector to filter and count the changes in a diff', :insertions, [200, 139, 384]
+          it_behaves_like 'using the default diff size counter, without a file selector', :insertions
+          it_behaves_like 'using a file selector to filter and count the changes in a diff', :insertions, [200, 139, 384]
         end
 
         context 'with the deletions in the diff' do
-          include_examples 'using the default diff size counter, without a file selector', :deletions
-          include_examples 'using a file selector to filter and count the changes in a diff', :deletions, [221, 380, 1157]
+          it_behaves_like 'using the default diff size counter, without a file selector', :deletions
+          it_behaves_like 'using a file selector to filter and count the changes in a diff', :deletions, [221, 380, 1157]
         end
       end
 
@@ -221,19 +221,19 @@ module Danger
           end
 
           context 'when fail on error is false and a custom message is given' do
-            include_examples 'reporting PR length check custom warnings or errors', false, 'this is my custom warning message'
+            it_behaves_like 'reporting PR length check custom warnings or errors', false, 'this is my custom warning message'
           end
 
           context 'when fail on error is false' do
-            include_examples 'reporting PR length check custom warnings or errors', false
+            it_behaves_like 'reporting PR length check custom warnings or errors', false
           end
 
           context 'when fail on error is true' do
-            include_examples 'reporting PR length check custom warnings or errors', true
+            it_behaves_like 'reporting PR length check custom warnings or errors', true
           end
 
           context 'when a custom error message is given and fail on error is true' do
-            include_examples 'reporting PR length check custom warnings or errors', true, 'this is my custom error message'
+            it_behaves_like 'reporting PR length check custom warnings or errors', true, 'this is my custom error message'
           end
         end
       end

data/spec/spec_helper.rb

@@ -58,8 +58,14 @@ def testing_dangerfile
   Danger::Dangerfile.new(env, testing_ui)
 end
 
-def fixture(name)
-  File.read("spec/fixtures/#{name}")
+# Returns the full path of the fixture at the given subpath (relative to `spec/fixtures`)
+def fixture_path(*path_components)
+  File.join('spec', 'fixtures', *path_components)
+end
+
+# Returns the content of the fixture at the given path (relative to `spec/fixtures`)
+def fixture(*path_components)
+  File.read(fixture_path(*path_components))
 end
 
 # custom matchers