rordash 0.1.0

data/lib/rordash/file_util.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Rordash
+  module FileUtil
+    FILE_EXTENSION_MATCH = /^.*\.\S+\w$/.freeze
+    CONTENT_TYPE_TO_EXT_MATCH = %r{/(.*)$}.freeze
+    UNSUPPORTED_CONTENT_TYPE_MAP = {
+      'application/vnd.ms-publisher' => 'pub'
+    }.freeze
+
+    class << self
+      def filename_with_ext_from(filename:, content_type:)
+        filename = filename.to_s.strip
+        return filename if filename.blank?
+        return filename if filename_has_extension?(filename)
+        return filename if content_type.blank?
+
+        ext = content_type_to_extension(content_type)
+        return filename if ext.blank?
+
+        "#{filename}.#{ext}"
+      end
+
+      def content_type_to_extension(content_type)
+        return content_type if content_type.blank?
+
+        ext = mime_type_for_content_type(content_type)&.preferred_extension
+        ext = UNSUPPORTED_CONTENT_TYPE_MAP[content_type] if ext.blank?
+        ext = content_type.match(CONTENT_TYPE_TO_EXT_MATCH).to_a.last if ext.blank?
+        ext
+      end
+
+      def fixture_file_path(filename)
+        rel_path = PathUtil.fixtures_path('files')
+        path = rel_path.join(filename)
+
+        if path.exist?
+          path
+        else
+          msg = "the directory '%s' does not contain a file named '%s'"
+          raise ArgumentError, format(msg, rel_path, filename)
+        end
+      end
+
+      def fixture_file_path_str(filename)
+        fixture_file_path(filename).to_s
+      end
+
+      def read_fixture_file(rel_path)
+        File.read(PathUtil.fixtures_path(rel_path))
+      end
+
+      def open_fixture_file(filename)
+        pathname = Utils::FileUtil.fixture_file_path(filename)
+        return nil unless pathname.exist?
+
+        ::File.open(pathname.to_s)
+      end
+
+      def read_fixture_file_as_hash(rel_path)
+        HashUtil.from_string(read_fixture_file(rel_path))
+      end
+
+      def create_file_blob(filename:, content_type: nil, metadata: nil)
+        content_type = content_type.present? ? content_type : content_type_from_filename(filename) || Mime[:jpg]
+
+        raise StandardError, "ActiveStorage must be installed" unless defined? ActiveStorage::Blob
+
+        ActiveStorage::Blob.create_after_upload! io: ::File.open(fixture_file_path(filename).to_s), filename: filename,
+                                                 content_type: content_type, metadata: metadata
+      end
+
+      def file_url_for(filename)
+        Addressable::URI.parse(Faker::Internet.url)&.join(filename).to_s
+      end
+
+      def content_type_from_filename(filename)
+        mime_type = mime_type_from_filename(filename)
+        mime_type&.content_type
+      end
+
+      def mime_type_from_filename(filename)
+        MIME::Types.type_for(filename).first
+      end
+
+      def mime_type_for_content_type(content_type)
+        MIME::Types[content_type].first
+      end
+
+      def filename_has_extension?(filename)
+        filename.to_s.match?(FILE_EXTENSION_MATCH)
+      end
+    end
+  end
+end

