monolens 0.3.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a6edbb2568985503bf9228ded96c6d179acc196
-  data.tar.gz: f37432cfc01970a18c57884547f5520ac31fb374
+  metadata.gz: 9f60bac69139624ed4d81f0ae72e710b384ca42f
+  data.tar.gz: f69b94c2440bd260a61d7619f9883501fa5237d7
 SHA512:
-  metadata.gz: e83f9436b81460041e6ed9edd73c1fd95ca8b095f2cd0d27d063649b49c8b125363735258c5d03293c1fb74afaa1d042e4a4663b47c2a45276c0b8a730d8ee77
-  data.tar.gz: 5c704058d773ab5bddc4d58541d043a63ef176ad68f9a5f7ba670335b167da7df50c7935691ecb8951e98b354bd39d79ad5d36fb8cafa210372d30d44376051f
+  metadata.gz: 5e9cebb9122bac25f9787f8061242b69315bac0bfa5c27eb9cea4c22802060b8b3c7d28e82c536d25011b23756f14663f00030f75d1a8852fea688b5ac6a3a55
+  data.tar.gz: de6e9e3fedf61c3ef624d11a958ff2de6a5e3d8babd6b8d6f65175179e015e8eff77088bcf7c93e1d571aeeb97ea67b30b94a3b90ff65922c1acd2058b1bbe96

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,96 @@
+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)
+      case ::File.extname(file)
+      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
+    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/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/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,31 @@
+module Monolens
+  class ErrorHandler
+    include Enumerable
+
+    def initialize
+      @errors = []
+    end
+
+    def call(error)
+      @errors << error
+    end
+
+    def each(&bl)
+      @errors.each(&bl)
+    end
+
+    def size
+      @errors.size
+    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/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/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,27 +8,65 @@ 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|
+          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
         result
       end
 
+    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|
+          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
@@ -37,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/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,8 +1,8 @@
 module Monolens
   module Version
     MAJOR = 0
-    MINOR = 3
-    TINY  = 0
+    MINOR = 5
+    TINY  = 1
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

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