run_length_encoding_rb 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79d5976a4c25210fa4e2ac722b4d25f8e8d69d28527cad8ac38965f35aa97026
-  data.tar.gz: 8b5547077da37fb7ba5870b37783b1d30ae2eb0d6fa949bb0bd1d82e38b0dd0b
+  metadata.gz: 58c5fa25ae5085cbc17f1107dcf7df5c7ac13014613df72bb9c235fbadb56a22
+  data.tar.gz: c4406fd2bccb4b6942764cc8baa581c9bcbfad7b6d54562afbaac6a88b652f6a
 SHA512:
-  metadata.gz: 9343ec73fa5899b7af382825918bac63e2357a15f05707750a22061d85f7b3a62a54070e5bc4114c0cdc1d7d0da7c764ce525de5162405cc6f46ca02ef3eac29
-  data.tar.gz: e5f1be41e8af7f2528b542a623a134983a447a4b0ff9dadf411951c83f917458f633f2b92f6958f1e0f34a6803cc47b21be1d78539d214189b39aa4af069ace0
+  metadata.gz: 3c5fd9a1be1c71c03d7c2b50a68469f76240acb5997d26d0700f5eb23e8f159f413609ced27abe1b7522c3dd2368bb699ee75980891efb150ca1d64cc8132da4
+  data.tar.gz: d7c3e0783c080bd4d1d8df55c5bc305d17fd233281d1694feb30b88aebe29538f95068a575e828d50a48a9780853b60946355575383f2b990fe2aa9d77c3d534

data/.rubocop.yml

@@ -1,3 +1,6 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
 Style/StringLiterals:
   Enabled: true
   EnforcedStyle: double_quotes
@@ -10,4 +13,4 @@ Layout/LineLength:
   Max: 120
 
 Metrics/MethodLength:
-  Max: 25
+  Max: 10

data/CHANGELOG.md

@@ -1,16 +1,3 @@
-### 0.2.1 / 2023-01-25
+### 1.0.0 / 2023-10-21
 
-* Updated docs.
-
-### 0.2.0 / 2023-01-25
-
-* Improvements:
-  * Decoding is implemented now;
-  * Code was refactored;
-  * Changed gem's name to pass RubyGems.org name filter;
-  * Now gem is available at RubyGems.org.
-
-### 0.1.0 / 2022-12-15
-
-* Initial release:
-  * Only encoding is implemented yet.
+* New API, code refactoring, bug fixes, tests.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    run_length_encoding_rb (0.2.0)
+    run_length_encoding_rb (0.2.1)
 
 GEM
   remote: https://rubygems.org/
@@ -37,4 +37,4 @@ DEPENDENCIES
   run_length_encoding_rb!
 
 BUNDLED WITH
-   2.2.3
+   2.4.19

data/README.md

@@ -1,13 +1,15 @@
+# run_length_encoding_rb [![Gem Version](https://badge.fury.io/rb/run_length_encoding_rb.svg)](https://badge.fury.io/rb/run_length_encoding_rb)
+
 ## Description
 
-A simple gem that does run-length encoding.
+Run-length encoding for Ruby.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add this line to your application"s Gemfile:
 
 ```ruby
-gem 'run_length_encoding_rb'
+gem "run_length_encoding_rb"
 ```
 
 And then execute:
@@ -22,7 +24,7 @@ Or install it yourself as:
 
 ### Encoding
 
-obj.encode(data [, separator]) -> array
+RunLengthEncodingRb.encode(data [, separator]) -> array
 
 #### Arguments
 
@@ -35,44 +37,37 @@ obj.encode(data [, separator]) -> array
 
 + _separator_
 
-    A String or Regexp to split the string into single elements. Used only if _data_ is a String.
+    A String or Regexp to split the _data_ string into single elements. Used only if _data_ is a String.
 
 #### Returns
 
-+ _Array<Hash{:chunk => Object, :count => Integer}>_
++ _Array\<RunLengthEncodingRb::RLEElement\>_
 
