lazy_mapper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '08c13aa83740c1719069305ba2be381b32c65ed59017fa251d16a2c5590dd945'
+  data.tar.gz: 5f1febab53594a456df8b842972f8ea26015270fd3043853a991ab7b467eae9e
+SHA512:
+  metadata.gz: d4c44f93957f6b04c7069b3f7991862f75d6539ab8b2ae70ebbbcdfbfe4080d59548b9a7b2364cc18dd0c16a1b4b223df6417fb039d57fd36718fd17aa36da17
+  data.tar.gz: 05523ef4f8fc5d26a335c0b8be671d8e38e677ada3a350e6817cc1a13691b616ed6d8c0b7617c16735894bfe6e799117076dfd100abe15ab44c5798afa8aa2e3

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+coverage
+/.bundle
+vendor/bundle
+bin/
+log/
+tmp/
+.idea/
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'i18n', require: false
+  platform :mri do
+    gem 'simplecov', require: false
+  end
+end
+
+group :tools do
+  gem 'pry-byebug', platform: :mri
+  gem 'pry', platform: :jruby
+
+  unless ENV['TRAVIS']
+    gem 'mutant', git: 'https://github.com/mbj/mutant'
+    gem 'mutant-rspec', git: 'https://github.com/mbj/mutant'
+  end
+end

