monolens 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 704980b0a35ef47c4ea022a0b2bf39922966a11d
-  data.tar.gz: 0a032437e56dbd4d2214ba7b435120ceceb62709
+  metadata.gz: b2a9267753f8725ed91fc71b3c9b995a11d3b0c1
+  data.tar.gz: 4aaaf0247bcb4f2195052a416ebe7742bfd2b72a
 SHA512:
-  metadata.gz: 2a580e3564f5bd208273e16c0c1da4c261917d371e0e6236bab873920b6a2372b7f36e5a085654f8f2ff79490f762cfeb68a8d38a24265d8cd4da5e983389f6e
-  data.tar.gz: '0229785824434dd14c87581f0060a784b623e3154b514bea8548d7cce94bb35563ceb6fdbc45146a883c4ca476c1c329b9adbd6a329ab1382f197377709170a6'
+  metadata.gz: 99df61206eb26141c13a7a364fc9f5af97ade23d9a50e92e82cd8b2980cb88790e36402a852116d800a2caebe71af7b1bb90e4ad3dc8fdd450360d1ce63fe5e6
+  data.tar.gz: a93491cec013f9993299ee227c2055c0c93a9f224c5da6a2526afbb95fe2516bf1b29250670c769667cd93bb018e613e3ae21b98d545a62109602e2fa2c1f843

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/array/compact.rb

@@ -3,8 +3,8 @@ module Monolens
     class Compact
       include Lens
 
-      def call(arg, *rest)
-        is_array!(arg)
+      def call(arg, world = {})
+        is_array!(arg, world)
 
         arg.compact
       end

data/lib/monolens/array/join.rb

@@ -3,8 +3,8 @@ module Monolens
     class Join
       include Lens
 
-      def call(arg, *rest)
-        is_array!(arg)
+      def call(arg, world = {})
+        is_array!(arg, world)
 
         arg.join(option(:separator, ' '))
       end

data/lib/monolens/array/map.rb

@@ -3,16 +3,55 @@ module Monolens
     class Map
       include Lens
 
-      def initialize(lens)
-        super({})
-        @lens = Monolens.lens(lens)
+      def initialize(arg)
+        options, lenses = case arg
+        when ::Hash
+          opts = arg.dup; opts.delete(:lenses)
+          _, ls = fetch_on(:lenses, arg)
+          raise ArgumentError, 'Lenses are required' if ls.nil?
+          [ opts, ls ]
+        else
+          [{}, arg]
+        end
+        super(options)
+        @lenses = Monolens.lens(lenses)
       end
 
-      def call(arg, *rest)
-        is_enumerable!(arg)
+      def call(arg, world = {})
+        is_enumerable!(arg, world)
 
-        arg.map { |a| @lens.call(a) }
+        result = []
+        arg.each_with_index do |a, i|
+          deeper(world, i) do |w|
+            begin
+              result << @lenses.call(a, w)
+            rescue Monolens::LensError => ex
+              strategy = option(:on_error, :fail)
+              handle_error(strategy, ex, result, world)
+            end
+          end
+        end
+        result
       end
+
+      def handle_error(strategy, ex, result, world)
+        strategy = strategy.to_sym unless strategy.is_a?(::Array)
+        case strategy
+        when ::Array
+          strategy.each{|s| handle_error(s, ex, result, world) }
+        when :handler
+          error_handler!(world).call(ex)
+        when :fail
+          raise
+        when :null
+          result << nil
+        when :skip
+          nil
+        else
+          raise Monolens::Error, "Unexpected error strategy `#{strategy}`"
+        end
+      end
+      private :handle_error
     end
   end
 end

data/lib/monolens/array.rb

@@ -10,8 +10,8 @@ module Monolens
     end
     module_function :join
 
-    def map(lens)
-      Map.new(lens)
+    def map(options)
+      Map.new(options)
     end
     module_function :map
 

data/lib/monolens/coerce/date.rb

@@ -5,13 +5,21 @@ module Monolens
     class Date
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      DEFAULT_FORMATS = [
+        nil
+      ]
 
-        date, first_error = nil, nil
-        @options[:formats].each do |format|
+      def call(arg, world = {})
+        return arg if arg.is_a?(::Date)
+
+        is_string!(arg, world)
+
+        date = nil
+        first_error = nil
+        formats = @options.fetch(:formats, DEFAULT_FORMATS)
+        formats.each do |format|
           begin
-            return date = ::Date.strptime(arg, format)
+            return date = strptime(arg, format)
           rescue ArgumentError => ex
             first_error ||= ex
           rescue ::Date::Error => ex
@@ -19,7 +27,15 @@ module Monolens
           end
         end
 
-        raise Monolens::LensError, first_error.message
+        fail!(first_error.message, world)
+      end
+
+      def strptime(arg, format = nil)
+        if format.nil?
+          ::Date.strptime(arg)
+        else
+          ::Date.strptime(arg, format)
+        end
       end
     end
   end

data/lib/monolens/coerce/date_time.rb

@@ -5,13 +5,21 @@ module Monolens
     class DateTime
       include Lens
 