data/lib/rordash/hash_util.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Rordash
+  # rubocop:disable Metrics/ModuleLength
+  module HashUtil
+    ROOT_PATHS = %w[. *].freeze
+
+    class << self
+      def from_string(json_str)
+        return json_str unless json_str.is_a?(String)
+
+        Oj.load(json_str, symbol_keys: true)
+      end
+
+      def to_str(obj)
+        return Oj.dump(obj.deep_stringify_keys) if hash_or_array?(obj)
+
+        obj.to_s
+      end
+
+      def pretty(obj)
+        return obj unless hash_or_array?(obj)
+
+        JSON.pretty_generate(obj)
+      end
+
+      def get(obj, path, default: nil)
+        return obj if ROOT_PATHS.include?(path)
+
+        value = R_.get(obj, path.to_s)
+        return default if value.nil?
+
+        value
+      end
+
+      def get_first_present(obj, dotted_paths)
+        dotted_paths.each do |path|
+          value = R_.get(obj, path)
+          return value if value.present?
+        end
+
+        nil
+      end
+
+      def set(hash, path, value)
+        R_.set(hash, path.to_s, value)
+      end
+
+      def group_by(obj, key_or_proc)
+        proc = if key_or_proc.is_a?(Proc)
+                 key_or_proc
+               else
+                 ->(hash) { R_.get(hash, key_or_proc.to_s) }
+               end
+
+        R_.group_by(obj, proc)
+      end
+
+      def dot(hash, keep_arrays: true, &block)
+        return Dottie.flatten(hash) unless keep_arrays
+
+        results = {}
+        Dottie.flatten(hash, intermediate: true).each do |k, v|
+          next if RegexUtil.match?(:dotted_index, k)
+          next if v.is_a?(::Hash)
+
+          value = block ? yield(k, v) : v
+          results.merge!(k => value)
+        end
+
+        results
+      end
+
+      def deep_key?(obj, key)
+        return false unless obj.is_a?(::Hash)
+        return obj.key?(key) unless key.is_a?(String) && key.include?('.')
+
+        dotted_keys(obj).include?(key)
+      end
+
+      def dotted_keys(obj, keep_arrays: true)
+        dot(obj, keep_arrays: keep_arrays).keys
+      end
+
+      # rubocop:disable Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/AbcSize
+      def pick(hash, paths, keep_arrays: true)
+        all_paths = paths.is_a?(Array) ? paths.map(&:to_s) : [paths.to_s]
+        has_deep_paths = all_paths.any? { |path| path.include?('.') }
+
+        results = {}
+        dotted_hash = has_deep_paths ? Dottie.flatten(hash, intermediate: true) : hash
+        filtered_keys = dotted_hash.keys.select { |path| all_paths.include?(path.to_s) }
+        filtered_dotted_hash = dotted_hash.slice(*filtered_keys)
+
+        return filtered_dotted_hash unless has_deep_paths
+
+        if keep_arrays
+          filtered_dotted_hash.each_pair { |k, v| Utils::HashUtil.set(results, k, v) }
+          return results
+        else
+          filtered_dotted_hash.each_pair do |dotted_key, val|
+            stringify_dotted_key = dotted_key.to_s
+            next if all_paths.exclude?(stringify_dotted_key)
+
+            should_reconstruct_array = RegexUtil.match?(:dotted_index, stringify_dotted_key)
+            key = should_reconstruct_array ? dotted_key.split('[').first : dotted_key
+            value = should_reconstruct_array ? (results[key] || []).push(val) : val
+
+            results.merge!(key => value)
+          end
+        end
+
+        undot(results)
+      end
+      # rubocop:enable Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/AbcSize
+
+      def undot(hash, &block)
+        results = {}
+        Dottie.flatten(hash, { intermediate: false }).each do |k, v|
+          value = block ? yield(k, v) : v
+          set(results, k, value)
+        end
+        results
+      end
+
+      def deep_compact(attrs, each_value_proc: nil)
+        result = {}
+
+        dot(attrs, keep_arrays: true) do |k, v|
+          value = each_value_proc.respond_to?(:call) ? each_value_proc&.call(k, v) : v.compact
+          next if value.nil?
+
+          set(result, k, value)
+        end
+
+        result
+      end
+
+      def reject_blank_values(obj)
+        return obj unless hash_or_array?(obj)
+
+        obj.compact.reduce({}) do |memo, (k, v)|
+          v = v.is_a?(String) ? v.strip : v
+          next memo if !hash_or_array?(v) && v.blank?
+
+          memo.merge(k => v)
+        end
+      end
+
+      def deep_reject_blank_values(attrs)
+        deep_compact(attrs, each_value_proc: lambda do |_k, v|
+          v = v.is_a?(String) ? v.strip : v
+          v = v.compact if hash_or_array?(v)
+          if v.is_a?(Array)
+            v = v.reject do |val|
+              val = val.is_a?(String) ? val.strip : val
+              val.blank?
+            end
+          end
+          v.blank? ? nil : v
+        end)
+      end
+
+      def deep_symbolize_keys(obj)
+        return obj unless hash_or_array?(obj)
+        return obj.deep_symbolize_keys if obj.is_a?(::Hash)
+
+        obj.map { |item| item.is_a?(::Hash) ? item.deep_symbolize_keys : item }
+      end
+
+      def digest(obj)
+        Digest::SHA1.base64digest Marshal.dump(obj)
+      end
+
+      def hash_or_array?(obj)
+        obj.is_a?(::Hash) || obj.is_a?(Array)
+      end
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end

