json-path-builder 0.1.0

data/bin/rubocop

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dev/setup.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Sets up environment for running specs and via irb e.g. `$ irb -r ./dev/setup`
+require 'delegate'
+require "pathname"
+require "rudash"
+
+require 'rspec/core'
+
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/json'
+require 'active_support/core_ext/enumerable'
+
+%w[../../lib/json_path ../../spec/spec_helper].each do |rel_path|
+  require File.expand_path(rel_path, Pathname.new(__FILE__).realpath)
+end
+

data/json_path_builder.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'English'
+require File.expand_path('lib/json-path/version', __dir__)
+
+Gem::Specification.new do |gem|
+  gem.authors = ["Desmond O'Leary"]
+  gem.email = ["desoleary@gmail.com"]
+  gem.description = 'Declarative mapping JSON/Hash data structures'
+  gem.summary = 'Declarative mapping JSON/Hash data structures'
+  gem.homepage = "https://github.com/omnitech-solutions/json-path-builder"
+  gem.license = "MIT"
+
+  gem.files = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  gem.executables = gem.files.grep(%r{^exe/}).map { |f| File.basename(f) }
+  gem.name = "json-path-builder"
+  gem.require_paths = ["lib"]
+  gem.version = JsonPathBuilder::VERSION
+  gem.required_ruby_version = ">= 2.7"
+
+  gem.metadata["homepage_uri"] = gem.homepage
+  gem.metadata["source_code_uri"] = gem.homepage
+  gem.metadata["changelog_uri"] = "#{gem.homepage}/CHANGELOG.md"
+
+  gem.add_runtime_dependency 'activesupport', '>= 5'
+  gem.add_runtime_dependency 'rordash', '~> 0.1.2'
+
+  gem.add_development_dependency("codecov", "~> 0.6.0")
+  gem.add_development_dependency("rake", "~> 13.0.6")
+  gem.add_development_dependency("rspec", "~> 3.12.0")
+  gem.add_development_dependency("simplecov", "~> 0.21.2")
+  gem.metadata['rubygems_mfa_required'] = 'true'
+end

data/lib/json-path/builder.rb

