json_data_extractor 0.0.16 → 0.1.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb1e531fd36334345d1fdaf9668b1c03c0a65e8f954605c8d4071734d70f7153
-  data.tar.gz: ee96e0f43442b7c1f7a8ca9b43c61a98ebf4a7067b2fe4daf19d14d32aac4088
+  metadata.gz: '012010608b89947225b392976e3210abca9e88d681fa7378b3539fe13743fd04'
+  data.tar.gz: e1f53a06b1dc6484462933b7251b7b190e739d01679a5d3788c993e5102a9728
 SHA512:
-  metadata.gz: 1e25722f1867eced86d8367f9202f83155363547448876b75ec10c3865f5e6360bbd329fbd3aee7e87cef123324b0b157405b8d36c1ec6af4662309f188d0d85
-  data.tar.gz: 59db96a9ce39007d3bc87bcf242efc07dcf0142f2d997f32c443e86552276abdc29c2c205630944e3023019f446371a041ad334cff92a951fccd3be0c1feeafd
+  metadata.gz: 5bd3b61458071e431776fbbb35f8d6756c32ecd2167c545a0da8479f0ae9dbfa2fe6c8e678219dbda23a5dd03b9ebe8c59aeebac39f9045a4e3ec199ceff6034
+  data.tar.gz: 3d343943e8b028680c22d11e3fc100a45d3b2d1379635f765663c770756eed3f0f59437e615406fc9a9e56f7952dbb8508debffa002d7d5a5a0c8cb1f735571b

data/README.md

@@ -1,7 +1,5 @@
 # JsonDataExtractor
 
-NOTE: This is still a very early beta.
-
 Transform JSON data structures with the help of a simple schema and JsonPath expressions.
 Use the JsonDataExtractor gem to extract and modify data from complex JSON structures using a
 straightforward syntax

data/json_data_extractor.gemspec

@@ -1,6 +1,6 @@
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'src/version'
+require 'json_data_extractor/version'
 
 Gem::Specification.new do |spec|
   spec.name    = 'json_data_extractor'
@@ -31,6 +31,7 @@ transformations. The schema is defined as a simple Ruby hash that maps keys to p
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'amazing_print'
+  spec.add_development_dependency 'rubocop'
 
   spec.add_dependency 'jsonpath'
 end

data/lib/{src → json_data_extractor}/configuration.rb

@@ -1,4 +1,7 @@
-class JsonDataExtractor
+# frozen_string_literal: true
+
+module JsonDataExtractor
+  # handles the settings for JSON data extraction.
   class Configuration
     attr_accessor :strict_modifiers
 
@@ -6,4 +9,4 @@ class JsonDataExtractor
       @strict_modifiers = true
     end
   end
-end
+end

data/lib/json_data_extractor/extractor.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module JsonDataExtractor
+  # does the main job of the gem
+  class Extractor
+    attr_reader :data, :modifiers
+
+    # @param json_data [Hash,String]
+    # @param modifiers [Hash]
+    def initialize(json_data, modifiers = {})
+      @data = json_data.is_a?(Hash) ? json_data.to_json : json_data
+      @modifiers = modifiers.transform_keys(&:to_sym)
+      @results = {}
+    end
+
+    # @param modifier_name [String, Symbol]
+    def add_modifier(modifier_name, &block)
+      modifier_name = modifier_name.to_sym unless modifier_name.is_a?(Symbol)
+      modifiers[modifier_name] = block
+    end
+
+    # @param schema [Hash] schema of the expected data mapping
+    def extract(schema)
+      schema.each do |key, val|
+        element = JsonDataExtractor::SchemaElement.new(val.is_a?(Hash) ? val : { path: val })
+
+        extracted_data = JsonPath.on(@data, element.path) if element.path
+
+        if extracted_data.nil? || extracted_data.empty?
+          # we either got nothing or the `path` was initially nil
+          @results[key] = element.fetch_default_value
+          next
+        end
+
+        # check for nils and apply defaults if applicable
+        extracted_data.map! { |item| item.nil? ? element.fetch_default_value : item }
+
+        # apply modifiers if present
+        extracted_data = apply_modifiers(extracted_data, element.modifiers) if element.modifiers.any?
+
+        # apply maps if present
+        @results[key] = element.maps.any? ? apply_maps(extracted_data, element.maps) : extracted_data
+
+        @results[key] = resolve_result_structure(@results[key], element)
+      end
+
+      @results
+    end
+
+    private
+
+    def resolve_result_structure(result, element)
+      if element.nested
+        # Process nested data
+        result = extract_nested_data(result, element.nested)
+        return element.array_type ? result : result.first
+      end
+
+      # Handle single-item extraction if not explicitly an array type or having multiple items
+      return result.first if result.size == 1 && !element.array_type
+
+      # Default case: simply return the result, assuming it's correctly formed
+      result
+    end
+
+    def extract_nested_data(data, schema)
+      Array(data).map do |item|
+        self.class.new(item, modifiers).extract(schema)
+      end
+    end
+
+    def apply_maps(data, maps)
+      data.map do |value|
+        maps.reduce(value) { |mapped_value, map| map[mapped_value] }
+      end
+    end
+
+    def apply_modifiers(data, modifiers)
+      data.map do |value|
+        modifiers.reduce(value) do |modified_value, modifier|
+          apply_single_modifier(modifier, modified_value)
+        end
+      end
+    end
+
+    def apply_single_modifier(modifier, value)
+      return modifier.call(value) if modifier.respond_to?(:call)
+      return modifiers[modifier].call(value) if modifiers.key?(modifier)
+      return value.public_send(modifier) if value.respond_to?(modifier)
+
+      if JsonDataExtractor.configuration.strict_modifiers
+        raise ArgumentError, "Modifier: <:#{modifier}> cannot be applied to value <#{value.inspect}>"
+      end
+
+      value
+    end
+  end
+end

