lazy_mapper 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 702528c73dfd2a707526f0e792472df55077dd97bf4cf034f6187b97f885ff41
-  data.tar.gz: c2b4708374ca625b5e81a6645cf279854241721705bfafdfee3f258f27f2ab8a
+  metadata.gz: caacc733f90e5a2fc3b40bc026ea256db983ba02af30c643942a5c5cd3b24223
+  data.tar.gz: 5038181e2d90b18bb2ae24c8be4e460b85e91a304269184ebf50092d997a5476
 SHA512:
-  metadata.gz: 0540ab08d1cdcaac33e99876987df7d64ed6f4a31c4bac7f03581cf2d7ec64ee45ac35c9692614c6b78b8ca85952803fc5eab7f61818f790f784490b7c804271
-  data.tar.gz: e22803584b494a25427b059fa32ae059091ab614b72ef2293581dd81486a05b6193372f32b4b576262f7b8f876c74d9b41e1660cce43355472fcf5f1fbcbce31
+  metadata.gz: 5e0d6d4ec22ace2d4c67a9c7a791bf89fde2de9c5bdc0e0191d126fa6b16fac946b2812046835a873286c44f94f4b737a68495220da4377c695ac4e1b0a9e3a3
+  data.tar.gz: 840263f4c9bdbecc26d0466c3f21fa0d6a56502a8c9bf4155d0d8a8372b27cf1a2114d91fcdc6b6e117faa72768cac917f313cb0b798a4b1c726a6b235cbe54c

data/.gitignore

@@ -9,3 +9,4 @@ doc/
 .idea/
 Gemfile.lock
 *.gem
+.ruby-version

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+#0.4.0
+
+## Changed
+
+* Removed deprecated factory method `.from_json`
+* Enable inheritance of mappers added after the derived class is defined
+
+#0.3.2
+
+## Fixed
+
+* No more BigDecimal deprecation warning
+
+#0.3.1
+
+## Fixed
+
+* Collections no longer missing from `#to_h` and `#inspect`
+
+#0.3.0
+
+## Changed
+* `.from_json` renamed to `.from`. `.from_json` is kept as an alias to the new method.
+
+## Added
+
+* `#to_h` method
+
+#0.2.1
+
+(No user visible changes)
+

data/README.md

@@ -6,7 +6,7 @@ The mapped values are memoized.
 
 Example:
 
-    class Foo < LazyMapper
+    class Foo < LazyMapper::Model
       one :id, Integer, from: 'iden'
       one :created_at, Time
       one :amount, Money, map: Money.method(:parse)
@@ -15,8 +15,12 @@ Example:
 
 ## Documentation
 
