Gist 230650

100%

✓ Published0🌍 Public

Last edited Nov 10, 2009

Created on Nov 10, 2009

This example demonstrates how DataMapper tracks object changes before and after an attribute update. It shows the `dirty?` state of a newly created `Foo` resource, then applies `update(:is_admin => true)` and inspects the result. The code uses the `dm-core` Ruby library and defines a `Foo` class with a `Boolean` `is_admin` property marked as the primary key. It illustrates DataMapper’s dirty-tracking API by printing the initial and post-update status of the resource instance.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 201082

This example demonstrates a bug in DataMapper's dirty-tracking behavior for associated resources. It shows that after creating a `Foo` with two `Baz` children and a `Bar` belonging to it, modifying the `Bar`'s name and saving it still leaves `bar.dirty?` returning true—even after a reload. The code uses DataMapper’s `dm-core` resource properties (`Serial`, `String`, `:nullable`), relationships (`has 1`, `has n`, `belongs_to`), and methods like `create`, `save`, and `reload` with an in-memory SQLite3 setup.

XXXX

78% match

Loading thumbnail…

Gist 203774

This example demonstrates a data model involving three linked DataMapper resources—Foo, Bar, and Baz—with bidirectional associations and a nullable belongs-to relationship for tracking a current bar. It shows how to define database schema properties, Sweatshop fixtures for generating sample records, and an in-memory SQLite setup followed by auto-migration. The code creates a Foo with its bars and bazs, then updates the Foo’s current_bar reference to its first bar, illustrating persistence and association handling through DataMapper’s API and the `dm-sweatshop` fixture generator.

XXXX

69% match

Loading thumbnail…

Gist 206559

This example demonstrates a subtle bug in DataMapper, a Ruby ORM, where defining a custom `foo` method and `foo=` setter on a resource class shadows the association defined by `belongs_to`. The code creates a `Foo` and a `Bar`, then assigns the string `'boom'` to `bar.foo` and reads it back, showing that the custom setter and getter are invoked instead of the association. It uses DataMapper’s `Resource` module, `has n` and `belongs_to` macros, and `DataMapper.setup` with an in-memory SQLite database via `sqlite3::memory:`. The output is a simple string assignment and retrieval, illustrating the override behavior.

XXXX

69% match

Loading thumbnail…

Gist 246048

This example shows a Ruby code snippet that extends DataMapper’s Resource class with a custom method for saving attributes while handling update conflicts. The `save_attributes` method first attempts an `update`, and on catching a `DataMapper::UpdateConflictError`, it assigns the attributes and calls `save` as a fallback. The visualization displays the raw source code from a GitHub gist, using no graphical libraries—it presents the code text directly as the primary visual element, with the DataMapper API as the concrete framework referenced.

XXXX

69% match

Loading thumbnail…

Gist 231720

This example demonstrates a bug in DataMapper validation where a boolean field incorrectly accepts `false` as valid. The code defines a `Foo` resource with an `age_check` Boolean property and a `validates_is_accepted` rule that should reject unaccepted values. Using DataMapper’s `setup` and `auto_migrate!` with an in-memory SQLite database, it creates a new record with `age_check` set to `false` and calls `valid?`, which returns `true` instead of the expected `false`. The snippet highlights the validation’s failure specifically for Boolean types, noting that changing the property to a String resolves the issue.

XXXX

63% match

Loading thumbnail…

Gist 54292

This example demonstrates how Ruby’s `instance_variable_set` and `instance_variable_get` can dynamically alter and read an instance variable defined on a class, using a module-scoped `@foo` that starts as `"bar"` and is changed to `"changed"` via a nested class method. The code defines a `What` module containing `@foo` and a `Whatever` class whose `change_foo` method mutates that variable, then prints its initial and updated values using `p`. The output, shown as comments (`# >> "bar"` and `# >> "changed"`), confirms the state change. No external libraries or rendering APIs are used; the example relies solely on Ruby’s core object model and metaprogramming features.

DDylanFM

60% match

Loading thumbnail…

Gist 189418

This example captures a runtime error trace from a Ruby on Rails application using DataMapper and SQLite. The visualization maps the call stack of a failed database INSERT operation, showing the sequence of method calls from the SQL adapter through the ORM to the controller and test framework. It highlights the datatype mismatch that occurs when inserting a record into the "locations" table, with the error propagating through the Merb framework and RSpec test suite. The gist documents the exact code path and failure point for debugging.

XXXX

54% match

Loading thumbnail…

Gist 850654

This example shows how to test authorization and role-protected attribute updates in a Rails controller using RSpec. It verifies that a user cannot edit another user’s profile, can change their own given name, and cannot modify their role field, with assertions on flash messages, response codes, and assigned attributes. The code uses Devise::TestHelpers to sign in a factory-built user, and RSpec’s `describe`, `context`, and `it` blocks to structure the test cases.

VVortex

54% match