data/lib/json_data_extractor/schema_element.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module JsonDataExtractor
+  # parses the input schema element
+  class SchemaElement
+    attr_reader :path, :default_value, :maps, :modifiers, :array_type, :nested
+
+    def initialize(schema_definition)
+      validate_schema_definition(schema_definition)
+
+      @path = schema_definition[:path] if schema_definition.key?(:path)
+      @default_value = schema_definition[:default]
+      @maps = fetch_maps(schema_definition[:maps] || schema_definition[:map])
+      @modifiers = fetch_modifiers(schema_definition[:modifiers] || schema_definition[:modifier])
+      @array_type = schema_definition[:type] == 'array'
+      @nested = schema_definition[:schema]
+    end
+
+    def fetch_default_value
+      @default_value.respond_to?(:call) ? @default_value.call : @default_value
+    end
+
+    private
+
+    def validate_schema_definition(schema_definition)
+      raise ArgumentError, 'Schema definition must be a Hash' unless schema_definition.is_a?(Hash)
+      raise ArgumentError, 'Schema definition must not be empty' if schema_definition.empty?
+
+      schema_definition.transform_keys!(&:to_sym)
+
+      return if schema_definition.key?(:path) || schema_definition.key?(:default)
+
+      raise ArgumentError, 'Either path or default_value must be present in schema definition'
+    end
+
+    def fetch_maps(map_value)
+      Array([map_value]).flatten.compact.map do |map|
+        raise ArgumentError, "Invalid map: #{map.inspect}" unless map.is_a?(Hash)
+
+        map
+      end
+    end
+
+    def fetch_modifiers(modifier_value)
+      Array(modifier_value).map do |mod|
+        case mod
+        when Symbol, Proc; then mod
+        when Class; then validate_modifier_class(mod)
+        when String; then mod.to_sym
+        else
+          raise ArgumentError, "Invalid modifier: #{mod.inspect}"
+        end
+      end
+    end
+
+    def validate_modifier_class(mod)
+      raise ArgumentError, "Modifier class must respond to call: #{mod.inspect}" unless mod.respond_to?(:call)
+
+      mod
+    end
+  end
+end

data/lib/json_data_extractor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JsonDataExtractor
+  VERSION = '0.1.01'
+end

data/lib/json_data_extractor.rb

