monolens 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30152f626d5675640e96816c7036d5a6dbac8a25
-  data.tar.gz: a26d4e5d0715bd511aea96da758fd12d36e2a70b
+  metadata.gz: b2a9267753f8725ed91fc71b3c9b995a11d3b0c1
+  data.tar.gz: 4aaaf0247bcb4f2195052a416ebe7742bfd2b72a
 SHA512:
-  metadata.gz: 7b27ab005aaf2a6bf1abdc8c9284072ce1307498b7edad606526198c3e4ae003d0ddda72eb532266b7b737fbb04146959903868c50e16be4fbb8f1a073f20e9b
-  data.tar.gz: 8fd2b3ad776ff72da243ba29ab7fc2bd5fd05e88b8d34c93cd38c362142b83ff4c8164559af707d3ea314c39af3b9c415c1716841c269ab73bf9e06b852c883e
+  metadata.gz: 99df61206eb26141c13a7a364fc9f5af97ade23d9a50e92e82cd8b2980cb88790e36402a852116d800a2caebe71af7b1bb90e4ad3dc8fdd450360d1ce63fe5e6
+  data.tar.gz: a93491cec013f9993299ee227c2055c0c93a9f224c5da6a2526afbb95fe2516bf1b29250670c769667cd93bb018e613e3ae21b98d545a62109602e2fa2c1f843

data/lib/monolens/command.rb

@@ -47,10 +47,19 @@ module Monolens
     end
 
     def read_file(file)
-      content = ::File.read(file)
       case ::File.extname(file)
-      when /json$/ then JSON.parse(content)
-      when /ya?ml$/ then YAML.safe_load(content)
+      when /json$/
+        content = ::File.read(file)
+        JSON.parse(content)
+      when /ya?ml$/
+        content = ::File.read(file)
+        YAML.safe_load(content)
+      when /csv$/
+        require 'bmg'
+        Bmg.csv(file).to_a
+      when /xlsx?$/
+        require 'bmg'
+        Bmg.excel(file).to_a
       else
         fail!("Unable to use #{file}")
       end

data/lib/monolens/core/mapping.rb

@@ -5,11 +5,31 @@ module Monolens
 
       def call(arg, world = {})
         option(:values, {}).fetch(arg) do
-          fail!("Unrecognized value `#{arg}`", world) if option(:fail_if_missing)
+          on_missing(arg, world)
+        end
+      end
+
+    private
 
-          option(:default)
+      def on_missing(arg, world)
+        strategy = option(:on_missing, :fail)
+        case strategy.to_sym
+        when :fail
+          fail!("Unrecognized value `#{arg}`", world)
+        when :default
+          option(:default, nil)
+        when :null
+          nil
+        when :fallback
+          missing_fallback = ->(arg, world) do
+            raise Monolens::Error, "Unexpected missing fallback handler"
+          end
+          option(:fallback, missing_fallback).call(self, arg, world)
+        else
+          raise Monolens::Error, "Unexpected missing strategy `#{strategy}`"
         end
       end
+      private :on_missing
     end
   end
 end

data/lib/monolens/lens.rb

@@ -11,6 +11,11 @@ module Monolens
     end
     attr_reader :options
 
+    def fail!(msg, world)
+      location = world[:location]&.to_a || []
+      raise Monolens::LensError.new(msg, location)
+    end
+
   protected
 
     def option(name, default = nil)
@@ -58,10 +63,5 @@ module Monolens
 
       fail!("Array expected, got #{arg.class}", world)
     end
-
-    def fail!(msg, world)
-      location = world[:location]&.to_a || []
-      raise Monolens::LensError.new(msg, location)
-    end
   end
 end

data/lib/monolens/object/select.rb

@@ -9,20 +9,12 @@ module Monolens
         result = {}
         is_symbol = arg.keys.any?{|k| k.is_a?(Symbol) }
         defn.each_pair do |new_attr, selector|
