philiprehberger-data_mapper 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b536c5754e08456bd41fea7777a7dcf6cbeb55ab0c992f459f060e5832ee8c
-  data.tar.gz: 90c15710312855a5ed3024bec8e5e72332952a2fc7daed3daa1a4eed8e58aaf7
+  metadata.gz: 733532dbc2fd5c16c4067433a3c09f73a293691bc83e2977abeb5058194cb27b
+  data.tar.gz: edb9db9094b27203b7b3b395d0766cd9526c1996ee0943ea190b2253d001d8a5
 SHA512:
-  metadata.gz: f3f0822f41600c574e975173b1bcaba176a614b3fccaafe88e4df7969c2c2841f165d5544c5beac45a594723b808f85857afbd8ddf590f6a83c8020cb1ae2a71
-  data.tar.gz: 3eed507cf33a5ecec686831d187cd4fa5bcdf3ff0be7bf311e580c6c5b6c78576d92e03e0b49246f8d78bd89a1a650d9f60a9ed2e866683de3c2229ca9a48919
+  metadata.gz: f75f4ed87fdee1160d66dd3e8101a8553c4ec37f6b3a88e450b52492430725744b98f721995a7bb4b0a5cd9423170eae691cc5407648bf9ab7e7039b516b23ca
+  data.tar.gz: 5f53956dd0beecf8dc0a3ba191f70e7e11f17347b6224be58330753b7f61abcb9eb7f589a6b905ffc3aacfad5d65932a8a89f631c36fe7ff60d51c158505b672

data/CHANGELOG.md

@@ -1,10 +1,5 @@
 # Changelog
 
-## 0.2.1
-
-- Add License badge to README
-- Add bug_tracker_uri to gemspec
-
 All notable changes to this gem will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
@@ -12,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-03-17
+
+### Added
+- Conditional mapping with `if:` parameter to include fields only when a condition is met
+- Computed fields via `computed` DSL method for deriving values from the full record
+- Collection mapping with `array_field` DSL method to split string values into arrays
+- Reverse mapping via `reverse` method to transform output back to input schema
+- Validation support with `validate:` parameter and `map_with_validation` method
+- `MappingResult` class wrapping mapped value and collected validation errors
+
+## [0.2.1] - 2026-03-14
+
+### Changed
+- Add License badge to README
+- Add bug_tracker_uri to gemspec
+
 ## [0.2.0] - 2026-03-12
 
 ### Added

data/README.md

@@ -114,14 +114,100 @@ mapping.map(input)
 
 Supported types: `:string`, `:integer`, `:float`, `:boolean`.
 
+### Conditional mapping
+
+Include a field only when a condition is met using the `if:` parameter:
+
+```ruby
+mapping = Philiprehberger::DataMapper.define do
+  field :name
+  field :role, from: :raw_role, if: ->(record) { record[:admin] }
+end
+
+mapping.map({ name: "Alice", raw_role: "superuser", admin: true })
+# => { name: "Alice", role: "superuser" }
+
+mapping.map({ name: "Bob", raw_role: "superuser", admin: false })
+# => { name: "Bob" }
+```
+
+### Computed fields
+
+Derive fields from the full source record using `computed`:
+
+```ruby
+mapping = Philiprehberger::DataMapper.define do
+  field :email
+  computed(:full_name) { |record| "#{record[:first]} #{record[:last]}" }
+  computed(:initials) { |record| "#{record[:first][0]}#{record[:last][0]}" }
+end
+
+mapping.map({ email: "a@b.com", first: "Alice", last: "Smith" })
+# => { email: "a@b.com", full_name: "Alice Smith", initials: "AS" }
+```
+
+### Collection mapping
+
+Split a single string value into an array using `array_field`:
+
+```ruby
+mapping = Philiprehberger::DataMapper.define do
+  array_field :tags, from: :tag_csv, split: ","
+  array_field :items, from: :item_str, split: "|"
+end
+
+mapping.map({ tag_csv: "ruby,rails,gem", item_str: "one|two|three" })
+# => { tags: ["ruby", "rails", "gem"], items: ["one", "two", "three"] }
+```
+
+### Reverse mapping
+
+Transform output back to the input schema using inverse field mappings:
+
+```ruby
+mapping = Philiprehberger::DataMapper.define do
+  field :full_name, from: :name
+  field :years, from: :age
+end
+
+output = { full_name: "Alice", years: 30 }
+mapping.reverse(output)
+# => { name: "Alice", age: 30 }
+```
+
+### Validation
+
+Validate mapped values using the `validate:` parameter. Use `map_with_validation` to collect errors:
+
+```ruby
+mapping = Philiprehberger::DataMapper.define do
+  field :age, from: :raw_age, type: :integer, validate: ->(v) { v > 0 }
+  field :name, validate: ->(v) { !v.nil? && !v.empty? }
+end
+
+result = mapping.map_with_validation({ raw_age: "25", name: "Alice" })
+result.valid?  # => true
+result.value   # => { age: 25, name: "Alice" }
+result.errors  # => []
+
+result = mapping.map_with_validation({ raw_age: "-1", name: "" })
+result.valid?  # => false
+result.value   # => { age: -1, name: "" }
+result.errors  # => [{ field: :age, value: -1 }, { field: :name, value: "" }]
+```
+
 ## API
 
 | Method | Description |
 |--------|-------------|
 | `DataMapper.define(&block)` | Create a new mapping with the DSL |
