monolens 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: fded1da33ff2b2e68f5c0ec9177d77fed38d12576a7a505e7e50d25dd8c356c8
-  data.tar.gz: ebcc624d96c03a82b1939a9cd9d76c0902fd170510ca93a670b5fbf02e477f08
+SHA1:
+  metadata.gz: 30152f626d5675640e96816c7036d5a6dbac8a25
+  data.tar.gz: a26d4e5d0715bd511aea96da758fd12d36e2a70b
 SHA512:
-  metadata.gz: 508ede1d192eb3cc5d5f9a359cb18f627e44b5cdbd4d9c89bc89c90b52787b96061efcd95a01a4855f7477213e33aa56a7178c9afe4ccf16124af9155d54af1d
-  data.tar.gz: 82138ad714e74d73c880eff43423d01546cfdf59569913d7d20734460dfc6ad08bab6ac7e4e8ae760a3a9de7884716297bd2433bd2a7c88f109d7fbc400b0fbd
+  metadata.gz: 7b27ab005aaf2a6bf1abdc8c9284072ce1307498b7edad606526198c3e4ae003d0ddda72eb532266b7b737fbb04146959903868c50e16be4fbb8f1a073f20e9b
+  data.tar.gz: 8fd2b3ad776ff72da243ba29ab7fc2bd5fd05e88b8d34c93cd38c362142b83ff4c8164559af707d3ea314c39af3b9c415c1716841c269ab73bf9e06b852c883e

data/README.md

@@ -37,13 +37,13 @@ The following monolens file, say `lens.yml`
 ---
 version: 1.0
 lenses:
-- map:
-  - object.transform
+- array.map:
+  - object.transform:
       status:
       - str.upcase
       body:
       - str.strip
-  - object.rename
+  - object.rename:
       body: description
 ```
 
@@ -76,24 +76,32 @@ result = lens.call(input)
 ## Available lenses
 
 ```
-core.map          - Apply a lens to each member of an Array
+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
 
 str.strip         - Remove leading and trailing spaces of an input string
+str.split         - Splits the input string as an array
 str.downcase      - Converts the input string to lowercase
 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
 object.values     - Applies a lens to all values of the input object
+object.select     - Builds an object by selecting key/values from the input object
 
 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
+array.map         - Apply a lens to each member of an Array
 ```
 
 ## Public API
@@ -110,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

@@ -0,0 +1,13 @@
+module Monolens
+  module Array
+    class Join
+      include Lens
+
+      def call(arg, world = {})
+        is_array!(arg, world)
+
+        arg.join(option(:separator, ' '))
+      end
+    end
+  end
+end

data/lib/monolens/array/map.rb

@@ -0,0 +1,57 @@
+module Monolens
+  module Array
+    class Map
+      include 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, world = {})
+        is_enumerable!(arg, world)
+
+        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

@@ -5,7 +5,19 @@ module Monolens
     end
     module_function :compact
 
+    def join(options = {})
+      Join.new(options)
+    end
+    module_function :join
+
+    def map(options)
+      Map.new(options)
+    end
+    module_function :map
+
     Monolens.define_namespace 'array', self
   end
 end
 require_relative 'array/compact'
+require_relative 'array/join'
+require_relative 'array/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,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/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

@@ -0,0 +1,15 @@
+module Monolens
+  module Core
+    class Mapping
+      include Lens
+
+      def call(arg, world = {})
+        option(:values, {}).fetch(arg) do
+          fail!("Unrecognized value `#{arg}`", world) if option(:fail_if_missing)
+
+          option(:default)
+        end
+      end
+    end
+  end
+end

data/lib/monolens/core.rb

@@ -5,13 +5,19 @@ module Monolens
     end
     module_function :chain
 
-    def map(lens)
-      Map.new(lens)
+    def dig(options)
+      Dig.new(options)
     end
-    module_function :map
+    module_function :dig
+
+    def mapping(options)
+      Mapping.new(options)
+    end
+    module_function :mapping
 
     Monolens.define_namespace 'core', self
   end
 end
 require_relative 'core/chain'
-require_relative 'core/map'
+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