-    Encoded data in the following format:
-    Array<Hash{:chunk => Object, :count => Integer}>, where:
-    - :chunk => Object: a repeated element;
-    - :count => Integer: how many times the element is repeated.
+    Encoded data. Each element is a RunLengthEncodingRb::RLEElement object with the attributes #chunk (the repeated element) and #run_length (how many times the element is repeated).
 
 ### Encoding examples
 
 ```ruby
-require 'run_length_encoding'
+require "run_length_encoding_rb"
 
-rle = RunLengthEncoding.new
+RLE = RunLengthEncodingRb
 
 # Encode an array:
 a = %w[foo foo bar foo foo foo]
+RLE.encode(a)
 
-rle.encode(a)
-# => [{:chunk=>"foo", :count=>2}, {:chunk=>"bar", :count=>1}, {:chunk=>"foo", :count=>3}]
-
-# Encode a string with a default separator (each character is treated as a single element):
-str = 'foo'
-rle.encode(str)
-# => [{:chunk=>"f", :count=>1}, {:chunk=>"o", :count=>2}]
+# Encode a string with a default separator (each character 
+# will be treated as a single element):
+str = "foo"
+RLE.encode(str)
 
-# Encode a string with a custom separator:
-str = 'foo_foo_bar'
-rle.encode(str, '_')
-# => [{:chunk=>"foo", :count=>2}, {:chunk=>"bar", :count=>1}]
+# Encode a string with a explicit separator:
+str = "foo_foo_bar"
+RLE.encode(str, "_")
 
 # Encode an enumerator:
-str = 'foo'
-rle.encode(str.each_byte)
-# => [{:chunk=>102, :count=>1}, {:chunk=>111, :count=>2}]
+str = "foo"
+RLE.encode(str.each_byte)
 ```
 
 ### Decoding
@@ -83,35 +78,29 @@ obj.decode(data) -> array
 
 + _data_
 
