lazy_mapper 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fc03c578aa1fc21f450802874c88cacfd78512e963d8dd840c59a3258bb18cf
-  data.tar.gz: 6566aec14a6fd1c00eac05f3e5c973c5a48628e086c2631641c426426240bd97
+  metadata.gz: d96e0b06dde82ad35dad5af9b8df984d184350697d3b52bc13bca736d4fddc83
+  data.tar.gz: 3da907ac56b03e014ac47a0bcc21fdb9bd15727efe34ac72ceba9c80f2fe2687
 SHA512:
-  metadata.gz: 8ef3c23e999803cae1da99eeb44cc6185be584507e32f1cf2ba827fe218d09ee9ff3d7d891b3647fa8bb71500d8208d0fbc868af7d72c1c3fc4b748ac6a01d2a
-  data.tar.gz: abd2639ae80601c08b13a861e9d76ae7271e3da5d93f1027e81f4623f681614b6c8fadaed0bb22ef54ffb4806eb81b7e09e54a5e494f78ca43af5ea53bb58ef1
+  metadata.gz: 0ec71a118de6245dcf684f3a7380f2b83400305c9a62ac1734f88672eff5b97c9b253e10408b13bdde3b12b37dafbfd8f3b7f775737145a2ff42b8479875810d
+  data.tar.gz: 0da914f451230d8a9bbbe341aa47fb806e5465a5a0b60adb868b0484ed3a63b7895cea42788f077b606afeda188729e865c2a1f7559667f025dd098797bc8403

data/.rubocop.yml

@@ -0,0 +1,124 @@
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 120
+  # To make it possible to copy or click on URIs in the code, we allow lines
+  # containing a URI to be longer than Max.
+  AllowHeredoc: true
+  AllowURI: true
+  URISchemes:
+    - http
+    - https
+
+Metrics/MethodLength:
+  CountComments: false  # count full line comments?
+  Max: 15
+
+Metrics/ClassLength:
+  CountComments: false  # count full line comments?
+  Max: 150
+
+Metrics/ModuleLength:
+  CountComments: false  # count full line comments?
+  Max: 150
+
+Metrics/BlockLength:
+  CountComments: false  # count full line comments?
+  Max: 150 # Nothing wrong with e.g. big Structs
+
+Layout/SpaceInsideStringInterpolation:
+  EnforcedStyle: space
+
+Layout/SpaceInsideArrayLiteralBrackets:
+  Enabled: false
+
+Style/RedundantSelf:
+  Enabled: false
+
+Style/BlockDelimiters:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Layout/EmptyLinesAroundBlockBody:
+  Description: "Keeps track of empty lines around block bodies."
+  Enabled: false
+
+Layout/EmptyLinesAroundClassBody:
+  Description: "Keeps track of empty lines around class bodies."
+  Enabled: false
+
+Layout/EmptyLinesAroundModuleBody:
+  Description: "Keeps track of empty lines around module bodies."
+  Enabled: false
+
+Layout/EmptyLinesAroundMethodBody:
+  Description: "Keeps track of empty lines around method bodies."
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Layout/AlignHash:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Layout/AlignParameters:
+  EnforcedStyle: with_first_parameter
+
+Layout/IndentArray:
+  EnforcedStyle: consistent
+
+Layout/IndentHash:
+  EnforcedStyle: consistent
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/MutableConstant:
+  Enabled: false
+
+Style/MethodDefParentheses:
+  Enabled: false
+  EnforcedStyle: require_no_parentheses_except_multiline
+
+Style/StabbyLambdaParentheses:
+  Enabled: false
+
+Layout/SpaceInLambdaLiteral:
+  Enabled: false
+
+Style/StructInheritance:
+  Enabled: false
+
+Naming/PredicateName:
+  Enabled: false
+
+Style/FormatStringToken:
+  Enabled: false
+
+Rails/DynamicFindBy:
+  Enabled: false
+
+Style/RescueStandardError:
+  EnforcedStyle: implicit

data/Gemfile

@@ -10,8 +10,8 @@ group :test do
 end
 
 group :tools do
-  gem 'pry-byebug', platform: :mri
   gem 'pry', platform: :jruby
