array_collection 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1b8d9912e71cb9bf842e79331cb5019bc5df52a6f520434cc693d9a23fe3309
-  data.tar.gz: 1a34a7d6fc2cae2fac86f4951f9c7f11df31e7c97982af29231ff541b413a2dd
+  metadata.gz: ef33c3e653a6e11b9d4c92b2524b71f772cdb1e49399ab6d9da1138af9d08612
+  data.tar.gz: 4c029f0f9e11c739b26737bb7db34573221c377e76958b872a3813f87dab7810
 SHA512:
-  metadata.gz: 651ee3fe050356295b805b8aaeb2264b83fc169ec8cac23ae7a65db8a84f35263885bf869fe87a2b8825d0e8216501dbe5c2484c844528215028ac3573ca914a
-  data.tar.gz: 7bde4d6ea23ad092d88d6617c5552c2a98c2bddfc1daf67d6c3f89ffe1fe8c0751b3cc78eac0b5e200225bdc90c2e17ddadf249b47fec1b478619e153611bb47
+  metadata.gz: d6b3624550f8f9e00ddffcf950b198fe4f7bfc4c544ae258d9d4c2da1eac0a3ecfe4f09b05cbeff050b047d25d9ab2449926473417ceb63bd4a79aa762ac0d6f
+  data.tar.gz: 89011dea94eb965e5cdcadb013b92a388b5f3ed5a3fcd459c2bfc28a24a5cfef3c1af34099d92b3fca20511b379e99789bb4ea40e2afd59a3baea6b556fac1d9

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [0.3.1](https://github.com/WailanTirajoh/ruby_collection/compare/v0.3.0...v0.3.1) (2024-03-31)
+
+
+### Bug Fixes
+
+* **lint:** use described_class ([afba961](https://github.com/WailanTirajoh/ruby_collection/commit/afba961936538978109642db7c582a5746bbd5ea))
+
+
+### Features
+
+* **contional:** #unless ([#12](https://github.com/WailanTirajoh/ruby_collection/issues/12)) ([5d141b3](https://github.com/WailanTirajoh/ruby_collection/commit/5d141b3aa05eef1d5649ae1cd3aae14215ec5e17))
+* **join:** cross join ([#14](https://github.com/WailanTirajoh/ruby_collection/issues/14)) ([9657d6b](https://github.com/WailanTirajoh/ruby_collection/commit/9657d6bab25af6d00b329bc6d72bc0b560846b5a))
+* **json:** allow string keys as input ([#10](https://github.com/WailanTirajoh/ruby_collection/issues/10)) ([4b47b1d](https://github.com/WailanTirajoh/ruby_collection/commit/4b47b1de2b5f3a7f0d35186321ecaa8adc4048bb))
+
+
+
 # [0.3.0](https://github.com/WailanTirajoh/ruby_collection/compare/v0.2.8...v0.3.0) (2024-03-29)
 
 

data/lib/array_collection/array_components/data_handling.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ArrayCollection
+  module ArrayComponents
+    module DataHandling # rubocop:disable Style/Documentation
+      def wrap(value)
+        return [] if value.nil?
+        return value if value.is_a?(Array)
+
+        [value]
+      end
+
+      def append(array, *elements)
+        array + elements
+      end
+
+      def prepend(array, *elements)
+        elements + array
+      end
+
+      def diff(array1, array2)
+        (array1 - array2) | (array2 - array1)
+      end
+    end
+  end
+end

data/lib/array_collection/array_components/filtering.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ArrayCollection
+  module ArrayComponents
+    module Filtering # rubocop:disable Style/Documentation
+      def filter(array, &block)
+        array.select(&block)
+      end
+
+      def where(array, *args)
+        if args.size == 2
+          key, value = args
+          array.select { |item| item[key] == value }
+        elsif args.size == 3
+          key, operator, value = args
+          array.select { |item| ArrayCollection::CollectionFilter.apply_operator(operator, item[key], value) }
+        else
+          raise ArgumentError, "Invalid number of arguments"
+        end
+      end
+
+      def where_not_nil(array)
+        array.compact
+      end
+    end
+  end
+end

data/lib/array_collection/array_components/joining.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "array_collection/collection_filter"
+
+module ArrayCollection
+  module ArrayComponents
+    # Module containing methods for joining arrays
+    module Joining
+      def join(array1, array2, key1, key2)
+        inner_join(array1, array2, key1, key2)
+      end
+
+      def inner_join(array1, array2, key1, key2)
+        array1.reject do |item1|
+          matching_items = array2.select { |item2| item1[key1] == item2[key2] }
+          matching_items.each { |matched_item| item1.merge!(matched_item) }
+          matching_items.empty?
+        end
+      end
+
+      def left_join(array1, array2, key1, key2)
+        return array1 if array2.count.zero?
+
+        right_index = build_index(array2, key2)
+
+        result = []
+        array1.each do |left_item|
+          right_items = right_index[left_item[key1]] || [nil_attributes(array2)]
+          merge_items(result, left_item, right_items)
+        end
+        result
+      end
+
+      def right_join(array1, array2, key1, key2)
+        left_index = build_index(array1, key1)
+
+        result = []
+        array2.each do |right_item|
+          left_items = left_index[right_item[key2]] || [nil_attributes(array1)]
+          merge_items(result, right_item, left_items)
+        end
+        result
+      end
+
+      def full_join(array1, array2, key1, key2)
+        left_join_result = left_join(array1, array2, key1, key2)
+        right_join_result = right_join(array1, array2, key1, key2)
+
+        left_join_result.concat(right_join_result).uniq
+      end
+
+      def full_outter_join(array1, array2, key1, key2)
+        full_join(array1, array2, key1, key2)
+      end
+
+      def cross_join(array1, array2)
+        return cross_join_hashes(array1, array2) if array1.all?(Hash) && array2.all?(Hash)
+
+        array1.product(array2)
+      end
+
+      private
+
+      def cross_join_hashes(array1, array2)
+        array1.flat_map { |hash1| array2.map { |hash2| hash1.merge(hash2) } }
+      end
+
+      def build_index(array, key)
+        array.group_by { |item| item[key] }
+      end
+
+      def merge_items(result, left_item, right_items)
+        right_items.each do |right_item|
+          result << left_item.merge(right_item)
+        end
+      end
+
+      def nil_attributes(array)
+        array.first.keys.each_with_object({}) { |key, hash| hash[key] = nil }
+      end
+    end
+  end
+end

data/lib/array_collection/array_components/key_filtering.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ArrayCollection
+  module ArrayComponents
+    module KeyFiltering # rubocop:disable Style/Documentation
+      def key_by(records, key)
+        records.to_h { |record| [record[key].to_s, yield(record)] }
+      end
+
+      def except(array, *keys)
+        raise ArgumentError, "Empty key list" if keys.empty?
+
+        array.map { |hash| hash.except(*keys) }
+      end
+
+      def only(array, *keys)
+        raise ArgumentError, "Empty key list" if keys.empty?
+
+        array.map { |hash| hash.select { |k, _| keys.include?(k) } }
+      end
+    end
+  end
+end

data/lib/array_collection/array_components/mapping.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ArrayCollection
+  module ArrayComponents
+    module Mapping # rubocop:disable Style/Documentation
+      def map(array, &block)
+        array.map(&block)
+      end
+
+      def map_with_keys(hash, &block)
+        hash.transform_values(&block)
+      end
+    end
+  end
+end

data/lib/array_collection/collect.rb

@@ -2,112 +2,120 @@
 
 require_relative "collection_array"
 require_relative "hooks"
+require_relative "json_parser"
 
 module ArrayCollection
   # Set of chainable collections
-  class Collect
+  class Collect # rubocop:disable Metrics/ClassLength
     extend ArrayCollection::Hooks
 
     def initialize(items)
-      @items = get_arrayable_items(items)
+      parsed_hash = parse(items)
+      @items, @is_json = get_arrayable_items(parsed_hash)
     end
 
     def all
-      @items
+      parse_output(@items)
     end
 
     def count(&block)
       @items.count(&block)
     end
 
-    def uniq
-      self.class.new(@items.uniq)
+    def index_of(value)
+      @items.index(value)
     end
 
-    def filter(&block)
-      self.class.new(ArrayCollection::CollectionArray.filter(@items, &block))
+    def key_by(key, &block)
+      ArrayCollection::CollectionArray.key_by(@items, key.to_sym, &block)
     end
 
-    def where(key, *args)
-      self.class.new(ArrayCollection::CollectionArray.where(@items, key, *args))
+    def when(boolean)
+      return self if boolean == false
+
+      yield(self)
     end
 
-    def where_not_nil
-      self.class.new(ArrayCollection::CollectionArray.where_not_nil(@items))
+    def unless(boolean)
+      return self if boolean == true
+
+      yield(self)
     end
 
-    def index_of(value)
-      @items.index(value)
+    def append(value)
+      clone(ArrayCollection::CollectionArray.append(@items, value))
     end
 
-    def key_by(key, &block)
-      ArrayCollection::CollectionArray.key_by(@items, key, &block)
+    def prepend(value)
+      clone(ArrayCollection::CollectionArray.prepend(@items, value))
     end
 
-    def sort(&block)
-      self.class.new(@items.sort(&block))
+    def diff(items)
+      clone(ArrayCollection::CollectionArray.diff(@items, items))
     end
 
-    def sort_desc(&block)
-      self.class.new(@items.sort(&block).reverse)
+    def filter(&block)
+      clone(ArrayCollection::CollectionArray.filter(@items, &block))
     end
 
-    def sort_by_key(key)
-      self.class.new(@items.sort_by { |item| item[key] })
+    def where(key, *args)
+      clone(ArrayCollection::CollectionArray.where(@items, key, *args))
     end
 
-    def append(value)
-      self.class.new(ArrayCollection::CollectionArray.append(@items, value))
+    def where_not_nil
+      clone(ArrayCollection::CollectionArray.where_not_nil(@items))
     end
 
-    def prepend(value)
-      self.class.new(ArrayCollection::CollectionArray.prepend(@items, value))
+    def uniq
+      clone(@items.uniq)
     end
 
-    def map(&block)
-      self.class.new(ArrayCollection::CollectionArray.map(@items, &block))
+    def only(*keys)
+      clone(ArrayCollection::CollectionArray.only(@items, *keys.map(&:to_sym)))
     end
 
-    def when(boolean)
-      return self if boolean == false
+    def except(*keys)
+      clone(ArrayCollection::CollectionArray.except(@items, *keys.map(&:to_sym)))
+    end
 
-      yield(self)
+    def map(&block)
+      clone(ArrayCollection::CollectionArray.map(@items, &block))
     end
 
-    def only(*keys)
-      self.class.new(ArrayCollection::CollectionArray.only(@items, *keys))
+    def sort(&block)
+      clone(@items.sort(&block))
     end
 
-    def except(*keys)
-      self.class.new(ArrayCollection::CollectionArray.except(@items, *keys))
+    def sort_desc(&block)
+      clone(@items.sort(&block).reverse)
     end
 
-    def diff(items)
-      self.class.new(ArrayCollection::CollectionArray.diff(@items, items))
+    def sort_by_key(key)
+      clone(@items.sort_by { |item| item[key.to_sym] })
     end
 
     def inner_join(items, left_key, right_key)
-      self.class.new(ArrayCollection::CollectionArray.inner_join(@items, get_arrayable_items(items), left_key,
-                                                                 right_key))
+      clone(ArrayCollection::CollectionArray.inner_join(@items, get_arrayable_items(items), left_key, right_key))
     end
 
     def left_join(items, left_key, right_key)
-      self.class.new(ArrayCollection::CollectionArray.left_join(@items, get_arrayable_items(items), left_key,
-                                                                right_key))
+      clone(ArrayCollection::CollectionArray.left_join(@items, get_arrayable_items(items), left_key, right_key))
     end
 
     def right_join(items, left_key, right_key)
-      self.class.new(ArrayCollection::CollectionArray.right_join(@items, get_arrayable_items(items), left_key,
-                                                                 right_key))
+      clone(ArrayCollection::CollectionArray.right_join(@items, get_arrayable_items(items), left_key, right_key))
     end
 
     def full_join(items, left_key, right_key)
-      self.class.new(ArrayCollection::CollectionArray.full_join(@items, get_arrayable_items(items), left_key,
-                                                                right_key))
+      clone(ArrayCollection::CollectionArray.full_join(@items, get_arrayable_items(items), left_key, right_key))
     end
 
     private
 
+    def clone(result)
+      self.class.new(parse_output(result))
+    end
+
     def get_arrayable_items(items)
       case items
       when Array
@@ -123,6 +131,25 @@ module ArrayCollection
       raise ArgumentError, "Input must be an array of hashes" unless @items.all?(Hash)
     end
 
+    def json?
+      @is_json
+    end
+
+    def parse(items)
+      is_json = ArrayCollection::JsonParser.json_like?(items)
+      result = is_json ? ArrayCollection::JsonParser.parse_to_hash(items) : items
+
+      [get_arrayable_items(result), is_json]
+    end
+
+    def parse_output(items)
+      if json?
+        ArrayCollection::JsonParser.parse_to_json(items)
+      else
+        items
+      end
+    end
+
     # Hooks
     before :key_by, :check_hash_item
     before :only, :check_hash_item

data/lib/array_collection/collection_array.rb

@@ -1,136 +1,20 @@
 # frozen_string_literal: true
 
-require_relative "collection_filter"
+require_relative "array_components/filtering"
+require_relative "array_components/mapping"
+require_relative "array_components/data_handling"
+require_relative "array_components/key_filtering"
+require_relative "array_components/joining"
 
 module ArrayCollection
   # Sets of array utilities methods
   class CollectionArray
     class << self
-      def filter(array, &block)
-        array.select(&block)
-      end
-
-      def where(array, *args)
-        if args.size == 2
-          key, value = args
-          array.select { |item| item[key] == value }
-        elsif args.size == 3
-          key, operator, value = args
-          array.select { |item| ArrayCollection::CollectionFilter.apply_operator(operator, item[key], value) }
-        else
-          raise ArgumentError, "Invalid number of arguments"
-        end
-      end
-
-      def where_not_nil(array)
-        array.compact
-      end
-
-      def wrap(value)
-        return [] if value.nil?
-        return value if value.is_a?(Array)
-
-        [value]
-      end
-
-      def append(array, *elements)
-        array + elements
-      end
-
-      def prepend(array, *elements)
-        elements + array
-      end
-
-      def map(array, &block)
-        array.map(&block)
-      end
-
-      def map_with_keys(hash, &block)
-        hash.transform_values(&block)
-      end
-
-      def key_by(records, key)
-        records.to_h { |record| [record[key].to_s, yield(record)] }
-      end
-
-      def except(array, *keys)
-        raise ArgumentError, "Empty key list" if keys.empty?
-
-        array.map { |hash| hash.except(*keys) }
-      end
-
-      def only(array, *keys)
-        raise ArgumentError, "Empty key list" if keys.empty?
-
-        array.map { |hash| hash.select { |k, _| keys.include?(k) } }
-      end
-
-      def diff(array1, array2)
-        (array1 - array2) | (array2 - array1)
-      end
-
-      def join(array1, array2, key1, key2)
-        inner_join(array1, array2, key1, key2)
-      end
-
-      def inner_join(array1, array2, key1, key2)
-        array1.reject do |item1|
-          matching_items = array2.select { |item2| item1[key1] == item2[key2] }
-          matching_items.each { |matched_item| item1.merge!(matched_item) }
-          matching_items.empty?
-        end
-      end
-
-      def left_join(array1, array2, key1, key2)
-        return array1 if array2.count.zero?
-
-        right_index = build_index(array2, key2)
-
-        result = []
-        array1.each do |left_item|
-          right_items = right_index[left_item[key1]] || [nil_attributes(array2)]
-          merge_items(result, left_item, right_items)
-        end
-        result
-      end
-
-      def right_join(array1, array2, key1, key2)
-        left_index = build_index(array1, key1)
-
-        result = []
-        array2.each do |right_item|
-          left_items = left_index[right_item[key2]] || [nil_attributes(array1)]
-          merge_items(result, right_item, left_items)
-        end
-        result
-      end
-
-      def full_join(array1, array2, key1, key2)
-        left_join_result = left_join(array1, array2, key1, key2)
-        right_join_result = right_join(array1, array2, key1, key2)
-
-        left_join_result.concat(right_join_result).uniq
-      end
-
-      def full_outter_join(array1, array2, key1, key2)
-        full_join(array1, array2, key1, key2)
-      end
-
-      private
-
-      def build_index(array, key)
-        array.group_by { |item| item[key] }
-      end
-
-      def merge_items(result, left_item, right_items)
-        right_items.each do |right_item|
-          result << left_item.merge(right_item)
-        end
-      end
-
-      def nil_attributes(array)
-        array.first.keys.each_with_object({}) { |key, hash| hash[key] = nil }
-      end
+      include ArrayCollection::ArrayComponents::Filtering
+      include ArrayCollection::ArrayComponents::Mapping
+      include ArrayCollection::ArrayComponents::DataHandling
+      include ArrayCollection::ArrayComponents::KeyFiltering
+      include ArrayCollection::ArrayComponents::Joining
     end
   end
 end

data/lib/array_collection/json_parser.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ArrayCollection
+  # JSON Parser for collection
+  class JsonParser
+    class << self
+      def json_like?(input)
+        return false if input.nil? || input.count.zero?
+
+        hash = input[0]
+        hash.is_a?(Hash) && hash.keys.all?(String)
+      end
+
+      def parse_to_hash(json_like)
+        json_like.map { |hash| deep_string_to_symbol(hash) }
+      end
+
+      def parse_to_json(hashes)
+        hashes.map { |hash| deep_stringify_keys(hash) }
+      end
+
+      private
+
+      def deep_string_to_symbol(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), result|
+          new_key = key.is_a?(String) ? key.to_sym : key
+          result[new_key] = deep_string_to_symbol(value)
+        end
+      end
+
+      def deep_stringify_keys(hash)
+        hash.each_with_object({}) do |(key, value), result|
+          new_key = key.to_s
+          new_value = value.is_a?(Hash) ? deep_stringify_keys(value) : value
+          result[new_key] = new_value
+        end
+      end
+    end
+  end
+end

data/lib/array_collection/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArrayCollection
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: array_collection
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Wailan Tirajoh
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-03-29 00:00:00.000000000 Z
+date: 2024-03-31 00:00:00.000000000 Z
 dependencies: []
 description: Write a longer description or delete this line.
 email:
@@ -28,12 +28,18 @@ files:
 - Rakefile
 - collection.gemspec
 - lib/array_collection.rb
+- lib/array_collection/array_components/data_handling.rb
+- lib/array_collection/array_components/filtering.rb
+- lib/array_collection/array_components/joining.rb
+- lib/array_collection/array_components/key_filtering.rb
+- lib/array_collection/array_components/mapping.rb
 - lib/array_collection/collect.rb
 - lib/array_collection/collection_array.rb
 - lib/array_collection/collection_filter.rb
 - lib/array_collection/data_accessor.rb
 - lib/array_collection/helper.rb
 - lib/array_collection/hooks.rb
+- lib/array_collection/json_parser.rb
 - lib/array_collection/version.rb
 - package.json
 - sig/collection.rbs