-See [RubyDoc](https://www.rubydoc.info/gems/lazy_mapper/0.3.1)
+See [RubyDoc](https://www.rubydoc.info/gems/lazy_mapper/0.4.0)
 
 ## License
 
 See LICENSE file.
+
+## Changes
+
+See CHANGES.md

data/lazy_mapper.gemspec

@@ -1,6 +1,11 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'lazy_mapper/version'
+
 Gem::Specification.new do |spec|
   spec.name          = 'lazy_mapper'
-  spec.version       = '0.3.2'
+  spec.version       = LazyMapper::VERSION
   spec.summary       = 'A lazy object mapper'
   spec.description   = 'Wraps primitive data in a semantically rich model'
   spec.authors       = ['Adam Lett']

data/lib/lazy_mapper.rb

@@ -1,403 +1,8 @@
 # frozen_string_literal: true
 
-require 'bigdecimal'
-require 'bigdecimal/util'
-require 'time'
-
-#
-# Wraps a Hash or Hash-like data structure of primitive values and lazily maps
-# its attributes to semantically rich domain objects using either a set of
-# default mappers (for Ruby's built-in value types), or custom mappers which
-# can be added either at the class level or at the instance level.
-#
-# Example:
-#     class Foo < LazyMapper
-#       one :id, Integer, from: 'xmlId'
-#       one :created_at, Time
-#       one :amount, Money, map: Money.method(:parse)
-#       many :users, User, map: ->(u) { User.new(u) }
-#     end
-#
 class LazyMapper
-
-  #
-  # Default mappings for built-in types
-  #
-  DEFAULT_MAPPINGS = {
-    Object     => :itself.to_proc,
-    String     => :to_s.to_proc,
-    Integer    => :to_i.to_proc,
-    BigDecimal => :to_d.to_proc,
-    Float      => :to_f.to_proc,
-    Symbol     => :to_sym.to_proc,
-    Hash       => :to_h.to_proc,
-    Time       => Time.method(:iso8601),
-    Date       => Date.method(:parse),
-    URI        => URI.method(:parse)
-  }.freeze
-
-  #
-  # Adds (or overrides) a default type for a given type
-  #
-  def self.default_value_for type, value
-    default_values[type] = value
-  end
-
-  def self.default_values
-    @default_values ||= DEFAULT_VALUES
-  end
-
-  #
-  # Default values for built-in value types
-  #
-  DEFAULT_VALUES = {
-    String     => '',
-    Integer    => 0,
-    Numeric    => 0,
-    Float      => 0.0,
-    BigDecimal => BigDecimal(0),
-    Array      => []
-  }.freeze
-
-  #
-  # Adds a mapper for a give type
-  #
-  def self.mapper_for(type, mapper)
-    mappers[type] = mapper
-  end
-
-  def self.mappers
-    @mappers ||= DEFAULT_MAPPINGS
-  end
-
-  def self.attributes
-    @attributes ||= {}
-  end
-
-  def self.inherited klass # :nodoc:
-    # Make the subclass "inherit" the values of these class instance variables
-    %i[
-      mappers
-      default_values
-      attributes
-    ].each do |s|
-      klass.instance_variable_set IVAR[s], self.send(s).dup
-    end
-  end
-
-  def mappers
-    @mappers ||= self.class.mappers
-  end
-
-  IVAR = lambda { |name| # :nodoc:
-    name_as_str = name.to_s
-    name_as_str = name_as_str[0...-1] if name_as_str[-1] == '?'
-
-    ('@' + name_as_str).freeze
-  }
-
-  WRITER = -> name { (name.to_s.delete('?') + '=').to_sym }
-
-  #
-  # Creates a new instance by giving a Hash of attribues.
-  #
-  # Attribute values are type checked according to how they were defined.
-  #
-  # Fails with +TypeError+, if a value doesn't have the expected type.
-  #
-  # == Example
-  #
-  #     Foo.new :id => 42,
-  #       :created_at => Time.parse("2015-07-29 14:07:35 +0200"),
-  #       :amount => Money.parse("$2.00"),
-  #       :users => [
-  #         User.new("id" => 23, "name" => "Adam"),
-  #         User.new("id" => 45, "name" => "Ole"),
-  #         User.new("id" => 66, "name" => "Anders"),
-  #         User.new("id" => 91, "name" => "Kristoffer)
-  #       ]
-
-  def initialize(values = {})
-    @mappers = {}
-    values.each do |name, value|
-      send(WRITER[name], value)
-    end
-  end
-
-  #
-  # Create a new instance by giving a Hash of unmapped attributes.
-  #
-  # The keys in the Hash are assumed to be camelCased strings.
-  #
-  # == Arguments
-  #
-  # +unmapped_data+ - The unmapped data as a Hash(-like object). Must respond to #to_h.
-  # Keys are assumed to be camelCased string
-  #
-  # +mappers:+ - Optional instance-level mappers.
-  # Keys can either be classes or symbols corresponding to named attributes.
-  #
-  #
-  # == Example
-  #
-  #     Foo.from({
-  #       "xmlId" => 42,
-  #       "createdAt" => "2015-07-29 14:07:35 +0200",
-  #       "amount" => "$2.00",
-  #       "users" => [
-  #         { "id" => 23, "name" => "Adam" },
-  #         { "id" => 45, "name" => "Ole" },
-  #         { "id" => 66, "name" => "Anders" },
-  #         { "id" => 91, "name" => "Kristoffer" } ]},
-  #       mappers: {
-  #         :amount => -> x { Money.new(x) },
-  #         User    => User.method(:new) })
-  #
-  def self.from unmapped_data, mappers: {}
-    return nil if unmapped_data.nil?
-    fail TypeError, "#{ unmapped_data.inspect } is not a Hash" unless unmapped_data.respond_to? :to_h
-
-    instance = new
-    instance.send :unmapped_data=, unmapped_data.to_h
-    instance.send :mappers=, mappers
-    instance
-  end
-
-  def self.from_json *args, &block # :nodoc:
-    warn "#{ self }.from_json is deprecated. Use #{ self }.from instead."
-    from(*args, &block)
-  end
-
-  #
-  # Defines an attribute and creates a reader and a writer for it.
-  # The writer verifies the type of it's supplied value.
-  #
-  # == Arguments
-  #
-  # +name+ - The name of the attribue
-  #
-  # +type+ - The type of the attribute. If the wrapped value is already of that type, the mapper is bypassed.
-  # If the type is allowed be one of several, use an Array to to specify which ones
-  #
-  # +from:+ - Specifies the name of the wrapped value in the JSON object. Defaults to camelCased version of +name+.
-  #
-  # +map:+ - Specifies a custom mapper to apply to the wrapped value.
-  # If unspecified, it defaults to the default mapper for the specified +type+ or simply the identity mapper
-  # if no default mapper exists.
-  #
-  # +default:+ - The default value to use, if the wrapped value is not present in the wrapped JSON object.
-  #
-  # +allow_nil:+ - If true, allows the mapped value to be nil. Defaults to true.
-  #
-  # == Example
-  #
-  #    class Foo < LazyMapper
-  #      one :boss, Person, from: "supervisor", map: ->(p) { Person.new(p) }
-  #      one :weapon, [BladedWeapon, Firearm], default: Sixshooter.new
-  #      # ...
-  #    end
-  #
-  def self.one(name, type, from: map_name(name), allow_nil: true, **args)
-
-    ivar = IVAR[name]
-
-    # Define writer
-    define_method(WRITER[name]) { |val|
-      check_type! val, type, allow_nil: allow_nil
-      instance_variable_set(ivar, val)
-    }
-
-    # Define reader
-    define_method(name) {
-      memoize(name, ivar) {
-        unmapped_value = unmapped_data[from]
-        mapped_value(name, unmapped_value, type, **args)
-      }
-    }
-
-    attributes[name] = type
-  end
-
-  #
-  # Converts a value to +true+ or +false+ according to its truthyness
-  #
-  TO_BOOL = -> b { !!b }
-
-  #
-  # Defines an boolean attribute
-  #
-  # == Arguments
-  #
-  # +name+ - The name of the attribue
-  #
-  # +from:+ - Specifies the name of the wrapped value in the JSON object.
-  # Defaults to camelCased version of +name+.
-  #
-  # +map:+ - Specifies a custom mapper to apply to the wrapped value. Must be a Callable.
-  # Defaults to TO_BOOL if unspecified.
-  #
-  # +default:+ The default value to use if the value is missing. False, if unspecified
-  #
-  # == Example
-  #
-  #    class Foo < LazyMapper
-  #      is :green?, from: "isGreen", map: ->(x) { !x.zero? }
-  #      # ...
-  #    end
-  #
-  def self.is name, from: map_name(name), map: TO_BOOL, default: false
-    one name, [TrueClass, FalseClass], from: from, allow_nil: false, map: map, default: default
-  end
-
-  singleton_class.send(:alias_method, :has, :is)
-
-  #
-  # Defines a collection attribute
-  #
-  # == Arguments
-  #
-  # +name+ - The name of the attribute
-  #
-  # +type+ - The type of the elements in the collection.
-  #
-  # +from:+ - Specifies the name of the wrapped array in the unmapped data.
-  # Defaults to camelCased version of +name+.
-  #
-  # +map:+ - Specifies a custom mapper to apply to each elements in the wrapped collection.
-  # If unspecified, it defaults to the default mapper for the specified +type+ or simply the identity mapper
-  # if no default mapper exists.
-  #
-  # +default:+ - The default value to use, if the unmapped value is missing.
-  #
-  # == Example
-  #
-  #    class Bar < LazyMapper
-  #      many :underlings, Person, from: "serfs", map: ->(p) { Person.new(p) }
-  #      # ...
-  #    end
-  #
-  def self.many(name, type, from: map_name(name), **args)
-
-    # Define setter
-    define_method(WRITER[name]) { |val|
-      check_type! val, Enumerable, allow_nil: false
-      instance_variable_set(IVAR[name], val)
-    }
-
-    # Define getter
-    define_method(name) {
-      memoize(name) {
-        unmapped_value = unmapped_data[from]
-        if unmapped_value.is_a? Array
-          unmapped_value.map { |v| mapped_value(name, v, type, **args) }
-        else
-          mapped_value name, unmapped_value, Array, **args
-        end
-      }
-    }
-
-    attributes[name] = Array
-  end
-
-  #
-  # Adds an instance-level type mapper
-  #
-  def add_mapper_for(type, &block)
-    mappers[type] = block
-  end
-
-  def to_h
-    attributes.each_with_object({}) { |(key, _value), h|
-      h[key] = self.send key
-    }
-  end
-
-  def inspect
-    @__under_inspection__ ||= 0
-    return "<#{ self.class.name } ... >" if @__under_inspection__.positive?
-
-    @__under_inspection__ += 1
-    present_attributes = attributes.keys.each_with_object({}) { |name, memo|
-      ivar = IVAR[name]
-      next unless self.instance_variable_defined? ivar
-
-      memo[name] = self.instance_variable_get ivar
-    }
-
-    res = "<#{ self.class.name } #{ present_attributes.map { |k, v| k.to_s + ': ' + v.inspect }.join(', ') } >"
-    @__under_inspection__ -= 1
-    res
-  end
-
-  #
-  # Defines how to map an attribute name
-  # to the corresponding name in the unmapped
-  # JSON object.
-  #
-  # Defaults to CAMELIZE
-  #
-  def self.map_name(name)
-    CAMELIZE[name]
-  end
-
-  private
-
-  attr_writer :unmapped_data
-  attr_writer :mappers
-
-  def unmapped_data
-    @unmapped_data ||= {}
-  end
-
-  def mapping_for(name, type)
-    mappers[name] || mappers[type] || self.class.mappers[type]
-  end
-
-  def default_value(type)
-    self.class.default_values[type]
-  end
-
-  def attributes
-    self.class.attributes
-  end
-
-  def mapped_value(name, unmapped_value, type, map: mapping_for(name, type), default: default_value(type))
-    return default.dup if unmapped_value.nil? # Duplicate to prevent accidental sharing between instances
-
-    if map.nil?
-      fail ArgumentError, "missing mapper for #{ name } (#{ type }). "\
-        "Unmapped value: #{ unmapped_value.inspect }"
-    end
-
-    return map.call(unmapped_value, self) if map.arity > 1
-
-    map.call(unmapped_value)
-  end
-
-  def check_type! value, type, allow_nil:
-    permitted_types = allow_nil ? Array(type) + [ NilClass ] : Array(type)
-    return if permitted_types.any? value.method(:is_a?)
-
-    fail TypeError.new "#{ self.class.name }: "\
-      "#{ value.inspect } is a #{ value.class } "\
-      "but was supposed to be a #{ humanize_list permitted_types, conjunction: ' or ' }"
-  end
-
-  # [1,2,3] -> "1, 2 and 3"
-  # [1, 2]  -> "1 and 2"
-  # [1]     -> "1"
-  def humanize_list list, separator: ', ', conjunction: ' and '
-    *all_but_last, last = list
-    return last if all_but_last.empty?
-
-    [ all_but_last.join(separator), last ].join conjunction
-  end
-
-  def memoize name, ivar = IVAR[name]
-    send WRITER[name], yield unless instance_variable_defined?(ivar)
-    instance_variable_get(ivar)
-  end
-
-  SNAKE_CASE_PATTERN = /(_[a-z])/ # :nodoc:
-  CAMELIZE = -> name { name.to_s.gsub(SNAKE_CASE_PATTERN) { |x| x[1].upcase }.delete('?') }
 end
+
+require 'lazy_mapper/version'
+require 'lazy_mapper/defaults'
+require 'lazy_mapper/lazy_mapper'

data/lib/lazy_mapper/defaults.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'time'
+
+class LazyMapper
+  #
+  # Default mappings for built-in types
+  #
+  DEFAULT_MAPPINGS = {
+    Object     => :itself.to_proc,
+    String     => :to_s.to_proc,
+    Integer    => :to_i.to_proc,
+    BigDecimal => :to_d.to_proc,
+    Float      => :to_f.to_proc,
+    Symbol     => :to_sym.to_proc,
+    Hash       => :to_h.to_proc,
+    Time       => Time.method(:iso8601),
+    Date       => Date.method(:parse),
+    URI        => URI.method(:parse)
+  }.freeze
+
+  #
+  # Default values for built-in value types
+  #
+  DEFAULT_VALUES = {
+    String     => '',
+    Integer    => 0,
+    Numeric    => 0,
+    Float      => 0.0,
+    BigDecimal => BigDecimal(0),
+    Array      => []
+  }.freeze
+end

data/lib/lazy_mapper/lazy_mapper.rb

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+#
+# Wraps a Hash or Hash-like data structure of primitive values and lazily maps
+# its attributes to semantically rich domain objects using either a set of
+# default mappers (for Ruby's built-in value types), or custom mappers which
+# can be added either at the class level or at the instance level.
+#
+# Example:
+#     class Foo < LazyMapper
+#       one :id, Integer, from: 'xmlId'
+#       one :created_at, Time
+#       one :amount, Money, map: Money.method(:parse)
+#       many :users, User, map: ->(u) { User.new(u) }
+#     end
+#
+class LazyMapper
+
+  #
+  # Adds (or overrides) a default type for a given type
+  #
+  def self.default_value_for type, value
+    default_values[type] = value
+  end
+
+  def self.default_values
+    @default_values ||= DEFAULT_VALUES
+  end
+
+  #
+  # Adds a mapper for a give type
+  #
+  def self.mapper_for(type, mapper)
+    mappers[type] = mapper
+  end
+
+  def self.mappers
+    @mappers ||= DEFAULT_MAPPINGS
+  end
+
+  def self.attributes
+    @attributes ||= {}
+  end
+
+  def self.inherited klass # :nodoc:
+    # Make the subclass "inherit" the values of these class instance variables
+    %i[
+      default_values
+      attributes
+    ].each do |s|
+      klass.instance_variable_set IVAR[s], self.send(s).dup
+    end
+
+    # If a mapper is does not exist in the derived class, look it up in this class
+    klass.instance_variable_set('@mappers', Hash.new { |_mappers, type| mappers[type] })
+  end
+
+  def mappers
+    @mappers ||= self.class.mappers
+  end
+
+  IVAR = lambda { |name| # :nodoc:
+    name_as_str = name.to_s
+    name_as_str = name_as_str[0...-1] if name_as_str[-1] == '?'
+
+    ('@' + name_as_str).freeze
+  }
+
+  WRITER = -> name { (name.to_s.delete('?') + '=').to_sym }
+
+  #
+  # Creates a new instance by giving a Hash of attribues.
+  #
+  # Attribute values are type checked according to how they were defined.
+  #
+  # Fails with +TypeError+, if a value doesn't have the expected type.
+  #
+  # == Example
+  #
+  #     Foo.new :id => 42,
+  #       :created_at => Time.parse("2015-07-29 14:07:35 +0200"),
+  #       :amount => Money.parse("$2.00"),
+  #       :users => [
+  #         User.new("id" => 23, "name" => "Adam"),
+  #         User.new("id" => 45, "name" => "Ole"),
+  #         User.new("id" => 66, "name" => "Anders"),
+  #         User.new("id" => 91, "name" => "Kristoffer)
+  #       ]
+
+  def initialize(values = {})
+    @mappers = {}
+    values.each do |name, value|
+      send(WRITER[name], value)
+    end
+  end
+
+  #
+  # Create a new instance by giving a Hash of unmapped attributes.
+  #
+  # The keys in the Hash are assumed to be camelCased strings.
+  #
+  # == Arguments
+  #
+  # +unmapped_data+ - The unmapped data as a Hash(-like object). Must respond to #to_h.
+  # Keys are assumed to be camelCased string
+  #
+  # +mappers:+ - Optional instance-level mappers.
+  # Keys can either be classes or symbols corresponding to named attributes.
+  #
+  #
+  # == Example
+  #
+  #     Foo.from({
+  #       "xmlId" => 42,
+  #       "createdAt" => "2015-07-29 14:07:35 +0200",
+  #       "amount" => "$2.00",
+  #       "users" => [
+  #         { "id" => 23, "name" => "Adam" },
+  #         { "id" => 45, "name" => "Ole" },
+  #         { "id" => 66, "name" => "Anders" },
+  #         { "id" => 91, "name" => "Kristoffer" } ]},
+  #       mappers: {
+  #         :amount => -> x { Money.new(x) },
+  #         User    => User.method(:new) })
+  #
+  def self.from unmapped_data, mappers: {}
+    return nil if unmapped_data.nil?
+    fail TypeError, "#{ unmapped_data.inspect } is not a Hash" unless unmapped_data.respond_to? :to_h
+
+    instance = new
+    instance.send :unmapped_data=, unmapped_data.to_h
+    instance.send :mappers=, mappers
+    instance
+  end
+
+  #
+  # Defines an attribute and creates a reader and a writer for it.
+  # The writer verifies the type of it's supplied value.
+  #
+  # == Arguments
+  #
+  # +name+ - The name of the attribue
+  #
+  # +type+ - The type of the attribute. If the wrapped value is already of that type, the mapper is bypassed.
+  # If the type is allowed be one of several, use an Array to to specify which ones
+  #
+  # +from:+ - Specifies the name of the wrapped value in the JSON object. Defaults to camelCased version of +name+.
+  #
+  # +map:+ - Specifies a custom mapper to apply to the wrapped value.
+  # If unspecified, it defaults to the default mapper for the specified +type+ or simply the identity mapper
+  # if no default mapper exists.
+  #
+  # +default:+ - The default value to use, if the wrapped value is not present in the wrapped JSON object.
+  #
+  # +allow_nil:+ - If true, allows the mapped value to be nil. Defaults to true.
+  #
+  # == Example
+  #
+  #    class Foo < LazyMapper
+  #      one :boss, Person, from: "supervisor", map: ->(p) { Person.new(p) }
+  #      one :weapon, [BladedWeapon, Firearm], default: Sixshooter.new
+  #      # ...
+  #    end
+  #
+  def self.one(name, type, from: map_name(name), allow_nil: true, **args)
+
+    ivar = IVAR[name]
+
+    # Define writer
+    define_method(WRITER[name]) { |val|
+      check_type! val, type, allow_nil: allow_nil
+      instance_variable_set(ivar, val)
+    }
+
+    # Define reader
+    define_method(name) {
+      memoize(name, ivar) {
+        unmapped_value = unmapped_data[from]
+        mapped_value(name, unmapped_value, type, **args)
+      }
+    }
+
+    attributes[name] = type
+  end
+
+  #
+  # Converts a value to +true+ or +false+ according to its truthyness
+  #
+  TO_BOOL = -> b { !!b }
+
+  #
+  # Defines an boolean attribute
+  #
+  # == Arguments
+  #
+  # +name+ - The name of the attribue
+  #
+  # +from:+ - Specifies the name of the wrapped value in the JSON object.
+  # Defaults to camelCased version of +name+.
+  #
+  # +map:+ - Specifies a custom mapper to apply to the wrapped value. Must be a Callable.
+  # Defaults to TO_BOOL if unspecified.
+  #
+  # +default:+ The default value to use if the value is missing. False, if unspecified
+  #
+  # == Example
+  #
+  #    class Foo < LazyMapper
+  #      is :green?, from: "isGreen", map: ->(x) { !x.zero? }
+  #      # ...
+  #    end
+  #
+  def self.is name, from: map_name(name), map: TO_BOOL, default: false
+    one name, [TrueClass, FalseClass], from: from, allow_nil: false, map: map, default: default
+  end
+
+  singleton_class.send(:alias_method, :has, :is)
+
+  #
+  # Defines a collection attribute
+  #
+  # == Arguments
+  #
+  # +name+ - The name of the attribute
+  #
+  # +type+ - The type of the elements in the collection.
+  #
+  # +from:+ - Specifies the name of the wrapped array in the unmapped data.
+  # Defaults to camelCased version of +name+.
+  #
+  # +map:+ - Specifies a custom mapper to apply to each elements in the wrapped collection.
+  # If unspecified, it defaults to the default mapper for the specified +type+ or simply the identity mapper
+  # if no default mapper exists.
+  #
+  # +default:+ - The default value to use, if the unmapped value is missing.
+  #
+  # == Example
+  #
+  #    class Bar < LazyMapper
+  #      many :underlings, Person, from: "serfs", map: ->(p) { Person.new(p) }
+  #      # ...
+  #    end
+  #
+  def self.many(name, type, from: map_name(name), **args)
+
+    # Define setter
+    define_method(WRITER[name]) { |val|
+      check_type! val, Enumerable, allow_nil: false
+      instance_variable_set(IVAR[name], val)
+    }
+
+    # Define getter
+    define_method(name) {
+      memoize(name) {
+        unmapped_value = unmapped_data[from]
+        if unmapped_value.is_a? Array
+          unmapped_value.map { |v| mapped_value(name, v, type, **args) }
+        else
+          mapped_value name, unmapped_value, Array, **args
+        end
+      }
+    }
+
+    attributes[name] = Array
+  end
+
+  #
+  # Adds an instance-level type mapper
+  #
+  def add_mapper_for(type, &block)
+    mappers[type] = block
+  end
+
+  #
+  # Returns a +Hash+ with keys corresponding to attribute names, and values
+  # corresponding to *mapped* attribute values.
+  #
+  # Note: This will eagerly map all attributes that haven't yet been mapped
+  #
+  def to_h
+    attributes.each_with_object({}) { |(key, _value), h|
+      h[key] = self.send key
+    }
+  end
+
+  def inspect
+    @__under_inspection__ ||= 0
+    return "<#{ self.class.name } ... >" if @__under_inspection__.positive?
+
+    @__under_inspection__ += 1
+    present_attributes = attributes.keys.each_with_object({}) { |name, memo|
+      ivar = IVAR[name]
+      next unless self.instance_variable_defined? ivar
+
+      memo[name] = self.instance_variable_get ivar
+    }
+
+    res = "<#{ self.class.name } #{ present_attributes.map { |k, v| k.to_s + ': ' + v.inspect }.join(', ') } >"
+    @__under_inspection__ -= 1
+    res
+  end
+
+  #
+  # Defines how to map an attribute name
+  # to the corresponding name in the unmapped
+  # JSON object.
+  #
+  # Defaults to CAMELIZE
+  #
+  def self.map_name(name)
+    CAMELIZE[name]
+  end
+
+  private
+
+  attr_writer :unmapped_data
+  attr_writer :mappers
+
+  def unmapped_data
+    @unmapped_data ||= {}
+  end
+
+  def mapping_for(name, type)
+    mappers[name] || mappers[type] || self.class.mappers[type]
+  end
+
+  def default_value(type)
+    self.class.default_values[type]
+  end
+
+  def attributes
+    self.class.attributes
+  end
+
+  def mapped_value(name, unmapped_value, type, map: mapping_for(name, type), default: default_value(type))
+    return default.dup if unmapped_value.nil? # Duplicate to prevent accidental sharing between instances
+
+    if map.nil?
+      fail ArgumentError, "missing mapper for #{ name } (#{ type }). "\
+        "Unmapped value: #{ unmapped_value.inspect }"
+    end
+
+    return map.call(unmapped_value, self) if map.arity > 1
+
+    map.call(unmapped_value)
+  end
+
+  def check_type! value, type, allow_nil:
+    permitted_types = allow_nil ? Array(type) + [ NilClass ] : Array(type)
+    return if permitted_types.any? value.method(:is_a?)
+
+    fail TypeError.new "#{ self.class.name }: "\
+      "#{ value.inspect } is a #{ value.class } "\
+      "but was supposed to be a #{ humanize_list permitted_types, conjunction: ' or ' }"
+  end
+
+  # [1,2,3] -> "1, 2 and 3"
+  # [1, 2]  -> "1 and 2"
+  # [1]     -> "1"
+  def humanize_list terms, separator: ', ', conjunction: ' and '
+    *all_but_last, last = terms
+    return last if all_but_last.empty?
+
+    [ all_but_last.join(separator), last ].join conjunction
+  end
+
+  def memoize name, ivar = IVAR[name]
+    send WRITER[name], yield unless instance_variable_defined?(ivar)
+    instance_variable_get(ivar)
+  end
+
+  SNAKE_CASE_PATTERN = /(_[a-z])/ # :nodoc:
+  CAMELIZE = -> name { name.to_s.gsub(SNAKE_CASE_PATTERN) { |x| x[1].upcase }.delete('?') }
+
+end

data/lib/lazy_mapper/version.rb

@@ -0,0 +1,3 @@
+class LazyMapper
+  VERSION = '0.4.0'
+end

data/spec/lazy_mapper_spec.rb

@@ -20,7 +20,7 @@ describe LazyMapper do
     let(:klass) {
       t = type
       m = map
-      Class.new LazyMapper do
+      Class.new described_class do
         one :created_at, Date
         many :updated_at, Date
         one :foo, t, map: m, default: 666
@@ -92,14 +92,14 @@ describe LazyMapper do
 
         let(:klass_foo) {
           b = bar_builder
-          Class.new LazyMapper do
+          Class.new described_class do
             one :bar, Object, map: b
           end
         }
 
         let(:klass_bar) {
           b = foo_builder
-          Class.new LazyMapper do
+          Class.new described_class do
             one :foo, Object, map: b
           end
         }
@@ -116,7 +116,7 @@ describe LazyMapper do
     describe 'the :from option' do
 
       let(:klass) {
-        Class.new LazyMapper do
+        Class.new described_class do
           one :baz, Integer, from: 'BAZ'
           is :fuzzy?, from: 'hairy'
           is :sweet?, from: 'sugary'
@@ -136,7 +136,7 @@ describe LazyMapper do
     context "if the mapper doesn't map to the correct type" do
 
       let(:klass) {
-        Class.new LazyMapper do
+        Class.new described_class do
           one :bar, Float, map: ->(x) { x.to_s }
         end
       }
@@ -149,7 +149,7 @@ describe LazyMapper do
 
     it 'supports adding custom type mappers to instances' do
       type = Struct.new(:val1, :val2)
-      klass = Class.new LazyMapper do
+      klass = Class.new described_class do
         one :composite, type
       end
 
@@ -164,7 +164,7 @@ describe LazyMapper do
 
     it 'supports injection of customer mappers during instantiation' do
       type = Struct.new(:val1, :val2)
-      klass = Class.new LazyMapper do
+      klass = Class.new described_class do
         one :foo, type
         one :bar, type
       end
@@ -180,7 +180,7 @@ describe LazyMapper do
     end
 
     it 'expects the supplied mapper to return an Array if the unmapped value of a "many" attribute is not an array' do
-      klass = Class.new LazyMapper do
+      klass = Class.new described_class do
         many :foos, String, map: ->(v) { return v.split '' }
         many :bars, String, map: ->(v) { return v }
       end
@@ -194,9 +194,11 @@ describe LazyMapper do
     context 'when it is derived from another LazyMapper' do
       let(:klass) { Class.new(base) }
       let(:composite_type) { Struct.new(:val1, :val2) }
+      let(:new_type) { Class.new }
+      let(:new_type_mapper) { new_type.method(:new) }
       let(:base) {
         type = composite_type
-        Class.new(LazyMapper) do
+        Class.new(described_class) do
           default_value_for type, type.new('321', '123')
           mapper_for type, ->(unmapped_value) { type.new(*unmapped_value.split(' ')) }
           one :composite, type
@@ -215,6 +217,13 @@ describe LazyMapper do
       it 'inherits default mappers' do
         expect(klass.from('composite' => 'abc def').composite).to eq composite_type.new('abc', 'def')
       end
+
+      it 'inherits default mappers that are added to its parent after it has been defined', wip: true do
+        expect(klass.mappers[new_type]).to be_nil
+        base.mapper_for new_type, new_type_mapper
+        expect(base.mappers[new_type]).to eq new_type_mapper
+        expect(klass.mappers[new_type]).to eq new_type_mapper
+      end
     end
   end
 
@@ -224,7 +233,7 @@ describe LazyMapper do
     let(:values) { {} }
 
     let(:klass) {
-      Class.new LazyMapper do
+      Class.new described_class do
         one :title, String
         one :count, Integer
         one :rate, Float
@@ -270,7 +279,7 @@ describe LazyMapper do
 
     context 'when no values are provided' do
 
-      it 'have sensible fallback values for primitive types' do
+      it 'has sensible default values for primitive types' do
         expect(instance.title).to eq('')
         expect(instance.count).to eq(0)
         expect(instance.rate).to eq(0.0)
@@ -278,15 +287,15 @@ describe LazyMapper do
         expect(instance.tags).to eq []
       end
 
-      it 'use the supplied default values' do
+      it 'uses the supplied default values' do
         expect(instance.things).to eq(['something'])
       end
 
-      it 'fall back to nil in all other cases' do
+      it 'falls back to nil in all other cases' do
         expect(instance.widget).to be_nil
       end
 
-      it 'don\'t share their default values between instances' do
+      it 'dosn\'t share its default values with other instances' do
         instance1 = klass.new
         instance2 = klass.new
         instance1.tags << 'dirty'

data/spec/spec_helper.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
-$LOAD_PATH.unshift __dir__
-
 if ENV['RCOV']
   require 'simplecov'
   SimpleCov.start do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lazy_mapper
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Adam Lett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-05 00:00:00.000000000 Z
+date: 2019-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -47,11 +47,15 @@ files:
 - ".gitignore"
 - ".rubocop.yml"
 - ".ruby-version"
+- CHANGELOG.md
 - Gemfile
 - LICENCE
 - README.md
 - lazy_mapper.gemspec
 - lib/lazy_mapper.rb
+- lib/lazy_mapper/defaults.rb
+- lib/lazy_mapper/lazy_mapper.rb
+- lib/lazy_mapper/version.rb
 - spec/lazy_mapper_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/bruun-rasmussen/lazy_mapper