@@ -0,0 +1,232 @@
+module JsonPath
+  # rubocop:disable Metrics/ClassLength
+  class Builder
+    attr_reader :path_context_collection, :parent_path_context
+
+    delegate :source_data, :nested_paths, :data_wrapper_class, :reject_from_paths!, to: :path_context_collection,
+                                                                                    allow_nil: true
+
+    def initialize(parent_path_context: nil)
+      @parent_path_context = parent_path_context
+      @path_context_collection = PathContextCollection.new(self)
+    end
+
+    def within(json_path, &block)
+      path_context_collection.within(json_path, &block)
+
+      self
+    end
+
+    def with_wrapped_data_class(klass)
+      path_context_collection.with_wrapped_data_class(klass)
+
+      self
+    end
+
+    # rubocop:disable Metrics/ParameterLists
+    def from(json_path, to: nil, transform: nil, defaults: nil, fallback: nil, transform_with_builder: false)
+      @path_context_collection.add_path(json_path, self,
+                                        iterable_data: false,
+                                        to: to,
+                                        transform: transform,
+                                        use_builder: transform_with_builder,
+                                        defaults: defaults,
+                                        fallback_proc: fallback,
+                                        skip_if_proc: nil)
+
+      self
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    # rubocop:disable Metrics/ParameterLists
+    def from_each(json_path, to: nil, transform: nil, skip_if: nil, defaults: nil, fallback: nil,
+                  transform_with_builder: false)
+      @path_context_collection.add_path(json_path, self,
+                                        to: to,
+                                        iterable_data: true,
+                                        transform: transform,
+                                        use_builder: transform_with_builder,
+                                        defaults: defaults,
+                                        fallback_proc: fallback,
+                                        skip_if_proc: skip_if)
+
+      self
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def with_source_data(data)
+      path_context_collection.with_source_data(data)
+
+      self
+    end
+
+    def without_from_paths!(from_paths_to_remove)
+      path_context_collection.reject_from_paths!(from_paths_to_remove)
+
+      self
+    end
+
+    def build
+      raise 'source data must be filled' if source_data.nil?
+
+      build_for(source_data)
+    end
+
+    def build_for(data, &each_value_block)
+      path_contexts = with_source_data(data).path_context_collection
+      self.class.build_for(path_contexts, &each_value_block)
+    end
+
+    def paths?
+      @path_context_collection.count.positive?
+    end
+
+    class << self
+      def build_for(path_contexts, &each_value_block)
+        mapped_data = {}
+        identity_proc = proc { |val| val }
+        each_value_block = identity_proc unless each_value_block.is_a?(Proc)
+
+        path_contexts.each do |path_context|
+          path_context.with_prev_mapped_data(mapped_data)
+
+          if path_context.unmatched_nested?
+            set_mapped_value(mapped_data, key: path_context.to, value: get_fallback_value(path_context))
+            next path_context
+          end
+
+          picked_value = value_at(path_context)
+          transformed_value = get_transformed_value(picked_value, path_context)
+          transformed_value = each_value_block.call(transformed_value, path_context)
+
+          set_mapped_value(mapped_data, key: path_context.to, value: transformed_value)
+        end
+        mapped_data
+      end
+
+      private
+
+      def set_mapped_value(mapped_data, key:, value:)
+        Rordash::HashUtil.set(mapped_data, key.to_s, value)
+      end
+
+      def get_transformed_value(picked_value, path_context)
+        return get_transformed_values(picked_value, path_context) if path_context.iterable_data?
+
+        transformed_value = transform_value(picked_value, path_context)
+        return transformed_value unless transformed_value.nil?
+
+        get_fallback_value(path_context)
+      end
+
+      def get_fallback_value(path_context)
+        return nil unless path_context.fallback?
+
+        call_proc(path_context.fallback_proc, path_context)
+      end
+
+      def get_transformed_values(value, path_context)
+        value = (value || [])
+        value = value.reject { |val| path_context.skip_if_proc.call(val) } if path_context.skippable?
+        Rordash::HashUtil.deep_symbolize_keys(value).each_with_index.map do |item|
+          transform_value(item, path_context)
+        end
+      end
+
+      def transform_value(value, path_context)
+        return transform_value_with_builder(value, path_context) if path_context.transform_with_builder?
+        return call_proc(path_context.transform, value, path_context) if path_context.transformable?
+
+        value
+      end
+
+      def transform_value_with_builder(value, path_context)
+        builder = PathsBuilder.new(parent_path_context: path_context)
+        pb = call_proc(path_context.transform, builder, path_context)
+        return pb.build_for(value) if pb&.paths?
+
+        value
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+      def value_at(path_context)
+        from = path_context.from
+        data = path_context.data
+
+        val = if %w[* .].include?(from)
+                data
+              elsif from.is_a?(Array)
+                Rordash::HashUtil.pick(data, from)
+              elsif from.to_sym == :wrapped_source_data
+                return path_context.wrapped_source_data
+              else
+                Rordash::HashUtil.get(data, from)
+              end
+
+        value = if path_context.iterable_data?
+                  val = [val] unless val.is_a?(Array)
+                  (val || []).map { |item| apply_defaults(item, path_context) }
+                else
+                  apply_defaults(val, path_context)
+                end
+
+        Rordash::HashUtil.deep_symbolize_keys(value)
+      end
+      # rubocop:enable Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+
+      def apply_defaults(data, path_context)
+        return data unless data.is_a?(Hash) && path_context.defaults?
+
+        path_context.defaults.merge(data)
+      end
+
+      def exec_transform(value, path_context)
+        return value unless path_context.transformable?
+
+        call_proc(path_context.transform, value, path_context)
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize
+      def call_proc(proc, *args, **extra_args)
+        return nil unless proc.is_a?(Proc)
+
+        allowed_proc_args = %i[req opt]
+        proc_args_count = proc.parameters.count { |type, _| allowed_proc_args.include?(type) }
+
+        allowed_kw_args = %i[key keyreq]
+        proc_kw_args = proc.parameters.select { |type, _| allowed_kw_args.include?(type) }.map(&:second)
+
+        without_extra_args = proc_args_count.zero? && proc_kw_args && args.present? && args.first.is_a?(Hash)
+        extra_args = without_extra_args ? args.first : extra_args
+
+        missing_args_count = [proc_args_count - args.count, 0].max
+
+        found_args = proc_args_count.positive? ? args.take(proc_args_count) : []
+        filled_args = found_args.present? ? found_args.fill(nil, found_args.count...missing_args_count + 1) : []
+        filled_extra_args = extra_args.slice(*proc_kw_args)
+
+        if proc_kw_args.present?
+          call_proc_with_extra_args(proc, filled_args, filled_extra_args)
+        else
+          filled_args.present? ? proc.call(*filled_args) : proc.call
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize
+
+      def call_proc_with_extra_args(proc, args, **extra_args)
+        if args.present?
+          args.first.is_a?(Hash) ? proc.call(**args.first) : proc.call
+
+          proc.call(*args, **extra_args)
+        else
+          proc.call(**extra_args)
+        end
+      end
+    end
+
+    def keys
+      path_context_collection.map(&:to)
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/json-path/default_data_wrapper.rb