-| `Mapping#field(target, from:, default:, type:, &transform)` | Define a field mapping |
+| `Mapping#field(target, from:, default:, type:, if:, validate:, split:, &transform)` | Define a field mapping |
+| `Mapping#computed(target, &block)` | Define a computed field derived from the full record |
+| `Mapping#array_field(target, from:, split:, &transform)` | Define a field that splits a string into an array |
 | `Mapping#map(hash)` | Apply mapping to a single hash |
+| `Mapping#map_with_validation(hash)` | Apply mapping and return a `MappingResult` with errors |
 | `Mapping#map_all(array)` | Apply mapping to an array of hashes |
+| `Mapping#reverse(hash)` | Transform output hash back to input schema |
 | `Mapping#from_csv(string, headers: true)` | Parse CSV and map each row |
 | `Mapping#from_json(json_string)` | Parse JSON string and map the result |
 

data/lib/philiprehberger/data_mapper/computed_definition.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module DataMapper
+    class ComputedDefinition
+      attr_reader :target
+
+      def initialize(target, &block)
+        @target = target
+        @block = block
+      end
+
+      def compute(record)
+        @block.call(record)
+      end
+    end
+  end
+end

data/lib/philiprehberger/data_mapper/field_definition.rb

@@ -3,26 +3,46 @@
 module Philiprehberger
   module DataMapper
     class FieldDefinition
-      attr_reader :target, :source, :default, :type
+      attr_reader :target, :source, :default, :type, :condition, :validator, :split_delimiter
 
       BOOLEAN_TRUE_VALUES = %w[true 1 yes].freeze
       BOOLEAN_FALSE_VALUES = %w[false 0 no].freeze
 
-      def initialize(target, from: nil, default: nil, type: nil, &transform)
+      def initialize(target, **opts, &transform)
         @target = target
-        @source = from || target
-        @default = default
-        @type = type
+        @source = opts[:from] || target
+        @default = opts[:default]
+        @type = opts[:type]
+        @condition = opts[:if]
+        @validator = opts[:validate]
+        @split_delimiter = opts[:split]
         @transform = transform
       end
 
       def apply(value)
         value = @default if value.nil?
+        value = value.to_s.split(@split_delimiter) if @split_delimiter && value.is_a?(String)
         value = @transform.call(value) if @transform
         value = coerce(value) if @type
         value
       end
 
+      def conditional?
+        !@condition.nil?
+      end
+
+      def include?(record)
+        return true unless conditional?
+
+        @condition.call(record)
+      end
+
+      def valid?(value)
+        return true unless @validator
+
+        @validator.call(value)
+      end
+
       private
 
       def coerce(value)

data/lib/philiprehberger/data_mapper/mapping.rb

@@ -1,46 +1,78 @@
 # frozen_string_literal: true
 
-require "csv"
-require "json"
+require_relative "parsable"
+require_relative "reversible"
 
 module Philiprehberger
   module DataMapper
     class Mapping
+      include Parsable
+      include Reversible
+
       def initialize(&block)
         @fields = []
+        @computed_fields = []
         instance_eval(&block) if block
       end
 
-      def field(target, from: nil, default: nil, type: nil, &transform)
-        @fields << FieldDefinition.new(target, from: from, default: default, type: type, &transform)
+      def field(target, ...)
+        @fields << FieldDefinition.new(target, ...)
+      end
+
+      def computed(target, &)
+        @computed_fields << ComputedDefinition.new(target, &)
+      end
+
+      def array_field(target, from: nil, split: ",", &transform)
+        field(target, from: from, split: split, &transform)
       end
 
       def map(hash)
-        @fields.each_with_object({}) do |field, result|
-          value = dig_value(hash, field.source)
-          result[field.target] = field.apply(value)
-        end
+        result = map_fields(hash)
+        apply_computed(hash, result)
+        result
+      end
+
+      def map_with_validation(hash)
+        result = {}
+        errors = collect_errors(hash, result)
+        apply_computed(hash, result)
+        MappingResult.new(result, errors)
       end
 
       def map_all(array)
         array.map { |hash| map(hash) }
       end
 