@@ -1,128 +1,21 @@
-require 'src/version'
-require 'src/configuration'
-require 'jsonpath'
-
-class JsonDataExtractor
-  attr_reader :data, :modifiers
-
-  def initialize(json_data, modifiers = {})
-    @data      = json_data.is_a?(Hash) ? json_data.to_json : json_data # hopefully it's a string; maybe we'll add some validation here
-    @modifiers = modifiers.transform_keys(&:to_sym) # todo address this later
-  end
-
-  # @param modifier_name [String, Symbol]
-  def add_modifier(modifier_name, &block)
-    modifier_name            = modifier_name.to_sym unless modifier_name.is_a?(Symbol)
-    modifiers[modifier_name] = block
-  end
-
-  # @param schema [Hash] schema of the expected data mapping
-  def extract(schema)
-    results = {}
-    schema.each do |key, val|
-      default_value = nil
-      if val.is_a?(Hash)
-        val.transform_keys!(&:to_sym)
-        path       = val[:path]
-        default_value = val[:default]
-        maps       = Array([val[:maps] || val[:map]]).flatten.compact.map do |map|
-          if map.is_a?(Hash)
-            map
-          else
-            raise ArgumentError, "Invalid map: #{map.inspect}"
-          end
-        end
-        modifiers  = Array(val[:modifiers] || val[:modifier]).map do |mod|
-          case mod
-          when Symbol, Proc
-            mod
-          when Class
-            if mod.respond_to?(:call)
-              mod
-            else
-              raise ArgumentError, "Modifier class must respond to call: #{mod.inspect}"
-            end
-          when String
-            mod.to_sym
-          else
-            raise ArgumentError, "Invalid modifier: #{mod.inspect}"
-          end
-        end
-        array_type = 'array' == val[:type]
-        nested     = val.dup.delete(:schema)
-      else
-        path      = val
-        modifiers = []
-        maps      = []
-      end
-
-      extracted_data = JsonPath.on(@data, path) if path
-
-      if extracted_data.nil? || extracted_data.empty?
-        results[key] = default_value.is_a?(Proc) ? default_value.call : (default_value || nil)
-      else
-        extracted_data.map! { |val| val.nil? ? default_value : val }
-        transformed_data = apply_modifiers(extracted_data, modifiers)
-        results[key]     = apply_maps(transformed_data, maps)
-
-        if array_type && nested
-          results[key] = extract_nested_data(results[key], nested)
-        elsif !array_type && nested
-          results[key] = extract_nested_data(results[key], nested).first
-        elsif !array_type && 1 < results[key].size
-          # TODO: handle case where results[key] has more than one item
-          # do nothing for now
-        elsif array_type && !nested
-          # do nothing, it is already an array
-        else
-          results[key] = results[key].first
-        end
-      end
-    end
-    results
-  end
-
-  private
+# frozen_string_literal: true
 
-  def extract_nested_data(data, schema)
-    Array(data).map do |item|
-      self.class.new(item, modifiers).extract(schema)
-    end
-  end
-
-  def apply_maps(data, maps)
-    data.map do |value|
-      mapped_value = value
-      maps.each { |map| mapped_value = map[mapped_value] }
-      mapped_value
-    end
-  end
-
-  def apply_modifiers(data, modifiers)
-    data.map do |value|
-      modified_value = value
-      modifiers.each do |modifier|
-        modified_value = apply_single_modifier(modifier, modified_value)
-      end
-      modified_value
-    end
-  end
-
-  def apply_single_modifier(modifier, value)
-    if modifier.respond_to?(:call) # Matches Proc, Lambda, Method, and callable objects
-      modifier.call(value)
-    elsif modifiers.key?(modifier)
-      modifiers[modifier].call(value)
-    elsif value.respond_to?(modifier)
-      value.send(modifier)
-    elsif self.class.configuration.strict_modifiers
-      raise ArgumentError, "Modifier: <:#{modifier}> cannot be applied to value <#{value.inspect}>"
-    else
-      value
+require 'jsonpath'
+require_relative 'json_data_extractor/version'
+require_relative 'json_data_extractor/configuration'
+require_relative 'json_data_extractor/extractor'
+require_relative 'json_data_extractor/schema_element'
+
+# Transform JSON data structures with the help of a simple schema and JsonPath expressions.
+# Use the JsonDataExtractor gem to extract and modify data from complex JSON structures using a straightforward syntax
+# and a range of built-in or custom modifiers.
+module JsonDataExtractor
+  class << self
+    # Backward compatibility
+    def new(*args)
+      Extractor.new(*args)
     end
-  end
 
-  class << self
     def configuration
       @configuration ||= Configuration.new
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json_data_extractor
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.1.01
 platform: ruby
 authors:
 - Max Buslaev
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: jsonpath
   requirement: !ruby/object:Gem::Requirement
@@ -116,8 +130,10 @@ files:
 - bin/setup
 - json_data_extractor.gemspec
 - lib/json_data_extractor.rb
-- lib/src/configuration.rb
-- lib/src/version.rb
+- lib/json_data_extractor/configuration.rb
+- lib/json_data_extractor/extractor.rb
+- lib/json_data_extractor/schema_element.rb
+- lib/json_data_extractor/version.rb
 homepage: https://github.com/austerlitz/json_data_extractor
 licenses:
 - MIT

data/lib/src/version.rb

@@ -1,3 +0,0 @@
-class JsonDataExtractor
-  VERSION = '0.0.16'
-end