data/lib/rordash/numeric_util.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rordash
+  module NumericUtil
+    class << self
+      module Unit
+        FEET = :ft
+        METER = :m
+      end
+
+      def numeric?(value)
+        !Float(value.to_s).nil?
+      rescue StandardError
+        false
+      end
+
+      def convert_unit(value, from_unit:, to_unit:)
+        Measured::Length.new(value, from_unit).convert_to(to_unit).value.to_f
+      end
+
+      def convert_unit_sq(value, from_unit:, to_unit:)
+        value = value.is_a?(String) ? BigDecimal(value) : value
+        val = convert_unit(value, from_unit: from_unit, to_unit: to_unit)
+        (val * val) / value
+      end
+    end
+  end
+end

data/lib/rordash/object_util.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rordash
+  module ObjectUtil
+    class << self
+      def to_class(classname)
+        classname.constantize if classname.is_a?(String)
+        classname
+      end
+
+      def to_classname(klass)
+        return klass.name if Object.const_defined?(klass)
+
+        nil
+      end
+    end
+  end
+end

data/lib/rordash/path_util.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rordash
+  module PathUtil
+    class << self
+      def fixtures_path(path = '')
+        Rails.root.join('spec', 'fixtures', path)
+      end
+    end
+  end
+end

data/lib/rordash/regex_util.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rordash
+  module RegexUtil
+    EMAIL_MATCH = URI::MailTo::EMAIL_REGEXP
+    POSTAL_CODE_MATCH = /[A-Za-z]\d[A-Za-z][ -]?\d[A-Za-z]\d/.freeze
+    DOTTED_INDEX_MATCH = /\w+\[\d+\]/.freeze
+    URI_MATCH = URI::DEFAULT_PARSER.make_regexp.freeze
+
+    TYPE = {
+      email: EMAIL_MATCH,
+      uri: URI_MATCH,
+      postal_code: POSTAL_CODE_MATCH,
+      dotted_index: DOTTED_INDEX_MATCH
+    }.freeze
+
+    class << self
+      def match?(type, value)
+        TYPE[type].match?(value)
+      end
+
+      def match(type, value)
+        TYPE[type].match(value)
+      end
+
+      def replace(type, value, replacement)
+        return value unless value.is_a?(String)
+
+        regex = TYPE[type]
+        return value if regex.nil?
+
+        value.sub(regex, replacement)
+      end
+    end
+  end
+end

data/lib/rordash/url_util.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rordash
+  module UrlUtil
+    class << self
+      def safe_escape(url)
+        Addressable::URI.escape(url).to_s
+      end
+
+      def error_from_http_status(http_status)
+        Rack::Utils::HTTP_STATUS_CODES[http_status.to_i] || 'Invalid HTTP Status Code'
+      end
+    end
+  end
+end

data/lib/rordash/version.rb

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

data/lib/rordash.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+%w[
+version
+debug_util
+regex_util
+hash_util
+path_util
+file_util
+url_util
+object_util
+numeric_util
+].each do |filename|
+  require File.expand_path("../rordash/#{filename}", Pathname.new(__FILE__).realpath)
+end
+
+module Rordash
+  ; end

