uber/RIBs

Features

• Router-Interactor-Builder Implementations - Defines the core Router-Interactor-Builder pattern that structures every component in the framework.
• Mobile Architecture Frameworks - Provides a complete mobile architecture framework with isolated business logic units and lifecycle-scoped state management.
• Navigation Workflows - Provides a workflow engine that models multi-step navigation sequences as chains of asynchronous steps traversing the RIB tree.
• Viewless Components - Creates viewless RIB scopes that manage routing and business logic without allocating a view in the hierarchy.
• Nested State Management - Manages complex state transitions by attaching and detaching child RIBs in a tree hierarchy, scoping decisions per unit.
• Immutable Reactive Stream Exposure - Exposes read-only reactive streams to child RIBs, allowing observation without mutation.
• Static Analysis Rules - Enforces null safety and architectural rules through build-time static analysis across the component hierarchy.
• Navigation Workflow Engines - Ships a workflow engine that models multi-step navigation sequences and deep link handling across the RIB tree.
• Navigation Workflow Runners - Defines sequences of asynchronous steps that traverse the component tree to transition the app to a target state.
• Protocol-Based Dependency Declarations - Ships a protocol-based dependency declaration system where each RIB defines its required dependencies in a component class.
• Listener Interfaces - Ships listener interfaces for child-to-parent event communication, enabling loose coupling between RIBs.
• Architecture Rule Enforcement - Runs build-time static analysis to enforce null safety, subscription disposal, and structural constraints across the component tree.
• Lifecycle-Scoped Execution - Scopes interactor subscriptions and state changes to active lifecycles, preventing stale updates and memory leaks.
• Reactive Stream Lifecycles - Manages reactive stream subscriptions scoped to component lifecycles with automatic disposal.
• iOS-Android Component Alignment - Synchronizes component structure and patterns across iOS and Android to maintain implementation alignment between platforms.
• Dependency Injection Frameworks - Implements a hierarchical dependency injection system scoping dependencies per business logic node.
• Component-Based Dependency Management - Ships a component-based dependency injection system that scopes dependencies per business logic node.
• Mobile Injection Frameworks - Provides a hierarchical dependency injection system optimized for mobile application lifecycles.
• Business Logic Scopes - Defines business scopes purely by application logic states, separate from view-based UI scopes.
• Hierarchical Component Wiring - Provides a hierarchical dependency injection system that wires parent builder components to child RIB dependencies.
• Protocol-Oriented Injection - Passes builder and view controller dependencies through constructor injection using protocols for loose coupling and testability.
• Dynamic Child Attachment - Dynamically attaches child RIBs to parent routers, giving interactors control over child appearance.
• Parent-Child Listener Communication - Uses listener interfaces for child-to-parent event communication, keeping child RIBs unaware of parent implementation details.
• Compile-Time Disposal Enforcement - Blocks compilation when Rx subscriptions lack AutoDispose scoping, preventing memory leaks at build time.
• Cross-Platform Mobile Architectures - Provides a shared architectural pattern across iOS and Android for aligned business logic and routing.
• Batch Disposals - Disposes Rx subscriptions automatically when a child component detaches from its parent, preventing memory leaks.
• Lifecycle-Scoped Stream Subscriptions - Subscribes to observable data streams in interactors and automatically disposes subscriptions when deactivated.
• Listener-Based Reactive Updates - Updates parent state by passing data through listener callbacks and updating shared reactive streams.
• Build-Time Null Check Verification - Verifies null safety at build time by checking that nullable values are handled before use, preventing null-pointer exceptions.
• Scoped Stateful Object Sharing - Provides scoped singleton state sharing across a RIB and its child RIBs.
• View-Independent Logic Trees - Decouples business logic from the view hierarchy, allowing deep logic scopes with a shallow view tree.
• Subscription Lifecycle Management - Enforces automatic disposal of Rx subscriptions scoped to interactor lifecycles, blocking compilation on missing disposal.
• Presenter-Mediated Event Routing - Routes view events like button clicks to the interactor through a presenter interface for business logic processing.
• Business Logic Isolation - Encapsulates business logic, routing, and view logic into separate classes with distinct lifecycles for testability.
• Child RIB Routing - Attaches and detaches child RIBs from parent routers to keep the RIB and view hierarchies consistent.
• Dynamic Child Attachment and Detachment - Dynamically attaches and detaches child RIBs with their views to transition between application states.
• Builder Method Data Injection - Passes dynamic data into RIB builder methods so child RIBs access them as scoped dependencies.
• Component Communication - Passes data downward through reactive streams or build parameters and upward through listener interfaces between components.
• State-Driven UI Rendering - Drives view rendering based on application state, such as showing a login screen when the user is logged out.
• Parent-to-Child Data Flows - Passes runtime data from parent RIBs to children through the dependency injection tree during build time.
• Hierarchical Dependency Scopes - Provides hierarchical dependency injection that scopes object lifetimes per business logic node in the component tree.
• Per-Node Dependency Scopes - Defines explicit dependencies per business logic node and injects them from parent nodes through hierarchical DI.
• Listener-Based Action Processing - Processes user actions by routing view events to interactors through listener protocols for business logic handling.
• Viewless - Supports viewless business logic nodes that manage routing and state independently from the view hierarchy.
• Component-Based State Management - Manages application state through isolated, lifecycle-scoped business logic units in a tree hierarchy.
• Lifecycle-Managed Child Routing - Implements a routing pattern where parent RIBs transfer control to child RIBs with full lifecycle management.
• Sequential Step Orchestrators - Links a series of actions so each step receives the result of the previous one and passes control to the next actionable item.
• Viewless RIB Generators - Generates viewless RIBs with cleanup methods for manual view hierarchy management.
• Deep Link Data Validators - Validates parsed deep link models and aborts workflows if required fields are missing.
• Deep Link Workflow Definitions - Defines multi-step navigation sequences in a single place that compile to chains of actions for deep link handling.
• Conditional Navigation Waiting - Provides conditional waiting in workflow steps, blocking until asynchronous conditions are met before continuing navigation.
• RIB Template Generators - Creates standard RIB file sets from IDE templates to reduce manual boilerplate.
• Code Generation Tools - Provides IDE-integrated code generation for RIB components and test stubs from templates.
• Test Scaffolding Generators - Generates unit test scaffolding for Router and Interactor classes from Xcode templates.
• RIB Component Generators - Provides Xcode templates for generating Router-Interactor-Builder units with optional view controllers.
• IDE Code Generation Plugins - Provides IDE plugins that generate boilerplate RIB components and test stubs from templates.
• RIB Component Scaffolders - Generates complete RIB component sets including Builder, Interactor, Router, and View classes from IDE commands.
• RIB Scaffolding Plugins - Ships IDE plugins that scaffold new RIBs and test files for both iOS and Android.
• URL Scheme Handlers - Registers custom URL schemes and forwards incoming URLs to the root interactor for processing.
• Reactive Score Streams - Tracks scores using mutable reactive streams scoped to parent RIBs with read-only observable interfaces for children.
• Workflow-Based Activity Launchers - Starts secondary activities from any RIB and delivers results back via workflows, handling process death and state restoration.
• Deep Link Routing - Parses deep link parameters and navigates directly to the corresponding screen, skipping intermediate states.
• Deep Link Intent Parsers - Extracts parameters from incoming intents into validated model objects that drive navigation workflows.
• Deep Link Workflows - Implements multi-step asynchronous workflows for parsing, validating, and routing deep links.
• Ownership in Component Trees - Assigns strong and weak references between routers, interactors, and views to prevent retain cycles in the RIB tree.
• RIB - Generates Builder, Interactor, Router, and ViewController classes from Xcode templates.
• Shared State Management - Elevates shared state into an AppScope or designs RIB hierarchies independent of views for cross-service state access.
• Interactor - Tests interactor behavior using generated helpers and mocks to verify listener calls without device dependencies.
• Router Behavior - Verifies routing logic by mocking builder and router dependencies and counting method invocations on those mocks.
• Viewless Component Cleanup - Automatically removes child views from the parent hierarchy when a viewless RIB is detached.
• Independent Navigation Stacks - Lets each RIB define its own back stack behavior with utility classes for common navigation strategies.
• Dependency-Injected Data Display - Displays data by injecting named string dependencies into child interactors and passing them to presenters.
• Architecture Best Practices - Cross-platform mobile architecture framework.

Star-Verlauf