data/LICENCE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Bruun Rasmussen A/S
+
+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,18 @@
+# LazyModel
+
+Wraps a JSON object and lazily maps its attributes to rich domain objects using either a set of default mappers (for Ruby's built-in types), or custom mappers specified by the client.
+
+The mapped values are memoized.
+
+Example:
+
+    class Foo < LazyMapper
+      one :id, Integer, from: 'iden'
+      one :created_at, Time
+      one :amount, Money, map: Money.method(:parse)
+      many :users, User, map: ->(u) { User.new(u) }
+    end
+
+## License
+
+See `LICENSE` file.

data/lazy_mapper.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |spec|
+  spec.name          = 'lazy_mapper'
+  spec.version       = '0.1.0'
+  spec.summary       = "A lazy object mapper"
+  spec.description   = "Wraps primitive data in a semantically rich model"
+  spec.authors       = ["Adam Lett"]
+  spec.email         = 'adam@bruun-rasmussen.dk'
+  spec.homepage      = 'https://github.com/bruun-rasmussen/lazy_mapper'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0") - ['bin/console']
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'activesupport', '>= 3'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rspec'
+end

data/lib/lazy_mapper.rb

@@ -0,0 +1,341 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'time'
+require 'active_support/core_ext/class/attribute'
+
+##
+# Wraps a JSON object and lazily maps its attributes to domain objects
+# using either a set of default mappers (for Ruby's built-in types), or
+# custom mappers specified by the client.
+#
+# The mapped values are memoized.
+#
+# 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     => ->(o) { o },
+    String     => ->(s) { s.to_s },
+    Integer    => ->(i) { i.to_i },
+    BigDecimal => ->(d) { d.to_d },
+    Float      => ->(f) { f.to_f },
+    Symbol     => ->(s) { s.to_sym },
+    Hash       => ->(h) { h.to_h },
+    Time       => Time.method(:iso8601),
+    Date       => Date.method(:parse),
+    URI        => URI.method(:parse)
+  }.freeze
+
+  # Default values for primitive types
+  DEFAULT_VALUES = {
+    String     => '',
+    Integer    => 0,
+    Numeric    => 0,
+    Float      => 0.0,
+    BigDecimal => BigDecimal.new('0'),
+    Array      => []
+  }.freeze
+
+  def self.mapper_for(type, mapper)
+    mappers[type] = mapper
+  end
+
+  class_attribute :mappers
+  self.mappers = {}
+
+  attr_reader :mappers
+
+  IVAR = -> name {
+    name_as_str = name.to_s
+    if name_as_str[-1] == '?'
+      name_as_str = name_as_str[0...-1]
+    end
+
+    ('@' + name_as_str).freeze
+  }
+
+  WRITER = -> name { (name.to_s.gsub('?', '') + '=').to_sym }
+
+  # = ::new
+  #
+  # Create a new instance by giving a Hash of attribues.
+  #
+  # == 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 = {})
+    @json = {}
+    @mappers = {}
+    values.each do |name, value|
+      send(WRITER[name], value)
+    end
+  end
+
+  # = ::from_json
+  #
+  # Create a new instance by giving a Hash of unmapped attributes.
+  #
+  # The keys in the Hash are assumed to be camelCased strings.
+  #
+  # == Example
+  #
+  #     Foo.from_json "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" }
+  #       ]
+  #
+  def self.from_json json, mappers: {}
+    return nil if json.nil?
+    fail TypeError, "#{ json.inspect } is not a Hash" unless json.respond_to? :to_h
+    instance = new
+    instance.send :json=, json.to_h
+    instance.send :mappers=, mappers
+    instance
+  end
+
+  def self.attributes
+    @attributes ||= {}
+  end
+
+  # = ::one
+  #
+  # Defines an attribute
+  #
+  # == 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.
+  #
+  # +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. 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.
+  #
+  # == Example
+  #
+  #    class Foo < LazyMapper
+  #      one :boss, Person, from: "supervisor", map: ->(p) { Person.new(p) }
+  #      # ...
+  #    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 = json[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 }
+
+  # = ::is
+  #
+  # 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)
+
+
+  # = ::many
+  #
+  # Wraps a collection
+  #
+  # == Arguments
+  #
+  # +name+ - The name of the attribue
+  #
+  # +type+ - The type of the elemnts in the collection. If an element is
+  #          already of that type, the mapper is bypassed for that element.
+  #
+  # +from:+ - Specifies the name of the wrapped array in the JSON object.
+  #           Defaults to camelCased version of +name+.
+  #
+  # +map:+ - Specifies a custom mapper to apply to the elements in the wrapped
+  #          array. Must respond to +#call+. 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.
+  #
+  # == 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 = json[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
+      }
+    }
+  end
+
+  def add_mapper_for(type, &block)
+    mappers[type] = block
+  end
+
+  def inspect
+    attributes = self.class.attributes
+    if self.class.superclass.respond_to? :attributes
+      attributes = self.class.superclass.attributes.merge attributes
+    end
+    present_attributes = attributes.keys.each_with_object({}) {|name, memo|
+      value = self.send name
+      memo[name] = value unless value.nil?
+    }
+    "<#{ self.class.name } #{ present_attributes.map {|k,v| k.to_s + ': ' + v.inspect }.join(', ') } >"
+  end
+
+  protected
+
+  def json
+    @json ||= {}
+  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 :json
+  attr_writer :mappers
+
+  def mapping_for(name, type)
+    mappers[name] || mappers[type] || self.class.mappers[type] || DEFAULT_MAPPINGS[type]
+  end
+
+  def default_value(type)
+    DEFAULT_VALUES.fetch(type) { nil }
+  end
+
+  def mapped_value(name, unmapped_value, type, map: mapping_for(name, type), default: default_value(type))
+    if unmapped_value.nil?
+      # Duplicate to prevent accidental sharing between instances
+      default.dup
+    else
+      fail ArgumentError, "missing mapper for #{ name } (#{ type }). Unmapped value: #{ unmapped_value.inspect }" if map.nil?
+      result = map.arity > 1 ? map.call(unmapped_value, self) : map.call(unmapped_value)
+      result
+    end
+  end
+
+  def check_type! value, type, allow_nil:
+    permitted_types = allow_nil ? Array(type) + [ NilClass ] : Array(type)
+    fail TypeError.new "#{ self.class.name }: #{ value.inspect } is a #{ value.class } but was supposed to be a #{ humanize_list permitted_types, conjunction: ' or ' }" unless permitted_types.any? value.method(:is_a?)
+  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])/
+
+  # "foo_bar_baz" -> "fooBarBaz"
+  # "foo_bar?" -> "fooBar"
+  def self.camelize(name)
+    name.to_s.gsub(SNAKE_CASE_PATTERN) { |x| x[1].upcase }.gsub('?', '')
+  end
+end

