monolens 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a6edbb2568985503bf9228ded96c6d179acc196
-  data.tar.gz: f37432cfc01970a18c57884547f5520ac31fb374
+  metadata.gz: 30152f626d5675640e96816c7036d5a6dbac8a25
+  data.tar.gz: a26d4e5d0715bd511aea96da758fd12d36e2a70b
 SHA512:
-  metadata.gz: e83f9436b81460041e6ed9edd73c1fd95ca8b095f2cd0d27d063649b49c8b125363735258c5d03293c1fb74afaa1d042e4a4663b47c2a45276c0b8a730d8ee77
-  data.tar.gz: 5c704058d773ab5bddc4d58541d043a63ef176ad68f9a5f7ba670335b167da7df50c7935691ecb8951e98b354bd39d79ad5d36fb8cafa210372d30d44376051f
+  metadata.gz: 7b27ab005aaf2a6bf1abdc8c9284072ce1307498b7edad606526198c3e4ae003d0ddda72eb532266b7b737fbb04146959903868c50e16be4fbb8f1a073f20e9b
+  data.tar.gz: 8fd2b3ad776ff72da243ba29ab7fc2bd5fd05e88b8d34c93cd38c362142b83ff4c8164559af707d3ea314c39af3b9c415c1716841c269ab73bf9e06b852c883e

data/README.md

