Code Monkey home page Code Monkey logo

keepitclean's Introduction

pipeline status

KeepItClean

An awesome implementation of MVI and Clean Architecture. The current project makes use of all the latest depedencies and android tools. The project is completely written in kotlin, cherry on the ice is that the gradle files too are writtend using DSLs that make this project up to date till now. The project follows complete Test Driven Development. A star thing in this TDD is that the testing is performed even before the Presentation Layer(UI components) are prepared. The project is stale nowadays due to multiple engagements but will be continued soon

  • If you are looking to submit patches, then please do note that reviewing practices are quite strict, so sometimes you may have to add appetize url of the apk in the PR when demanded or needed.

Deploying to Appetize.io

Follow these steps to deploy your app to appetize.io:-

  1. Get an API token from here: https://appetize.io/docs#request-api-token.

  2. Create a CI/CD variable for api token named "APPETIZE_API".
    Follow this guide to learn how to add CI/CD variables to your gitlab repository: https://docs.gitlab.com/ee/ci/variables/#creating-a-custom-environment-variable

  3. Run the following command once to upload the app.
    curl https://[email protected]/v1/apps -F "file=@path_of_file_to_be_uploaded.apk" -F "platform=android"
    Replace API_TOKEN with the api token you got in step 1.
    Replace file_to_upload.apk with your apk file.

  4. Command in step 3 will return a response. Note the public key from your response and add a CI/CD varible named "APPETIZE_KEY" and enter this public key as value.
    Make sure to make both the varibales protected and make your branch protected too. Follow this guide: https://docs.gitlab.com/ee/user/project/protected_branches.html#configuring-protected-branches

    This is a one time setup, subsequent changes you make in your repository will be reflected in your link you got in the response automatically.

Info regarding the branch(deepenCore)

  • This branch is all about deepening the core module functionality
  • Means in the commits made in this branch i've added more functionalities like DataChannelManager and hence deepened the core module
  • More specifically, in this branch, i've written classes that manage state,i.e, StateManagement oriented

State Management

  • Consider a scenario where a user clicks an interactive component of the app
  • (This is the current initial state of the app)
  • A corresponding output/change is then reflected on the screen
  • Technically speaking, that reflected change is termed as a state change
  • (State here has got no special meaning, it is just what it is normally)
  • The process that occurs down the architecture lane behind the scenes to cause the change reflected on the screen is handled by stateManagement

keepitclean's People

Contributors

s-ayush2903 avatar tejas1510 avatar

Stargazers

 avatar  avatar  avatar  avatar

Watchers

 avatar

keepitclean's Issues

feat: Optimize InsertNewNote Use Case

  • Currently there is no error handling for caching and
  • There exists nothing like safeApiCall while updating/inserting the note(s) to the firestore
  • SafeApiCall is something that responses in a good manner for failed requests, errors and exceptions
  • Implement both of 'em

feat: Plan UseCases

  • Plan UseCases for the module
  • This is a simple noteTaking app, nothing fancy, only thing to learn is arch.
  • So, write normal/common usecases
  • Take care of networking services(Firestore) while writing 'em
  • You are just supposed to plan 'em only, the functionality can/will be implemented later
  • By planning, you are expected to just create classes only
  • Don't disturb the module structuring, i.e., the way the packages are sorted and placed
  • While filing an MR, attach the visual of the package structure for easy reviewing
  • And please don't touch the gradle.kts files

chore: Modify NoteServices

  • Abstract NoteDaoService and NoteFirestoreService the correct way
  • Currently NoteDaoService has search function implemented the wrong way
  • Change that and look for same nits in the NoteFirestoreService

chore: Use ktDSLs

  • Write gradle files containing dependencies in ktDomainSpecificLang.
  • Keep it as clean as possible
  • Structure package tree better/beautiful

chore: Implement Core Domain Module

Initialize the project by writing a few of the innermost/core cases/files for the module so first begin by Domain Module.

Proceed as follows:

  • Start by building the Domain Layer
  • Define Note Objects/classes
  • Add a factory for the same
  • Simultaneously handle the timestamp and date conversion issues as well
  • Make use of firebase utility/in-built functions to minimize the efforts and maintain brevity
  • Do all of the above assuming that the dagger has been implemented
  • (The best one is to introduce di and then start doing all that stuff)
  • Be as succinct as possible
  • Write proper neat and well documented code

tests: Setup Test Environ

We'll be following the tdd completely, no excuses!

  • So setup the environment for testing in the codebase
  • Try using fakes as far as possible

chore: Build Data Layer for Network

  • Start by writing constants
  • Then go for event handlers
  • Then write abstractions and implementations of network layer
  • Afterwards, ResponseHandlers for the result from handlers(mentioned in 2nd point)
  • If get stuck, then follow #16

chore: Build CacheLayer

  • Start building the caching layer in the module
  • Follow the practices that were being followed in solving the previous issues
  • Use Generics

docs: A patch needed for readme

  • Explain how the clean architecture works, it functionality most of it along with the proper diagrams(handwritten or slides, either would work) and add some material/resources like blogs for absolute Naives to begin with.
  • The readme should be powerful enough to instill a deep meaning of Clean Arch. in the mind of that Naive
  • For your assistance, I'm attaching a few resources to begin with observe their documenting style(only of readme)
  1. Repo(in Kt.)
  2. Most Popular Repo(in Java)
  • Ask if you get stuck, don't hesitate to ask

Docs: Add Contributing.md file

I think it is important to have contributing guidelines so that an open-source contributor know how to contribute properly.
Can I work on this?

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.