-      def from_csv(csv_string, headers: true)
-        rows = CSV.parse(csv_string, headers: headers)
-        rows.map { |row| map(row_to_hash(row)) }
-      end
+      private
 
-      def from_json(json_string)
-        parsed = JSON.parse(json_string)
+      def map_fields(hash)
+        applicable_fields(hash).each_with_object({}) do |f, result|
+          value = dig_value(hash, f.source)
+          result[f.target] = f.apply(value)
+        end
+      end
 
-        case parsed
-        when Array then map_all(parsed.map { |h| symbolize_keys(h) })
-        when Hash  then map(symbolize_keys(parsed))
+      def collect_errors(hash, result)
+        errors = []
+        applicable_fields(hash).each do |f|
+          value = dig_value(hash, f.source)
+          mapped = f.apply(value)
+          errors << { field: f.target, value: mapped } unless f.valid?(mapped)
+          result[f.target] = mapped
         end
+        errors
       end
 
-      private
+      def applicable_fields(hash)
+        @fields.select { |f| f.include?(hash) }
+      end
+
+      def apply_computed(hash, result)
+        @computed_fields.each do |c|
+          result[c.target] = c.compute(hash)
+        end
+      end
 
       def dig_value(hash, source)
         key_str = source.to_s
@@ -58,16 +90,6 @@ module Philiprehberger
           current[key.to_sym] || current[key]
         end
       end
-
-      def symbolize_keys(hash)
-        hash.each_with_object({}) do |(key, value), result|
-          result[key.to_sym] = value.is_a?(Hash) ? symbolize_keys(value) : value
-        end
-      end
-
-      def row_to_hash(row)
-        row.to_h.transform_keys(&:to_sym)
-      end
     end
   end
 end

data/lib/philiprehberger/data_mapper/mapping_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module DataMapper
+    class MappingResult
+      attr_reader :value, :errors
+
+      def initialize(value, errors = [])
+        @value = value
+        @errors = errors
+      end
+
+      def valid?
+        @errors.empty?
+      end
+    end
+  end
+end

data/lib/philiprehberger/data_mapper/parsable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "csv"
+require "json"
+
+module Philiprehberger
+  module DataMapper
+    module Parsable
+      def from_csv(csv_string, headers: true)
+        rows = CSV.parse(csv_string, headers: headers)
+        rows.map { |row| map(row_to_hash(row)) }
+      end
+
+      def from_json(json_string)
+        parsed = JSON.parse(json_string)
+
+        case parsed
+        when Array then map_all(parsed.map { |h| symbolize_keys(h) })
+        when Hash  then map(symbolize_keys(parsed))
+        end
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) do |(key, value), result|
+          result[key.to_sym] = value.is_a?(Hash) ? symbolize_keys(value) : value
+        end
+      end
+
+      def row_to_hash(row)
+        row.to_h.transform_keys(&:to_sym)
+      end
+    end
+  end
+end

data/lib/philiprehberger/data_mapper/reversible.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module DataMapper
+    module Reversible
+      def reverse(hash)
+        build_reverse_mapping(hash)
+      end
+
+      private
+
+      def build_reverse_mapping(hash)
+        @fields.each_with_object({}) do |field, result|
+          next unless hash.key?(field.target)
+
+          result[field.source] = hash[field.target]
+        end
+      end
+    end
+  end
+end

data/lib/philiprehberger/data_mapper/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module DataMapper
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/philiprehberger/data_mapper.rb

@@ -2,6 +2,8 @@
 
 require_relative "data_mapper/version"
 require_relative "data_mapper/field_definition"
+require_relative "data_mapper/computed_definition"
+require_relative "data_mapper/mapping_result"
 require_relative "data_mapper/mapping"
 
 module Philiprehberger

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-data_mapper
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-16 00:00:00.000000000 Z
+date: 2026-03-17 00:00:00.000000000 Z
 dependencies: []
 description: A zero-dependency Ruby gem for transforming data between formats with
-  a mapping DSL, field renaming, type conversion, and CSV support.
+  a mapping DSL, field renaming, type conversion, validation, and CSV support.
 email:
 - me@philiprehberger.com
 executables: []
@@ -22,8 +22,12 @@ files:
 - LICENSE
 - README.md
 - lib/philiprehberger/data_mapper.rb
+- lib/philiprehberger/data_mapper/computed_definition.rb
 - lib/philiprehberger/data_mapper/field_definition.rb
 - lib/philiprehberger/data_mapper/mapping.rb
+- lib/philiprehberger/data_mapper/mapping_result.rb
+- lib/philiprehberger/data_mapper/parsable.rb
+- lib/philiprehberger/data_mapper/reversible.rb
 - lib/philiprehberger/data_mapper/version.rb
 homepage: https://github.com/philiprehberger/rb-data-mapper
 licenses: