tuan188/RxCleanArchitecture

This system is an iOS application built on a Clean Architecture pattern, utilizing RxSwift for reactive programming and Core Data for local persistence. It provides a complete user interface for managing users, repositories, and products, featuring paginated lists, carousels, and form validation. The codebase includes extensive unit and integration tests covering domain use cases, view models, and UI components.

10 changes.

This period focused on establishing the foundational structure of the CleanArchitecture project, including the Xcode workspace, Core Data setup, and key UI components like the Main and Login screens. The team implemented core architectural patterns, such as the AppViewModel and RxPagingTableView, while simultaneously adding unit tests to verify the new logic and UI interactions.

17 changes.

This period focused on implementing the core features of a Clean Architecture application, introducing domain entities, use cases, and UI scenes for login, products, and repositories. The work established a robust data layer with Core Data and UserDefaults storage, supported by comprehensive unit tests for all new components.

7 changes.

The project established a Clean Architecture foundation by introducing RxSwift-based reactive utilities, a CoreDataRepository abstraction, and domain use cases for user and repository management. This backend and logic layer was paired with new UI components, including a multi-section repository carousel and paging-enabled table/collection views, to display data in various formats.

A new Core Data model and Swift extension were added to enable persistence of the User entity. The model defines a CDUser entity with attributes for id, name, birthday, and gender. The User+CoreData.swift file implements the CoreDataMappable protocol, providing bidirectional mapping between the domain User object and the CDUser Core Data entity.

CleanArchitecture/Data/CoreData · high confidence

Introduced new \PagingTableView\ and \PagingCollectionView\ classes that integrate with RxSwift and ESPullToRefresh to provide pull-to-refresh and infinite scrolling (load-more) capabilities. These components expose bindable states (\isRefreshing\, \isLoadingMore\) and reactive triggers (\refreshTrigger\, \loadMoreTrigger\) to manage UI updates, while also supporting custom header and footer animators for both standard and extended refresh behaviors.

PagingTableView · high confidence

Users can now view a curated list of repositories organized into three distinct visual sections: a horizontal carousel of the first six items, a vertical list of the next eight, and a card-style view of the remaining five. This new scene integrates with the existing navigation and data-fetching infrastructure, allowing users to browse and select individual repository details.

CleanArchitecture/Scenes/Repo/RepoCarousel · high confidence

Introduced the primary user interface for the application by adding a Main storyboard containing a MainViewController with a table view, and a LoginViewController with username and password fields. A Swift enum was added to provide type-safe access to the Main storyboard resource.

CleanArchitecture/Scenes/Storyboards · high confidence

Users can now access the app's primary navigation through a new MainViewController that displays a sectioned table view of menu items. The menu is organized into groups (Mock Data, API, Core Data, and Login), each containing specific screens such as product lists, repo collections, and user lists. Selecting a menu item navigates to the corresponding feature, with the MainViewModel handling the routing logic for all listed scenes.

CleanArchitecture/Scenes/Main · high confidence

Introduced a new \DynamicEditProduct\ scene for editing product details, including its view controller, view model, and associated table view cells. Added a suite of navigation protocols and implementations in the \Navigator\ directory to handle presenting various app screens, such as login, main, and product lists. The changes also include a \ValidationResultViewModel\ to manage validation state for form inputs.

CleanArchitecture/Scenes/Product · high confidence

Users can now view repositories in both a standard list and a grid layout. This change introduces the \ReposViewController\ and \RepoCell\ for a vertical list, as well as the \RepoCollectionViewController\ and \RepoCollectionCell\ for a grid view. Both scenes are wired to new \ReposViewModel\ and \RepoItemViewModel\ classes that handle data binding, loading states, and navigation to repository details.

CleanArchitecture/Scenes/Repo/Repos · high confidence

Introduced a new reusable UI component, EmptyDataView, which renders a simple 'NO DATA' message. This view is implemented via a new Swift class and its corresponding XIB file, providing a consistent way to display empty states across the application.

CleanArchitecture/Scenes/Common · high confidence

The app now includes a new \ColorCompatibility\ utility that provides fallback color values for iOS versions prior to 13, ensuring consistent theming across different OS versions. Additionally, a suite of extension methods was added to \UIViewController\, \UITableView\, \UICollectionView\, and \SharedSequenceConvertibleType\ to support reactive programming with RxSwift and RxCocoa, including error handling, loading states, and sequence synchronization.

CleanArchitecture/Support · high confidence

New domain entity structs have been introduced to represent core data models in the application. Product is a simple struct with id, name, and price. Repo represents a repository with details like name, URL, and owner, including coding keys for JSON mapping. User includes id, name, gender (with a name property for display), and birthday. All entities conform to the Then protocol for testability.

CleanArchitecture/Domain/Entities · high confidence

New domain use cases have been introduced to handle user and repository operations. This includes SetUpUserData for initializing user data and managing first-run states, FetchRepos for paginated repository fetching, and AddUsers for creating new users with validation. Additionally, FetchUsers and FetchPageDto support data fetching with pagination and caching options.

(repo-wide) · high confidence

The iOS application now includes the necessary asset catalog files to define the app icon for iPhone and iPad across all required resolutions and scales, as well as a LaunchScreen storyboard that displays the 'Clean Architecture Templates' text on startup.

CleanArchitecture/Resources · high confidence

Introduced new domain use cases for managing products, including DeleteProduct, FetchProductList, UpdateProduct, and their corresponding Data Transfer Objects (ProductDto, DeleteProductDto). These additions enable the application to handle product deletion, list fetching, and updates through a clean architecture pattern, with validation rules applied to product names and prices.

CleanArchitecture/Domain/UseCases/Product · high confidence

The repo carousel scene now includes a complete set of UI components for displaying repository items in different formats. This includes a card-style layout for grid display, a list-style layout for vertical scrolling, and a horizontal carousel with snapping behavior. The implementation introduces new cell types (CardPageItemCell, CarouselPageItemCell, ListPageItemCell) and their corresponding XIB files, along with layout configuration classes (CardSectionLayout, CarouselSectionLayout, ListSectionLayout) and supporting infrastructure like LayoutOptions and PageItemCell base class.

CleanArchitecture/Scenes/Repo/RepoCarousel/PageSection · high confidence

The RxCleanArchitecture package introduces a suite of reactive utilities for iOS development. It adds an ActivityIndicator system (including MultiActivityIndicator and PageActivityIndicator) to track loading states for single and paginated data sources. It also provides an ErrorTracker for centralized error observation, a Bindable protocol for view-controller binding, and helper extensions on RxSwift's Observable and SharedSequence types. Additionally, it includes a PagingInfo model and ViewModel extensions for fetching lists and pages of data.

RxCleanArchitecture · high confidence

The project's Xcode workspace and project configuration files have been added or updated, establishing the build environment for the CleanArchitecture application. This includes the main project file (project.pbxproj) which defines the source files, resources, and framework dependencies (such as RxSwift, SDWebImage, and CoreDataRepository), as well as the workspace data and settings files that manage the development environment.

CleanArchitecture.xcodeproj · high confidence

The CleanArchitecture module has been initialized with a complete base structure, including the main application entry point (AppDelegate) which sets up Core Data storage and binds the AppViewModel, alongside a dedicated UnitTestViewController for testing purposes. The project also introduces domain entities for paginated lists (PageItem, PageSection) and API endpoint definitions (GitEndpoint), establishing the foundational layers for the application's architecture.

CleanArchitecture · high confidence

The login use-case is now implemented in the domain layer, featuring a LoginDto that enforces non-empty username and password fields via the ValidatedPropertyKit. The Login protocol extension provides login and validation methods, integrating with the Dto package for data transfer and validation.

CleanArchitecture/Domain/UseCases/Login · medium confidence

Added three new Swift files in the CleanArchitecture/Data/UserDefaults directory: AppSettings.swift, CacheStorage.swift, and Storage.swift. These introduce @property wrappers (Storage and CacheStorage) that simplify reading and writing Codable values to UserDefaults, replacing the previous manual serialization and storage logic.

CleanArchitecture/Data/UserDefaults · high confidence

Added AppViewModel to centralize app-level logic and state management using the Factory pattern for dependency injection. Additionally, introduced RxPagingTableView to provide built-in support for pull-to-refresh and infinite scroll loading states, enhancing the user experience for list-based views.

CleanArchitecture/Scenes · high confidence

The application now uses dedicated gateway structs (AppGateway, ProductGateway, RepoGateway, UserGateway) to handle specific domain responsibilities. AppGateway manages first-run state, ProductGateway handles product listing and updates, RepoGateway fetches repository data via APIService, and UserGateway manages user data using CoreStore and CoreDataRepository. Each gateway is registered in the dependency injection container for injection into the rest of the application.

CleanArchitecture/Data/Gateways · high confidence

