monolens 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 937b78e577006ce716022cb0ae10fe2dfd21f174be62e67c2f9eefe161f07151
-  data.tar.gz: 90493bf5855603ea1181a5c86a9ba313937954cadb659d95dbca6386b5ba085b
+  metadata.gz: 808d9126b39444b34dde2d81926a680af37ad5351994e6b640a035b3555807fb
+  data.tar.gz: f2eab3c0f2911e83096e7a72520d9812575830c38192ad98b0f609b68f6ab814
 SHA512:
-  metadata.gz: 362211783818b1906bfa90fb42979084e9f1d2bdf7e893313ad5b1d0ef7f2184e1441661221a8df78cfcd530231f7011e678091f26900e041d06414ec92ff116
-  data.tar.gz: ad30e2d1b2fddd5f72ec7c939f275ab098586400d70f4f8d6b4e0e4453c30bd63a32c10b6ebc68d815d8e6bde3aaddd041d50b4bb4b8342f84eb23419d31dda7
+  metadata.gz: 50586006606bd32d8f1cf2d35c885c906883d61da10a7746f63ca7cf1e66e6fd81624025def49287400edee1554e86c69e7f27573bc8ad9311872be8a545270a
+  data.tar.gz: acdb391077a3c35b1888fb2cb6f8bbddf8be6d5ba68001f6297a0686079fc5b1aa13077eca3079fa8d98c4d56d804da43ca0ccb5c912b579117f815d312a673f

data/lib/monolens/stdlib/core/digs.rb

@@ -0,0 +1,63 @@
+module Monolens
+  module Core
+    class Digs
+      include Lens
+
+      signature(Type::Diggable, Type::Any, {
+        defn: [
+          Type::Array.of(Type::Array.of(Type::Any.of(Type::Integer, Type::String))),
+          true
+        ],
+        on_missing: [Type::Strategy.missing(%w{fail null}), false]
+      })
+
+      def call(arg, world = {})
+        to_dig = option(:defn, [])
+        to_dig.map {|digging|
+          digging.inject(arg) do |memo, part|
+            dig_on(part, memo, world)
+          end
+        }
+      end
+
+    private
+
+      def path
+        option(:defn, []).join('.')
+      end
+
+      def dig_on(attr, arg, world)
+        if arg.is_a?(::Array)
+          index = attr.to_i
+          on_missing(world) if index >= arg.size
+          arg[index]
+        elsif arg.is_a?(::Hash)
+          actual, value = fetch_on(attr, arg)
+          on_missing(world) unless actual
+          value
+        elsif arg
+          if attr.is_a?(::Integer)
+            is_array!(arg, world)
+          else
+            is_hash!(arg, world)
+          end
+        else
+          on_missing(world)
+        end
+      end
+
+      def on_missing(world)
+        strategy = option(:on_missing, :fail)
+        case strategy.to_sym
+        when :fail
+          fail!("Unable to find #{path}", world)
+        when :null
+          nil
+        else
+          raise Monolens::Error, "Unexpected missing strategy `#{strategy}`"
+        end
+      end
+      private :on_missing
+    end
+  end
+end

data/lib/monolens/stdlib/core.rb

@@ -12,6 +12,11 @@ module Monolens
     end
     module_function :dig
 
+    def digs(options, registry)
+      Digs.new(options, registry)
+    end
+    module_function :digs
+
     def literal(options, registry)
       Literal.new(options, registry)
     end
@@ -27,5 +32,6 @@ module Monolens
 end
 require_relative 'core/chain'
 require_relative 'core/dig'
+require_relative 'core/digs'
 require_relative 'core/mapping'
 require_relative 'core/literal'

data/lib/monolens/stdlib/object/select.rb