-    Data to decode in the following format:
-    Array<Hash{:chunk => Object, :count => Integer}>, where:
-    - :chunk => Object: a repeated element;
-    + :count => Integer: how many times the element is repeated.
+    Array of RunLengthEncodingRb::RLEElement (or any duck-typed objects, which have the obj#chunk and obj#run_length attributes).
 
 #### Returns
 
-Array<Object>
++ Array\<Object\>
 
-Decoded data.
-<!-- -->
+    Decoded data.
 
 ### Decoding example
 
 ```ruby
-require 'run_length_encoding'
+require "run_length_encoding_rb"
 
-rle = RunLengthEncoding.new
+RLE = RunLengthEncodingRb
 
-# Decode data of mixed types:
 data = [
-  { count: 3, chunk: "foo" },
-  { count: 1, chunk: "bar" },
-  { count: 2, chunk: nil },
-  { count: 4, chunk: 1 }
+  RunLengthEncodingRb::RLEElement.new(chunk: "foo", run_length: 3),
+  RunLengthEncodingRb::RLEElement.new(chunk: "bar", run_length: 1),
+  RunLengthEncodingRb::RLEElement.new(chunk: nil, run_length: 2),
 ]
 
-rle.decode(data)
-# => ["foo", "foo", "foo", "bar", nil, nil, 1, 1, 1, 1]
+RLE.decode(data)
+# => ["foo", "foo", "foo", "bar", nil, nil]
 ```
 
 ## Development

data/lib/run_length_encoding_rb/decoder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "decoder_mixin"
+
+module RunLengthEncodingRb
+  #
+  # Decode run-length encoded data.
+  #
+  class Decoder
+    include DecoderMixin
+
+    #
+    # Decode data.
+    #
+    # @param [Array<::RLEElement, #chunk, #run_length>] data
+    #   Data to decode.
+    #
+    # @return [Array<Object>]
+    #   Decoded data.
+    #
+    def decode(data)
+      _raise_on_unsupported_type(data.class) unless data.is_a?(Array)
+
+      _decode(data)
+    end
+
+    private
+
+    #
+    # @param [Array<::RLEElement, #chunk, #run_length>] data
+    #
+    # @return [Array]
+    #
+    def _decode(data)
+      decoded_data = []
+
+      data.each do |e|
+        # @todo: catch and try to fix an exception,
+        # e.g.: ignore the element, etc.
+        _inspect_element(e)
+
+        e.run_length.times { decoded_data.append(e.chunk) }
+      end
+
+      decoded_data
+    end
+
+    #
+    # Raise an error to notify that data isn't an array.
+    #
+    # @param [Class] klass
+    #
+    # @raise [::TypeError]
+    #
+    def _raise_on_unsupported_type(klass)
+      raise(
+        RunLengthEncodingRb::TypeError,
+        "wrong argument type #{klass} (expected Array)"
+      )
+    end
+  end
+end

data/lib/run_length_encoding_rb/decoder_mixin.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module RunLengthEncodingRb
+  #
+  # Provides methods to validate #decode input data.
+  #
+  module DecoderMixin
+    EXPECTED_ATTRIBUTES = %w[run_length chunk].freeze
+
+    private
+
+    #
+    # Ensure that the obj complies with the following requirements:
+    # 1. has instant variables:
+    #   - obj.chunk;
+    #   - obj.run_length;
+    # 2. instant variables are accessible (i.e. has the attr_reader
+    #    or the attr_accessor);
+    # 3. obj.run_length is an Integer;
+    # 4. obj.run_length is a positive Integer.
+    #
+    # @param [Object] obj
+    #   Object to inspect.
+    #
+    def _inspect_element(obj)
+      attrs_defined_status = _get_attrs_defined_status(obj, EXPECTED_ATTRIBUTES)
+      attrs_access_status = _get_attr_accessibility_status(obj, EXPECTED_ATTRIBUTES)
+
+      _ensure_element_has_defined_attrs(obj, attrs_defined_status)
+      _ensure_element_has_accessible_attrs(obj, attrs_access_status)
+      _ensure_length_int(obj)
+      _ensure_length_non_negative(obj)
+    end
+
+    #
+    # Ensure that element has defined attributes.
+    #
+    # @param [Object] obj
+    #
+    # @param [Hash{ String => Boolean }] attrs_status
+    #
+    # @raise [::AttrMissingError]
+    #
+    def _ensure_element_has_defined_attrs(obj, attrs_status)
+      return if _all_pass?(attrs_status.values)
+
+      raise(
+        RunLengthEncodingRb::AttrMissingError,
+        "the element #{obj} doesn't have the attribute(s): " \
+        "#{_get_bad_attributes(attrs_status).join(", ")}"
+      )
+    end
+
+    #
+    # Ensure that element has accessible attributes.
+    #
+    # @param [Object] obj
+    #
+    # @param [Hash{ String => Boolean }] attrs_status
+    #
+    # @raise [::AttrInaccessibleError]
+    #
+    def _ensure_element_has_accessible_attrs(obj, attrs_status)
+      return if _all_pass?(attrs_status.values)
+
+      raise(
+        RunLengthEncodingRb::AttrInaccessibleError,
+        "in the element #{obj}, the following attribute(s) are inaccessible: " \
+        "#{_get_bad_attributes(attrs_status).join(", ")} (attr_reader/attr_accessor is missing?)"
+      )
+    end
+
+    #
+    # Return an array of the attribute names that are
+    # missing or inaccessible.
+    #
+    # @param [Hash{ String => Boolean }] hash
+    #
+    # @return [Array<String>]
+    #
+    def _get_bad_attributes(hash)
+      hash.select { |_k, v| v == false }.keys
+    end
+
+    #
+    # @param [Array<Boolean>] array
+    #
+    # @return [Boolean]
+    #
+    def _all_pass?(array)
+      array.all? { |e| e == true }
+    end
+
+    #
+    # Return the array of missing attributes.
+    #
+    # @param [Array<Boolean>] attr_accessibility
+    #   Attributes accessability.
+    #
+    # @param [Array<String>] attrs_arr
+    #
+    # @return [Array<String>]
+    #   Array of attributes that are not accessable.
+    #
+    def _missing_attributes(attr_accessibility, attrs_arr)
+      (
+        Hash[
+          attrs_arr.zip(attr_accessibility)
+        ].delete_if { |_k, v| v == true }
+      ).keys
+    end
+
+    #
+    # For the object 'obj', get attribute presence status for
+    # each attribute name from the 'attrs_arr'.
+    #
+    # @param [Object] obj
+    #   Object to inspect.
+    #
+    # @param [Array<String>] attrs_arr
+    #   Array of attribute names.
+    #
+    # @return [Hash{ String => Boolean }]
+    #
+    def _get_attrs_defined_status(obj, attrs_arr)
+      _get_attr_status(obj, attrs_arr) do |obj_to_check, attr_name|
+        obj_to_check.instance_variable_defined?("@#{attr_name}")
+      end
+    end
+
+    #
+    # For the object 'obj', get attribute accessibility status for
+    # each attribute from the 'attrs_arr'.
+    #
+    # @param [Object] obj
+    #   Object to inspect.
+    #
+    # @param [Array<String>] attrs_arr
+    #   Array of attribute names.
+    #
+    # @return [Hash{ String => Boolean }]
+    #
+    def _get_attr_accessibility_status(obj, attrs_arr)
+      _get_attr_status(obj, attrs_arr) do |obj_to_check, attr_name|
+        obj_to_check.respond_to?(attr_name)
+      end
+    end
+
+    #
+    # Abstract method to get statuses (true/false) for the elements
+    # of the 'attrs_arr' input array. The actual check with a boolean
+    # response should be handled by the block.
+    #
+    # @param [Object] obj
+    #
+    # @param [Array<String>] attrs_arr
+    #
+    # @yeld [obj_to_check, attr_name]
+    #   Performs actual check for an element 'e'.
+    #
+    # @yieldparam [Object] obj_to_check
+    #
+    # @yieldparam [String] attr_name
+    #
+    # @yieldreturn [Boolean]
+    #
+    # @return [Hash{ String => Boolean }]
+    #
+    def _get_attr_status(obj, attrs_arr, &_block)
+      statuses_arr = attrs_arr.map { |e| yield(obj, e) }
+      Hash[attrs_arr.zip(statuses_arr)]
+    end
+
+    #
+    # Ensure that run-length attribute of the element is an Integer.
+    #
+    # @param [Object] obj
+    #
+    # @raise [::TypeError]
+    #
+    def _ensure_length_int(obj)
+      return if obj.run_length.is_a?(Integer)
+
+      raise(
+        RunLengthEncodingRb::TypeError,
+        "wrong run-length type: #{obj.run_length.class} (expected Integer)"
+      )
+    end
+
+    #
+    # Ensure that run-length attribute of the element is a non-negative Integer.
+    #
+    # @param [Object] obj
+    #
+    # @raise [::NegativeIntError]
+    #
+    def _ensure_length_non_negative(obj)
+      return if obj.run_length >= 0
+
+      raise(
+        RunLengthEncodingRb::NegativeIntError,
+        "error in #{obj}: run-length should be a non-negative Integer"
+      )
+    end
+  end
+end

data/lib/run_length_encoding_rb/encoder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RunLengthEncodingRb
+  #
+  # Encode data with RLE.
+  #
+  class Encoder
+    #
+    # Encode an array with the run-length encoding.
+    #
+    # @param [Array, String, Enumerator] data
+    #   Data to encode.
+    #
+    # @option [String, Regexp] separator ("")
+    #   Separator for the String-typed data.
+    #
+    # @return [Array<::RLEElement>]
+    #   Encoded data.
+    #
+    def encode(data, separator = "")
+      array = _to_array(data, separator)
+
+      _raise_on_unsupported_type(data.class) unless array
+
+      _encode(array)
+    end
+
+    private
+
+    #
+    # @param [Array] data
+    #   Data to encode.
+    #
+    # @return [Array<::RLEElement>]
+    #   Encoded data.
+    #
+    def _encode(data)
+      result = []
+
+      data.each.inject([]) do |memo, element|
+        if memo.last && element == memo.last.last
+          memo.last[0] += 1
+        else
+          memo << [1, element]
+        end
+        result = memo
+      end
+      result.map { |run_length, chunk| RLEElement.new(chunk: chunk, run_length: run_length) }
+    end
+
+    #
+    # Raise an error to notify that input data isn't an array
+    # and can't be converted to an array.
+    #
+    # @param [Class] klass
+    #
+    # @raise [::TypeError]
+    #
+    def _raise_on_unsupported_type(klass)
+      raise(
+        RunLengthEncodingRb::TypeError,
+        "wrong argument type #{klass} (expected Array, String or Enumerator)"
+      )
+    end
+
+    #
+    # Return an array representation of an input data.
+    #
+    # @param [Object] data
+    #
+    # @option [String, Regexp]
+    #
+    # @return [Array, nil] data
+    #   nil indicates that input data cannot be converted to an array.
+    #
+    def _to_array(data, separator)
+      case data
+      when Array
+        return data
+      when String
+        return data.split(separator)
+      when Enumerator
+        return data.to_a
+      end
+
+      nil
+    end
+  end
+end

data/lib/run_length_encoding_rb/error/attr_inaccessible_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RunLengthEncodingRb
+  #
+  # Raises if an element has inaccessible attribute
+  # (misses attr_reader or attr_accessor).
+  #
+  class AttrInaccessibleError < Error
+    attr_reader :message
+
+    def initialize(message = "")
+      super(message)
+    end
+  end
+end

data/lib/run_length_encoding_rb/error/attr_missing_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RunLengthEncodingRb
+  #
+  # Raises if an element lacks attribute.
+  #
+  class AttrMissingError < Error
+    attr_reader :message
+
+    def initialize(message = "")
+      super(message)
+    end
+  end
+end

data/lib/run_length_encoding_rb/error/negative_int_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RunLengthEncodingRb
+  #
+  # Raises if run-length is negative.
+  #
+  class NegativeIntError < Error
+    attr_reader :message
+
+    def initialize(message = "")
+      super(message)
+    end
+  end
+end

data/lib/run_length_encoding_rb/error/type_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RunLengthEncodingRb
+  #
+  # Raises on incorrect data type.
+  #
+  class TypeError < Error
+    attr_reader :message
+
+    def initialize(message = "")
+      super(message)
+    end
+  end
+end

data/lib/run_length_encoding_rb/error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RunLengthEncodingRb
+  #
+  # Base class.
+  #
+  class Error < ::StandardError
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+      super()
+    end
+  end
+end

data/lib/run_length_encoding_rb/rle_element.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RunLengthEncodingRb
+  #
+  # Stores an run-length encoded element.
+  #
+  class RLEElement
+    attr_accessor :chunk, :run_length
+
+    def initialize(chunk:, run_length:)
+      @chunk = chunk
+      @run_length = run_length
+    end
+  end
+end

data/lib/run_length_encoding_rb/version.rb

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

data/lib/run_length_encoding_rb.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "run_length_encoding_rb/decoder"
+require_relative "run_length_encoding_rb/encoder"
+require_relative "run_length_encoding_rb/error"
+require_relative "run_length_encoding_rb/error/attr_inaccessible_error"
+require_relative "run_length_encoding_rb/error/attr_missing_error"
+require_relative "run_length_encoding_rb/error/negative_int_error"
+require_relative "run_length_encoding_rb/error/type_error"
+require_relative "run_length_encoding_rb/rle_element"
+require_relative "run_length_encoding_rb/version"
+
+#
+# Run-length encoding/decoding.
+#
+module RunLengthEncodingRb
+  #
+  # Encode data.
+  #
+  # @param [Array, String, Enumerator] data
+  #   Data to encode.
+  #
+  # @option [String, Regexp] separator ("")
+  #   Separator for the String-typed data.
+  #
+  # @return [Array<::RLEElement>]
+  #   Encoded data.
+  #
+  def self.encode(data, separator = "")
+    encoder = Encoder.new
+    encoder.encode(data, separator)
+  end
+
+  #
+  # Decode data.
+  #
+  # @param [Array<::RLEElement, #chunk, #run_length>] data
+  #   Data to decode.
+  #
+  # @return [Array<Object>]
+  #   Decoded data.
+  #
+  def self.decode(data)
+    decoder = Decoder.new
+    decoder.decode(data)
+  end
+end

data/run_length_encoding.gemspec

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "lib/run_length_encoding/version"
+require_relative "lib/run_length_encoding_rb/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "run_length_encoding_rb"
-  spec.version       = RunLengthEncoding::VERSION
+  spec.version       = RunLengthEncodingRb::VERSION
   spec.authors       = ["8bit-mate"]
 
   spec.summary       = "Run-length encoding/decoding."
   spec.homepage      = "https://github.com/8bit-mate/run_length_encoding.rb"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org/"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: run_length_encoding_rb
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - 8bit-mate
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-24 00:00:00.000000000 Z
+date: 2023-10-21 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: 
@@ -26,12 +26,17 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- lib/run_length_encoding.rb
-- lib/run_length_encoding/constants.rb
-- lib/run_length_encoding/decoder.rb
-- lib/run_length_encoding/decoding_element_check.rb
-- lib/run_length_encoding/encoder.rb
-- lib/run_length_encoding/version.rb
+- lib/run_length_encoding_rb.rb
+- lib/run_length_encoding_rb/decoder.rb
+- lib/run_length_encoding_rb/decoder_mixin.rb
+- lib/run_length_encoding_rb/encoder.rb
+- lib/run_length_encoding_rb/error.rb
+- lib/run_length_encoding_rb/error/attr_inaccessible_error.rb
+- lib/run_length_encoding_rb/error/attr_missing_error.rb
+- lib/run_length_encoding_rb/error/negative_int_error.rb
+- lib/run_length_encoding_rb/error/type_error.rb
+- lib/run_length_encoding_rb/rle_element.rb
+- lib/run_length_encoding_rb/version.rb
 - run_length_encoding.gemspec
 homepage: https://github.com/8bit-mate/run_length_encoding.rb
 licenses:
@@ -49,14 +54,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: Run-length encoding/decoding.

data/lib/run_length_encoding/constants.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Constants
-  CHUNK_KEY = :chunk
-  COUNT_KEY = :count
-end

data/lib/run_length_encoding/decoder.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "decoding_element_check"
-require_relative "constants"
-
-#
-# Decode run-length encoded data.
-#
-module Decoder
-  include Constants
-  include DecodingElementCheck
-
-  #
-  # Pass data to the decoder.
-  #
-  # @param [Array<Hash{ Symbol => Object }>] data
-  #
-  # @return [Array]
-  #
-  # @raise [ArgumentError, TypeError]
-  #   Raises if data isn't an Array [TypeError] or an empty Array [ArgumentError].
-  #
-  def decode(data)
-    ex_details = _check_dec_data(data)
-
-    raise(ex_details[:ex_type], ex_details[:ex_msg]) if ex_details
-
-    _decode(data)
-  end
-
-  private
-
-  def _check_dec_data(data)
-    case data
-    when Array
-      if data.to_a.empty?
-        {
-          ex_type: ArgumentError,
-          ex_msg: "the given data is empty (no data to decode)"
-        }
-      end
-    else
-      {
-        ex_type: TypeError,
-        ex_msg: "wrong argument type #{data.class} (expected Array)"
-      }
-    end
-  end
-
-  #
-  # Decode data.
-  #
-  # @param [Array<Hash{ Symbol => Object }>] data
-  #
-  # @return [Array]
-  #
-  # @raise [ArgumentError, TypeError]
-  #
-  def _decode(data)
-    decoded_data = []
-
-    data.each do |hash|
-      check_result = _valid_hash?(hash)
-      raise(check_result[:ex_type], check_result[:ex_msg]) unless check_result[:comply]
-
-      hash[COUNT_KEY].times { decoded_data.append(hash[CHUNK_KEY]) }
-    end
-
-    decoded_data
-  end
-end

data/lib/run_length_encoding/decoding_element_check.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "constants"
-
-#
-# Set of checks of a single element to decode.
-#
-module DecodingElementCheck
-  include Constants
-
-  private
-
-  #
-  # Check if element obj complies with the following requirements:
-  # 1. is a hash;
-  # 2. has keys:
-  #   - Constants::CHUNK_KEY (repeating element),
-  #   - Constants::COUNT_KEY (how many times element is repeating);
-  # 3. COUNT_KEY's value is an Integer;
-  # 4. COUNT_KEY's value is a positive number.
-  #
-  # @param [Object] obj
-  #   Object to check.
-  #
-  # @return [Hash{ Symbol => Object }] result
-  #   Result of checks.
-  #   If all checks are passed:
-  #     result = { comply: true }
-  #
-  #   If a check is failed, result also contains exception type and exception message:
-  #     result = { comply: false, ex_type: Exception, ex_msg: String }
-  #
-  def _valid_hash?(obj)
-    check_list = [
-      method(:_a_hash?),
-      method(:_valid_keys?),
-      method(:_count_is_integer?),
-      method(:_count_is_positive?)
-    ]
-
-    for method in check_list
-      result = method.call(obj)
-      break unless result[:comply]
-    end
-
-    result
-  end
-
-  # Check if obj is a hash.
-  def _a_hash?(obj)
-    if obj.is_a?(Hash)
-      {
-        comply: true
-      }
-    else
-      {
-        ex_type: TypeError,
-        ex_msg: "wrong argument type #{obj.class} (expected Hash)",
-        comply: false
-      }
-    end
-  end
-
-  # Check if hash has valid keys.
-  def _valid_keys?(hash)
-    if hash.key?(CHUNK_KEY) && hash.key?(COUNT_KEY)
-      {
-        comply: true
-      }
-    else
-      {
-        ex_type: ArgumentError,
-        ex_msg: "hash #{hash} has wrong keys (key is missing or has a wrong name)",
-        comply: false
-      }
-    end
-  end
-
-  # Check if count is an Integer.
-  def _count_is_integer?(hash)
-    if hash[COUNT_KEY].is_a?(Integer)
-      {
-        comply: true
-      }
-    else
-      {
-        ex_type: TypeError,
-        ex_msg: "wrong argument type #{hash[COUNT_KEY].class} (expected Integer)",
-        comply: false
-      }
-    end
-  end
-
-  # Check if count is a positive number.
-  def _count_is_positive?(hash)
-    if hash[COUNT_KEY].positive?
-      {
-        comply: true
-      }
-    else
-      {
-        ex_type: ArgumentError,
-        ex_msg: "error in #{hash}: count should be a positive Integer",
-        comply: false
-      }
-    end
-  end
-end

data/lib/run_length_encoding/encoder.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "constants"
-
-#
-# Encode data with RLE.
-#
-module Encoder
-  include Constants
-
-  #
-  # Check and then pass data to the actual encoder.
-  #
-  # @param [Array, String, Enumerator] data
-  #   Data to encode.
-  #
-  # @param [String, Regexp] separator ("")
-  #   Separator for the string arguments.
-  #
-  # @return [Array<Hash{ Symbol => Object }>]
-  #   Encoded data. Each element is a Hash with the following key-value pairs:
-  #     [Constants::CHUNK_KEY => Object]
-  #       A repeated object.
-  #
-  #     [Constants::COUNT_KEY => Integer]
-  #       How many times the object is repeated.
-  #
-  # @raise [ArgumentError, TypeError]
-  #   Raises if data isn't an Array/String/Enumerator [TypeError] or an empty Array [ArgumentError].
-  #
-  def encode(data, separator = "")
-    valid_data, ex_details = _check_enc_data(data, separator)
-
-    raise(ex_details[:ex_type], ex_details[:ex_msg]) if ex_details
-
-    _encode(valid_data)
-  end
-
-  private
-
-  #
-  # Check if data is an array, convert to an array if possible.
-  #
-  # @return [Array] data
-  #   Ready-to-be-encoded data.
-  #
-  # @return [Hash{ Symbol => Object }] ex_details
-  #   Exception type and error if data can't be encoded.
-  #
-  def _check_enc_data(data, separator)
-    ex_details = nil
-
-    case data
-    when Array
-      array = data
-    when String
-      array = data.split(separator)
-    when Enumerator
-      array = data.to_a
-    else
-      ex_details = {
-        ex_type: TypeError,
-        ex_msg: "wrong argument type #{data.class} (expected Array, String or Enumerator)"
-      }
-    end
-
-    if array.to_a.empty?
-      ex_details = {
-        ex_type: ArgumentError,
-        ex_msg: "the given data is empty (no data to encode)"
-      }
-    end
-
-    return array, ex_details
-  end
-
-  #
-  # Encode array using run-length encoding.
-  #
-  # @param [Array] data
-  #   Data to encode.
-  #
-  # @return [Array<Hash{ Symbol => Object }>]
-  #   Encoded data. Each element is a Hash with the following key-value pairs:
-  #     [Constants::CHUNK_KEY => Object]
-  #       A repeated object.
-  #
-  #     [Constants::COUNT_KEY => Integer]
-  #       How many times the object is repeated.
-  #
-  def _encode(data)
-    result = []
-
-    data.each.inject([]) do |memo, element|
-      if memo.last && element == memo.last.last
-        memo.last[0] += 1
-      else
-        memo << [1, element]
-      end
-      result = memo
-    end
-    result.map { |count, chunk| { CHUNK_KEY => chunk, COUNT_KEY => count } }
-  end
-end

data/lib/run_length_encoding/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class RunLengthEncoding
-  VERSION = "0.2.1"
-end

data/lib/run_length_encoding.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "run_length_encoding/version"
-require_relative "run_length_encoding/decoder"
-require_relative "run_length_encoding/encoder"
-
-#
-# Provides methods to encode and decode data using RLE.
-#
-class RunLengthEncoding
-  include Encoder
-  include Decoder
-
-  def initialize(*); end
-end