A new CoreDataRepository protocol and implementation have been added to the codebase, providing a reactive (RxSwift-based) and non-reactive API for creating, fetching, and deleting Core Data entities. This introduces a standardized way to interact with the local data store using the CoreStore library, exposing methods like create, fetchOne, fetchAll, and fetchCount that wrap Core Data operations in Observables for easier asynchronous handling.

CoreDataRepository · high confidence

Added a new LoginViewController and LoginViewModel to the CleanArchitecture project, introducing a reactive login flow using RxSwift and Factory for dependency injection. The screen includes text fields for username and password with real-time validation messages, enabling/disabling the login button based on input validity and loading states, and handles login success or error states.

CleanArchitecture/Scenes/Login · high confidence

Added API repository tests and test helpers; Added iOS test bundle configuration; Added mock gateway implementations for testing; Added test support utilities for the CleanArchitectureTests suite; Added unit tests for Main, UserList, and Menu components; Added unit tests for Product and Repo scenes; Added unit tests for the AppViewModel; Added unit tests for the Login scene; Added unit tests for the product list retrieval use case; Added unit tests for user data setup and repository list fetching.

The project now includes Swift Package Manager (SPM) manifests and a resolved dependency graph for the iOS application. This introduces dependencies on RxSwift (v6.8.0), CoreStore (v9.2.0), Factory (v2.3.2), SDWebImage (v5.19.7), and several other libraries, enabling the use of reactive programming patterns and data persistence in the Clean Architecture layers.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 50 → 46 (-3.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 98 (-2.4)
• Architecture 100 → 94 (-5.6)
• Maturity 41 → 56 (+15.3)
• Readiness 24 → 51 (+26.3)
• Security 100 → 100 (+0.0)
• Accessibility 25 (new)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• No exposed public API
• Scanner failed to run — not a clean result
• Test reliability not included
• complexity unreadable for .swift — churn × complexity hotspots could not be measured
• dormant codebase — no living knowledge left to concentrate

• Coverage not measured — Swift suite
• Documentation: no contributor guidance (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 3) (CleanArchitecture/Scenes/Repo/RepoCarousel/PageSection/Card/CardPageItemCell.swift)
• Duplicated block (10 lines × 3) (CleanArchitecture/Sources/LoadMore/RxPagingTableView.swift)
• Duplicated block (10 lines × 3) (CleanArchitecture/Sources/LoadMore/RxPagingTableView.swift)
• Duplicated block (10–11 lines × 2) (CleanArchitecture/Scenes/Product/Products/ProductsViewModel.swift)
• Duplicated block (11 lines × 2) (CleanArchitecture/Scenes/Product/SectionedProductCollection/SectionedProductCollectionViewController.swift)
• Duplicated block (12 lines × 2) (RxCleanArchitecture/Sources/RxCleanArchitecture/ViewModel/ViewModel+FetchList.swift)
• Duplicated block (13 lines × 2) (RxCleanArchitecture/Sources/RxCleanArchitecture/ViewModel/ViewModel+FetchList.swift)
• Duplicated block (13–15 lines × 2) (CleanArchitecture/Scenes/Product/DynamicEditProduct/DynamicEditProductViewModel.swift)
• Duplicated block (14 lines × 2) (CleanArchitecture/Scenes/Repo/RepoCollection/RepoCollectionCell.swift)
• Duplicated block (14 lines × 2) (CleanArchitecture/Support/Extensions/UICollectionView+.swift)
• Duplicated block (14–15 lines × 3) (CleanArchitecture/Sources/LoadMore/RxPagingTableView.swift)
• Duplicated block (15 lines × 2) (CleanArchitecture/Scenes/Product/Products/ProductsViewModel.swift)
• Duplicated block (15 lines × 3) (CoreDataRepository/Sources/CoreDataRepository/CoreDataRepository.swift)
• Duplicated block (15 lines × 3) (CoreDataRepository/Sources/CoreDataRepository/CoreDataRepository.swift)
• Duplicated block (15 lines × 5) (CoreDataRepository/Sources/CoreDataRepository/CoreDataRepository.swift)
• Duplicated block (15 lines × 6) (CleanArchitecture/Scenes/Product/SectionedProductCollection/SectionedProductCollectionViewController.swift)
• Duplicated block (17 lines × 2) (CleanArchitecture/Scenes/Repo/RepoCarousel/RepoCarouselViewModel.swift)
• …and 32 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

tuan188/RxCleanArchitecture was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.