blueberry 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 24490f20780296b37c98f69ffa36471bc7b77540
+  data.tar.gz: 14dfd7db95081fdf7708c79f35c6a9dbeeed03f2
+SHA512:
+  metadata.gz: a250a12f92cc83a891243a25c627f09c1e05455d4a514582fe6ad545663d1d38ff2bfd1329b62c06d8335f11059c9134b2d65ce4a41f02aa31eaee66ed69a8c9
+  data.tar.gz: b8076b29169f0bcb283f172068124b8f174f51f4395d333276b93ae12ff6693ea0f7ee51cb6b92ef3ff862a23ecf0fc9b7e07622b80f22c48fb9fd16e7b1c596

data/README

@@ -0,0 +1 @@
+My blueberry gem ;)

data/bin/blue

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/playlist'
+require_relative '../lib/movie3d'
+
+playlist = Flicks::Playlist.new("Making knowledge MINE")
+
+default_movies_file = 
+	File.join(File.dirname(__FILE__),'movies.csv')
+
+playlist.load_file(ARGV.shift || default_movies_file)
+
+#Whenever you type a command that uses a file, 
+#the working directory(where you called the script from)
+#will be the first place your shell looks to find the file.
+#therefore, you need to provide absolute path for 'avengers'
+
+#and we can call this script anywhere once gem is installed 
+#because gem loads bin/executable file on ruby's load path 
+#once it is installed
+
+movie3d = Flicks::Movie3D.new('95%',5,10)
+playlist.add_movie(movie3d)
+
+loop do
+	puts "\nHow many viewings? ('quit' to exit)"
+	answer = gets.chomp.downcase #get string, gets next line from $stdin
+	#chomp removes any characters hanging onto end of string
+	case answer #answer is string because its from $stdin, you type in as string
+	when 'quit','exit'
+		playlist.print_stats
+		playlist.save_file
+		break 
+	when /^\d*$/
+		puts "Enjoy your #{answer} viewings, achiever!"
+		playlist.play(answer.to_i) 
+	else
+		puts "\nPlease enter a number or 'quit' to exit "
+	end
+end
+
+
+
+
+
+
+

data/bin/movies.csv

@@ -0,0 +1,7 @@
+charlie,5
+shiny,5
+dany,5 
+kevin,5 
+ray,5
+yohan,5 
+jeremiah,5

data/lib/dok2_and_quiet.rb

@@ -0,0 +1,28 @@
+require_relative 'movie'
+
+module Dok2AndQuiet
+
+	def self.roll
+		@number = rand(1..6)
+	end
+
+	def self.review(movie)
+
+		case roll #or self.roll
+
+			when 1..2
+				movie.thumbs_down
+				puts "#{movie.title} got thumbs down"
+			when 3..4
+				puts "#{movie.title} got skipped"
+			when 5..6
+				movie.thumbs_up
+				puts "#{movie.title} got thumbs up!"
+		end
+	end
+end
+
+if __FILE__ == $0
+	movie = Movie.new("ironman")
+	puts Dok2AndQuiet::review(movie) #Dok2AndQuiet.review(movie)
+end

data/lib/mixins.rb

@@ -0,0 +1,58 @@
+module Rankable
+	def thumbs_up
+		puts "#{self.title} got a thumbs_up"
+	end
+end
+
+class Movie
+	include Rankable
+	attr_accessor :title, :rank
+	def initialize(title,rank)
+		@title = title
+		@rank = rank
+
+	end
+end
+
+class Song
+	include Rankable
+	attr_accessor :title, :rank
+
+	def initialize(title,rank)
+		self.title = title
+		self.rank = rank
+	end
+end
+
+if __FILE__ == $0
+	movie = Movie.new('goonies',10)
+	movie.thumbs_up
+	song = Song.new('Ruby baby',10)
+	song.thumbs_up
+end
+
+#mixins - simply a module that has methods
+# and those methods gets mixed into other classes
+
+#we want to share some common behaviors across
+#these classes which arent in the same inheritance hierchy
+#(they are not in same ancestors line, no child and parent)
+
+#mixed in modules effectively behave like superclasses.
+#it changes the method look-up hierchy
+#module lives in between the class that includes the
+#module and their direct superclass
+#so when we call a method, it looks into the object's 
+#class then it looks in the module, then it looks in
+#the superclass and then all the way into the top
+
+# It generally considered better practice if
+# a module depends on a method or an attribute in the 
+# hosting class(the class that it gets mixed into)
+# as opposted to relying on the instance variable being present
+
+
+
+
+
+

