monolens 0.5.1 → 0.6.0

data/lib/monolens.rb

@@ -1,81 +1,38 @@
 require 'yaml'
+require 'date'
+require 'ostruct'
+
 module Monolens
-  NAMESPACES = { }
+  require_relative 'monolens/version'
+  require_relative 'monolens/error'
+  require_relative 'monolens/error_handler'
+  require_relative 'monolens/type'
+  require_relative 'monolens/jsonpath'
+  require_relative 'monolens/lens'
+  require_relative 'monolens/namespace'
+  require_relative 'monolens/registry'
+  require_relative 'monolens/macros'
+
+  STDLIB = Registry.new
 
   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)
-      NAMESPACES[name] = impl_module
+      STDLIB.define_namespace(name, impl_module)
     end
 
-    require_relative 'monolens/file'
-    require_relative 'monolens/core'
-    require_relative 'monolens/skip'
-    require_relative 'monolens/str'
-    require_relative 'monolens/array'
-    require_relative 'monolens/object'
-    require_relative 'monolens/coerce'
-
     def load_file(file)
-      Monolens::File.new(YAML.safe_load(::File.read(file)))
+      STDLIB.load_file(file)
     end
 
-    def load_yaml(yaml)
-      Monolens::File.new(YAML.safe_load(yaml))
+    def load_yaml(yaml_str)
+      STDLIB.load_yaml(yaml_str)
     end
 
     def lens(arg)
-      case arg
-      when Lens               then arg
-      when ::Array            then chain(arg)
-      when ::String, ::Symbol then leaf_lens(arg)
-      when ::Hash             then hash_lens(arg)
-      else
-        raise Error, "No such lens #{arg} (#{arg.class})"
-      end
-    end
-
-    def chain(lenses)
-      Core::Chain.new(lenses.map{|l| lens(l) })
-    end
-    private :chain
-
-    def file_lens(arg)
-      File.new(arg)
+      STDLIB.lens(arg)
     end
-
-    def leaf_lens(arg)
-      namespace_name, lens_name = arg.to_s.split('.')
-      factor_lens(namespace_name, lens_name, {})
-    end
-    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
-      namespace_name, lens_name = if name =~ /^[a-z]+\.[a-z]+$/
-        name.to_s.split('.')
-      else
-        ['core', name]
-      end
-      factor_lens(namespace_name, lens_name, options)
-    end
-    private :hash_lens
-
-    def factor_lens(namespace_name, lens_name, options)
-      namespace = NAMESPACES[namespace_name]
-      if namespace&.private_method_defined?(lens_name, false)
-        namespace.send(lens_name, options)
-      else
-        raise Error, "No such lens #{[namespace_name, lens_name].join('.')}"
-      end
-    end
-    private :factor_lens
   end
+
+  require_relative 'monolens/file'
+  require_relative 'monolens/stdlib'
 end

data/spec/fixtures/macro.yml

@@ -0,0 +1,13 @@
+---
+version: "1.0"
+#
+macros:
+  join_them:
+  - array.map:
+    - str.strip
+    - str.upcase
+  - array.join: { separator: <.separator }
+#
+lenses:
+- join_them:
+    separator: ', '

data/spec/fixtures/recursive.yml

@@ -0,0 +1,15 @@
+---
+version: "1.0"
+#
+macros:
+  join_them:
+  - array.map:
+    - str.strip
+    - str.upcase
+  - array.join: { separator: <.separator }
+  ## This is strictly forbidden
+  - join_them: { separator: ',' }
+#
+lenses:
+- join_them:
+    separator: ', '

data/spec/monolens/command/literal.yml

@@ -0,0 +1,2 @@
+---
+$([0]) $([1])

data/spec/monolens/command/literal2.yml

@@ -0,0 +1,2 @@
+---
+$

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

@@ -0,0 +1,4 @@
+---
+version: '1.0'
+lenses:
+- str.upcase

data/spec/monolens/lens/test_options.rb

@@ -4,7 +4,7 @@ module Monolens
   module Lens
     describe Options do
       subject do
-        Options.new(input)
+        Options.new(input, STDLIB, Signature::MISSING)
       end
 
       describe 'initialize' do
@@ -28,19 +28,7 @@ module Monolens
           it 'converts it to lenses' do
             expect(subject.to_h.keys).to eql([:lenses])
             lenses = subject.to_h[:lenses]
-            expect(lenses).to be_a(Core::Chain)
-          end
-        end
-
-        context('when used with a String') do
-          let(:input) do
-            'str.strip'
-          end
-
-          it 'converts it to lenses' do
-            expect(subject.to_h.keys).to eql([:lenses])
-            lenses = subject.to_h[:lenses]
-            expect(lenses).to be_a(Str::Strip)
+            expect(lenses).to eql(input)
           end
         end
       end

