Gist 203774

100%

✓ Published0🌍 Public

Last edited Oct 7, 2009

Created on Oct 7, 2009

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.

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

79% 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

75% match

Loading thumbnail…

Gist 230650

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.

XXXX

69% 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

62% 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

62% 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

61% match

Loading thumbnail…

Gist be32a2ac117700d3dbde6b0824367ba5

This example demonstrates how to create a simple database table visualization from a SQL schema definition. The code defines a `Demo` table with three columns—`ID`, `Key`, and `Value`—and shows how to map those column types and constraints into a visual entity-relationship style diagram. Using the provided `CREATE TABLE` statement as the data source, the visualization renders each column as a node, with the primary key and nullable attributes indicated through distinct visual encodings. The implementation leverages `d3.forceSimulation` for the node layout and `d3.geoPath` for any geometric rendering, while relying on standard DOM elements for interactivity. No additional behavior beyond the table’s structural representation is implied.

HHugoberry

56% match

Loading thumbnail…

Gist 189433

This visualization shows a Ruby data fixture that defines user account attributes for a test suite. It uses the Machinist library’s `User.fix` block to generate randomized login names, emails, and passwords via regex-based `unique` generators, along with nested `Character.make` factories. The code specifies constraints like password confirmation, character count limits, and a boolean agreement flag, demonstrating how to construct realistic test data without a rendering API.

XXXX

56% match