@@ -76,6 +76,7 @@ result = lens.call(input)
 ## Available lenses
 
 ```
+core.dig          - Extract from the input value (object or array) using a path.
 core.chain        - Applies a chain of lenses to an input value
 core.mapping      - Converts the input value via a key:value mapping
 
@@ -86,6 +87,7 @@ str.upcase        - Converts the input string to uppercase
 
 skip.null         - Aborts the current lens transformation if nil
 
+object.extend     - Adds key/value(s) to the input object
 object.rename     - Rename some keys of the input object
 object.transform  - Applies specific lenses to specific values of the input object
 object.keys       - Applies a lens to all keys of the input object
@@ -94,6 +96,8 @@ object.select     - Builds an object by selecting key/values from the input obje
 
 coerce.date       - Coerces the input value to a date
 coerce.datetime   - Coerces the input value to a datetime
+coerce.string     - Coerces the input value to a string (aka to_s)
+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
@@ -114,6 +118,8 @@ Anyway, the public interface will cover at least the following:
 
 * Exception classes: `Monolens::Error`, `Monolens::LensError`
 
+* bin/monolens, its args, options and general behavior
+
 Everything else is condidered private and may change any time
 (i.e. even on patch releases).
 

data/bin/monolens

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+retried = false
+begin
+  require 'monolens'
+  require 'monolens/command'
+rescue LoadError
+  $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+  to_retry, retried = !retried, true
+  to_retry ? retry : raise
+end
+Monolens::Command.call(ARGV)

data/lib/monolens/coerce/date.rb

@@ -10,6 +10,8 @@ module Monolens
       ]
 
       def call(arg, world = {})
+        return arg if arg.is_a?(::Date)
+
         is_string!(arg, world)
 
         date = nil

data/lib/monolens/coerce/date_time.rb

@@ -10,6 +10,8 @@ module Monolens
       ]
 
       def call(arg, world = {})
+        return arg if arg.is_a?(::DateTime)
+
         is_string!(arg, world)
 
         date = nil
@@ -28,12 +30,20 @@ module Monolens
         fail!(first_error.message, world)
       end
 
+    private
+
       def strptime(arg, format = nil)
-        if format.nil?
-          ::DateTime.strptime(arg)
+        parsed = if format.nil?
+          parser.parse(arg)
         else
-          ::DateTime.strptime(arg, format)
+          parser.strptime(arg, format)
         end
+        parsed = parsed.to_datetime if parsed.respond_to?(:to_datetime)
+        parsed
+      end
+
+      def parser
+        option(:parser, ::DateTime)
       end
     end
   end

data/lib/monolens/coerce/integer.rb

@@ -0,0 +1,15 @@
+require 'date'
+
+module Monolens
+  module Coerce
+    class Integer
+      include Lens
+
+      def call(arg, world = {})
+        Integer(arg)
+      rescue => ex
+        fail!(ex.message, world)
+      end
+    end
+  end
+end

data/lib/monolens/coerce.rb

@@ -5,6 +5,11 @@ module Monolens
     end
     module_function :date
 
+    def integer(options = {})
+      Integer.new(options)
+    end
+    module_function :integer
+
     def datetime(options = {})
       DateTime.new(options)
     end
@@ -20,4 +25,5 @@ module Monolens
 end
 require_relative 'coerce/date'
 require_relative 'coerce/date_time'
+require_relative 'coerce/integer'
 require_relative 'coerce/string'

data/lib/monolens/command.rb

@@ -0,0 +1,87 @@
+require 'optparse'
+require 'date'
+require 'json'
+require 'yaml'
+
+module Monolens
+  class Command
+    def initialize(argv, stdin, stdout, stderr)
+      @argv = argv
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+      @pretty = false
+    end
+    attr_reader :argv, :stdin, :stdout, :stderr
+    attr_reader :pretty
+
+    def self.call(argv, stdin = $stdin, stdout = $stdout, stderr = $stderr)
+      new(argv, stdin, stdout, stderr).call
+    end
+
+    def call
+      lens, input = options.parse!(argv)
+      show_help_and_exit if lens.nil? || input.nil?
+
+      lens, input = read_file(lens), read_file(input)
+      error_handler = ErrorHandler.new
+      lens = Monolens.lens(lens)
+      result = lens.call(input, error_handler: error_handler)
+
+      unless error_handler.empty?
+        stderr.puts(error_handler.report)
+      end
+
+      if result
+        output = if pretty
+          JSON.pretty_generate(result)
+        else
+          result.to_json
+        end
+
+        stdout.puts output
+      end
+    rescue Monolens::LensError => ex
+      stderr.puts("[#{ex.location.join('/')}] #{ex.message}")
+      do_exit(-2)
+    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)
+      else
+        fail!("Unable to use #{file}")
+      end
+    end
+
+    def fail!(msg)
+      stderr.puts(msg)
+      do_exit(1)
+    end
+
+    def do_exit(status)
+      exit(status)
+    end
+
+    def show_help_and_exit
+      stdout.puts options
+      do_exit(0)
+    end
+
+    def options
+      @options ||= OptionParser.new do |opts|
+        opts.banner = 'Usage: monolens [options] LENS INPUT'
+
+        opts.on('--version', 'Show version and exit') do
+          stdout.puts "Monolens v#{VERSION} - (c) Enspirit #{Date.today.year}"
+          do_exit(0)
+        end
+        opts.on('-p', '--[no-]pretty', 'Show version and exit') do |pretty|
+          @pretty = pretty
+        end
+      end
+    end
+  end
+end

data/lib/monolens/core/dig.rb

@@ -0,0 +1,52 @@
+module Monolens
+  module Core
+    class Dig
+      include Lens
+
+      def call(arg, world = {})
+        option(:defn, []).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/core.rb

@@ -5,6 +5,11 @@ module Monolens
     end
     module_function :chain
 
+    def dig(options)
+      Dig.new(options)
+    end
+    module_function :dig
+
     def mapping(options)
       Mapping.new(options)
     end
@@ -14,4 +19,5 @@ module Monolens
   end
 end
 require_relative 'core/chain'
+require_relative 'core/dig'
 require_relative 'core/mapping'

data/lib/monolens/error_handler.rb

@@ -0,0 +1,21 @@
+module Monolens
+  class ErrorHandler
+    def initialize
+      @errors = []
+    end
+
+    def call(error)
+      @errors << error
+    end
+
+    def empty?
+      @errors.empty?
+    end
+
+    def report
+      @errors
+        .map{|err| "[#{err.location.join('/')}] #{err.message}" }
+        .join("\n")
+    end
+  end
+end

data/lib/monolens/lens/fetch_support.rb

@@ -1,7 +1,6 @@
 module Monolens
   module Lens
     module FetchSupport
-
       def fetch_on(attr, arg, default = nil)
         if arg.key?(attr)
           [ attr, arg[attr] ]
@@ -15,7 +14,6 @@ module Monolens
           nil
         end
       end
-
     end
   end
 end

data/lib/monolens/object/extend.rb

@@ -0,0 +1,53 @@
+module Monolens
+  module Object
+    class Extend
+      include Lens
+
+      def initialize(options)
+        super(options)
+        ts = option(:defn, {})
+        ts.each_pair do |k,v|
+          ts[k] = Monolens.lens(v)
+        end
+      end
+
+      def call(arg, world = {})
+        is_hash!(arg, world)
+
+        result = arg.dup
+        is_symbol = arg.keys.any?{|k| k.is_a?(Symbol) }
+        option(:defn, {}).each_pair do |attr, lens|
+          deeper(world, attr) do |w|
+            actual = is_symbol ? attr.to_sym : attr.to_s
+            begin
+              result[actual] = lens.call(arg, w)
+            rescue Monolens::LensError => ex
+              strategy = option(:on_error, :fail)
+              handle_error(strategy, ex, result, actual, world)
+            end
+          end
+        end
+        result
+      end
+
+      def handle_error(strategy, ex, result, attr, world)
+        strategy = strategy.to_sym unless strategy.is_a?(::Array)
+        case strategy
+        when ::Array
+          strategy.each{|s| handle_error(s, ex, result, attr, world) }
+        when :handler
+          error_handler!(world).call(ex)
+        when :fail
+          raise
+        when :null
+          result[attr] = nil
+        when :skip
+          nil
+        else
+          raise Monolens::Error, "Unexpected error strategy `#{strategy}`"
+        end
+      end
+      private :handle_error
+    end
+  end
+end