@@ -4,7 +4,8 @@ module Monolens
       include Lens
 
       signature(Type::Object, Type::Object, {
-        strategy: [Type::Strategy.selection(%w{all first}), false],
+        strategy: [Type::Strategy.selection(%w{all first concat}), false],
+        separator: [Type::String, false],
         defn: [Type::Any.of(
           Type::Array.of(Type::Name),
           Type::Map.of(Type::Name, Type::Any.of(Type::Array.of(Type::Name), Type::Name))
@@ -41,13 +42,20 @@ module Monolens
       end
 
       def do_array_select(arg, selector, world)
-        case option(:strategy, :all).to_sym
+        case strategy = 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 :concat
+          values = selector.each_with_object([]) do |old_attr, values|
+            catch (:skip) do
+              values << do_single_select(arg, old_attr, world)
+            end
+          end
+          values.join(option(:separator, ' '))
         when :first
           selector.each do |old_attr|
             actual, fetched = fetch_on(old_attr, arg)

data/lib/monolens/stdlib/str/null_if_empty.rb

@@ -0,0 +1,15 @@
+module Monolens
+  module Str
+    class NullIfEmpty
+      include Lens
+
+      signature(Type::String, Type::String)
+
+      def call(arg, world = {})
+        is_string!(arg, world)
+
+        arg.to_s.strip.empty? ? nil : arg
+      end
+    end
+  end
+end

data/lib/monolens/stdlib/str.rb

@@ -7,6 +7,11 @@ module Monolens
     end
     module_function :downcase
 
+    def nullIfEmpty(options, registry)
+      NullIfEmpty.new(options, registry)
+    end
+    module_function :nullIfEmpty
+
     def strip(options, registry)
       Strip.new(options, registry)
     end
@@ -29,3 +34,4 @@ require_relative 'str/downcase'
 require_relative 'str/strip'
 require_relative 'str/split'
 require_relative 'str/upcase'
+require_relative 'str/null_if_empty'

data/lib/monolens/version.rb

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

data/spec/monolens/stdlib/core/test_digs.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Monolens, "core.digs" do
+  let(:lens) do
+    Monolens.lens('core.digs' => {
+      defn: [
+        ['foo'],
+        ['hobbies', 1, 'name'],
+      ]
+    })
+  end
+
+  it 'works' do
+    input = {
+      hobbies: [
+        { name: 'programming' },
+        { name: 'music' }
+      ],
+      foo: 'Hello'
+    }
+    expected = ['Hello', 'music']
+    expect(lens.call(input)).to eql(expected)
+  end
+
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          lenses: {
+            'core.digs' => {
+              on_missing: on_missing,
+              defn: [
+                ['foo'],
+                ['hobbies', 1, 'name'],
+              ]
+            }.compact
+          }
+        }
+      })
+    end
+
+    subject do
+      begin
+        lens.call(input)
+      rescue Monolens::LensError => ex
+        ex
+      end
+    end
+
+    context 'default behavior' do
+      let(:on_missing) do
+        nil
+      end
+
+      let(:input) do
+        [{
+          hobbies: [
+            { name: 'programming' }
+          ]
+        }]
+      end
+
+      it 'fails as expected' do
+        expect(subject).to be_a(Monolens::LensError)
+        expect(subject.location).to eql([0])
+      end
+    end
+
+    context 'on_missing: null' do
+      let(:on_missing) do
+        :null
+      end
+
+      let(:input) do
+        [{
+          hobbies: [
+            { name: 'programming' }
+          ]
+        }]
+      end
+
+      it 'works' do
+        expect(subject).to eql([[nil, nil]])
+      end
+    end
+  end
+end

data/spec/monolens/stdlib/object/test_select.rb

@@ -160,6 +160,80 @@ describe Monolens, 'object.select' do
     end
   end
 
+  context 'when using strategy: concat' do
+    subject do
+      Monolens.lens('object.select' => {
+        defn: {
+          name: [:firstname, :lastname],
+          status: :priority
+        },
+        strategy: 'concat',
+        separator: "\n",
+        on_missing: on_missing
+      }.compact)
+    end
+
+    context 'with :skip as on_missing' do
+      let(:on_missing) do
+        :skip
+      end
+
+      it 'works as expected with first only 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 only is present' do
+        input = {
+          lastname: 'Lambeau',
+          priority: 12
+        }
+        expected = {
+          name: 'Lambeau',
+          status: 12
+        }
+        expect(subject.call(input)).to eql(expected)
+      end
+
+      it 'works as expected when both are present' do
+        input = {
+          firstname: 'Bernard',
+          lastname: 'Lambeau',
+          priority: 12
+        }
+        expected = {
+          name: "Bernard\nLambeau",
+          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: "\n",
+          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' => {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monolens
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-09 00:00:00.000000000 Z
+date: 2024-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -138,6 +138,7 @@ files:
 - lib/monolens/stdlib/core.rb
 - lib/monolens/stdlib/core/chain.rb
 - lib/monolens/stdlib/core/dig.rb
+- lib/monolens/stdlib/core/digs.rb
 - lib/monolens/stdlib/core/literal.rb
 - lib/monolens/stdlib/core/mapping.rb
 - lib/monolens/stdlib/object.rb
@@ -153,6 +154,7 @@ files:
 - lib/monolens/stdlib/skip/null.rb
 - lib/monolens/stdlib/str.rb
 - lib/monolens/stdlib/str/downcase.rb
+- lib/monolens/stdlib/str/null_if_empty.rb
 - lib/monolens/stdlib/str/split.rb
 - lib/monolens/stdlib/str/strip.rb
 - lib/monolens/stdlib/str/upcase.rb
@@ -200,6 +202,7 @@ files:
 - spec/monolens/stdlib/coerce/test_integer.rb
 - spec/monolens/stdlib/coerce/test_string.rb
 - spec/monolens/stdlib/core/test_dig.rb
+- spec/monolens/stdlib/core/test_digs.rb
 - spec/monolens/stdlib/core/test_literal.rb
 - spec/monolens/stdlib/core/test_mapping.rb
 - spec/monolens/stdlib/object/test_allbut.rb