+  gem 'pry-byebug', platform: :mri
 
   unless ENV['TRAVIS']
     gem 'mutant', git: 'https://github.com/mbj/mutant'

data/README.md

@@ -15,7 +15,7 @@ Example:
 
 ## Documentation
 
-See [RubyDoc](https://www.rubydoc.info/gems/lazy_mapper/LazyMapper)
+See [RubyDoc](https://www.rubydoc.info/gems/lazy_mapper/0.3.0)
 
 ## License
 

data/lazy_mapper.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |spec|
   spec.name          = 'lazy_mapper'
-  spec.version       = '0.2.1'
-  spec.summary       = "A lazy object mapper"
-  spec.description   = "Wraps primitive data in a semantically rich model"
-  spec.authors       = ["Adam Lett"]
+  spec.version       = '0.3.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'

data/lib/lazy_mapper.rb

@@ -3,11 +3,10 @@ require 'bigdecimal/util'
 require 'time'
 
 #
-# 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.
+# 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
@@ -17,7 +16,6 @@ require 'time'
 #       many :users, User, map: ->(u) { User.new(u) }
 #     end
 #
-
 class LazyMapper
 
   #
@@ -70,32 +68,40 @@ class LazyMapper
     @mappers ||= DEFAULT_MAPPINGS
   end
 
-  def self.inherited(klass)
-    klass.instance_variable_set IVAR[:mappers], self.mappers.dup
-    klass.instance_variable_set IVAR[:default_values], self.default_values.dup
+  def self.attributes
+    @attributes ||= {}
   end
 
+  def self.inherited(klass)
+    # 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 = -> name {
+  IVAR = lambda { |name| # :nodoc:
     name_as_str = name.to_s
-    if name_as_str[-1] == '?'
-      name_as_str = name_as_str[0...-1]
-    end
+    name_as_str = name_as_str[0...-1] if name_as_str[-1] == '?'
 
     ('@' + name_as_str).freeze
   }
 
-  WRITER = -> name { (name.to_s.gsub('?', '') + '=').to_sym }
+  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.
-  # If a value has the wrong type, a `TypeError` is raised.
+  #
+  # Fails with +TypeError+, if a value doesn't have the expected type.
   #
   # == Example
   #
@@ -110,7 +116,6 @@ class LazyMapper
   #       ]
 
   def initialize(values = {})
-    @json = {}
     @mappers = {}
     values.each do |name, value|
       send(WRITER[name], value)
@@ -124,7 +129,7 @@ class LazyMapper
   #
   # == Arguments
   #
-  # +json+ - The unmapped data as a Hash(-like object). Must respond to #to_h.
+  # +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.
@@ -133,7 +138,7 @@ class LazyMapper
   #
   # == Example
   #
-  #     Foo.from_json({
+  #     Foo.from({
   #       "xmlId" => 42,
   #       "createdAt" => "2015-07-29 14:07:35 +0200",
   #       "amount" => "$2.00",
@@ -146,17 +151,18 @@ class LazyMapper
   #         :amount => -> x { Money.new(x) },
   #         User    => User.method(:new) })
   #
-  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
+  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 :json=, json.to_h
+    instance.send :unmapped_data=, unmapped_data.to_h
     instance.send :mappers=, mappers
     instance
   end
 
-  def self.attributes
-    @attributes ||= {}
+  def self.from_json *args, &block
+    warn "#{ self }.from_json is deprecated. Use #{ self }.from instead."
+    from *args, &block
   end
 
   #
@@ -201,7 +207,7 @@ class LazyMapper
     # Define reader
     define_method(name) {
       memoize(name, ivar) {
-        unmapped_value = json[from]
+        unmapped_value = unmapped_data[from]
         mapped_value(name, unmapped_value, type, **args)
       }
     }
@@ -210,7 +216,7 @@ class LazyMapper
   end
 
   #
-  # Converts a value to true or false according to its truthyness
+  # Converts a value to +true+ or +false+ according to its truthyness
   #
   TO_BOOL = -> b { !!b }
 
@@ -251,15 +257,14 @@ class LazyMapper
   #
   # +type+ - The type of the elements in the collection.
   #
-  # +from:+ - Specifies the name of the wrapped array in the JSON object.
+  # +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 wrapped value is not present
-  # in the wrapped JSON object.
+  # +default:+ - The default value to use, if the unmapped value is missing.
   #
   # == Example
   #
@@ -279,7 +284,7 @@ class LazyMapper
     # Define getter
     define_method(name) {
       memoize(name) {
-        unmapped_value = json[from]
+        unmapped_value = unmapped_data[from]
         if unmapped_value.is_a? Array
           unmapped_value.map { |v| mapped_value(name, v, type, **args) }
         else
@@ -296,30 +301,28 @@ class LazyMapper
     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__ > 0
     @__under_inspection__ += 1
-    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|
+    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(', ') } >"
-    res = "<#{ self.class.name } #{ present_attributes.map {|k,v| k.to_s + ': ' + v.inspect }.join(', ') } >"
+    "<#{ self.class.name } #{ present_attributes.map { |k, v| k.to_s + ': ' + v.inspect }.join(', ') } >"
+    res = "<#{ self.class.name } #{ present_attributes.map { |k, v| k.to_s + ': ' + v.inspect }.join(', ') } >"
     @__under_inspection__ -= 1
     res
   end
 
   protected
 
-  def json
-    @json ||= {}
-  end
-
   #
   # Defines how to map an attribute name
   # to the corresponding name in the unmapped
@@ -333,9 +336,13 @@ class LazyMapper
 
   private
 
-  attr_writer :json
+  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
@@ -344,6 +351,10 @@ class LazyMapper
     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))
     if unmapped_value.nil?
       # Duplicate to prevent accidental sharing between instances
@@ -369,12 +380,11 @@ class LazyMapper
     [ 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 }.gsub('?', '') }