data/lib/movie.rb

@@ -0,0 +1,59 @@
+require_relative 'rankable'
+
+module Flicks
+	class Movie
+		include Rankable
+
+		attr_reader :snack_carbs,:title
+		attr_accessor :rank
+
+		def initialize(title, rank=0)
+			@title = title.capitalize
+			@rank = rank
+			@snack_carbs = Hash.new(0)
+		end
+
+		def self.convert(line)
+			title,rank = line.split(',')
+			Movie.new(title,Integer(rank))
+		end
+
+		def expose_hash           
+			@snack_carbs.each do |key,value|
+				snack = Snack.new(key,value.to_i)
+				yield(snack)
+			end
+		end
+
+		def carbs_consumed
+			@snack_carbs.values.reduce(0) {|sum,snack| sum + snack }
+			# @snacks_carbs.values.reduce(0,:+)
+		end
+
+		def ate_snack(snack)
+			@snack_carbs[snack.name] += snack.carbs
+			puts "Sold ~> #{snack.name.capitalize} - #{snack.carbs} carbs" 
+			puts @snack_carbs
+		end
+
+		def title=(title)
+			@title = title.capitalize
+		end
+
+		def to_s
+			"#{@title} with a rank of #{@rank} (#{status})"
+		end
+
+	end
+end
+
+if __FILE__ == $0
+	movie1 = Flicks::Movie.new("Amazing Spiderman",8)
+	puts movie1
+	puts movie1.normalized_rank
+	movie1.thumbs_up
+	movie1.thumbs_down
+	puts movie1.rank
+	movie1.title="crappy spiderman"
+	puts movie1.title
+end

data/lib/movie3d.rb