@@ -0,0 +1,7 @@
+module JsonPath
+  class DefaultDataWrapper < SimpleDelegator
+    def initialize(data)
+      super(data.deep_symbolize_keys)
+    end
+  end
+end

data/lib/json-path/path_context.rb

@@ -0,0 +1,135 @@
+module JsonPath
+  # rubocop:disable Metrics/ParameterLists,Metrics/PerceivedComplexity
+  class PathContext
+    COMMON_TRANSFORMS = {
+      iso8601: ->(val) { val.is_a?(Date) ? val.iso8601 : val },
+      date: lambda do |val|
+        val.is_a?(String) ? (defined? Time.zone.parse) && Time.zone.parse(val)&.to_date : val
+      rescue ArgumentError
+        val
+      end
+    }.freeze
+
+    attr_reader :from, :to, :transform, :use_builder, :defaults, :fallback_proc, :skip_if_proc, :builder, :data,
+                :source_data, :nested_paths, :nested_data, :mapped_data
+
+    delegate :data_wrapper_class, to: :builder
+
+    # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize
+    def initialize(json_path, paths_builder, iterable_data:, transform:, use_builder:, defaults:, fallback_proc:,
+                   to: nil, skip_if_proc: nil)
+      allowed_transform_types = COMMON_TRANSFORMS.keys
+
+      raise ArgumentError, '`from` must be filled' if json_path.blank?
+
+      if (transform.is_a?(Symbol) || transform.is_a?(String)) && COMMON_TRANSFORMS.keys.exclude?(transform.to_sym)
+        raise ArgumentError,
+              "`transform`: '#{transform}' must be one of #{allowed_transform_types.inspect}"
+      end
+
+      @builder = paths_builder
+      @from = json_path.is_a?(Array) ? json_path.map(&:to_s) : json_path.to_s
+      @iterable_data = iterable_data
+      @nested_paths = paths_builder.nested_paths.dup.freeze
+      @to = to.present? ? to : json_path.to_s
+      @transform = transform.is_a?(Symbol) ? COMMON_TRANSFORMS[transform] : transform
+      @use_builder = use_builder
+      @defaults = Rordash::HashUtil.deep_symbolize_keys(defaults || {})
+      @fallback_proc = fallback_proc
+      @skip_if_proc = skip_if_proc || proc { false }
+
+      @skip = false
+      @nested_data = nil
+    end
+    # rubocop:enable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize
+
+    def parent
+      builder.parent_path_context
+    end
+
+    def wrapped_source_data
+      return nil if source_data.nil?
+
+      @wrapped_source_data ||= data_wrapper_class.new(source_data)
+    end
+
+    def iterable_data?
+      @iterable_data
+    end
+
+    def skippable?
+      skip_if_proc.is_a?(Proc)
+    end
+
+    def fallback?
+      fallback_proc.is_a?(Proc)
+    end
+
+    def nested?
+      @nested_paths.present?
+    end
+
+    def defaults?
+      @defaults.is_a?(Hash) && @defaults.present?
+    end
+
+    def transform_with_builder?
+      !!@use_builder
+    end
+
+    def transformable?
+      transform.is_a?(Proc)
+    end
+
+    def unmatched_nested?
+      nested? && nested_data.blank?
+    end
+
+    def nested_data?
+      @nested_data.present?
+    end
+
+    def with_source_data(data)
+      @source_data = data.dup.freeze
+      set_nested_data
+      set_data
+
+      self
+    end
+
+    def with_prev_mapped_data(data)
+      @mapped_data = data.dup.freeze
+    end
+
+    def to_h
+      {
+        from: from,
+        to: to,
+        data: data,
+        source_data: source_data,
+        nested_data: nested_data,
+        mapped_data: mapped_data,
+        transform: transform,
+        use_builder: use_builder,
+        defaults: defaults,
+        fallback_proc: fallback_proc,
+        skip_if_proc: skip_if_proc
+      }
+    end
+
+    private
+
+    def set_nested_data
+      return if @nested_paths.empty?
+
+      @nested_data = Rordash::HashUtil.get(source_data, @nested_paths.join('.'))
+    end
+
+    def set_data
+      @data = nested_data? ? nested_data.dup : source_data.dup
+
+      self
+    end
+  end
+  # rubocop:enable Metrics/ParameterLists,Metrics/PerceivedComplexity
+end

