darthjee-core_ext 1.7.4 → 2.0.0

data/lib/darthjee/core_ext/math.rb

@@ -1,11 +1,42 @@
 # frozen_string_literal: true
 
-module Math
-  def self.average(values)
-    values = values.map { |v| [v, 1] }.to_h unless values.is_a?(Hash)
+module Darthjee
+  module CoreExt
+    # @api public
+    module Math
+      # Calculates avarage from a series of values
+      #
+      # @overload average(values)
+      #   @param values [::Array] list of values
+      #
+      # @overload average(values)
+      #   @param values [::Hash] hash of values and its weights
+      #
+      # @return [::Float]
+      #
+      # @example Average of array
+      #   values = [1,2,3,4]
+      #
+      #   Math.average(values) # returns 2.5
+      #
+      # @example Average of hash
+      #   values = { 1 => 3, 7 => 1 }
+      #
+      #   Math.average(values) # returns 2.5
+      def average(values)
+        if values.is_a?(Hash)
+          weight_sum = values.values.sum
+          values = values.map { |value, weight| value * weight }
+        else
+          weight_sum = values.length
+        end
 
-    values.inject(0) do |sum, vals|
-      sum + vals.inject { |a, b| a * b }
-    end / values.values.sum.to_f
+        values.sum / weight_sum.to_f
+      end
+    end
   end
 end
+
+module Math
+  extend Darthjee::CoreExt::Math
+end

data/lib/darthjee/core_ext/numeric.rb

@@ -2,7 +2,17 @@
 
 module Darthjee
   module CoreExt
+    # @api public
     module Numeric
+      # Returns the percentage over total
+      #
+      # @param total [::Numeric] total over which to calculate
+      #   the percentage
+      #
+      # @return [::Float]
+      #
+      # @example
+      #   10.percent_of(30) # returns 33.33333333333333
       def percent_of(total)
         return Float::INFINITY if total&.zero?
         (to_f / total.to_f) * 100.0

data/lib/darthjee/core_ext/object.rb

@@ -2,12 +2,41 @@
 
 module Darthjee
   module CoreExt
+    # @api public
     module Object
+      # Checks if object is any of the given classes
+      #
+      # @param classes [::Array<::Class>] classes to be checked
+      #   against
+      #
+      # @return [::TrueClass,::FalseClass]
+      #
+      # @example
+      #   object = [1, 2, 3]
+      #
+      #   object.is_any?(Hash,  Class)      # false
+      #   object.is_any?(Hash,  Array)      # true
+      #   object.is_any?(Enumerable, Class) # true
       def is_any?(*classes)
         classes.any? do |clazz|
           is_a?(clazz)
         end
       end
+
+      # Checks if object is evaluated to true
+      #
+      # @return [::TrueClass,::FalseClass]
+      #
+      # @example
+      #   nil.trueful? # returns false
+      #   [].trueful?  # returns true
+      #   {}.trueful?  # returns true
+      #   "".trueful?  # returns true
+      def trueful?
+        # rubocop: disable Style/DoubleNegation
+        !!self
+        # rubocop: enable Style/DoubleNegation
+      end
     end
   end
 end

data/lib/darthjee/core_ext/symbol.rb

@@ -2,11 +2,31 @@
 
 module Darthjee
   module CoreExt
+    # @api public
+    #
+    # @author darthjee
     module Symbol
-      def camelize(type = :upper)
-        to_s.camelize(type).to_sym
+      # Creates new symbol camelized
+      #
+      # @param first_letter [::Symbol] type of first letter
+      #
+      # @return [::Symbol]
+      #
+      # @example
+      #   :the_symbol.camelize # returns :TheSymbol
+      def camelize(first_letter = :upper)
+        to_s.camelize(first_letter).to_sym
       end
 
+      # The reverse of {#camelize}
+      #
+      # Makes an underscored, lowercase form from
+      # the expression in the Symbol
+      #
+      # @return [::Symbol]
+      #
+      # @example
+      #   :theSymbol.camelize # returns :the_symbol
       def underscore
         to_s.underscore.to_sym
       end

data/lib/darthjee/core_ext/version.rb

@@ -2,6 +2,6 @@
 
 module Darthjee
   module CoreExt
-    VERSION = '1.7.4'
+    VERSION = '2.0.0'
   end
 end

data/scripts/check_readme.sh

@@ -0,0 +1,6 @@
+#! /bin/bash
+
+PROJECT=darthjee/core_ext
+VERSION=$(grep VERSION lib/$PROJECT/version.rb  | sed -e "s/.*'\(.*\)'/\1/g")
+
+grep https://www.rubydoc.info/gems/darthjee-core_ext/$VERSION README.md