+  CAMELIZE = -> name { name.to_s.gsub(SNAKE_CASE_PATTERN) { |x| x[1].upcase }.delete('?') }
 end

data/spec/lazy_mapper_spec.rb

@@ -5,11 +5,18 @@ require 'lazy_mapper'
 
 describe LazyMapper do
 
-  describe 'when constructed with .from_json' do
+  describe 'when constructed from unmapped data' do
 
-    subject(:instance) { klass.from_json json }
+    subject(:instance) { klass.from unmapped_data }
 
-    let(:json) { nil }
+    let(:unmapped_data) {
+      {
+        'createdAt' => '2015-07-27',
+        'updatedAt' => ['2015-01-01', '2015-01-02'],
+        'foo'       => '42',
+        'blue'      => true
+      }
+    }
     let(:klass) {
       t = type
       m = map
@@ -25,11 +32,13 @@ describe LazyMapper do
     let(:type) { Integer }
 
     context 'if the supplied data is nil' do
+      let(:unmapped_data) { nil }
+
       it { is_expected.to be_nil }
     end
 
     context 'when invalid data is supplied' do
-      let(:json) { 'not a hash' }
+      let(:unmapped_data) { 'not a hash' }
 
       it 'fails with a TypeError' do
         expect { instance }.to raise_error(TypeError)
@@ -38,20 +47,11 @@ describe LazyMapper do
 
     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
+      it 'maps primitives 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
+      it 'maps arrays of primitives 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
@@ -79,8 +79,8 @@ describe LazyMapper do
 
         subject(:instance) { foo }
 
-        let(:foo) { klass_foo.from_json 'bar' => 'bar' }
-        let(:bar) { klass_bar.from_json 'foo' => 'foo' }
+        let(:foo) { klass_foo.from 'bar' => 'bar' }
+        let(:bar) { klass_bar.from 'foo' => 'foo' }
         let(:foo_builder) { proc { foo } }
         let(:bar_builder) { proc { bar } }
 
@@ -116,9 +116,9 @@ describe LazyMapper do
         end
       }
 
-      let(:json) { { 'BAZ' => 999, 'hairy' => true } }
+      let(:unmapped_data) { { 'BAZ' => 999, 'hairy' => true } }
 
-      it 'specifies a different name in the JSON object for the attribute' do
+      it 'specifies the name of the attribute in the unmapped data' do
         expect(instance.baz).to eq(999)
       end
 