data/spec/lazy_mapper_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'lazy_mapper'
+
+describe LazyMapper do
+
+  describe '.from_json' do
+
+    subject(:instance) { klass.from_json json }
+
+    let(:json) { nil }
+    let(:klass) {
+      t = type
+      m = map
+      Class.new LazyMapper do
+        one :created_at, Date
+        many :updated_at, Date
+        one :foo, t, map: m, default: 666
+        is :blue?
+      end
+    }
+    let(:mapper) { spy 'mapper', map: 42 }
+    let(:map) { ->(x) { mapper.map(x) } }
+    let(:type) { Integer }
+
+    context 'if the supplied data is nil' do
+      it { is_expected.to be_nil }
+    end
+
+    context 'when invalid data is supplied' do
+      let(:json) { 'not a hash' }
+
+      it 'fails with a TypeError' do
+        expect { instance }.to raise_error(TypeError)
+      end
+    end
+
+    context 'when valid data is supplied' do
+
+      let(:json) {
+        {
+          'createdAt' => '2015-07-27',
+          'updatedAt' => ['2015-01-01', '2015-01-02'],
+          'foo'       => '42',
+          'blue'      => true
+        }
+      }
+
+      it 'maps JSON attributes to domain objects' do
+        expect(instance.created_at).to eq(Date.new(2015, 7, 27))
+      end
+
+      it 'maps arrays of JSON values to arrays of domain objects' do
+        expect(instance.updated_at).to be_a(Array)
+        expect(instance.updated_at.first).to be_a(Date)
+        expect(instance).to be_blue
+      end
+
+      it 'memoizes mapped value so that potentially expensive mappings are performed just once' do
+        3.times do
+          expect(instance.foo).to eq(42)
+        end
+        expect(mapper).to have_received(:map).exactly(1).times.with('42')
+      end
+
+      context 'if the mapped value is nil' do
+        let(:map) { -> x { mapper.map(x); nil } }
+
+        it 'even memoizes that' do
+          3.times do
+            expect(instance.foo).to be_nil
+          end
+          expect(mapper).to have_received(:map).exactly(1).times.with('42')
+        end
+      end
+    end
+
+    describe 'the :from option' do
+
+      let(:klass) {
+        Class.new LazyMapper do
+          one :baz, Integer, from: 'BAZ'
+          is :fuzzy?, from: 'hairy'
+          is :sweet?, from: 'sugary'
+        end
+      }
+
+      let(:json) { { 'BAZ' => 999, 'hairy' => true } }
+
+      it 'specifies a different name in the JSON object for the attribute' do
+        expect(instance.baz).to eq(999)
+      end
+
+      it { is_expected.to be_fuzzy }
+      it { is_expected.to_not be_sweet }
+    end
+
+    context "if the mapper doesn't map to the correct type" do
+
+      let(:klass) {
+        Class.new LazyMapper do
+          one :bar, Float, map: ->(x) { x.to_s }
+        end
+      }
+
+      it 'fails with a TypeError when an attribute is accessed' do
+        instance = klass.from_json 'bar' => 42
+        expect { instance.bar }.to raise_error(TypeError)
+      end
+    end
+
+    it 'supports adding custom type mappers to instances' do
+      type = Struct.new(:val1, :val2)
+      klass = Class.new LazyMapper do
+        one :composite, type
+      end
+
+      instance = klass.from_json 'composite' => '123 456'
+      instance.add_mapper_for(type) { |unmapped_value| type.new(*unmapped_value.split(' ')) }
+
+      expect(instance.composite).to eq type.new('123', '456')
+
+      instance = klass.new composite: type.new('abc', 'cde')
+      expect(instance.composite).to eq type.new('abc', 'cde')
+    end
+
+    it 'supports adding default mappers to derived classes' do
+      type = Struct.new(:val1, :val2)
+
+      klass = Class.new LazyMapper do
+        mapper_for type, ->(unmapped_value) { type.new(*unmapped_value.split(' ')) }
+        one :composite, type
+      end
+
+      instance = klass.from_json 'composite' => '123 456'
+      expect(instance.composite).to eq type.new('123', '456')
+    end
+
+    it 'supports injection of customer mappers during instantiation' do
+      type = Struct.new(:val1, :val2)
+      klass = Class.new LazyMapper do
+        one :foo, type
+        one :bar, type
+      end
+
+      instance = klass.from_json({ 'foo' => '123 456', 'bar' => 'abc def' },
+                                 mappers: {
+                                   foo: ->(f) { type.new(*f.split(' ').reverse) },
+                                   type => ->(t) { type.new(*t.split(' ')) }
+                                 })
+
+      expect(instance.foo).to eq type.new('456', '123')
+      expect(instance.bar).to eq type.new('abc', 'def')
+    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
+        many :foos, String, map: ->(v) { return v.split '' }
+        many :bars, String, map: ->(v) { return v }
+      end
+
+      instance = klass.from_json 'foos' => 'abc', 'bars' => 'abc'
+
+      expect(instance.foos).to eq %w[a b c]
+      expect { instance.bars }.to raise_error(TypeError)
+    end
+  end
+
+  context 'construction' do
+
+    subject(:instance) { klass.new values }
+    let(:values) { {} }
+
+    let(:klass) {
+      Class.new LazyMapper do
+        one :title, String
+        one :count, Integer
+        one :rate, Float
+        one :tags, Array
+        one :widget, Object
+        one :things, Array, default: ['something']
+        is  :green?
+        has :flowers?
+      end
+    }
+
+    context 'when values are provided' do
+
+      let(:values) {
+        {
+          title:  'A title',
+          count:  42,
+          rate:   3.14,
+          tags:   %w[red hot],
+          widget: Date.new,
+          things: %i[one two three],
+          green?: true
+        }
+      }
+
+      it 'uses those values' do
+        values.each do |name, value|
+          expect(instance.send(name)).to eq(value)
+        end
+      end
+
+      context 'if a value given in the constructor is not of the specified type' do
+        let(:values) {
+          { title: :'Not a string' }
+        }
+
+        it 'fails with a TypeError' do
+          expect { instance }.to raise_error(TypeError)
+        end
+      end
+    end
+
+    context 'when no values are provided' do
+
+      it 'have sensible fallback values for primitive types' do
+        expect(instance.title).to eq('')
+        expect(instance.count).to eq(0)
+        expect(instance.rate).to eq(0.0)
+        expect(instance.widget).to be_nil
+        expect(instance.tags).to eq []
+      end
+
+      it 'use the supplied default values' do
+        expect(instance.things).to eq(['something'])
+      end
+
+      it 'fall 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
+        instance1 = klass.new
+        instance2 = klass.new
+        instance1.tags << 'dirty'
+        instance1.things.pop
+        expect(instance2.tags).to be_empty
+        expect(instance2.things).to_not be_empty
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# 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
+    add_filter '/spec/'
+  end
+end
+
+RSpec.configure do |config|
+  config.pattern = '**{,/*/**}/*{_,.}spec.rb'
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: lazy_mapper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adam Lett
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Wraps primitive data in a semantically rich model
+email: adam@bruun-rasmussen.dk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENCE
+- README.md
+- lazy_mapper.gemspec
+- lib/lazy_mapper.rb
+- spec/lazy_mapper_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bruun-rasmussen/lazy_mapper
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A lazy object mapper
+test_files:
+- spec/lazy_mapper_spec.rb
+- spec/spec_helper.rb