data/scripts/rubycritic.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+DIFF_LIST=$(git diff --name-only $CIRCLE_SHA1 $(git merge-base $CIRCLE_SHA1 origin/master) | grep "^lib/")
+
+if [ ! -z "$DIFF_LIST" ]; then
+  mkdir -p tmp/rubycritic/compare
+  bundle exec rubycritic --format console --branch origin/master -t 0 $DIFF_LIST
+else
+  echo "No changes detected. Skipping rubycritic..."
+fi

data/spec/integration/readme/array_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+describe Array do
+  describe 'readme' do
+    describe '#as_hash' do
+      subject(:array) { [10, 20, 30, 40] }
+
+      let(:keys) { %i[ten twenty thirty fourty] }
+
+      it 'pairs keys and values' do
+        expect(array.as_hash(keys))
+          .to eq(ten: 10, twenty: 20, thirty: 30, fourty: 40)
+      end
+    end
+
+    describe '#average' do
+      subject(:array) { [1, 2, 3, 4] }
+
+      it 'calculates the average' do
+        expect(array.average).to eq(2.5)
+      end
+    end
+
+    describe '#chain_map' do
+      subject(:array) { %i[a long_name sym] }
+
+      it 'maps calling the methods' do
+        expect(array.chain_map(:to_s, :size, :to_s))
+          .to eq(%w[1 9 3])
+      end
+
+      context 'when giving a block' do
+        let(:mapped) do
+          array.chain_map(:to_s, :size) { |v| "final: #{v}" }
+        end
+
+        it 'maps calling the methods' do
+          expect(mapped)
+            .to eq(['final: 1', 'final: 9', 'final: 3'])
+        end
+      end
+    end
+
+    describe 'mapk' do
+      let(:array) do
+        [
+          { a: { b: 1 }, b: 2 },
+          { a: { b: 3 }, b: 4 }
+        ]
+      end
+
+      it 'maps fetching keys' do
+        expect(array.mapk(:a, :b)).to eq([1, 3])
+      end
+    end
+
+    describe '#procedural_join' do
+      subject(:array) { [1, 2, -3, -4, 5] }
+
+      let(:mapper) { proc { |value| value.to_f.to_s } }
+      let(:string) do
+        array.procedural_join(mapper) do |_previous, nexte|
+          nexte.positive? ? ' +' : ' '
+        end
+      end
+
+      it 'joins with grace' do
+        expect(string).to eq('1.0 +2.0 -3.0 -4.0 +5.0')
+      end
+    end
+
+    describe '#random' do
+      let(:array) { [10, 20, 30] }
+
+      it 'returns a random element' do
+        expect(array).to include(array.random)
+      end
+    end
+
+    describe '#random!' do
+      let(:array) { [10, 20, 30] }
+
+      it 'returns a random element' do
+        expect(array.dup).to include(array.random!)
+      end
+
+      it 'removes an element from array' do
+        expect { array.random! }.to change(array, :size).by(-1)
+      end
+
+      it 'no longer includes removed element' do
+        expect(array).not_to include(array.random!)
+      end
+    end
+  end
+end