-      def call(arg, *rest)
-        is_string!(arg)
+      DEFAULT_FORMATS = [
+        nil
+      ]
 
-        date, first_error = nil, nil
-        @options[:formats].each do |format|
+      def call(arg, world = {})
+        return arg if arg.is_a?(::DateTime)
+
+        is_string!(arg, world)
+
+        date = nil
+        first_error = nil
+        formats = @options.fetch(:formats, DEFAULT_FORMATS)
+        formats.each do |format|
           begin
-            return date = ::DateTime.strptime(arg, format)
+            return date = strptime(arg, format)
           rescue ArgumentError => ex
             first_error ||= ex
           rescue ::Date::Error => ex
@@ -19,7 +27,23 @@ module Monolens
           end
         end
 
-        raise Monolens::LensError, first_error.message
+        fail!(first_error.message, world)
+      end
+
+    private
+
+      def strptime(arg, format = nil)
+        parsed = if format.nil?
+          parser.parse(arg)
+        else
+          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/string.rb

@@ -0,0 +1,13 @@
+require 'date'
+
+module Monolens
+  module Coerce
+    class String
+      include Lens
+
+      def call(arg, world = {})
+        arg.to_s
+      end
+    end
+  end
+end

data/lib/monolens/coerce.rb

@@ -5,16 +5,25 @@ module Monolens
     end
     module_function :date
 
+    def integer(options = {})
+      Integer.new(options)
+    end
+    module_function :integer
+
     def datetime(options = {})
       DateTime.new(options)
     end
     module_function :datetime
 
+    def string(options = {})
+      String.new(options)
+    end
+    module_function :string
+
     Monolens.define_namespace 'coerce', self
   end
 end
-require_relative 'str/strip'
-require_relative 'str/upcase'
-require_relative 'str/downcase'
 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/chain.rb

@@ -8,12 +8,12 @@ module Monolens
         @lenses = lenses
       end
 
-      def call(arg, *rest)
+      def call(arg, world = {})
         result = arg
         @lenses.each do |lens|
           done = false
           catch(:skip) do
-            result = lens.call(result, *rest)
+            result = lens.call(result, world)
             done = true
           end
           break unless done

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

@@ -3,13 +3,33 @@ module Monolens
     class Mapping
       include Lens
 
-      def call(arg, *rest)
+      def call(arg, world = {})
         option(:values, {}).fetch(arg) do
-          raise LensError 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.rb

@@ -1,4 +1,11 @@
 module Monolens
-  class Error < StandardError; end
-  class LensError < Error; end
+  class Error < StandardError
+  end
+  class LensError < Error
+    def initialize(message, location = [])
+      super(message)
+      @location = location
+    end
+    attr_reader :location
+  end
 end

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

@@ -2,13 +2,8 @@ module Monolens
   class File
     include Lens
 
-    def initialize(info)
-      super
-      options[:lenses] = Monolens.lens(options[:lenses])
-    end
-
-    def call(*args, &bl)
-      options[:lenses].call(*args, &bl)
+    def call(arg, world = {})
+      option(:lenses).call(arg, world)
     end
   end
 end

data/lib/monolens/lens/fetch_support.rb

@@ -0,0 +1,19 @@
+module Monolens
+  module Lens
+    module FetchSupport
+      def fetch_on(attr, arg, default = nil)
+        if arg.key?(attr)
+          [ attr, arg[attr] ]
+        elsif arg.key?(attr_s = attr.to_s)
+          [ attr_s, arg[attr_s] ]
+        elsif arg.key?(attr_sym = attr.to_sym)
+          [ attr_sym, arg[attr_sym] ]
+        elsif default
+          [ attr, default ]
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/monolens/lens/location.rb

@@ -0,0 +1,17 @@
+module Monolens
+  module Lens
+    class Location
+      def initialize(parts = [])
+        @parts = parts
+      end
+
+      def deeper(part)
+        yield Location.new(@parts + [part])
+      end
+
+      def to_a
+        @parts.dup
+      end
+    end
+  end
+end

data/lib/monolens/lens/options.rb

@@ -0,0 +1,41 @@
+module Monolens
+  module Lens
+    class Options
+      include FetchSupport
+
+      def initialize(options)
+        @options = case options
+        when Hash
+          options.dup
+        else
+          { lenses: options }
+        end
+        actual, lenses = fetch_on(:lenses, @options)
+        @options[actual] = Monolens.lens(lenses) if actual && lenses
+        @options.freeze
+      end
+      attr_reader :options
+      private :options
+
+      NO_DEFAULT = Object.new.freeze
+
+      def fetch(key, default = NO_DEFAULT, on = @options)
+        if on.key?(key)
+          on[key]
+        elsif on.key?(s = key.to_s)
+          on[s]
+        elsif on.key?(sym = key.to_sym)
+          on[sym]
+        elsif default != NO_DEFAULT
+          default
+        else
+          raise Error, "Missing option #{key}"
+        end
+      end
+
+      def to_h
+        @options.dup
+      end
+    end
+  end
+end