data/lib/monolens/object/select.rb

@@ -8,7 +8,7 @@ module Monolens
 
         result = {}
         is_symbol = arg.keys.any?{|k| k.is_a?(Symbol) }
-        option(:defn, {}).each_pair do |new_attr, selector|
+        defn.each_pair do |new_attr, selector|
           deeper(world, new_attr) do |w|
             is_array = selector.is_a?(::Array)
             values = []
@@ -29,6 +29,16 @@ module Monolens
         result
       end
 
+    private
+
+      def defn
+        defn = option(:defn, {})
+        defn = defn.each_with_object({}) do |attr, memo|
+          memo[attr] = attr
+        end if defn.is_a?(::Array)
+        defn
+      end
+
       def on_missing(attr, values, world)
         strategy = option(:on_missing, :fail)
         case strategy.to_sym

data/lib/monolens/object.rb

@@ -1,5 +1,10 @@
 module Monolens
   module Object
+    def extend(options)
+      Extend.new(options)
+    end
+    module_function :extend
+
     def rename(parts)
       Rename.new(parts)
     end
@@ -33,3 +38,4 @@ require_relative 'object/transform'
 require_relative 'object/keys'
 require_relative 'object/values'
 require_relative 'object/select'
+require_relative 'object/extend'

data/lib/monolens/version.rb

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

data/lib/monolens.rb

@@ -5,6 +5,7 @@ module Monolens
   class << self
     require_relative 'monolens/version'
     require_relative 'monolens/error'
+    require_relative 'monolens/error_handler'
     require_relative 'monolens/lens'
 
     def define_namespace(name, impl_module)
@@ -43,6 +44,10 @@ module Monolens
     end
     private :chain
 
+    def file_lens(arg)
+      File.new(arg)
+    end
+
     def leaf_lens(arg)
       namespace_name, lens_name = arg.to_s.split('.')
       factor_lens(namespace_name, lens_name, {})
@@ -50,6 +55,7 @@ module Monolens
     private :leaf_lens
 
     def hash_lens(arg)
+      return file_lens(arg) if arg['version'] || arg[:version]
       raise "Invalid lens #{arg}" unless arg.size == 1
 
       name, options = arg.to_a.first

data/spec/monolens/coerce/test_date.rb