data/lib/json-path/path_context_collection.rb

@@ -0,0 +1,65 @@
+module JsonPath
+  # rubocop:disable Metrics/ParameterLists
+  class PathContextCollection < SimpleDelegator
+    ROOT_PATHS = %w[* .].freeze
+
+    attr_reader :source_data, :builder
+
+    def initialize(paths_builder)
+      @builder = paths_builder
+      @source_data = nil
+      @nested_paths = []
+
+      super([])
+    end
+
+    def reject_from_paths!(from_paths)
+      reject! { |path_context| from_paths.include?(path_context.from.to_s) }
+    end
+
+    def data_wrapper_class
+      @data_wrapper_class || DefaultDataWrapper
+    end
+
+    def nested_paths
+      @nested_paths.reject { |p| p.blank? || ROOT_PATHS.include?(p) }
+    end
+
+    def within(json_path)
+      @nested_paths.push(json_path)
+      yield builder
+      @nested_paths.pop
+    end
+
+    def add_path(path, paths_builder,
+                 iterable_data:,
+                 transform:,
+                 defaults:,
+                 fallback_proc:,
+                 skip_if_proc:,
+                 to: nil,
+                 use_builder: true)
+      push(PathContext.new(path, paths_builder,
+                           to: to,
+                           iterable_data: iterable_data,
+                           transform: transform,
+                           use_builder: use_builder,
+                           defaults: defaults,
+                           fallback_proc: fallback_proc,
+                           skip_if_proc: skip_if_proc))
+      self
+    end
+
+    def with_source_data(data)
+      @source_data = data
+
+      each { |path| path.with_source_data(data) }
+      self
+    end
+
+    def with_wrapped_data_class(klass)
+      @data_wrapper_class = klass
+    end
+  end
+  # rubocop:enable Metrics/ParameterLists
+end

data/lib/json-path/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JsonPathBuilder
+  VERSION = "0.1.0"
+end

data/lib/json_path.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rordash'
+
+%w[
+  version
+  default_data_wrapper
+  path_context
+  path_context_collection
+  builder
+].each do |filename|
+  require File.expand_path("../json-path/#{filename}", Pathname.new(__FILE__).realpath)
+end
+
+module JsonPath; end

data/sig/json_path_builder.rbs

@@ -0,0 +1,4 @@
+module JsonPathBuilder
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/spec/coverage_helper.rb

@@ -0,0 +1,12 @@
+if ENV['RUN_COVERAGE_REPORT']
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter 'vendor/'
+    add_filter %r{^/spec/}
+  end
+  SimpleCov.minimum_coverage_by_file 90
+
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end