@@ -0,0 +1,138 @@
+require_relative 'movie'
+
+module Flicks
+	class Movie3D < Movie
+		attr_accessor :wow_factor
+
+		def initialize(title,rank,wow_factor)
+			super(title,rank)
+
+			@wow_factor = wow_factor
+		end
+
+		def thumbs_up
+			self.wow_factor.times { super }
+		end
+
+		def show_effect
+			puts "Wow " * self.wow_factor 
+		end
+	end
+end
+
+if __FILE__ == $0
+	movie3d = Flicks::Movie3D.new('90%',5,10)
+end
+
+# polymorphism - 3dmovie and movie is a kind of relationship
+# we can use 3dmovie on anywhere we expect to use movie this is polymorphism where
+# we can use object A as like, object b, because OBJECT A is kind of
+# object B - inherited 
+
+
+# movie.show_effect
+#above method that is defined in child class doesnt work on super class movie objects because
+#class Movie doesnt have this method. Ruby can only search methods UP on 
+#inhertiance hicharchy. only upwards, superclass and ancestors, never travel down
+#on inheritance. show_effect is a new unique method defined in child class.  
+
+#quickly show you how you can use 
+#reflection(act of reflecting casting back)
+#to look at the class Hierarchy
+#(system of things ranked one above another)
+#Class.superclass || Class.ancestors
+
+# *take away*
+# when you call a method on an object, ruby first tries
+# to find that method in the objects class. If that method 
+# isnt found,ruby looks in the objects super class or module defined inside
+#of superclass
+# and its super class and so on all the way up to the
+# top of the chain
+
+#subclasses inherit behavior(method) and 
+#attributes(instance variables) from parents class.
+#subclasses can also define their own unique behavior
+#that wont be available in their parent class.
+
+
+#subclasses can specialize(modify) behaviors(methods) by overwriting
+#methods that are already defined in the parent class.
+#and by using Super, they can modify existing method.
+
+#subclasses have access to parent class's @instance variables
+
+#we can call parent class methods on child class
+#by using something called super
+
+# class Animal
+#   attr_accessor :name
+
+#   def initialize(name)    #receives name attribute from super and invokes initialize method
+#     @name = name
+#   end
+# end
+
+# class BadDog < Animal
+#   def initialize(age, name)
+#     super(name)  #super invokes the whole initialize method in parent class and sends name attribute
+#     @age = age
+#   end
+# end
+# BadDog.new(2, "bear") => #<BadDog:0x007fb40b2beb68 @age=2, @name="bear">
+
+
+# class Animal
+# 	attr_accessor :name, :speed
+# 	def initialize(name,speed)
+# 		self.name = name
+# 		self.speed = speed
+# 	end
+
+# end
+
+
+# module Runnable
+# 	attr_accessor :name,:speed
+
+# 	def initialize(name,speed)
+# 		self.name = name
+# 		self.speed = speed
+# 	end
+# end
+
+# class Cheetah
+# 	include Runnable
+# 	attr_accessor :power
+# 	def initialize(name,speed,power)
+# 		super(name,speed)
+
+# 		@power = power
+# 	end
+
+# 	def stats
+# 		puts self.name
+# 		puts self.speed
+# 	end
+
+# end
+
+# cheetah = Cheetah.new('cheetah',50,70)
+# puts cheetah.name = "howdy"
+# puts cheetah.stats
+
+# animal = Animal.new('rocky',50)
+# puts animal.inspect
+# puts animal.name
+# cheetah = Cheetah.new('cheetah',50,9000)
+# puts cheetah.name, cheetah.speed,cheetah.power
+
+# When called with specific arguments, eg. super(a, b), the specified arguments will be sent up the method lookup chain. Let's see a quick example:
+# #super invokes same method(this time initialize method) its called on, so it calls on initialize of class Animal.
+
+# This is similar to our previous example, with the difference being that super takes an argument, hence(this time on) the passed in argument is sent to the superclass. Consequently(as a result,outcome,therefore), 
+#in this example when a BadDog class is created the passed in name argument ("bear") is passed to the superclass and set to the @name instance variable.
+
+
+# When you call super from within a method, it will search the inheritance hierarchy for a method(that called super)by the same name and then invoke it. 
+

data/lib/namespaces.rb

@@ -0,0 +1,30 @@
+module MovieSystem
+	VERSION = 1.0
+
+	def self.info
+		puts "Movie system version #{VERSION}"
+	end
+
+	class Player
+	end
+end
+
+
+module GameSystem
+	VERSION = 2.0
+
+	def self.info
+		puts "Game system version #{VERSION}"
+	end
+
+	class Player
+	end
+end
+
+puts MovieSystem::VERSION
+MovieSystem.info
+puts MovieSystem::Player.new
+
+puts GameSystem::VERSION
+GameSystem.info
+puts GameSystem::Player.new

data/lib/playlist.rb

