diff --git a/.rubocop.yml b/.rubocop.yml index e69de29..c0c7636 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -0,0 +1,33 @@ +AllCops: + Exclude: + - "db/**/*" + - "config/**/*" + - "Guardfile" + - "Rakefile" + DisplayCopNames: true + +Metrics/LineLength: + Max: 120 +Metrics/MethodLength: + Include: ["app/controllers/*"] + Max: 20 +Metrics/AbcSize: + Include: ["app/controllers/*"] + Max: 30 +Metrics/ClassLength: + Max: 150 +Metrics/BlockLength: + ExcludedMethods: ['describe'] + +Style/Documentation: + Enabled: false +Style/ClassAndModuleChildren: + Enabled: false + +Layout/AlignHash: + EnforcedColonStyle: key +Layout/ExtraSpacing: + AllowForAlignment: false +Layout/MultilineMethodCallIndentation: + Enabled: true + EnforcedStyle: indented diff --git a/.stickler.yml b/.stickler.yml index e69de29..2a4eb06 100644 --- a/.stickler.yml +++ b/.stickler.yml @@ -0,0 +1,10 @@ +linters: + rubocop: + display_cop_names: true +files: + ignore: + - "bin/*" + - "db/*" + - "config/*" + - "Guardfile" + - "Rakefile" diff --git a/Enumerable_Methods.rb b/Enumerable_Methods.rb index fee0ba6..e52ccac 100644 --- a/Enumerable_Methods.rb +++ b/Enumerable_Methods.rb @@ -5,140 +5,104 @@ module Enumerable - def my_each #This is my_each method - a = 0 - self.size.times do - yield(self[a]) - a += 1 + def my_each #my_each method + myeach = 0 + while myeach < size + yield self[myeach] + myeach += 1 end self end +end - def my_each_with_index #my_each_with_index - a = 0 - self.size.times do - yield(self[a], a) - a += 1 - end - - self +def my_each_with_index #my_each_with_index method + k = 0 + while k < size + yield(self[k], k) + k += 1 end + self +end - def my_select #my_select method - myselect = [] - self.my_each do |b| - if yield (b) - myselect.push (b) - - end +def my_select #my_select method + myselect = [] + while myselect < size + if yield (b) + myselect.push (b) end - myselect - end +end - def my_all? #my_all method - myall = [] - output = true - self.my_each do |b| - if yield (b) - myall.push (b) - end - end - if myall.length == self.length - output = true - else - output = false - end - output - end - def my_any? #my_any? method - output = false - self.my_each do |b| - if yield (b) - output = true - break + def my_all? #my_all? method + myall = 0 + myall.my_each do |d| + return false unless yield(d) + end + true +end - end - end - output + def my_any #my_any method + self.my_each { |n| return true if yield (n) } end - def my_none? #my_none methods - output = true + def my_none? #my_none method + mynone = true self.my_each do |b| - if yield (b) - output = false - break - end + return false if yield(b) end - output + true end - def my_count parameter = nil #my_count method + + def my_count #my_count method mycount = 0 - self.my_each do |b| - if parameter != nil - if parameter == self[b] + myhelp = self + myhelp.my_each do |a| + if block_given? + mycount += 1 if yield(a) mycount += 1 - end - else - if yield (b) - mycount += 1 - self.my_each do |element| - if parameter - if element == parameter - mycount += 1 - end - end - elsif block_given? - mycount += if yield(element) - else - mycount = self.length - end - end - mycount - end - - def my_map #my_map method - mymap = [] - self.my_each do |b| - mymap.push yield(b) + end end - mymap + mycount end - def my_map_again(myproc) #my_mapa_gain method which takes a proc - self.my_each do |b| - mymapagain.push myproc.call(b) - end - mymapagain - end - def my_map_final myproc = nil #my_map_final method which an either take a proc or a block - mymapfinal = [] - self.my_each do |b| - if myproc == nil - mymapfinal.push yield(b) - else - mymapfinal.push myproc.call(b) - end + def my_map(&proc) #my_map method + return self.to_enum unless block_given? + + + mymap = [] + if self.class == Hash + self.each do |a, b| + + mymap << proc.call(a, b) end - mymapfinal + mymap + else + self.my_each do |c| + mymap << proc.call(c) + end + mymap end +end - def my_inject #my_inject method - output = nil - my_each = output ? yield (output, b) : self |0| + + def my_inject(param = self[0]) #my_inject method + help = self + help[1..help.length].each do |b| + param = yield(param, b) end - output -end + param +end + + def multiply_els #multiply_els method my_inject {|mult, b | mult + b} @@ -148,84 +112,34 @@ def multiply_els #multiply_els method - +#Here are examples that could be used to test for some of the methods above. #Testing for my_each method #(To test each of these methods, you can take it out of the comment and go ahead with the testing ) -#arraysofnumbers = [2, 4, 6, 8, 10, 12] -#arraysofnumbers.my_each do |numbers| - # numbers *= 5 - # print "#{numbers}" +#k = [1, 2, 3, 4, 5] +#k.my_each do |myeach| +#puts myeach #end #Testing for my_each_with_index method -#arraysofnumbers = [2, 4, 6, 8, 10, 12, 20, 50, 19, 25, 30, 40] -#arraysofnumbers.my_each_with_index do |value, index| -#puts "arraysofnumbers index #{index} takes the value of #{value}" +#fruits = %w(Mango Pawpaw Cashew Pear Orange) +#fruits.my_each_with_index do |myeachwithindex, idx| +#puts "#{myeachwithindex} is the fruit with index #{idx}" #end #Testing for my_select method -#arraysofnumbers = [2, 4, 6, 8, 10, 12, 20, 50, 19, 25, 30, 50] -#output = arraysofnumbers.my_select do |numbers| numbers % 2 != 0; end -#print output - -#Testing for my_all method - -#arraysofnumbers = [2, 4, 6, 8, 10, 12, 20, 50, 19, 25, 30, 40] -#output = arraysofnumbers.my_all? do |b| b % 2 == 0; end -#print output - -#Testing for my_any method - -#arraysofnumbers = [2, 4, 6, 8, 10, 12, 20, 50, 19, 25, 30, 25] -#output = arraysofnumbers.my_any? do |b| b < 3; end -#print output - -#Testing for my_none method - -#arraysofnumbers = [2, 4, 6, 8, 10, 12, 20, 50, 19, 25, 30, 10] -#output = arraysofnumbers.my_none? do |b| b % 2 == 1; end -#print output - -#Testing for my_count method - -#arraysofnumbers = [2, 5, 8, 10, 20, 15, 25, 15, 8, 4, 6] -#arraysofnumbers = [5, 8, 10, 15, 15, 8, 4, 6, 8, 2, 12, 7, 8, 10] -#output = arraysofnumbers.my_count -#output = arraysofnumbers.my_count (10) -#output = arraysofnumbers () do |numbers| numbers % 2 == 1; end -#output = arraysofnumbers (5) do |numbers|; end -#print output - -#Testing for my_map method - -#arraysofnumbers = [2, 4, 6, 8, 10, 12, 20, 50, 19, 25, 30, 20] -#output = arraysofumbers.my_map do |numbers| numbers * 2; end -#print output - -#Testing for my_map_again method (that takes a proc) - -#arraysofnumbers = [2, 4, 6, 8, 10, 12, 20, 50, 19, 25, 30, 10, 10] -#myproc = Proc.new do |numbers| numbers * 2; end -#output = arraysofnumbers.my_map_again(myproc) -#print output - -#Testing for my_map_final(3) (that takes either a proc or a block) - -#arraysofnumbers = [2, 4, 6, 8, 10, 12, 20, 50, 19, 25, 35, 30] -#myproc = Proc.new do |numbers| numbers * 2; end -#output = arraysofnumbers.my_map_final do |numbers| numbers * 3; end -#print output +#strings = %w(Angle Ball Cat Capstone Conquer) +#puts strings.my_select {|word| word.size > 3 } +#end -#Testing for my_inject method -#def multiply_els(arraysofnumbers) -#arraysofnumbers.my_inject(1) do |total, numbers|total * numbers; end +#To test for my_inject +#array = [1, 2, 3, 4, 5] +#array.my_inject #end -#arraysofnumbers = [1, 4, 5, 3, 2] -#puts multiply_els(arraysofnumbers) + diff --git a/README.md b/README.md index f83871f..bf3b241 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,92 @@ -# Project Descriptioon: +# Name of Project: -Advanced Building Blocks - Enumerable Methods Using Ruby Language. +Enumerable Methods + +# Table of contents: + +1. About The Project +2. Built With +3. Getting Started With The Project +4. Contributing +5. License +6. Contact/Contributors + i. Link To Project On Github +7. What Was Learnt During The Project +8. Acknowledgements + +# About The Project: + +Enumerable is a module in Ruby that provides many methods that can help with traversal, transforming, sorting, and filtering. Any class that can implement the #each method can use Enumerable methods, which will then yield each item in the collection to a block. + +It can also be said that "Enumerable" is actually a "module", which means it is just a bunch of methods packaged together that can (and do) get "mixed in", or included, with other classes like Array and Hash. It's designed to provide useful functionality to classes representing collections of objects. + +# Built With: + +This Enumerable method project was built using the Ruby language. + +# Getting Started With The Project: + +To get started, here below are the steps that needs to be taken in order to achieve the required result from the project: + +1. Create a script file to house your methods and run it in IRB to test them later. +2. Add your new methods onto the existing Enumerable module. Ruby makes this easy for you because any class or module can be added to without trouble … just do something like: + + module Enumerable + def my_each + # your code here + end + end + +1. Create #my_each, a method that is identical to #each but (obviously) does not use #each. You’ll need to remember the yield statement. Make sure it returns the same thing as #each as well. +2. Create #my_each_with_index in the same way. +3. Create #my_select in the same way, though you may use #my_each in your definition (but not #each). +4. Create #my_all? (continue as above) +5. Create #my_any? +6. Create #my_none? +7. Create #my_count +8. Create #my_map +9. Create #my_inject +10. Test your #my_inject by creating a method called #multiply_els which multiplies all the elements of the array together by using #my_inject, e.g. multiply_els([2,4,5]) #=> 40 +11. Modify your #my_map method to take a proc instead. +12. Modify your #my_map method to take either a proc or a block. It won’t be necessary to apply both a proc and a block in the same #my_map call since you could get the same effect by chaining together one #my_map call with the block and one with the proc. This approach is also clearer, since the user doesn’t have to remember whether the proc or block will be run first. So if both a proc and a block are given, only execute the proc. + +# contributing: + +In this project, your contributions towards helping in improving this project is woild be well accomodated. With that, the project will get better rating and give programmers at any level the ability learn, be inspired and create better content. + +After you are done with your contributions, you can: + +i. Fork The project. +ii. Create your feature branch using git checkout -b feature/anyfeature(for example) +iii. Commit your changes following git commit -m 'Name it as it pleases you', when you are done, +iv. Push to the branch you have created using git push origin feature/anyfeature and finally +v. Open a pull request. + +# License: + +Distributed under the MIT Licence. See Licence for more informaton # Contributor(s): - -Kingsley McSimon Ogbonna https://github.com/KingsleyMcSimon @KingsleyMcSimon -# Link to the project on Github: +Kingsley McSimon Ogbonna @KingsleyMcSimon + +# Link To The Project On Github: https://github.com/KingsleyMcSimon/Enumerable-Methods +# What Was Learnt During The Project: + +I learnt from this project that modules like Enumerable are the ultimate in DRY (Don't Repeat Yourself) code. I also understood that Ruby programmers don't have to write all those methods as mentioned above many different times - they just write them once, package them up as Enumerables and tell Array and Hash to include them. + +# Acknowledgements: + +https://medium.com/yello-offline/ruby-the-enumerable-module-under-the-hood-some-caveats-f640ce39a07d + +https://github.com/othneildrew/Best-README-Template + +https://www.theodinproject.com/courses/ruby-programming/lessons/advanced-building-blocks + +https://www.vikingcodeschool.com/falling-in-love-with-ruby/the-enumerable-module + +