data/spec/monolens/lens/test_signature.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Monolens
+  module Lens
+    describe Signature do
+      let(:signature) do
+        Signature.new(Type::String, Type::String, {
+          separator: [Type::String, true],
+          help: [Type::String, false]
+        })
+      end
+
+      it 'is ok with valid options' do
+        expect {
+          signature.dress_options({ separator: ',' }, nil)
+        }.not_to raise_error
+      end
+
+      it 'detects a missing option' do
+        expect {
+          signature.dress_options({}, nil)
+        }.to raise_error(Error, /Missing option `separator`/)
+      end
+
+      it 'detects an extra option' do
+        expect {
+          signature.dress_options({ foo: 'bar' }, nil)
+        }.to raise_error(Error, /Invalid option `foo`/)
+      end
+
+      it 'detects an option of the wrong type' do
+        expect {
+          signature.dress_options({ separator: 12 }, nil)
+        }.to raise_error(Error, /Invalid option `separator`: Invalid string 12/)
+      end
+    end
+  end
+end

data/spec/monolens/{array → stdlib/array}/test_compact.rb

@@ -12,4 +12,12 @@ describe Monolens, 'array.compact' do
   it 'supports empty arrays' do
     expect(subject.call([])).to eql([])
   end
+
+  describe 'signature checking' do
+    it 'detects unexisting options' do
+      expect {
+        Monolens.lens('array.compact' => { foo: 'bar' })
+      }.to raise_error(Monolens::Error, /Invalid option `foo`/)
+    end
+  end
 end

data/spec/monolens/{array → stdlib/array}/test_map.rb

@@ -58,6 +58,21 @@ describe Monolens, 'array.map' do
     end
   end
 