data/rordash.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require File.expand_path('../lib/rordash/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors = ["Desmond O'Leary"]
+  gem.email = ["desoleary@gmail.com"]
+  gem.description = %q{Lodash inspired utilities}
+  gem.summary = %q{Lodash inspired utilities}
+  gem.homepage = "https://github.com/omnitech-solutions/rordash"
+  gem.license = "MIT"
+
+  gem.files = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^exe/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec|features)/})
+  gem.name = "rordash"
+  gem.require_paths = ["lib"]
+  gem.version = Rordash::VERSION
+  gem.required_ruby_version = ">= 2.6.0"
+
+  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 'stackprof', '>= 0.2'
+  gem.add_runtime_dependency 'colorize', '~> 0.8.1'
+  gem.add_runtime_dependency 'mime-types', '>= 3'
+  gem.add_runtime_dependency 'activesupport', '>= 5'
+  gem.add_runtime_dependency 'activestorage', '>= 5'
+  gem.add_runtime_dependency 'rack', '>= 2'
+  gem.add_runtime_dependency 'faker', '>= 2'
+  gem.add_runtime_dependency 'oj', '>= 3'
+  gem.add_runtime_dependency 'rudash', '>= 4'
+  gem.add_runtime_dependency 'dottie', '>= 0.0.2'
+  gem.add_runtime_dependency 'addressable', '>= 2.6.0'
+  gem.add_runtime_dependency 'measured', '>= 2.5'
+
+  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.add_development_dependency("codecov", "~> 0.6.0")
+end

data/sig/rordash.rbs

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

data/spec/coverage_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+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

data/spec/fixtures/files/sample.csv

@@ -0,0 +1,3 @@
+name,date,favorite_color
+John Smith,Oct 2 1901,blue
+Gemma Jones,Sept 1 2018,silver

data/spec/fixtures/files/sample.json

@@ -0,0 +1,6 @@
+[
+  {
+    "color": "red",
+    "value": "#f00"
+  }
+]

data/spec/rordash/debug_util_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rordash
+  # rubocop:disable  RSpec/MessageSpies
+  RSpec.describe DebugUtil do
+    describe '.calculate_duration' do
+      let(:tag) { nil }
+
+      subject(:calculated_duration) { described_class.calculate_duration(tag: tag) { 'do-something' } }
+
+      context 'without block' do
+        it 'raises missing block error' do
+          expect { described_class.calculate_duration }.to raise_error ArgumentError, 'Missing block'
+        end
+      end
+
+      context 'with tag' do
+        let(:tag) { 'some-tag' }
+
+        it 'includes tag' do
+          expect { calculated_duration }.to output(Regexp.new(/tag: `#{tag}` - total duration - /)).to_stdout
+        end
+      end
+
+      it 'prints duration' do
+        expect { calculated_duration }.to output(/tag: `default` - total duration - /).to_stdout
+      end
+    end
+
+    describe '.wrap_stack_prof' do
+      let(:tag) { nil }
+      let(:out) { nil }
+
+      subject(:profile_wrapper) { described_class.wrap_stack_prof(tag: tag, out: out) { 'do something' } }
+
+      it 'wraps block inside stackprof runner' do
+        expect(StackProf).to receive(:run).with(mode: :wall, out: 'tmp/stackprof.dump', raw: true, interval: 1000)
+
+        profile_wrapper
+      end
+
+      it 'prints output file location' do
+        expect(StackProf).to receive(:run).with(mode: :wall, out: 'tmp/stackprof.dump', raw: true, interval: 1000)
+
+        expect { profile_wrapper }.to output(Regexp.new(%r{StackProf output file: tmp/stackprof.dump})).to_stdout
+      end
+    end
+  end
+  # rubocop:enable  RSpec/MessageSpies
+end

