dry-transformer 0.1.0 → 0.1.1

data/.rubocop.yml

@@ -1,95 +0,0 @@
-# this file is managed by dry-rb/devtools project
-
-AllCops:
-  TargetRubyVersion: 2.4
-
-Style/EachWithObject:
-  Enabled: false
-
-Style/StringLiterals:
-  Enabled: true
-  EnforcedStyle: single_quotes
-
-Style/Alias:
-  Enabled: false
-
-Style/LambdaCall:
-  Enabled: false
-
-Style/StabbyLambdaParentheses:
-  Enabled: false
-
-Style/FormatString:
-  Enabled: false
-
-Style/Documentation:
-  Enabled: false
-
-Layout/SpaceInLambdaLiteral:
-  Enabled: false
-
-Layout/MultilineMethodCallIndentation:
-  Enabled: true
-  EnforcedStyle: indented
-
-Metrics/LineLength:
-  Max: 100
-
-Metrics/MethodLength:
-  Max: 22
-
-Metrics/ClassLength:
-  Max: 150
-
-Metrics/AbcSize:
-  Max: 20
-
-Metrics/BlockLength:
-  Enabled: false
-
-Metrics/CyclomaticComplexity:
-  Enabled: true
-  Max: 10
-
-Lint/BooleanSymbol:
-  Enabled: false
-
-Style/AccessModifierDeclarations:
-  Enabled: false
-
-Style/BlockDelimiters:
-  Enabled: false
-
-Layout/IndentFirstArrayElement:
-  EnforcedStyle: consistent
-
-Style/ClassAndModuleChildren:
-  Exclude:
-    - "spec/**/*_spec.rb"
-
-Lint/HandleExceptions:
-  Exclude:
-    - "spec/spec_helper.rb"
-
-Naming/FileName:
-  Exclude:
-    - "lib/dry-*.rb"
-
-Style/SymbolArray:
-  Exclude:
-    - "spec/**/*_spec.rb"
-
-Style/ConditionalAssignment:
-  Enabled: false
-
-Naming/MethodName:
-  Enabled: false
-
-Style/AsciiComments:
-  Enabled: false
-
-Style/DateTime:
-  Enabled: false
-
-Style/IfUnlessModifier:
-  Enabled: false

data/CODE_OF_CONDUCT.md