+  context 'keeping on error' do
+    subject do
+      Monolens.lens('array.map' => {
+        on_error: 'keep',
+        lenses: [ 'str.upcase' ]
+      })
+    end
+
+    it 'skips errors' do
+      input = [12, 'world']
+      expected = [12, 'WORLD']
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
   context 'on error with :handler' do
     subject do
       Monolens.lens('array.map' => {

data/spec/monolens/stdlib/check/test_not_empty.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Monolens, 'check.notEmpty' do
+  subject do
+    Monolens.lens('check.notEmpty' => options)
+  end
+
+  context 'with default options' do
+    let(:options) do
+      {}
+    end
+
+    it 'works on non empty strings' do
+      input = '12'
+      expect(subject.call(input)).to be(input)
+    end
+
+    it 'works on non empty arrays' do
+      input = ['12']
+      expect(subject.call(input)).to be(input)
+    end
+
+    it 'raises on empty strings' do
+      input = ''
+      expect {
+        subject.call(input)
+      }.to raise_error(Monolens::LensError, 'Input may not be empty')
+    end
+
+    it 'raises on empty arrays' do
+      input = []
+      expect {
+        subject.call(input)
+      }.to raise_error(Monolens::LensError, 'Input may not be empty')
+    end
+  end
+
+  context 'with a specific error message' do
+    let(:options) do
+      { message: 'Hello failure!' }
+    end
+
+    it 'raises on empty strings' do
+      input = ''
+      expect {
+        subject.call(input)
+      }.to raise_error(Monolens::LensError, 'Hello failure!')
+    end
+  end
+end

data/spec/monolens/{coerce → stdlib/coerce}/test_datetime.rb

@@ -35,7 +35,7 @@ describe Monolens, 'coerce.datetime' do
     end
 
     let(:timezone) do
-      Object.new
+      Struct.new(:parse, :strptime).new(1, 2)
     end
 
     before do

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

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Monolens, "core.literal" do
+  let(:lens) do
+    Monolens.lens('core.literal' => { defn: 'hello' })
+  end
+
+  it 'works' do
+    input = {}
+    expected = 'hello'
+    expect(lens.call(input)).to eql(expected)
+  end
+
+  context 'with a simple json path expressions' do
+    let(:lens) do
+      Monolens.lens('core.literal' => { defn: '$.foo' })
+    end
+
+    it 'works' do
+      input = { 'foo' => 'bar' }
+      expected = 'bar'
+      expect(lens.call(input)).to eql(expected)
+    end
+
+    it 'works with symbols too' do
+      input = { foo: 'bar' }
+      expected = 'bar'
+      expect(lens.call(input)).to eql(expected)
+    end
+  end
+
+  context 'with an object literal with json path expressions' do
+    let(:lens) do
+      Monolens.lens('core.literal' => {
+        defn: {
+          hobbies: [{
+            name: '$.foo'
+          }]
+        }
+      })
+    end
+
+    it 'works' do
+      input = { 'foo' => 'bar' }
+      expected = { hobbies: [{ name: 'bar' }] }
+      expect(lens.call(input)).to eql(expected)
+    end
+
+    it 'works with symbols too' do
+      input = { foo: 'bar' }
+      expected = { hobbies: [{ name: 'bar' }] }
+      expect(lens.call(input)).to eql(expected)
+    end
+  end
+
+  context 'changing the root symbol' do
+    let(:lens) do
+      Monolens.lens('core.literal' => {
+        defn: {
+          one: '<.foo',
+          interpolate: 'Hello <(.foo)'
+        },
+        jsonpath: { root_symbol: '<' }
+      })
+    end
+
+    it 'keeps working' do
+      input = { foo: 'bar' }
+      expected = { one: 'bar', interpolate: 'Hello bar' }
+      expect(lens.call(input)).to eql(expected)
+    end
+  end
+end

data/spec/monolens/{core → stdlib/core}/test_mapping.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Monolens, 'core.mapping' do
   let(:mapping) do
-    { 'values' => { 'todo' => 'open' } }
+    { 'defn' => { 'todo' => 'open' } }
   end
 
   context 'with default options' do
@@ -49,6 +49,20 @@ describe Monolens, 'core.mapping' do
     end
   end
 
+  context 'on_missing: keep' do
+    subject do
+      Monolens.lens('core.mapping' => mapping.merge('on_missing' => 'keep'))
+    end
+
+    it 'replaces the value by its mapped' do
+      expect(subject.call('todo')).to eql('open')
+    end
+
+    it 'returns nil if missing' do
+      expect(subject.call('nosuchone')).to eql('nosuchone')
+    end
+  end
+
   context 'on_missing: fallback' do
     subject do
       Monolens.lens('core.mapping' => mapping.merge(
@@ -90,4 +104,26 @@ describe Monolens, 'core.mapping' do
       expect(subject.location).to eql([1])
     end
   end
+
+  context 'backward compatibility' do
+    let(:mapping) do
+      { 'values' => { 'todo' => 'open' } }
+    end
+
+    context 'with using values instead of defn' do
+      subject do
+        Monolens.lens('core.mapping' => mapping)
+      end
+
+      it 'replaces the value by its mapped' do
+        expect(subject.call('todo')).to eql('open')
+      end
+
+      it 'raises if not found' do
+        expect {
+          subject.call('nosuchone')
+        }.to raise_error(Monolens::LensError)
+      end
+    end
+  end
 end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Monolens, 'object.allbut' do
+  subject do
+    Monolens.lens('object.allbut' => { defn: [ :lastname, :city ] })
+  end
+
+  it 'works as expected' do
+    input = {
+      'firstname' => 'Bernard',
+      'lastname' => 'Lambeau',
+      'city' => 'Brussels'
+    }
+    expected = {
+      'firstname' => 'Bernard',
+    }
+    expect(subject.call(input)).to eql(expected)
+  end
+
+  it 'works as expected with Symbol keys' do
+    input = {
+      firstname: 'Bernard',
+      lastname: 'Lambeau',
+      city: 'Brussels'
+    }
+    expected = {
+      firstname: 'Bernard',
+    }
+    expect(subject.call(input)).to eql(expected)
+  end
+end

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

@@ -0,0 +1,133 @@
+describe Monolens, 'object.merge' do
+  subject do
+    Monolens.lens('object.merge' => {
+      priority: priority,
+      deep: deep,
+      defn: {
+        name: 'Monolens',
+        version: "1.0",
+        links: {
+          github: "https://github.com/enspirit/monolens"
+        },
+      }
+    }.compact)
+  end
+
+  let(:priority) do
+    nil
+  end
+
+  let(:deep) do
+    nil
+  end
+
+  describe 'with default options' do
+    it 'works as expected on a flat structure' do
+      input = {
+        version: "1.2",
+        extra: "foo"
+      }
+      expected = {
+        name: 'Monolens',
+        version: "1.0",
+        links: {
+          github: "https://github.com/enspirit/monolens"
+        },
+        extra: "foo"
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+
+    it 'does not apply a deep merge' do
+      input = {
+        links: {
+          owner: "https://enspirit.be/"
+        },
+      }
+      expected = {
+        name: 'Monolens',
+        version: "1.0",
+        links: {
+          github: "https://github.com/enspirit/monolens"
+        }
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  describe 'priority: input' do
+    let(:priority) do
+      'input'
+    end
+
+    it 'reverse the logic on shared keys' do
+      input = {
+        version: "1.2",
+        extra: "foo",
+      }
+      expected = {
+        name: 'Monolens',
+        version: "1.2",
+        links: {
+          github: "https://github.com/enspirit/monolens"
+        },
+        extra: "foo"
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  describe 'deep: true' do
+    let(:deep) do
+      true
+    end
+
+    it 'applies a deep merge' do
+      input = {
+        version: "1.2",
+        links: {
+          owner: "https://enspirit.be/",
+          github: "https://github.com/enspirit/monolens/"
+        },
+      }
+      expected = {
+        name: 'Monolens',
+        version: "1.0",
+        links: {
+          owner: "https://enspirit.be/",
+          github: "https://github.com/enspirit/monolens"
+        }
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+
+  describe 'deep: true, priority: input' do
+    let(:deep) do
+      true
+    end
+
+    let(:priority) do
+      'input'
+    end
+
+    it 'applies a deep merge' do
+      input = {
+        version: "1.2",
+        links: {
+          owner: "https://enspirit.be/",
+          github: "https://github.com/enspirit/monolens/"
+        },
+      }
+      expected = {
+        name: 'Monolens',
+        version: "1.2",
+        links: {
+          owner: "https://enspirit.be/",
+          github: "https://github.com/enspirit/monolens/"
+        }
+      }
+      expect(subject.call(input)).to eql(expected)
+    end
+  end
+end