data/spec/rordash/file_util_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Rordash
+  RSpec.describe FileUtil do
+    let(:filename) { 'sample.csv' }
+    let(:rel_path) { "files/#{filename}" }
+
+    describe '.fixture_file_path' do
+      it 'returns file contents' do
+        actual = described_class.fixture_file_path(filename)
+
+        expect(actual.exist?).to be_truthy
+        expect(actual.to_s).to include("spec/fixtures/files/#{filename}")
+      end
+    end
+
+    describe '#fixture_file_path_str' do
+      it 'returns file contents' do
+        expect(described_class.fixture_file_path_str(filename)).to include("spec/fixtures/files/#{filename}")
+      end
+    end
+
+    describe '#read_fixture_file' do
+      it 'returns file contents' do
+        expect(described_class.read_fixture_file(rel_path)).to include("Gemma Jones,Sept 1 2018,silver")
+      end
+    end
+
+    describe '#read_fixture_file_as_hash' do
+      let(:rel_path) { 'files/sample.json' }
+
+      it 'returns file contents' do
+        expect(described_class.read_fixture_file_as_hash(rel_path)).to eql([
+                                                                             {
+                                                                               color: "red",
+                                                                               value: "#f00"
+                                                                             }
+                                                                           ])
+      end
+    end
+
+    describe '.content_type_from_filename' do
+      let(:filename) { 'sample.pdf' }
+
+      subject(:content_type) { described_class.content_type_from_filename(filename) }
+
+      it 'returns content type' do
+        expect(content_type).to eql('application/pdf')
+      end
+    end
+
+    describe '.mime_type_from_filename' do
+      let(:filename) { 'sample.pdf' }
+
+      subject(:mime_type) { described_class.mime_type_from_filename(filename) }
+
+      it 'returns content type' do
+        expect(mime_type).to eql(MIME::Types['application/pdf'].first)
+      end
+    end
+
+    describe '.file_url_for' do
+      let(:filename) { 'sample.pdf' }
+
+      subject(:file_url) { described_class.file_url_for(filename) }
+
+      it 'returns url with filename' do
+        expect(file_url).to match(RegexUtil::TYPE[:uri])
+        expect(file_url).to include(filename)
+      end
+    end
+
+    context 'with content types' do
+      let(:content_types) do
+        [
+          { content_type: 'image/png', extension: 'png' },
+          { content_type: 'text/csv', extension: 'csv' },
+          { content_type: 'application/msword', extension: 'doc' },
+          { content_type: 'text/html', extension: 'html' },
+          { content_type: 'application/zip', extension: 'zip' },
+          { content_type: 'image/bmp', extension: 'bmp' },
+          { content_type: 'application/vnd.ms-publisher', extension: 'pub' },
+          { content_type: 'image/jp2', extension: 'jp2' },
+          { content_type: 'video/mp4', extension: 'mp4' },
+          { content_type: 'application/pdf', extension: 'pdf' },
+          { content_type: 'image/svg+xml', extension: 'svg' },
+          { content_type: 'application/octet-stream', extension: 'bin' },
+          { content_type: 'image/webp', extension: 'webp' },
+          { content_type: 'image/gif', extension: 'gif' },
+          { content_type: 'text/plain', extension: 'txt' },
+          { content_type: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            extension: 'pptx' },
+          { content_type: 'image/heic', extension: 'heic' },
+          { content_type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            extension: 'docx' },
+          { content_type: 'image/jpeg', extension: 'jpeg' },
+          { content_type: 'image/tiff', extension: 'tiff' }
+        ]
+      end
+
+      describe '.filename_with_ext_from' do
+        let(:filename_without_extension) { 'filename' }
+
+        it 'returns the correct extension' do
+          content_types.each do |content_type:, extension:|
+            actual = described_class.filename_with_ext_from(filename: filename_without_extension,
+                                                            content_type: content_type)
+            expect(actual).to eql("#{filename_without_extension}.#{extension}")
+          end
+        end
+      end
+
+      describe '.content_type_to_extension' do
+        it 'returns the correct extension' do
+          content_types.each do |content_type:, extension:|
+            actual = described_class.content_type_to_extension(content_type)
+            expect(actual).to eql(extension)
+          end
+        end
+      end
+    end
+  end
+end