@@ -135,7 +135,7 @@ describe LazyMapper do
       }
 
       it 'fails with a TypeError when an attribute is accessed' do
-        instance = klass.from_json 'bar' => 42
+        instance = klass.from 'bar' => 42
         expect { instance.bar }.to raise_error(TypeError)
       end
     end
@@ -146,7 +146,7 @@ describe LazyMapper do
         one :composite, type
       end
 
-      instance = klass.from_json 'composite' => '123 456'
+      instance = klass.from 'composite' => '123 456'
       instance.add_mapper_for(type) { |unmapped_value| type.new(*unmapped_value.split(' ')) }
 
       expect(instance.composite).to eq type.new('123', '456')
@@ -155,35 +155,6 @@ describe LazyMapper do
       expect(instance.composite).to eq type.new('abc', 'cde')
     end
 
-    it 'supports adding inheritable 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
-
-      klass2 = Class.new(klass)
-      instance = klass.from_json 'composite' => '123 456'
-      expect(instance.composite).to eq type.new('123', '456')
-
-      instance2 = klass2.from_json 'composite' => '456 789'
-      expect(instance2.composite).to eq type.new('456', '789')
-    end
-
-    it 'supports adding or overriding inheritable default values for types to derived classes' do
-      type = Struct.new(:val1, :val2)
-
-      klass = Class.new LazyMapper do
-        default_value_for type, type.new('321', '123')
-        one :composite, type
-      end
-
-      klass2 = Class.new(klass)
-      instance = klass2.from_json({})
-      expect(instance.composite).to eq type.new('321', '123')
-    end
-
     it 'supports injection of customer mappers during instantiation' do
       type = Struct.new(:val1, :val2)
       klass = Class.new LazyMapper do
@@ -191,7 +162,7 @@ describe LazyMapper do
         one :bar, type
       end
 
-      instance = klass.from_json({ 'foo' => '123 456', 'bar' => 'abc def' },
+      instance = klass.from({ 'foo' => '123 456', 'bar' => 'abc def' },
                                  mappers: {
                                    foo: ->(f) { type.new(*f.split(' ').reverse) },
                                    type => ->(t) { type.new(*t.split(' ')) }
@@ -207,11 +178,37 @@ describe LazyMapper do
         many :bars, String, map: ->(v) { return v }
       end
 
-      instance = klass.from_json 'foos' => 'abc', 'bars' => 'abc'
+      instance = klass.from 'foos' => 'abc', 'bars' => 'abc'
 
       expect(instance.foos).to eq %w[a b c]
       expect { instance.bars }.to raise_error(TypeError)
     end
+
+    context 'when it is derived from another LazyMapper' do
+      let(:klass) { Class.new(base) }
+      let(:composite_type) { Struct.new(:val1, :val2) }
+      let(:base) {
+        type = composite_type
+        Class.new(LazyMapper) do
+          default_value_for type, type.new('321', '123')
+          mapper_for type, ->(unmapped_value) { type.new(*unmapped_value.split(' ')) }
+          one :composite, type
+        end
+      }
+
+      it 'inherits attributes' do
+        expect(klass.attributes.keys).to eq [:composite]
+        expect(instance).to respond_to(:composite)
+      end
+
+      it 'inherits default values' do
+        expect(instance.composite).to eq composite_type.new('321', '123')
+      end
+
+      it 'inherits default mappers' do
+        expect(klass.from('composite' => 'abc def').composite).to eq composite_type.new('abc', 'def')
+      end
+    end
   end
 
   context 'when constructed with .new' do
@@ -289,6 +286,19 @@ describe LazyMapper do
         expect(instance2.tags).to be_empty
         expect(instance2.things).to_not be_empty
       end
+
+      it 'still includes every attribute when converted to Hash' do
+        expect(instance.to_h).to eq(
+          title: '',
+          count: 0,
+          rate: 0.0,
+          tags: [],
+          widget: nil,
+          things: ['something'],
+          green?: false,
+          flowers?: false
+        )
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lazy_mapper
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Adam Lett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-15 00:00:00.000000000 Z
+date: 2018-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -45,6 +45,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - LICENCE
 - README.md