@@ -0,0 +1,111 @@
+require_relative 'dok2_and_quiet'
+require_relative 'snack_bar'
+require_relative 'movie'	
+
+module Flicks
+	class Playlist
+		attr_reader :movies, :name
+
+		def initialize(name)
+			@name = name.capitalize
+			@movies = []
+			puts "\n***#{@name}'s Playlist has been created***"
+		end
+
+		def name=(title)
+			@name = title.capitalize
+			puts "Name of playlist has been modified to #{@name}"
+		end	
+
+		def load_file(from_file)
+			puts "\n::::Loding File #{from_file.capitalize}::::"
+			File.readlines(from_file).each do |line|
+				add_movie(Movie.convert(line))
+			end
+		end
+
+		def save_file(to_file="final_records")
+			puts "\n::::::Saving To File #{to_file.capitalize}::::::"
+			File.open(to_file,"a+") do |file|
+				@movies.sort.map.with_index(1) do |movie, i|
+					file.puts("\t#{i}.#{movie.title},#{movie.rank}")
+				end
+				time = Time.new
+				file.puts time.strftime("Printed on %m/%d/%Y at %I:%M%p")
+			end
+		end
+
+		def add_movie(movie)
+			@movies << movie
+			puts "::added #{movie.title}::"
+		end
+
+		def play(viewings)
+
+			puts "\n\n~~Playing #{@name}'s playlist:~~"
+
+			@movies.sort {|x,y| y.rank <=> x.rank}.each do |movie|
+				puts "\tTrack: #{movie}"
+			end
+
+			snacks = SnackBar::SNACKS
+			puts "\nThere are #{snacks.size} snacks available in the Snack Bar."
+			snacks.sort {|x,y| y.carbs <=> x.carbs }.map.with_index(1) {|snack,i| puts "\t#{i}. #{snack.name.capitalize} - #{snack.carbs} carbs"}
+
+			puts "\nStarting the Movie,Enjoy your show!!"
+			1.upto(viewings) do |counter|
+				puts "\nViewing: #{counter}"
+				@movies.sort.each do |movie|
+					Dok2AndQuiet.review(movie)
+					snack = SnackBar.random
+					movie.ate_snack(snack)
+					puts movie
+					puts "**************************************************"
+				end
+			end
+		end
+
+		def total_playlist_carbs
+			@movies.reduce(0) {|sum,movie| sum + movie.carbs_consumed}
+		end
+
+		def total_playlist_snacks 
+			@movies.reduce(0) {|sum, movie| sum + movie.snack_carbs.keys.size}
+		end
+
+
+		def print_stats
+			puts "\n\n\nPlayList #{@name.upcase!}'s Stats: #{total_playlist_carbs} carbs - #{total_playlist_snacks} snacks"
+
+			@movies.sort {|x,y| y.carbs_consumed <=> x.carbs_consumed }.map.with_index(1) do |movie,i| 
+				puts "#{i}. #{movie.title} - #{movie.carbs_consumed} *total* grand carbs"
+				movie.expose_hash {|key| puts "\t #{key.name} - #{key.carbs} carbs"}
+			end
+
+			hits, flops = @movies.partition {|m| m.hit? }
+
+			puts "\nHits: "
+			hits.sort.each do |movie| 
+				puts "\t#{movie}"
+			end
+
+
+			puts "\nFlops: "
+			flops.sort.each do |movie|
+				puts "\t#{movie}"
+			end
+		end
+	end
+end
+
+if __FILE__ == $0
+	playlist1 = Flicks::Playlist.new("Mastering Ruby 1")
+	movie1 = Flicks::Movie.new("Knowledge and Skill",10)
+	movie2 = Flicks::Movie.new("Focus",20)
+	playlist1.add_movie(movie1)
+	playlist1.add_movie(movie2)
+	# puts playlist1.movies
+	# puts playlist1.name
+	playlist1.play(3)
+end
+

data/lib/rankable.rb

@@ -0,0 +1,26 @@
+module Rankable
+
+	def thumbs_up
+		self.rank += 1 
+	end
+
+	def thumbs_down
+		self.rank -= 1 
+	end
+
+	def hit?
+		self.rank >= 10
+	end
+
+	def status
+		hit? ? "Hit" : "Flop"
+	end
+
+	def normalized_rank
+		self.rank / 2 
+	end
+
+	def <=>(other)
+		other.rank <=> @rank
+	end
+end

data/lib/snack_bar.rb

@@ -0,0 +1,27 @@
+Snack = Struct.new(:name,:carbs)
+
+module SnackBar
+	#constant - identifier with value that cannot be altered(changed)
+	SNACKS = [
+		Snack.new(:popcorn,20),
+		Snack.new(:candy,15),
+		Snack.new(:nachos,40),#class Snack
+		Snack.new(:pretzel,10),
+		Snack.new(:pop,5) #instance object created by class Snack
+	]
+	
+	def self.random
+		SNACKS.sample
+	end
+
+end
+
+if __FILE__ == $0
+	snacks = SnackBar::SNACKS
+	puts snacks
+	snack = SnackBar.random
+	puts "Enjoy your random #{snack.name} with #{snack.carbs} carbs"
+end 
+
+#one snackbar in our program, so it is fit
+#to make module instead of class