data/spec/integration/readme/class_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: false
+
+describe Class do
+  describe 'readme' do
+    let(:instance) { klass.new }
+    let(:other)    { klass.new }
+
+    describe '#default_value' do
+      let(:klass) do
+        Class.new do |clazz|
+          clazz.send(:default_value, :name, 'John')
+        end
+      end
+
+      it 'adds method with default value' do
+        expect(instance.name)
+          .to eq('John')
+      end
+
+      it 'returns the same instance' do
+        expect(instance.name)
+          .to be_equal(other.name)
+      end
+    end
+
+    describe '#default_values' do
+      let(:klass) do
+        Class.new do |clazz|
+          clazz.send(
+            :default_values, :name, :nick_name, 'John'
+          )
+        end
+      end
+
+      it 'adds methods with default value' do
+        expect(instance.name)
+          .to eq('John')
+      end
+
+      it 'adds methods with default value on both methods' do
+        expect(instance.nick_name)
+          .to eq('John')
+      end
+
+      it 'returns the same instance' do
+        expect(instance.name)
+          .to be_equal(other.name)
+      end
+    end
+
+    describe '#default_reader' do
+      let(:klass) do
+        Class.new do |clazz|
+          clazz.send(:attr_writer, :name)
+          clazz.send(:default_reader, :name, 'John Doe')
+        end
+      end
+
+      it 'adds method returning default value' do
+        expect(instance.name).to eq('John Doe')
+      end
+
+      context 'when value is changed' do
+        before do
+          instance.name = 'Joe'
+        end
+
+        it 'returns new value' do
+          expect(instance.name).to eq('Joe')
+        end
+
+        context 'when it is changed to nil' do
+          before do
+            instance.name = nil
+          end
+
+          it { expect(instance.name).to be_nil }
+        end
+
+        context 'when another instance calls the method' do
+          it 'does not change the result of another instance' do
+            expect(instance.name).not_to eq(other.name)
+          end
+        end
+      end
+    end
+
+    describe '#default_readers' do
+      let(:klass) do
+        Class.new do |clazz|
+          clazz.send(:attr_writer, :cars, :houses)
+          clazz.send(:default_readers, :cars, :houses, 'none')
+        end
+      end
+
+      it 'adds method returning default value' do
+        expect(instance.cars).to eq('none')
+      end
+
+      it 'returns the same instance for both methods' do
+        expect(instance.cars).to be_equal(instance.houses)
+      end
+
+      context 'when setting cars' do
+        before { instance.cars = ['volvo'] }
+
+        it 'sets the value' do
+          expect(instance.cars).to eq(['volvo'])
+        end
+
+        it 'does not change the value on the other method' do
+          expect(instance.houses).to eq('none')
+        end
+
+        context 'when setting to nil' do
+          before { instance.cars = nil }
+
+          it { expect(instance.cars).to be_nil }
+        end
+      end
+    end
+  end
+end

data/spec/integration/readme/date_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Date do
+  describe 'readme' do
+    subject(:date) { described_class.new(2106, 10, 11) }
+
+    let(:future) { date + 1.year }
+    let(:past)   { date - 1.year }
+
+    it 'returns days between' do
+      expect(date.days_between(future)).to eq(365)
+    end
+
+    it 'returns positive' do
+      expect(date.days_between(past)).to eq(365)
+    end
+  end
+end

data/spec/integration/readme/enumerable_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+describe Enumerable do
+  describe 'readme' do
+    describe '#clean' do
+      let(:array) { [1, [], nil, {}, '', hash] }
+      let(:hash)  { { b: [], c: nil, d: {}, e: '' } }
+
+      it 'cleans array' do
+        expect(array.clean).to eq([1])
+      end
+    end
+
+    describe '#clean!' do
+      let(:hash) do
+        {
+          a: 1,
+          b: [],
+          c: nil,
+          d: {},
+          e: '',
+          f: {
+            b: [],
+            c: nil,
+            d: {},
+            e: ''
+          }
+        }
+      end
+
+      it 'cleans array' do
+        expect { hash.clean! }.to change { hash }
+          .to(a: 1)
+      end
+    end
+
+    describe '#map_and_find' do
+      let(:ids)          { [10, 21, 30, 31, 51, 55] }
+      let(:client)       { Client.new(existing_ids) }
+      let(:existing_ids) { [1, 11, 21, 31, 41, 51] }
+      let(:request)      { client.method(:request) }
+
+      it 'returns the value found' do
+        expect(ids.map_and_find(&request)).to eq(id: 21)
+      end
+
+      it 'does not perform all requests all' do
+        expect { ids.map_and_find(&request) }
+          .to change(client, :requested)
+          .from([]).to([10, 21])
+      end
+    end
+
+    describe '#map_and_select' do
+      let(:ids)          { [10, 21, 30, 31, 51, 55] }
+      let(:client)       { Client.new(existing_ids) }
+      let(:existing_ids) { [1, 11, 21, 31, 41, 51] }
+      let(:request)      { client.method(:request) }
+
+      it 'returns all values found' do
+        expect(ids.map_and_select(&request))
+          .to eq([{ id: 21 }, { id: 31 }, { id: 51 }])
+      end
+    end
+
+    describe '#map_to_hash' do
+      let(:ids)          { [10, 21, 30, 31, 51, 55] }
+      let(:client)       { Client.new(existing_ids) }
+      let(:existing_ids) { [1, 11, 21, 31, 41, 51] }
+      let(:request)      { client.method(:request) }
+      let(:expected) do
+        {
+          10 => nil,
+          21 => { id: 21 },
+          30 => nil,
+          31 => { id: 31 },
+          51 => { id: 51 },
+          55 => nil
+        }
+      end
+
+      it 'returns a hash with the mapped' do
+        expect(ids.map_to_hash(&request)).to eq(expected)
+      end
+    end
+  end
+end