ripple_effect 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e21f6c7b049337fe428c43688fc03649e6d0cba1900ffb4d0c201f21dbca43ae
+  data.tar.gz: 78f8ffcfb821ddbaeb8095c270896d75b8487052f453300d5df725fc8aceadca
+SHA512:
+  metadata.gz: 6cf0d03cf06db2aaf3994b801c0f34c84db7e02fd4310f5a89fb3dfe6d6216592f79f25f5b8e08c489b9974086ba25730b1271b0eda28b2dffa4f57e0851e768
+  data.tar.gz: f940b74752a7a87816d52e12ec6bfcb09ebad291cf0f0073f0a3e98288ea899839d33e59bf93c712112c2ffe29122f1f912a34f3292d9d50be4752cd8c57bbc2

data/.ripple-effect.yml.example

@@ -0,0 +1,56 @@
+version: 1
+
+paths:
+  include:
+    - app/**/*.rb
+    - lib/**/*.rb
+    - config/routes.rb
+    - config/routes/**/*.rb
+    - spec/**/*.rb
+    - test/**/*.rb
+  views:
+    - app/views/**/*.erb
+  discover_engines: true
+  exclude:
+    - vendor/**
+    - node_modules/**
+    - tmp/**
+    - log/**
+    - coverage/**
+    - public/assets/**
+    - storage/**
+    - .bundle/**
+    - .git/**
+
+analysis:
+  min_confidence: medium
+  default_depth: all
+  include_low_confidence: false
+
+rails:
+  routes: true
+  associations: true
+  callbacks: true
+  jobs: true
+  mailers: true
+  delegation: true
+  views: true
+
+tests:
+  framework: auto
+  unsafe_global_files:
+    - Gemfile
+    - Gemfile.lock
+    - config/application.rb
+    - config/environment.rb
+    - config/boot.rb
+    - config/environments/**
+    - config/initializers/**
+    - config/routes.rb
+    - spec/spec_helper.rb
+    - spec/rails_helper.rb
+    - test/test_helper.rb
+
+cache:
+  enabled: true
+  directory: tmp/ripple_effect

data/ARCHITECTURE.md

@@ -0,0 +1,222 @@
+# Architecture
+
+RippleEffect is a pipeline. Each stage has one job, produces plain value objects,
+and can be tested on its own.
+
+```
+project files
+     |
+     v
+[ Project ]            selects files, keeps every path inside the root
+     |
+     v
+[ StaticIndex ]        Rubydex, behind an adapter -> Declarations, References
+     |
+     v
+[ Extractors ]         Ruby structure, then Rails semantics -> Nodes, Edges
+     |
+     v
+[ Graph ]              typed, evidenced, deterministic; forward + reverse indexes
+     |                              ^
+     |                              |
+     |                        [ CacheStore ]  JSON on disk, content-keyed
+     v
+[ Query | Diff ]       a symbol, or Git-changed symbols
+     |
+     v
+[ ImpactWalker ]       breadth-first reverse traversal -> Impacts with evidence
+     |
+     v
+[ Risk | Tests ]       explainable band; ranked test files
+     |
+     v
+[ Result ]  ->  [ Formatters ]  text | json | dot
+```
+
+## The graph is the product
+
+Everything else exists to build it or to ask questions of it.
+
+A **node** is an addressable thing: a file, class, module, method, route, callback,
+job, or mailer action. Node IDs are deterministic strings that include the path,
+so a class reopened in two files does not collide:
+
+```
+method:app/services/billing_service.rb:BillingService#charge
+class:app/models/order.rb:Order
+route:config/routes.rb:5:route:POST:/checkout
+```
+
+An **edge** is a directed, evidenced relationship. The direction never varies:
+
+> `from_id` **depends on / invokes / references** `into_id`
+
+That single rule is what makes the whole thing work: walking edges *backwards*
+from a changed node finds everything that could break.
+
+Every edge carries an `evidence` code (`rails.after_commit`,
+`rubydex.constant_reference`, `convention.rspec_path`) and a `confidence` band.
+No extractor may add an edge it cannot evidence.
+
+## The Rubydex adapter boundary
+
+Ruby declarations and references come from [Rubydex](https://github.com/Shopify/rubydex).
+Rubydex is fast, Ruby-aware, and young: its API is still moving. So it is sealed
+behind `StaticIndex::Adapter`, and `RubydexAdapter` converts everything into our
+own `Declaration`, `MethodReference` and `ConstantReference` structs *immediately*.
+
+No Rubydex object is ever visible outside `lib/ripple_effect/static_index/`. There
+is a spec that asserts exactly this.
+
+The adapter also absorbs two things nobody else should have to know:
+
+- Rubydex reports **zero-indexed** lines. Git, editors and humans count from one,
+  so the adapter shifts them at the boundary.
+- Rubydex names singleton methods `Order::<Order>#recent`. The adapter normalises
+  that to the documented canonical form `Order.recent`.
+
+Replacing the indexer means rewriting one file.
+
+## Extractors
+
+Extractors add nodes and edges. They run in a fixed order because they build on
+each other:
+
+1. **RubyStructure**, files, classes, modules, methods, inheritance, mixins,
+   constant references, method calls. Creates the nodes everything else attaches
+   to, so it is never optional.
+2. **RailsAssociations**, `belongs_to`, `has_one`, `has_many`, `has_and_belongs_to_many`.
+3. **RailsCallbacks**, the lifecycle macros, including conditions and blocks.
+4. **RailsJobs**, job classes and `perform_later` / `perform_now` sites.
+5. **RailsMailers**, mailer actions and `deliver_later` / `deliver_now` sites.
+6. **RailsRoutes**, `config/routes.rb`.
+7. **RailsDelegation**, `delegate ..., to:`, which resolves targets *through*
+   associations, so it must run after them.
+8. **TestConventions**, links test files to what they cover. Runs last, so it can
+   see every node.
+
+The declaration index tells us *that* `belongs_to` was called; only an AST tells us
+what it was called with. The Rails extractors therefore parse with **Prism**,
+sharing one `SourceCache` so each file is parsed at most once.
+
+Each Rails extractor can be switched off in configuration.
+
+## Method call resolution
+
+Ruby dispatch is dynamic, so this is where honesty matters most.
+
+| Situation | What we do | Confidence |
+| --- | --- | --- |
+| Rubydex resolved the receiver | Link to that exact method | `high` |
+| Receiver unresolved, one method in the project has that name | Link to it | `medium` |
+| Receiver unresolved, several methods share the name | **No edge.** Record a diagnostic |, |
+| `send`, `public_send`, `method_missing`, generated methods | **No edge** |, |
+
+The third row is the important one. Picking one of several candidates would
+produce a confident falsehood, and one of those costs more trust than ten honest
+"I don't know"s.
+
+## Diff mapping
+
+Marking every declaration in a touched file as changed would give a one-line fix
+an enormous, useless blast radius. Instead:
+
+1. `git diff --unified=0` gives hunks with no context, so every reported line
+   really changed.
+2. Added and modified lines are mapped through the live index to the **smallest
+   enclosing declaration**, a method, not its class.
+3. Deleted lines exist only in the base revision, so that content is fetched with
+   `git show BASE:path` and parsed separately with Prism. If the deleted symbol is
+   gone entirely, the change is attributed to the class that owned it: which is
+   what its former dependents actually referenced.
+4. Lines inside a file but outside any declaration mean the *file* changed.
+5. Renames, deletions and untracked files are each recorded as diagnostics.
+
+Git is always invoked with argument arrays, so a ref is only ever a ref.
+
+With only a `BASE`, the comparison is against the working tree and includes
+staged, unstaged **and untracked** files. `git diff` alone cannot see the last of
+those, so they are collected separately.
+
+## Traversal
+
+`ImpactWalker` does a breadth-first reverse walk from the changed nodes.
+
+Breadth-first is not an implementation detail. It means the evidence path we
+report is the *shortest* chain of reasoning, which is the one a human can check
+fastest. Where two paths are equally short, the more confident one wins.
+
+A path's confidence is its **weakest link**, a chain of reasoning is only as good
+as its worst step.
+
+Cycles are handled with a visited set. Depth is unlimited by default, with
+`--depth N` to narrow.
+
+## Risk
+
+`Risk` turns graph facts into a band (`low` / `medium` / `high` / `critical`) plus
+the reasons for it. The formula lives in one class, is fully documented, and is
+tested against its thresholds.
+
+It counts dependents (capped, so one huge fan-out cannot dominate), adds points
+for reachability from an entry point (route, job, callback, mailer), for touching
+a whole class body rather than a method body, for changing a boot-impact file, and
+for spanning several architectural layers.
+
+File nodes are excluded from the counts: they exist so a file-level change can
+reach the code it declares, and counting them would inflate every score.
+
+Risk is a ranking aid for reviewers. It is not a prediction of defects, and there
+are no percentages.
+
+## Test relevance
+
+Test files reached by the walk are ranked by *why* they were reached:
+
+1. `reference`, the test actually mentions the changed code
+2. `rails_semantic`, reached through a Rails relationship
+3. `convention`, it sits at the conventional path
+4. `heuristic`, a looser path match, such as a request spec
+
+A changed test file is always worth running, so it ranks first.
+
+When a global or boot-impact file changes, no narrow answer is trustworthy, and
+`tests` refuses to print one unless `--allow-unsafe-focus` is given.
+
+## Cache
+
+A built graph is written to `tmp/ripple_effect/` as JSON: never Marshal, because a
+cache file is ordinary data that any process can write, and Marshal would turn a
+corrupted cache into arbitrary object construction.
+
+The cache key is a SHA-256 over the tool version, cache schema version, indexer
+version, Ruby version, config digest, and the content digest of every indexed
+file. Correctness beats clever invalidation.
+
+A cache that cannot be read is discarded and rebuilt, with a diagnostic. It is
+never fatal.
+
+## Determinism
+
+Identical input must produce byte-identical output, or the JSON contract cannot be
+snapshot-tested and CI diffs become noise.
+
+- Files are indexed in sorted order.
+- Node and edge IDs are derived, never random.
+- Duplicate edges are suppressed by `(from, into, type, evidence)`.
+- Every traversal sorts its frontier by node ID.
+- Results sort by `(depth, node id)`; diagnostics by `(path, line, code)`.
+- Serialised key order is fixed.
+
+## Security
+
+The threat model is simple: RippleEffect reads files and runs `git`.
+
+- No network, no telemetry.
+- The application is never booted; its source is never `eval`ed.
+- Git runs through `Open3.capture3` with argument arrays.
+- YAML is loaded with `safe_load_file`, no aliases, no permitted classes.
+- Paths are normalised, symlinks resolved, and anything resolving outside the
+  project root is refused.
+
+See [SECURITY.md](SECURITY.md).

data/CHANGELOG.md

@@ -0,0 +1,115 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Versioning policy
+
+The public API covered by SemVer is:
+
+- The `ripple-effect` command line: its commands, flags, exit codes, and the
+  stdout/stderr contract.
+- The JSON document, identified by `schema_version`. A breaking change to it
+  increments `schema_version` **and** the major version.
+- The documented Ruby API: `RippleEffect.analyze`, `.diff`, `.tests_for`, and the
+  public classes `Configuration`, `Project`, `Analyzer`, `Result`, `Node`, `Edge`,
+  `Error`.
+
+Not covered: extractor internals, the static-index adapter, exact risk scores,
+diagnostic message wording (the `code` is stable, the message is not), and the
+on-disk cache format.
+
+While the version is `0.x`, minor versions may make breaking changes; they will be
+listed here.
+
+## [Unreleased]
+
+Nothing yet.
+
+## [0.1.0] - 2026-09-10
+
+First release.
+
+### Added
+
+- **Change-impact graph.** Typed, evidenced, deterministic. Every edge carries an
+  evidence code and a confidence band (`high` / `medium` / `low`).
+- **Ruby structure analysis** via [Rubydex](https://github.com/Shopify/rubydex),
+  behind an adapter: classes, modules, instance and singleton methods,
+  inheritance, `include` / `prepend` / `extend`, constant references, and method
+  calls.
+- **Rails semantics** via [Prism](https://github.com/ruby/prism): associations,
+  lifecycle callbacks (including conditions and blocks), Active Job enqueues,
+  Action Mailer deliveries, routes, and delegation.
+- **`ripple-effect inspect SYMBOL`**, what may be affected by a change, and why.
+- **`ripple-effect diff BASE [HEAD]`**, blast radius of a Git range, mapping
+  changed lines to the smallest enclosing declaration rather than to whole files.
+  Handles added, modified, deleted, renamed, staged, unstaged and untracked files.
+- **`ripple-effect tests BASE [HEAD]`**, ranked relevant test files, printed as
+  bare paths so they compose in a shell. Refuses to narrow the suite when a
+  boot-impact file changes, unless `--allow-unsafe-focus` is given.
+- **`ripple-effect graph SYMBOL`**, the impacted subgraph as DOT or JSON.
+- **`ripple-effect doctor`**, project, environment and index health, plus a
+  restatement of the privacy guarantees.
+- **`ripple-effect version`.**
+- **Explainable risk scoring**, discrete bands with stated reasons, never a
+  probability.
+- **JSON output** with `schema_version: 1`, deterministic ordering, and a JSON
+  error envelope on stderr.
+- **Embeddable Ruby API**, `RippleEffect.analyze`, `.diff`, `.tests_for`.
+- **Content-keyed JSON cache** that self-heals when corrupt.
+- **View layer analysis.** ERB templates and partials are indexed: a controller
+  action links to its conventional template, templates link to the partials they
+  render, and template helper calls and constant references are resolved under
+  the same rules as Ruby. `helper_method` is modelled, including when the method
+  comes from an included concern. Templates are never rendered or executed.
+- **Configuration** via `.ripple-effect.yml`, safely loaded, with warnings for
+  unknown keys and hard errors for invalid values.
+
+### Added during validation against real applications
+
+- **Engine monorepo support.** Directories that are Rails engines or gems in
+  their own right: an `app/` plus a `*.gemspec` or `lib/**/engine.rb`, are
+  discovered and indexed. Solidus went from 2 indexed files to 1,810. Disable
+  with `paths.discover_engines: false`.
+- **`doctor` reports templates indexed and engines discovered.**
+- **`script/ground_truth.rb`**, which checks RippleEffect's answers against an
+  exhaustive text search of a real application.
+- **Rails DSL compatibility specs** that pin the routing, model, job, mailer and
+  template forms each supported Rails version uses. The CI Rails matrix now
+  actually exercises them; previously it ran a suite that never loaded Rails.
+
+### Fixed during validation against real applications
+
+- **A root whose casing differed from the directory on disk produced an empty
+  analysis with no error.** On case-insensitive filesystems (macOS, Windows)
+  `--root ~/code/appease` would find every file in `~/code/AppEase` and then
+  discard every declaration. The project root is now anchored on the filesystem's
+  own spelling, and symlinked roots resolve the same way.
+- **Indexer lint findings were reported as parse failures.** "assigned but unused
+  variable" and similar notes about perfectly valid files were surfaced as
+  `unparsed_file` warnings. They are now `index_note` diagnostics at `info`.
+- **A cached run reported no diagnostics at all**, so running twice made the tool
+  look more confident the second time. Diagnostics are now stored with the graph.
+- **Indexing files and finding no declarations is now a loud error**
+  (`empty_index`) rather than a confident empty answer.
+- **`doctor` created a directory inside the analysed project** while checking
+  cache writability, even when run with `--no-cache`. It now inspects the nearest
+  existing ancestor instead and creates nothing.
+- **The gem claimed support for Ruby 4.0, which does not exist.** Supported and
+  tested versions are Ruby 3.2, 3.3 and 3.4; the gemspec bound is now `< 5.0`.
+- Analysis of a 5,000-file project went from 7.1s to 1.5s by removing quadratic
+  path and ancestry lookups.
+
+### Security
+
+- No network access, no telemetry.
+- The analysed application is never booted and its source is never `eval`ed.
+- Git is invoked with argument arrays, never a shell string.
+- YAML is loaded with `safe_load_file`; the cache is JSON, never Marshal.
+- Paths are confined to the project root, with symlinks resolved before the check.
+
+[Unreleased]: https://github.com/iamzayn19/ripple-effect/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/iamzayn19/ripple-effect/releases/tag/v0.1.0

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,64 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body size,
+visible or invisible disability, ethnicity, sex characteristics, gender identity
+and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+- Focusing on what is best for the overall community
+
+Examples of unacceptable behavior:
+
+- The use of sexualized language or imagery, and sexual attention or advances
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive, or
+harmful.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an
+individual is officially representing the community in public spaces.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement through the
+repository's private contact channels. All complaints will be reviewed and
+investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+https://www.contributor-covenant.org/version/2/1/code_of_conduct.html.
+
+[homepage]: https://www.contributor-covenant.org

data/CONTRIBUTING.md

@@ -0,0 +1,112 @@
+# Contributing
+
+Thanks for considering a contribution.
+
+## Setup
+
+RippleEffect targets Ruby 3.2–4.0. The repository pins 3.4.7 in `.tool-versions`.
+
+```console
+$ bin/setup            # or: bundle install
+$ bundle exec rake     # specs + RuboCop; this must be green
+```
+
+## The commands you need
+
+```console
+$ bundle exec rake              # specs + RuboCop (the default task)
+$ bundle exec rspec             # specs only
+$ bundle exec rspec spec/unit   # fast unit specs
+$ bundle exec rubocop -a        # autocorrect
+$ bundle exec rake smoke        # build, install into a temp GEM_HOME, run the CLI
+$ bundle exec rake benchmark    # indexing benchmarks
+```
+
+Try it against the fixture application:
+
+```console
+$ bundle exec ruby -Ilib exe/ripple-effect --root spec/fixtures/rails_app inspect 'BillingService#charge'
+```
+
+## The principles this project is built on
+
+Please read [ARCHITECTURE.md](ARCHITECTURE.md) first. A few rules are not
+negotiable, because the product is trust:
+
+1. **Never invent an edge.** Every edge carries an evidence code and a confidence
+   band. If you cannot evidence a relationship, do not add it.
+2. **Prefer a false negative to a confident false positive.** When a target is
+   ambiguous, record a diagnostic and add nothing. One confident falsehood costs
+   more than ten honest "I don't know"s.
+3. **Never execute the analysed application.** No booting, no `eval`, no database,
+   no network. Ever.
+4. **Output must be deterministic.** Identical input, byte-identical output.
+5. **Keep Rubydex behind the adapter.** Nothing outside
+   `lib/ripple_effect/static_index/` may see a Rubydex object.
+6. **Keep the layers apart.** No CLI parsing in domain objects, no formatting in
+   analysis objects, no Rails dependency in core code, no global state.
+
+## Adding a Rails extractor
+
+Rails extractors are the most likely contribution. To add one:
+
+1. Create `lib/ripple_effect/extractors/rails_<thing>.rb`, subclassing
+   `Extractors::Base`.
+2. Define `self.feature` to return the config key that switches it off, and add
+   that key to `Configuration::RAILS_EXTRACTORS`.
+3. Read only **literal** DSL forms. Never execute a block, scope, or proc.
+4. Give every edge an evidence code (`rails.<macro>`) and an honest confidence
+   band. Emit a diagnostic when a target cannot be resolved.
+5. Register it in `Analyzer::EXTRACTORS`, in dependency order: associations must
+   run before delegation, and `TestConventions` runs last.
+6. Add `spec/unit/rails_<thing>_spec.rb` covering positive cases, negative cases,
+   the unresolvable case, and the config-off case.
+7. Document the edge types, evidence codes and diagnostics in
+   [docs/ANALYSIS_MODEL.md](docs/ANALYSIS_MODEL.md), a spec checks that every one
+   is documented.
+
+Use `Extractors::Base` helpers rather than re-parsing: `each_call_in_class`,
+`literal_keywords`, `literal_positional_names`, `constant_path_name`, `classify`.
+
+## Tests
+
+Every behaviour change needs a spec. See [docs/TESTING.md](docs/TESTING.md).
+
+- `spec/unit/`, one file per class or extractor.
+- `spec/integration/`, the fixture app, the Git diff engine, the JSON contract,
+  the CLI, and documentation consistency.
+- `spec/fixtures/rails_app/`, a static, Rails-shaped app. It never boots. Its
+  `*_spec.rb` files are **analysis input, not tests**, and are excluded from runs.
+
+Diff behaviour is tested against real, temporary Git repositories, because a stub
+would let us pass against a Git that behaves differently from the user's.
+
+## Style
+
+RuboCop is the arbiter; `bundle exec rake` must be green.
+
+Beyond that: boring, conventional Ruby. Small classes with one job. Keyword
+arguments for multi-parameter constructors. Value objects with readers. Explicit
+constants for kinds and types. No metaprogramming, no monkey patches.
+
+Comments should explain **why**, not restate the code. The interesting comments in
+this codebase are the ones explaining a judgement call: why an edge is `medium`
+and not `high`, why a fallback exists.
+
+## Pull requests
+
+- One logical change per PR.
+- Explain the reasoning, not just the diff.
+- Include specs, and update the docs when behaviour changes.
+- Add a `CHANGELOG.md` entry under `## [Unreleased]`.
+- Confirm `bundle exec rake` and `bundle exec rake smoke` both pass.
+
+## Issues
+
+For a bug, the most useful report includes: your Ruby and Rails versions, the
+command you ran, what you expected, what happened, and: if you can share it: a
+minimal snippet that reproduces it. `ripple-effect doctor --format json` output is
+very helpful.
+
+For a wrong or missing edge, please say what relationship you expected and where
+in your source it comes from. That is usually enough to write the failing spec.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iamzayn19
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.