data/spec/movie_spec.rb

@@ -0,0 +1,81 @@
+require 'movie'
+require_relative 'spec_helper'
+
+module Flicks
+	RSpec.describe Movie do
+		before do
+			$stdout = StringIO.new
+		end
+
+		context "Let's unit test Movie methods" do
+		    before do
+			   @initial_rank = 10
+			   @movie = Movie.new('goonies',@initial_rank)
+		    end
+
+			it "has a capitalized title" do
+				@movie.title.should_not == "goonies"
+				@movie.title.should == "Goonies"
+			end
+
+			it "has an initial rank" do
+				@movie.rank.should == 10
+			end
+
+			it "has a string representation" do
+				@movie.to_s.should == "Goonies with a rank of 10 (Hit)"
+			end
+
+			it "increases rank by 1 when given a thumbs up" do
+				@movie.thumbs_up
+				@movie.rank.should == @initial_rank + 1
+			end
+
+			it "decreases rank by 1 when given a thumbs down" do
+				@movie.thumbs_down
+				@movie.rank.should == @initial_rank - 1
+			end
+		end
+
+		context "can have default values" do
+			before do
+				@movie = Movie.new('goonies')
+			end
+			
+			it "has a default rank of 0 if not initialized" do
+				@movie.rank.should == 0 
+			end
+		end
+
+		context "with a rank of at least 10." do
+			before do
+				@movie = Movie.new('lawyer',10)
+			end
+
+			it "is a Hit" do 
+				expect(@movie).to be_hit
+			end
+
+			it "has a HIT status" do
+				expect(@movie.status).to eq("Hit")
+			end
+
+
+		end
+
+		context 'with a rank less than 10.' do
+			before do
+				@movie = Movie.new('fantastic 4',5)
+			end
+
+			it "is not a hit" do
+				expect(@movie).to_not be_hit
+			end
+
+			it 'has a Flop status' do
+				expect(@movie.status).to eq('Flop')
+			end
+		end
+	end
+end
+

data/spec/playlist_spec.rb

@@ -0,0 +1,37 @@
+require 'playlist'
+
+module Flicks
+	RSpec.describe Playlist do
+		before do
+			$stdout = StringIO.new
+			@playlist = Playlist.new('show me the money')
+		end
+
+		context '*being played with one movie.' do
+			before do
+				@initial_rank = 10
+				@movie = Movie.new('L4L',@initial_rank)
+				@playlist.add_movie(@movie)
+			end
+
+			it 'gives the movie a thumbs up when high number is rolled' do 
+				allow(Dok2AndQuiet).to receive(:roll).and_return(5)
+				@playlist.play(1)
+
+				expect(@movie.rank).to eq(@initial_rank + 1)
+			end
+
+			it 'skips the movie when medium number is rolled' do 
+				allow(Dok2AndQuiet).to receive(:roll).and_return(3)
+				@playlist.play(1)
+				expect(@movie.rank).to eq(@initial_rank)
+			end
+
+			it 'gives the movie a thumbs down if lower number is rolled' do
+				allow(Dok2AndQuiet).to receive(:roll).and_return(1)
+				@playlist.play(1)
+				expect(@movie.rank).to eq(@initial_rank - 1)
+			end
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]  # default, enables both `should` and `expect`
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = [:should, :expect]  # default, enables both `should` and `expect`
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: blueberry
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Dany Han
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-17 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables:
+- blue
+extensions: []
+extra_rdoc_files: []
+files:
+- README
+- bin/blue
+- bin/movies.csv
+- lib/dok2_and_quiet.rb
+- lib/mixins.rb
+- lib/movie.rb
+- lib/movie3d.rb
+- lib/namespaces.rb
+- lib/playlist.rb
+- lib/rankable.rb
+- lib/snack_bar.rb
+- spec/movie_spec.rb
+- spec/playlist_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: My blueberry gem ;)
+test_files: []