+          new_attr = is_symbol ? new_attr.to_sym : new_attr.to_s
+
           deeper(world, new_attr) do |w|
-            is_array = selector.is_a?(::Array)
-            values = []
-            Array(selector).each do |old_attr|
-              actual, fetched = fetch_on(old_attr, arg)
-              if actual.nil?
-                on_missing(old_attr, values, w)
-              else
-                values << fetched
-              end
-            end
-            new_attr = is_symbol ? new_attr.to_sym : new_attr.to_s
-            unless values.empty?
-              result[new_attr] = is_array ? values : values.first
+            catch (:skip) do
+              value = do_select(arg, selector, w)
+              result[new_attr] = value
             end
           end
         end
@@ -31,6 +23,42 @@ module Monolens
 
     private
 
+      def do_select(arg, selector, world)
+        if selector.is_a?(::Array)
+          do_array_select(arg, selector, world)
+        else
+          do_single_select(arg, selector, world)
+        end
+      end
+
+      def do_array_select(arg, selector, world)
+        case option(:strategy, :all).to_sym
+        when :all
+          selector.each_with_object([]) do |old_attr, values|
+            catch (:skip) do
+              values << do_single_select(arg, old_attr, world)
+            end
+          end
+        when :first
+          selector.each do |old_attr|
+            actual, fetched = fetch_on(old_attr, arg)
+            return fetched if actual
+          end
+          on_missing(selector.first, [], world).first
+        else
+          raise Monolens::Error, "Unexpected strategy `#{strategy}`"
+        end
+      end
+
+      def do_single_select(arg, selector, world)
+        actual, fetched = fetch_on(selector, arg)
+        if actual.nil?
+          on_missing(selector, [], world).first
+        else
+          fetched
+        end
+      end
+
       def defn
         defn = option(:defn, {})
         defn = defn.each_with_object({}) do |attr, memo|
@@ -47,9 +75,9 @@ module Monolens
         when :null
           values << nil
         when :skip
-          nil
+          throw :skip
         else
-          raise Monolens::Error, "Unexpected missing strategy `#{strategy}`"
+          raise Monolens::Error, "Unexpected on_missing strategy `#{strategy}`"
         end
       end
       private :on_missing

data/lib/monolens/object/transform.rb

@@ -30,7 +30,7 @@ module Monolens
 
       def on_missing(result, attr, world)
         strategy = option(:on_missing, :fail)
-        case strategy.to_sym
+        case strategy&.to_sym
         when :fail
           fail!("Expected `#{attr}` to be defined", world)
         when :null

data/lib/monolens/version.rb

@@ -1,7 +1,7 @@
 module Monolens
   module Version
     MAJOR = 0
-    MINOR = 4
+    MINOR = 5
     TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

data/spec/monolens/core/test_mapping.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Monolens, 'core.mapping' do
   let(:mapping) do
-    { 'values' => { 'todo' => 'open' }}
+    { 'values' => { 'todo' => 'open' } }
   end
 
   context 'with default options' do
@@ -14,14 +14,16 @@ describe Monolens, 'core.mapping' do
       expect(subject.call('todo')).to eql('open')
     end
 
-    it 'returns nil if not found' do
-      expect(subject.call('nosuchone')).to eql(nil)
+    it 'raises if not found' do
+      expect {
+        subject.call('nosuchone')
+      }.to raise_error(Monolens::LensError)
     end
   end
 
-  context 'specifying a default value' do
+  context 'on_missing: default' do
     subject do
-      Monolens.lens('core.mapping' => mapping.merge('default' => 'foo'))
+      Monolens.lens('core.mapping' => mapping.merge('on_missing' => 'default', 'default' => 'foo'))
     end
 
     it 'replaces the value by its mapped' do
@@ -33,19 +35,34 @@ describe Monolens, 'core.mapping' do
     end
   end
 
-  context 'lets raise if not found' do
+  context 'on_missing: null' do
     subject do