@@ -5,6 +5,11 @@ describe Monolens, 'coerce.date' do
     Monolens.lens('coerce.date' => { formats: ['%d/%m/%Y'] })
   end
 
+  it 'returns Date objects unchanged (idempotency)' do
+    input = Date.today
+    expect(subject.call(input)).to be(input)
+  end
+
   it 'coerces valid dates' do
     expect(subject.call('11/12/2022')).to eql(Date.parse('2022-12-11'))
   end

data/spec/monolens/coerce/test_datetime.rb

@@ -2,11 +2,49 @@ require 'spec_helper'
 
 describe Monolens, 'coerce.datetime' do
   subject do
-    Monolens.lens('coerce.datetime' => { formats: ['%d/%m/%Y %H:%M'] })
+    Monolens.lens('coerce.datetime' => {
+    }.merge(options))
   end
 
-  it 'coerces valid date times' do
-    expect(subject.call('11/12/2022 17:38')).to eql(DateTime.parse('2022-12-11 17:38'))
+  let(:options) do
+    {}
+  end
+
+  it 'returns DateTime objects unchanged (idempotency)' do
+    input = DateTime.now
+    expect(subject.call(input)).to be(input)
+  end
+
+  describe 'support for formats' do
+    let(:options) do
+      { formats: ['%d/%m/%Y %H:%M'] }
+    end
+
+    it 'coerces valid date times' do
+      expect(subject.call('11/12/2022 17:38')).to eql(DateTime.parse('2022-12-11 17:38'))
+    end
+  end
+
+  describe 'support for a timezone' do
+    let(:options) do
+      { parser: timezone }
+    end
+
+    let(:now) do
+      ::DateTime.now
+    end
+
+    let(:timezone) do
+      Object.new
+    end
+
+    before do
+      expect(timezone).to receive(:parse).and_return(now)
+    end
+
+    it 'uses it to parse' do
+      expect(subject.call('2022-01-01')).to be(now)
+    end
   end
 
   describe 'error handling' do

data/spec/monolens/coerce/test_integer.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Monolens, 'coerce.integer' do
+  subject do
+    Monolens.lens('coerce.integer')
+  end
+
+  it 'is idempotent' do
+    expect(subject.call(12)).to eql(12)
+  end
+
+  it 'coerces valid integers' do
+    expect(subject.call('12')).to eql(12)
+  end
+
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          :lenses => 'coerce.integer'
+        }
+      })
+    end
+
+    subject do
+      begin
+        lens.call(input)
+        nil
+      rescue Monolens::LensError => ex
+        ex
+      end
+    end
+
+    let(:input) do
+      ['12sh']
+    end
+
+    it 'fails on invalid integers' do
+      expect(subject).to be_a(Monolens::LensError)
+    end
+
+    it 'properly sets the location' do
+      expect(subject.location).to eql([0])
+    end
+  end
+end

data/spec/monolens/command/map-upcase.lens.yml

@@ -0,0 +1,5 @@
+---
+version: '1.0'
+lenses:
+- array.map:
+    - str.upcase

data/spec/monolens/command/names-with-null.json

@@ -0,0 +1,5 @@
+[
+  "Bernard",
+  null,
+  "David"
+]

data/spec/monolens/command/names.json

@@ -0,0 +1,4 @@
+[
+  "Bernard",
+  "David"
+]

data/spec/monolens/command/robust-map-upcase.lens.yml

@@ -0,0 +1,7 @@
+---
+version: '1.0'
+lenses:
+- array.map:
+    on_error: handler
+    lenses:
+    - str.upcase