@@ -1,13 +0,0 @@
-# Contributor Code of Conduct
-
-As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
-
-Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
-
-This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.4.0, available at [https://www.contributor-covenant.org/version/1/4/code-of-conduct](https://www.contributor-covenant.org/version/1/4/code-of-conduct)

data/CONTRIBUTING.md

@@ -1,29 +0,0 @@
-# Issue Guidelines
-
-## Reporting bugs
-
-If you found a bug, report an issue and describe what's the expected behavior versus what actually happens. If the bug causes a crash, attach a full backtrace. If possible, a reproduction script showing the problem is highly appreciated.
-
-## Reporting feature requests
-
-Report a feature request **only after discussing it first on [discourse.dry-rb.org](https://discourse.dry-rb.org)** where it was accepted. Please provide a concise description of the feature, don't link to a discussion thread, and instead summarize what was discussed.
-
-## Reporting questions, support requests, ideas, concerns etc.
-
-**PLEASE DON'T** - use [discourse.dry-rb.org](http://discourse.dry-rb.org) instead.
-
-# Pull Request Guidelines
-
-A Pull Request will only be accepted if it addresses a specific issue that was reported previously, or fixes typos, mistakes in documentation etc.
-
-Other requirements:
-
-1) Do not open a pull request if you can't provide tests along with it. If you have problems writing tests, ask for help in the related issue.
-2) Follow the style conventions of the surrounding code. In most cases, this is standard ruby style.
-3) Add API documentation if it's a new feature
-4) Update API documentation if it changes an existing feature
-5) Bonus points for sending a PR to [github.com/dry-rb/dry-rb.org](github.com/dry-rb/dry-rb.org) which updates user documentation and guides
-
-# Asking for help
-
-If these guidelines aren't helpful, and you're stuck, please post a message on [discourse.dry-rb.org](https://discourse.dry-rb.org) or join [our chat](https://dry-rb.zulipchat.com).

data/Gemfile

@@ -1,19 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-gem 'rake'
-gem 'rspec', '~> 3.8'
-gem 'dry-equalizer', '~> 0.2'
-
-platform :mri do
-  gem 'codacy-coverage', require: false
-  gem 'simplecov', require: false
-end
-
-group :tools do
-  gem 'pry'
-  gem 'byebug', platform: :mri
-  gem 'benchmark-ips'
-  gem 'ossy', git: 'https://github.com/solnic/ossy.git', branch: 'master', platform: :mri
-end

data/Rakefile

@@ -1,6 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-
-task default: :spec
-
-RSpec::Core::RakeTask.new(:spec)

data/docsite/source/built-in-transformations.html.md

@@ -1,47 +0,0 @@
----
-title: Built-in transformation
-layout: gem-single
-name: dry-transformer
----
-
-`dry-transformer` comes with a lot of built-in functions. They come in the form of modules with class methods, which you can import into a registry:
-
-* [Coercions](https://www.rubydoc.info/gems/dry-transformer/Dry/Transformer/Coercions)
-* [Array transformations](https://www.rubydoc.info/gems/dry-transformer/Dry/Transformer/ArrayTransformations)
-* [Hash transformations](https://www.rubydoc.info/gems/dry-transformer/Dry/Transformer/HashTransformations)
-* [Class transformations](https://www.rubydoc.info/gems/dry-transformer/Dry/Transformer/ClassTransformations)
-* [Proc transformations](https://www.rubydoc.info/gems/dry-transformer/Dry/Transformer/ProcTransformations)
-* [Conditional](https://www.rubydoc.info/gems/dry-transformer/Dry/Transformer/Conditional)
-* [Recursion](https://www.rubydoc.info/gems/dry-transformer/Dry/Transformer/Recursion)
-
-You can import everything with:
-
-```ruby
-module T
-  extend Dry::Transformer::Registry
-
-  import Dry::Transformer::Coercions
-  import Dry::Transformer::ArrayTransformations
-  import Dry::Transformer::HashTransformations
-  import Dry::Transformer::ClassTransformations
-  import Dry::Transformer::ProcTransformations
-  import Dry::Transformer::Conditional
-  import Dry::Transformer::Recursion
-end
-
-T[:to_string].(:abc) # => 'abc'
-```
-
-Or import selectively with:
-
-```ruby
-module T
-  extend Dry::Transformer::Registry
-
-  import :to_string, from: Dry::Transformer::Coercions, as: :stringify
-end
-
-T[:stringify].(:abc) # => 'abc'
-T[:to_string].(:abc)
-# => Dry::Transformer::FunctionNotFoundError: No registered function T[:to_string]
-```

data/docsite/source/index.html.md

@@ -1,15 +0,0 @@
----
-title: Introduction
-description: Data transformation toolkit
-layout: gem-single
-type: gem
-name: dry-transformer
-sections:
-  - transformation-objects
-  - built-in-transformations
-  - using-standalone-functions
----
-
-dry-transformer is a library that allows you to compose procs into a functional pipeline using left-to-right function composition.
-
-The approach came from Functional Programming, where simple functions are composed into more complex functions in order to transform some data. It works like `|>` in Elixir or `>>` in F#. dry-transformer provides a mechanism to define and compose transformations, along with a number of built-in transformations.

data/docsite/source/transformation-objects.html.md

@@ -1,32 +0,0 @@
----
-title: Transformation objects
-name: dry-transformer
-layout: gem-single
----
-
-You can define transformation classes using the DSL which converts every method call to its corresponding transformation, and composes these transformations into a transformation pipeline. Here's a simple example where the default registry is used:
-
-```ruby
-class MyMapper < Dry::Transformer[Dry::Transformer::Registry]
-  define! do
-    map_array do
-      symbolize_keys
-      rename_keys user_name: :name
-      nest :address, [:city, :street, :zipcode]
-    end
-  end
-end
-
-mapper = MyMapper.new
-
-mapper.(
-  [
-    { 'user_name' => 'Jane',
-      'city' => 'NYC',
-      'street' => 'Street 1',
-      'zipcode' => '123'
-    }
-  ]
-)
-# => [{:name=>"Jane", :address=>{:city=>"NYC", :street=>"Street 1", :zipcode=>"123"}}]
-```

data/docsite/source/using-standalone-functions.html.md

@@ -1,82 +0,0 @@
----
-title: Using standalone functions
-name: dry-transformer
-layout: gem-single
----
-
-You can use `dry-transformer` and its function registry feature stand-alone, without the need to define transformation classes. To do so, simply define a module and extend it with the registry API:
-
-``` ruby
-require 'json'
-require 'dry/transformer/all'
-
-# create your own local registry for transformation functions
-module Functions
-  extend Dry::Transformer::Registry
-end
-
-# import necessary functions from other transprocs...
-module Functions
-  # import all singleton methods from a module/class
-  import Dry::Transformer::HashTransformations
-  import Dry::Transformer::ArrayTransformations
-end
-
-# ...or from any external library
-require 'dry-inflector'
-
-Inflector = Dry::Inflector.new
-
-module Functions
-  # import only necessary singleton methods from a module/class
-  # and rename them locally
-  import :camelize, from: Inflector, as: :camel_case
-end
-
-def t(*args)
-  Functions[*args]
-end
-
-# use imported transformation
-transformation = t(:camel_case)
-
-transformation.call 'i_am_a_camel'
-# => "IAmACamel"
-
-transformation = t(:map_array, (
-  t(:symbolize_keys).>> t(:rename_keys, user_name: :user)
-  )).>> t(:wrap, :address, [:city, :street, :zipcode])
-
-transformation.call(
-  [
-    { 'user_name' => 'Jane',
-      'city' => 'NYC',
-      'street' => 'Street 1',
-      'zipcode' => '123' }
-  ]
-)
-# => [{:user=>"Jane", :address=>{:city=>"NYC", :street=>"Street 1", :zipcode=>"123"}}]
-
-# define your own composable transformation easily
-transformation = t(-> v { JSON.dump(v) })
-
-transformation.call(name: 'Jane')
-# => "{\"name\":\"Jane\"}"
-
-# ...or add it to registered functions via singleton method of the registry
-module Functions
-  # ...
-
-  def self.load_json(v)
-    JSON.load(v)
-  end
-end
-
-# ...or add it to registered functions via .register method
-Functions.register(:load_json) { |v| JSON.load(v) }
-
-transformation = t(:load_json) >> t(:map_array, t(:symbolize_keys))
-
-transformation.call('[{"name":"Jane"}]')
-# => [{ :name => "Jane" }]
-```

data/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-if ENV['COVERAGE'] == 'true'
-  require 'codacy-coverage'
-  Codacy::Reporter.start
-end
-
-begin
-  require 'byebug'
-rescue LoadError;end
-
-require 'dry/transformer/all'
-
-root = Pathname(__FILE__).dirname
-Dir[root.join('support/*.rb').to_s].each { |f| require f }
-
-# Namespace holding all objects created during specs
-module Test
-  def self.remove_constants
-    constants.each(&method(:remove_const))
-  end
-end
-
-RSpec.configure do |config|
-  config.after do
-    Test.remove_constants
-  end
-
-  config.disable_monkey_patching!
-  config.warnings = true
-end

data/spec/unit/array/combine_spec.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-RSpec.describe Dry::Transformer::ArrayTransformations do
-  describe '.combine' do
-    subject(:result) { described_class.t(:combine, mappings)[input] }
-
-    let(:input) { [[]] }
-    let(:mappings) { [] }
-
-    it { is_expected.to be_a(Array) }
-
-    it { is_expected.to eq([]) }
-
-    context 'without groups' do
-      let(:input) do
-        [
-          [
-            {name: 'Jane', email: 'jane@doe.org'}.freeze,
-            {name: 'Joe', email: 'joe@doe.org'}.freeze
-          ].freeze
-        ].freeze
-      end
-
-      it { is_expected.to eq input.first }
-    end
-
-    context 'with one group' do
-      let(:input) do
-        [
-          [
-            {name: 'Jane', email: 'jane@doe.org'}.freeze,
-            {name: 'Joe', email: 'joe@doe.org'}.freeze
-          ].freeze,
-          [
-            [
-              {user: 'Jane', title: 'One'}.freeze,
-              {user: 'Jane', title: 'Two'}.freeze,
-              {user: 'Joe', title: 'Three'}.freeze
-            ]
-          ]
-        ].freeze
-      end
-      let(:mappings) { [[:tasks, {name: :user}]] }
-
-      it 'merges hashes from arrays using provided join keys' do
-        output = [
-          {name: 'Jane', email: 'jane@doe.org', tasks: [
-            {user: 'Jane', title: 'One'},
-            {user: 'Jane', title: 'Two'}
-          ]},
-          {name: 'Joe', email: 'joe@doe.org', tasks: [
-            {user: 'Joe', title: 'Three'}
-          ]}
-        ]
-        is_expected.to eql(output)
-      end
-    end
-
-    context 'with empty nodes' do
-      let(:input) do
-        [
-          [{name: 'Jane', email: 'jane@doe.org'}.freeze].freeze,
-          [
-            []
-          ]
-        ].freeze
-      end
-
-      let(:mappings) { [[:tasks, {name: :user}]] }
-
-      it { is_expected.to eq([{name: 'Jane', email: 'jane@doe.org', tasks: []}]) }
-    end
-
-    context 'with double mapping' do
-      let(:input) do
-        [
-          [
-            {name: 'Jane', email: 'jane@doe.org'}.freeze
-          ].freeze,
-          [
-            [
-              {user: 'Jane', user_email: 'jane@doe.org', title: 'One'}.freeze,
-              {user: 'Jane', user_email: '', title: 'Two'}.freeze
-            ].freeze
-          ].freeze
-        ].freeze
-      end
-
-      let(:mappings) { [[:tasks, {name: :user, email: :user_email}]] }
-
-      it 'searches by two keys simultaneously' do
-        output = [
-          {name: 'Jane', email: 'jane@doe.org', tasks: [
-            {user: 'Jane', user_email: 'jane@doe.org', title: 'One'}
-          ]}
-        ]
-        is_expected.to eql(output)
-      end
-    end
-
-    context 'with non-array argument' do
-      let(:input) do
-        123
-      end
-
-      let(:mappings) { [[:page, {page_id: :id}]] }
-
-      it { is_expected.to eq(123) }
-    end
-
-    context 'with empty nested array' do
-      let(:input) do
-        [
-          [],
-          [
-            []
-          ]
-        ]
-      end
-
-      let(:mappings) { [[:menu_items, {id: :menu_id}, [[:page, {page_id: :id}]]]] }
-
-      it 'does not crash' do
-        expect { result }.not_to raise_error
-      end
-    end
-
-    context 'with enumerable input' do
-      let(:my_enumerator) do
-        Class.new do
-          include Enumerable
-          extend Forwardable
-
-          def_delegator :@array, :each
-
-          def initialize(array)
-            @array = array
-          end
-        end
-      end
-
-      let(:input) do
-        [
-          my_enumerator.new([
-            {name: 'Jane', email: 'jane@doe.org'}.freeze,
-            {name: 'Joe', email: 'joe@doe.org'}.freeze
-          ].freeze),
-          my_enumerator.new([
-            my_enumerator.new([
-              {user: 'Jane', title: 'One'}.freeze,
-              {user: 'Jane', title: 'Two'}.freeze,
-              {user: 'Joe', title: 'Three'}.freeze
-            ].freeze)
-          ].freeze)
-        ].freeze
-      end
-      let(:mappings) { [[:tasks, {name: :user}]] }
-
-      it 'supports enumerables as well' do
-        output = [
-          {name: 'Jane', email: 'jane@doe.org', tasks: [
-            {user: 'Jane', title: 'One'},
-            {user: 'Jane', title: 'Two'}
-          ]},
-          {name: 'Joe', email: 'joe@doe.org', tasks: [
-            {user: 'Joe', title: 'Three'}
-          ]}
-        ]
-        is_expected.to eql(output)
-      end
-    end
-
-    describe 'integration test' do
-      let(:input) do
-        [
-          [
-            {name: 'Jane', email: 'jane@doe.org'},
-            {name: 'Joe', email: 'joe@doe.org'}
-          ],
-          [
-            [
-              # user tasks
-              [
-                {user: 'Jane', title: 'One'},
-                {user: 'Jane', title: 'Two'},
-                {user: 'Joe', title: 'Three'}
-              ],
-              [
-                # task tags
-                [
-                  {task: 'One', tag: 'red'},
-                  {task: 'Three', tag: 'blue'}
-                ]
-              ]
-            ]
-          ]
-        ]
-      end
-
-      let(:mappings) { [[:tasks, {name: :user}, [[:tags, title: :task]]]] }
-
-      it 'merges hashes from arrays using provided join keys' do
-        output = [
-          {name: 'Jane', email: 'jane@doe.org', tasks: [
-            {user: 'Jane', title: 'One', tags: [{task: 'One', tag: 'red'}]},
-            {user: 'Jane', title: 'Two', tags: []}
-          ]},
-          {
-            name: 'Joe', email: 'joe@doe.org', tasks: [
-              {
-                user: 'Joe', title: 'Three', tags: [
-                  {task: 'Three', tag: 'blue'}
-                ]
-              }
-            ]
-          }
-        ]
-        is_expected.to eql(output)
-      end
-    end
-  end
-end