-      Monolens.lens('core.mapping' => mapping.merge('fail_if_missing' => true))
+      Monolens.lens('core.mapping' => mapping.merge('on_missing' => 'null'))
     end
 
     it 'replaces the value by its mapped' do
       expect(subject.call('todo')).to eql('open')
     end
 
-    it 'raises if not found' do
-      expect {
-        subject.call('nosuchone')
-      }.to raise_error(Monolens::LensError)
+    it 'returns nil if missing' do
+      expect(subject.call('nosuchone')).to eql(nil)
+    end
+  end
+
+  context 'on_missing: fallback' do
+    subject do
+      Monolens.lens('core.mapping' => mapping.merge(
+        'on_missing' => 'fallback',
+        'fallback' => ->(lens, arg, world) { 'foo' }
+      ))
+    end
+
+    it 'replaces the value by its mapped' do
+      expect(subject.call('todo')).to eql('open')
+    end
+
+    it 'returns nil if missing' do
+      expect(subject.call('nosuchone')).to eql('foo')
     end
   end
 
@@ -54,7 +71,7 @@ describe Monolens, 'core.mapping' do
       Monolens.lens({
         'array.map' => {
           :lenses => {
-            'core.mapping' => mapping.merge('fail_if_missing' => true)
+            'core.mapping' => mapping.merge('on_missing' => 'fail')
           }
         }
       })

data/spec/monolens/object/test_select.rb

@@ -75,6 +75,91 @@ describe Monolens, 'object.select' do
     end
   end
 
+  context 'when using strategy: first' do
+    subject do
+      Monolens.lens('object.select' => {
+        defn: {
+          name: [:firstname, :lastname],
+          status: :priority
+        },
+        strategy: 'first',
+        on_missing: on_missing
+      }.compact)
+    end
+
+    context 'without on_missing' do
+      let(:on_missing) do
+        nil
+      end
+
+      it 'works as expected when first option is present' do
+        input = {
+          firstname: 'Bernard',
+          priority: 12
+        }
+        expected = {
+          name: 'Bernard',
+          status: 12
+        }
+        expect(subject.call(input)).to eql(expected)
+      end
+
+      it 'works as expected when second is present' do
+        input = {
+          lastname: 'Lambeau',
+          priority: 12
+        }
+        expected = {
+          name: 'Lambeau',
+          status: 12
+        }
+        expect(subject.call(input)).to eql(expected)
+      end
+
+      it 'fails when none is present' do
+        input = {
+          priority: 12
+        }
+        expect {
+          subject.call(input)
+        }.to raise_error(Monolens::Error)
+      end
+    end
+
+    context 'with on_missing: skip' do
+      let(:on_missing) do
+        :skip
+      end
+
+      it 'works as expected when missing' do
+        input = {
+          priority: 12
+        }
+        expected = {
+          status: 12
+        }
+        expect(subject.call(input)).to eql(expected)
+      end
+    end
+
+    context 'with on_missing: null' do
+      let(:on_missing) do
+        :null
+      end
+
+      it 'works as expected when missing' do
+        input = {
+          priority: 12
+        }
+        expected = {
+          name: nil,
+          status: 12
+        }
+        expect(subject.call(input)).to eql(expected)
+      end
+    end
+  end
+
   context 'when using an array as selection' do
     subject do
       Monolens.lens('object.select' => {
@@ -186,7 +271,6 @@ describe Monolens, 'object.select' do
 
     subject do
       lens.call(input)
-      nil
     rescue Monolens::LensError => ex
       ex
     end
@@ -196,7 +280,7 @@ describe Monolens, 'object.select' do
     end
 
     it 'correctly updates the location' do
-      expect(subject.location).to eql([:status])
+      expect(subject.location).to eql(['status'])
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monolens
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-12 00:00:00.000000000 Z
+date: 2022-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: bmg
+  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: Data transformations inspired by Cambria lenses
 email: blambeau@gmail.com
 executables: []