data/spec/monolens/core/test_dig.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Monolens, "core.dig" do
+  let(:lens) do
+    Monolens.lens('core.dig' => { defn: ['hobbies', 1, 'name'] })
+  end
+
+  it 'works' do
+    input = {
+      hobbies: [
+        { name: 'programming' },
+        { name: 'music' }
+      ]
+    }
+    expected = 'music'
+    expect(lens.call(input)).to eql(expected)
+  end
+
+  describe 'error handling' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          lenses: {
+            'core.dig' => {
+              on_missing: on_missing,
+              defn: ['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])
+      end
+    end
+  end
+end

data/spec/monolens/object/test_extend.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe Monolens, 'object.extend' do
+  subject do
+    Monolens.lens('object.extend' => {
+      defn: {
+        name: [
+          { 'core.dig' => { defn: ['firstname'] } },
+          'str.upcase'
+        ]
+      }
+    })
+  end
+
+  it 'works as expected' do
+    input = {
+      'firstname' => 'Bernard',
+      'lastname' => 'Lambeau'
+    }
+    expected = input.merge({
+      'name' => 'BERNARD',
+    })
+    expect(subject.call(input)).to eql(expected)
+  end
+
+  describe 'on_error' do
+    let(:lens) do
+      Monolens.lens({
+        'array.map' => {
+          :lenses => {
+            'object.extend' => {
+              on_error: on_error,
+              defn: {
+                upcased: [
+                  { 'core.dig' => { defn: ['firstname'] } },
+                  'str.upcase'
+                ]
+              }
+            }.compact
+          }
+        }
+      })
+    end
+
+    subject do
+      lens.call(input)
+    rescue Monolens::LensError => ex
+      ex
+    end
+
+    context 'default' do
+      let(:on_error) do
+        nil
+      end
+
+      let(:input) do
+        [{}]
+      end
+
+      it 'works as expected' do
+        expect(subject).to be_a(Monolens::LensError)
+        expect(subject.location).to eql([0, :upcased])
+      end
+    end
+
+    context 'with :null' do
+      let(:on_error) do
+        :null
+      end
+
+      let(:input) do
+        [{}]
+      end
+
+      it 'works as expected' do
+        expect(subject).to eql([{'upcased' => nil}])
+      end
+    end
+
+    context 'with :skip' do
+      let(:on_error) do
+        :skip
+      end
+
+      let(:input) do
+        [{}]
+      end
+
+      it 'works as expected' do
+        expect(subject).to eql([{}])
+      end
+    end
+  end
+end

data/spec/monolens/object/test_select.rb

@@ -75,6 +75,30 @@ describe Monolens, 'object.select' do
     end
   end
 
+  context 'when using an array as selection' do
+    subject do
+      Monolens.lens('object.select' => {
+        defn: [
+          :firstname,
+          :priority
+        ]
+      })
+    end
+
+    it 'works as expected' do
+      input = {
+        firstname: 'Bernard',
+        lastname: 'Lambeau',
+        priority: 12
+      }
+      expected = {
+        firstname: 'Bernard',
+        priority: 12
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
   context 'when a key is missing and no option' do
     subject do
       Monolens.lens('object.select' => {

data/spec/monolens/test_command.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'stringio'
+require 'monolens'
+require 'monolens/command'
+
+module Monolens
+  class Exited < Monolens::Error
+  end
+  class Command
+    attr_reader :exit_status
+
+    def do_exit(status)
+      @exit_status = status
+      raise Exited
+    end
+  end
+  describe Command do
+    FIXTURES = (Path.dir/"command").expand_path
+
+    let(:command) do
+      Command.new(argv, stdin, stdout, stderr)
+    end
+
+    let(:stdin) do
+      StringIO.new
+    end
+
+    let(:stdout) do
+      StringIO.new
+    end
+
+    let(:stderr) do
+      StringIO.new
+    end
+
+    let(:file_args) do
+      [FIXTURES/'map-upcase.lens.yml', FIXTURES/'names.json']
+    end
+
+    subject do
+      begin
+        command.call
+      rescue Exited
+      end
+    end
+
+    before do
+      subject
+    end
+
+    def exit_status
+      command.exit_status
+    end
+
+    def reloaded_json
+      JSON.parse(stdout.string)
+    end
+
+    context 'with no option nor args' do
+      let(:argv) do
+        []
+      end
+
+      it 'prints the help and exits' do
+        expect(exit_status).to eql(0)
+        expect(stdout.string).to match(/monolens/)
+      end
+    end
+
+    context 'with --version' do
+      let(:argv) do
+        ['--version']
+      end
+
+      it 'prints the version and exits' do
+        expect(exit_status).to eql(0)
+        expect(stdout.string).to eql("Monolens v#{VERSION} - (c) Enspirit #{Date.today.year}\n")
+      end
+    end
+
+    context 'with a lens and a json input' do
+      let(:argv) do
+        file_args
+      end
+
+      it 'works as expected' do
+        expect(exit_status).to be_nil
+        expect(reloaded_json).to eql(['BERNARD', 'DAVID'])
+      end
+    end
+
+    context 'with --pretty' do
+      let(:argv) do
+        ['--pretty'] + file_args
+      end
+
+      it 'works as expected' do
+        expect(exit_status).to be_nil
+        expect(stdout.string).to match(/^\[\n/)
+        expect(reloaded_json).to eql(['BERNARD', 'DAVID'])
+      end
+    end
+
+    context 'when yielding an error' do
+      let(:argv) do
+        [FIXTURES/'map-upcase.lens.yml', FIXTURES/'names-with-null.json']
+      end
+
+      it 'works as expected' do
+        expect(exit_status).to eql(-2)
+        expect(stdout.string).to eql('')
+        expect(stderr.string).to eql("[1] String expected, got NilClass\n")
+      end
+    end
+
+    context 'when yielding an error on a robust lens' do
+      let(:argv) do
+        [FIXTURES/'robust-map-upcase.lens.yml', FIXTURES/'names-with-null.json']
+      end
+
+      it 'works as expected' do
+        expect(exit_status).to be_nil
+        expect(stdout.string).to eql('["BERNARD","DAVID"]'+"\n")
+        expect(stderr.string).to eql("[1] String expected, got NilClass\n")
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monolens
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-06 00:00:00.000000000 Z
+date: 2022-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -62,6 +62,7 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
+- bin/monolens
 - lib/monolens.rb
 - lib/monolens/array.rb
 - lib/monolens/array/compact.rb
@@ -70,17 +71,22 @@ files:
 - lib/monolens/coerce.rb
 - lib/monolens/coerce/date.rb
 - lib/monolens/coerce/date_time.rb
+- lib/monolens/coerce/integer.rb
 - lib/monolens/coerce/string.rb
+- lib/monolens/command.rb
 - lib/monolens/core.rb
 - lib/monolens/core/chain.rb
+- lib/monolens/core/dig.rb
 - lib/monolens/core/mapping.rb
 - lib/monolens/error.rb
+- lib/monolens/error_handler.rb
 - lib/monolens/file.rb
 - lib/monolens/lens.rb
 - lib/monolens/lens/fetch_support.rb
 - lib/monolens/lens/location.rb
 - lib/monolens/lens/options.rb
 - lib/monolens/object.rb
+- lib/monolens/object/extend.rb
 - lib/monolens/object/keys.rb
 - lib/monolens/object/rename.rb
 - lib/monolens/object/select.rb
@@ -102,9 +108,16 @@ files:
 - spec/monolens/array/test_map.rb
 - spec/monolens/coerce/test_date.rb
 - spec/monolens/coerce/test_datetime.rb
+- spec/monolens/coerce/test_integer.rb
 - spec/monolens/coerce/test_string.rb
+- spec/monolens/command/map-upcase.lens.yml
+- spec/monolens/command/names-with-null.json
+- spec/monolens/command/names.json
+- spec/monolens/command/robust-map-upcase.lens.yml
+- spec/monolens/core/test_dig.rb
 - spec/monolens/core/test_mapping.rb
 - spec/monolens/lens/test_options.rb
+- spec/monolens/object/test_extend.rb
 - spec/monolens/object/test_keys.rb
 - spec/monolens/object/test_rename.rb
 - spec/monolens/object/test_select.rb
@@ -115,6 +128,7 @@ files:
 - spec/monolens/str/test_split.rb
 - spec/monolens/str/test_strip.rb
 - spec/monolens/str/test_upcase.rb
+- spec/monolens/test_command.rb
 - spec/monolens/test_error_traceability.rb
 - spec/monolens/test_lens.rb
 - spec/spec_helper.rb