monolens 0.4.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30152f626d5675640e96816c7036d5a6dbac8a25
-  data.tar.gz: a26d4e5d0715bd511aea96da758fd12d36e2a70b
+  metadata.gz: 2b96981f78af52f468676e9de0aeb3f79e79ab66
+  data.tar.gz: fb6445fc49c216be5868b27bef78cdfba79a1264
 SHA512:
-  metadata.gz: 7b27ab005aaf2a6bf1abdc8c9284072ce1307498b7edad606526198c3e4ae003d0ddda72eb532266b7b737fbb04146959903868c50e16be4fbb8f1a073f20e9b
-  data.tar.gz: 8fd2b3ad776ff72da243ba29ab7fc2bd5fd05e88b8d34c93cd38c362142b83ff4c8164559af707d3ea314c39af3b9c415c1716841c269ab73bf9e06b852c883e
+  metadata.gz: 110e2c7da4dcc2195599813adf977af62d1698255339d0ba087bb1b1a7fb886ffd90bd12ded6eeb720547c327294eec758ae462f7e98024fffaecddb8e56c2cd
+  data.tar.gz: 1621c07cbba992d5a74c0811e420dd8489ff1c064eaf26bd698404b61bc3ab64ca60da65827ac3a061d0dfad28c483d3e2c07f83e50b4ec5eb22ea944b91d134

data/README.md

@@ -102,6 +102,8 @@ coerce.integer    - Coerces the input value to an integer
 array.compact     - Removes null from the input array
 array.join        - Joins values of the input array as a string
 array.map         - Apply a lens to each member of an Array
+
+check.notEmpty    - Throws an error if the input is null or empty
 ```
 
 ## Public API

data/lib/monolens/check/not_empty.rb

@@ -0,0 +1,26 @@
+require 'date'
+
+module Monolens
+  module Check
+    class NotEmpty
+      include Lens
+
+      def call(arg, world = {})
+        if arg.nil?
+          do_fail!(arg, world)
+        elsif arg.respond_to?(:empty?) && arg.empty?
+          do_fail!(arg, world)
+        else
+          arg
+        end
+      end
+
+    private
+
+      def do_fail!(arg, world)
+        message = option(:message, 'Input may not be empty')
+        fail!(message, world)
+      end
+    end
+  end
+end

data/lib/monolens/check.rb

@@ -0,0 +1,11 @@
+module Monolens
+  module Check
+    def notEmpty(options)
+      NotEmpty.new(options)
+    end
+    module_function :notEmpty
+
+    Monolens.define_namespace 'check', self
+  end
+end
+require_relative 'check/not_empty'

data/lib/monolens/coerce/date.rb

@@ -27,7 +27,7 @@ module Monolens
           end
         end
 
-        fail!(first_error.message, world)
+        fail!("Invalid date `#{arg}`", world) if first_error
       end
 
       def strptime(arg, format = nil)

data/lib/monolens/coerce/date_time.rb

@@ -27,7 +27,7 @@ module Monolens
           end
         end
 
-        fail!(first_error.message, world)
+        fail!("Invalid DateTime `#{arg}`", world) if first_error
       end
 
     private

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/error_handler.rb

@@ -1,5 +1,7 @@
 module Monolens
   class ErrorHandler
+    include Enumerable
+
     def initialize
       @errors = []
     end
@@ -8,6 +10,14 @@ module Monolens
       @errors << error
     end
 
+    def each(&bl)
+      @errors.each(&bl)
+    end
+
+    def size
+      @errors.size
+    end
+
     def empty?
       @errors.empty?
     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,8 +1,8 @@
 module Monolens
   module Version
     MAJOR = 0
-    MINOR = 4
-    TINY  = 0
+    MINOR = 5
+    TINY  = 2
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/lib/monolens.rb

@@ -19,6 +19,7 @@ module Monolens
     require_relative 'monolens/array'
     require_relative 'monolens/object'
     require_relative 'monolens/coerce'
+    require_relative 'monolens/check'
 
     def load_file(file)
       Monolens::File.new(YAML.safe_load(::File.read(file)))
@@ -59,7 +60,7 @@ module Monolens
       raise "Invalid lens #{arg}" unless arg.size == 1
 
       name, options = arg.to_a.first
-      namespace_name, lens_name = if name =~ /^[a-z]+\.[a-z]+$/
+      namespace_name, lens_name = if name =~ /^[a-z]+\.[a-z][a-zA-Z]+$/
         name.to_s.split('.')
       else
         ['core', name]

data/spec/monolens/check/test_not_empty.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Monolens, 'check.notEmpty' do
+  subject do
+    Monolens.lens('check.notEmpty' => options)
+  end
+
+  context 'with default options' do
+    let(:options) do
+      {}
+    end
+
+    it 'works on non empty strings' do
+      input = '12'
+      expect(subject.call(input)).to be(input)
+    end
+
+    it 'works on non empty arrays' do
+      input = ['12']
+      expect(subject.call(input)).to be(input)
+    end
+
+    it 'raises on empty strings' do
+      input = ''
+      expect {
+        subject.call(input)
+      }.to raise_error(Monolens::LensError, 'Input may not be empty')
+    end
+
+    it 'raises on empty arrays' do
+      input = []
+      expect {
+        subject.call(input)
+      }.to raise_error(Monolens::LensError, 'Input may not be empty')
+    end
+  end
+
+  context 'with a specific error message' do
+    let(:options) do
+      { message: 'Hello failure!' }
+    end
+
+    it 'raises on empty strings' do
+      input = ''
+      expect {
+        subject.call(input)
+      }.to raise_error(Monolens::LensError, 'Hello failure!')
+    end
+  end
+end

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.2
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-12 00:00:00.000000000 Z
+date: 2022-05-20 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: []
@@ -68,6 +82,8 @@ files:
 - lib/monolens/array/compact.rb
 - lib/monolens/array/join.rb
 - lib/monolens/array/map.rb
+- lib/monolens/check.rb
+- lib/monolens/check/not_empty.rb
 - lib/monolens/coerce.rb
 - lib/monolens/coerce/date.rb
 - lib/monolens/coerce/date_time.rb
@@ -106,6 +122,7 @@ files:
 - spec/monolens/array/test_compact.rb
 - spec/monolens/array/test_join.rb
 - spec/monolens/array/test_map.rb
+- spec/monolens/check/test_not_empty.rb
 - spec/monolens/coerce/test_date.rb
 - spec/monolens/coerce/test_datetime.rb
 - spec/monolens/coerce/test_integer.rb