data_composer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6ffd1070bf3de72bca82731ba913066c317e7b80d8c3501e342f4fe0435a83f0
+  data.tar.gz: eebe8db8bd858291aaa385bdec02d2c91ecf91cea6624186185decfac4fb4415
+SHA512:
+  metadata.gz: 31323e197afc7c4e58ab9e6128c9d905295430cef244bedf57f00b66debe41f5f4c386722cab34c488de578b7d6a1ab4e5219612cbfd1b9a3fcd4a94ccf85ef9
+  data.tar.gz: bda1447f583f9d16f8f274a5f818b5559273b4c387dd7190a0291b1bfc18ede15f59daffc5c69edce1a42b58f2a6236d0b0b693b2683b0040762dfe2dc573957

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,12 @@
+AllCops:
+  TargetRubyVersion: 3.1
+  SuggestExtensions: false
+
+# Allow longer blocks in spec files
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+
+# Standard gem structure
+Style/Documentation:
+  Enabled: true

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-08-20
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# 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 for our
+community include:
+
+* 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 not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* 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.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+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.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## 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][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Krzysztof Duda
+
+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.

data/README.md

@@ -0,0 +1,196 @@
+# DataComposer
+
+[![Gem Version](https://badge.fury.io/rb/data_composer.svg)](https://badge.fury.io/rb/data_composer)
+
+**DataComposer** provides a set of helpers to elegantly compose native Ruby `Data` objects into your ActiveRecord models.
+
+This gem lets you turn this:
+
+```ruby
+# db/migrate/xxxx.rb
+add_column :products, :price_amount, :decimal
+add_column :products, :price_currency, :string
+
+# app/models/product.rb
+Money = Data.define(:amount, :currency)
+composed_of :price, class_name: "Money", mapping: [%w[price_amount amount], %w[price_currency currency]]
+```
+
+Into this:
+
+```ruby
+# db/migrate/xxxx.rb
+t.data_object :price, members: { amount: :decimal, currency: :string }
+
+# app/models/product.rb
+Money = Data.define(:amount, :currency)
+compose_data :price, Money
+
+Product.first.price.amount #=> 100.0
+```
+
+## Core Concept
+
+The philosophy is simple:
+
+1.  **Define Value Objects with `Data.define`**: Use pure, native Ruby `Data` objects to represent concepts in your domain.
+2.  **Declare Schema in Migrations**: Use the `t.data_object` helper to explicitly define the database columns required to store your value object.
+3.  **Compose in the Model**: Use the `compose_data` helper in your model to map the database columns to your `Data` object.# DataComposer
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'data_composer'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Usage
+
+Let's walk through an example of storing a `Height` value object, composed of an `amount` and a `unit`, on a `User` model.
+
+### Step 1: Define Your Value Object
+
+Create a file for your value object. It's just a plain Ruby `Data` object—no special wrappers are needed.
+
+```ruby
+# app/models/height.rb
+Height = Data.define(:amount, :unit) do
+  # You can add any relevant domain logic here
+  def to_s
+    "#{amount} #{unit}"
+  end
+
+  def in_inches
+    unit == 'cm' ? (amount * 0.393701).round(2) : amount
+  end
+end
+```
+
+### Step 2: Create a Migration
+
+Generate a migration to add the columns to your table.
+
+```bash
+rails g migration AddHeightToUsers
+```
+
+Inside the migration file, use the `t.data_object` helper. You must explicitly define the member names and their corresponding database types.
+
+```ruby
+# db/migrate/xxxx_add_height_to_users.rb
+class AddHeightToUsers < ActiveRecord::Migration[7.0]
+  def change
+    change_table :users do |t|
+      t.data_object :height,
+                    members: { amount: :decimal, unit: :string },
+                    null: false,
+                    default: { amount: 0, unit: 'cm' }
+    end
+  end
+end
+```
+
+When you run `rails db:migrate`, this will create two columns: `height_amount` (`DECIMAL`) and `height_unit` (`STRING`).
+
+### Step 3: Compose it in Your Model
+
+In your ActiveRecord model, use `compose_data` to tie everything together. This method automatically infers that `:height` will be mapped from the `height_amount` and `height_unit` columns.
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  compose_data :height, Height
+end
+```
+
+### Step 4: Use It!
+
+Your `User` model now has a rich `height` attribute.
+
+```ruby
+# Create a user with a Height object
+user = User.create!(height: Height.new(amount: 180, unit: 'cm'))
+
+# Access the object and its members
+puts user.height
+#=> #<data Height amount=180, unit="cm">
+
+puts user.height.amount
+#=> 180
+
+puts user.height.to_s
+#=> "180 cm"
+
+puts user.height.in_inches
+#=> 70.87
+
+# The object is transparently saved to the database columns
+user.reload
+puts user.read_attribute(:height_amount) #=> 180
+puts user.read_attribute(:height_unit)   #=> "cm"
+
+# Assigning nil or invalid data also works as expected
+user.update!(height: nil)
+puts user.height #=> nil
+```
+
+## Advanced Features
+
+### Default Values
+
+You can specify default values for individual members:
+
+```ruby
+t.data_object :price,
+              members: { amount: :decimal, currency: :string },
+              default: { amount: 0, currency: "USD" }
+```
+
+### Multiple Data Objects
+
+You can have multiple data objects on the same model:
+
+```ruby
+class Product < ApplicationRecord
+  compose_data :price, Money
+  compose_data :dimensions, Dimensions
+  compose_data :weight, Weight
+end
+```
+
+### Custom Validation
+
+Data objects support standard ActiveRecord validations:
+
+```ruby
+class User < ApplicationRecord
+  compose_data :height, Height
+
+  validates :height, presence: true
+  validate :height_must_be_reasonable
+
+  private
+
+  def height_must_be_reasonable
+    return unless height
+
+    errors.add(:height, "must be positive") if height.amount <= 0
+    errors.add(:height, "seems too tall") if height.amount > 300
+  end
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/your-username/data_composer](https://github.com/your-username/data_composer).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/example.rb

@@ -0,0 +1 @@
+

data/lib/data_composer/migration_helpers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DataComposer
+  # Provides helper methods for defining data objects in database migrations.
+  module MigrationHelpers
+    def data_object(attribute_name, members:, **options)
+      raise MissingMembersError, 'members hash cannot be empty' if members.empty?
+
+      default_value = options.delete(:default)
+
+      members.each do |member_name, member_type|
+        column_name = DataComposer.column_name_for_member(attribute_name, member_name)
+        column_options = options.dup
+
+        column_options[:default] = default_value[member_name] if default_value && default_value.is_a?(Hash)
+
+        if column_options.empty?
+          column(column_name, member_type)
+        else
+          column(column_name, member_type, **column_options)
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActiveRecord)
+  ActiveRecord::ConnectionAdapters::Table.include(DataComposer::MigrationHelpers)
+  ActiveRecord::ConnectionAdapters::TableDefinition.include(DataComposer::MigrationHelpers)
+end

data/lib/data_composer/model.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module DataComposer
+  # ActiveRecord model concern that provides the compose_data method
+  # for mapping Data objects to database columns.
+  module Model
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class methods added to ActiveRecord models when DataComposer::Model is included.
+    module ClassMethods
+      def compose_data(attribute_name, data_class, **options)
+        validate_data_class!(data_class)
+
+        members = extract_data_members(data_class)
+        column_mapping = build_column_mapping(attribute_name, members)
+
+        define_data_accessors(attribute_name, data_class, column_mapping)
+        define_validation_if_needed(attribute_name, data_class, options)
+      end
+
+      private
+
+      def validate_data_class!(data_class)
+        return if data_class.respond_to?(:new) && data_class.respond_to?(:members)
+
+        raise InvalidDataObjectError, "#{data_class} must be a Data class created with Data.define"
+      end
+
+      def extract_data_members(data_class)
+        if data_class.respond_to?(:members)
+          data_class.members
+        else
+          sample_instance = data_class.new(*([nil] * data_class.method(:new).arity))
+          sample_instance.members
+        end
+      rescue StandardError
+        raise InvalidDataObjectError, "Cannot determine members for #{data_class}"
+      end
+
+      def build_column_mapping(attribute_name, members)
+        members.map do |member|
+          [member, DataComposer.column_name_for_member(attribute_name, member)]
+        end.to_h
+      end
+
+      def define_data_accessors(attribute_name, data_class, column_mapping)
+        define_data_getter(attribute_name, data_class, column_mapping)
+        define_data_setter(attribute_name, data_class, column_mapping)
+      end
+
+      def define_data_getter(attribute_name, data_class, column_mapping)
+        define_method(attribute_name) do
+          return nil if column_mapping.values.all? { |col| read_attribute(col).nil? }
+
+          member_values = column_mapping.transform_values { |col| read_attribute(col) }
+          data_class.new(**member_values)
+        end
+      end
+
+      def define_data_setter(attribute_name, data_class, column_mapping)
+        define_method("#{attribute_name}=") do |value|
+          if value.nil?
+            column_mapping.each_value { |col| write_attribute(col, nil) }
+          elsif value.is_a?(data_class)
+            column_mapping.each do |member, column|
+              write_attribute(column, value.public_send(member))
+            end
+          elsif value.is_a?(Hash)
+            symbolized_hash = value.respond_to?(:symbolize_keys) ? value.symbolize_keys : value.transform_keys(&:to_sym)
+            data_object = data_class.new(**symbolized_hash)
+            column_mapping.each do |member, column|
+              write_attribute(column, data_object.public_send(member))
+            end
+          else
+            raise ArgumentError, "Expected #{data_class}, Hash, or nil, got #{value.class}"
+          end
+        end
+      end
+
+      def define_validation_if_needed(attribute_name, _data_class, options)
+        return unless options[:validate] || options[:presence]
+
+        validates attribute_name, presence: true if options[:presence]
+
+        return unless options[:validate].is_a?(Proc)
+
+        validate -> { options[:validate].call(public_send(attribute_name)) }
+      end
+    end
+  end
+end

data/lib/data_composer/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DataComposer
+  # Rails integration for automatic inclusion of DataComposer functionality.
+  class Railtie < Rails::Railtie
+    initializer 'data_composer.include_model_concern' do
+      ActiveSupport.on_load(:active_record) do
+        include DataComposer::Model
+      end
+    end
+
+    initializer 'data_composer.include_migration_helpers' do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::ConnectionAdapters::Table.include(DataComposer::MigrationHelpers)
+        ActiveRecord::ConnectionAdapters::TableDefinition.include(DataComposer::MigrationHelpers)
+      end
+    end
+  end
+end

data/lib/data_composer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DataComposer
+  VERSION = '1.0.0'
+end

data/lib/data_composer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'data_composer/version'
+require_relative 'data_composer/model'
+require_relative 'data_composer/migration_helpers'
+
+# DataComposer provides helpers to elegantly compose native Ruby Data objects
+# into ActiveRecord models, automating migrations and model-level definitions.
+module DataComposer
+  class Error < StandardError; end
+  class InvalidDataObjectError < Error; end
+  class MissingMembersError < Error; end
+
+  def self.table_name_for_data_object(attribute_name)
+    "#{attribute_name}_"
+  end
+
+  def self.column_name_for_member(attribute_name, member_name)
+    "#{attribute_name}_#{member_name}"
+  end
+end
+
+require_relative 'data_composer/railtie' if defined?(Rails)

data/sig/data_composer.rbs

@@ -0,0 +1,4 @@
+module DataComposer
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: data_composer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Krzysztof Duda
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: DataComposer provides helpers to elegantly compose native Ruby Data objects
+  into ActiveRecord models, automating migrations and model-level definitions.
+email:
+- duda_krzysztof@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- example.rb
+- lib/data_composer.rb
+- lib/data_composer/migration_helpers.rb
+- lib/data_composer/model.rb
+- lib/data_composer/railtie.rb
+- lib/data_composer/version.rb
+- sig/data_composer.rbs
+homepage: https://github.com/your-username/data_composer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/your-username/data_composer
+  source_code_uri: https://github.com/your-username/data_composer
+  changelog_uri: https://github.com/your-username/data_composer/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Compose native Ruby Data objects into ActiveRecord models with automatic
+  migrations
+test_files: []