teaas 0.2.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc8f502b0b8d0aff48306cb45a88e4dc200013c5
-  data.tar.gz: f65bf1874853f229de8fea6d9d58b6739fa9ed1a
+  metadata.gz: 18a355e6063a1c263f226e3e1fb342108ce63e7b
+  data.tar.gz: e22de7d3d363e8bc51b57e901af700c20933c200
 SHA512:
-  metadata.gz: 83e119fa2d2dc4209b439fe853789945a0dee95f33c318abb1fe71ed020ec3ac02dfd7e68824450f16197955ec0488a6aab3a9471903599eae8c8505f2d7c8ce
-  data.tar.gz: 0fe5ced77d2c205100dd509253e0ea4321055058d91a743671a4ea8d962aa71c3ae739f9687538705ec655bd38786fba35691de4241565c199b0256ed1e36b16
+  metadata.gz: 01271a554fe2f262e5d1f835713df45b25e4d9de2082e99d80efa62d301a7ec39952c5f7d708aab8652bc3d9b0862ed34eb1f1d72f5f2177b8cfc589212ae384
+  data.tar.gz: e22a13ee0175f2a38bd755e05083a9e6646d803e2f99ebccfb1c67807685be9d10617df5e47f84a358ace37e115e926c839f29916fc7c0e6259e5744c5a958be

data/README.md

@@ -4,6 +4,8 @@
 
 Total Emojis as a Service (Teaas / TEAAS) is a lightweight library that wraps around [RMagick](https://github.com/rmagick/rmagick) and allows easy manipulation of emojis or emoji-like GIFs. Right now, it supports "Turbo"ing the emoji, making it spin, or making a marquee. This is a very early version, with more features and bug fixes to come in the future.
 
+Version `1.0.0.bacon` and higher changes APIs from any prior versions, so make sure to check the documentation.
+
 ## Requirements
 
 - Ruby 1.9.2 or higher
@@ -15,18 +17,32 @@ Total Emojis as a Service (Teaas / TEAAS) is a lightweight library that wraps ar
 
 ### Spin
 
-Spinning an image just takes the image that is input and makes it spin clockwise. It was intended for static images, however it does support spinning the last frame on an animated GIF.
+Spinning an image just takes the image that is input and makes it spin clockwise or counterclockwise. Additionally, it can now spin animated GIFs, as long as the option is selected. Otherwise, will spin a single frame of the GIF.
 
-**NOTE**: Spinning is buggy right now, and only works best on images that are square (32x32 for example). Images that are not square may return invalid results.
+**NOTE**: Spinning only works best on images that are square (32x32 for example). Images that are not square may return unexpected results.
 
 **NOTE**: Spinning removes any transparency from the image.
 
-### Marquee (new!)
+### Marquee
 
 Making an image a marquee involves taking a static image, and making intermediate images so that when the emojis are next to each other, they look like they're flowing together (like a marquee). It's best to try it out and see the results.
 
 **NOTE**: Marquee removes any transparency from the image.
 
+**NOTE**: Marquee supports aniamted GIFs, however depending on the type of GIF, it may not work properly.
+
+### Blood
+
+This overlays a blood animation over the image. Only works for static images, or a single frame of the GIF.
+
+**NOTE**: Blood removes any transparency from the image.
+
+### Fire
+
+This overlays a fire animation over the image. Only works for static images, or a single frame of the GIF.
+
+**NOTE**: Fire removes any transparency from the image.
+
 ## Documentation
 Docs are in [YARD](http://yardoc.org/) format. To build the HTML docs, just `gem install yard` then run `yard`. If you'd rather not use YARD, you can just read the documentation for the methods in the source files.
 
@@ -88,15 +104,51 @@ final_result = Teaas::Turbo.turbo(marquee_result, false)
 
 ### From a `Magick::ImageList`
 ```ruby
-image = Magick::ImageList.new
-
-//populate image here
+image = Magick::Image.read("file.png")
 
 marquee_result = Teaas::Marquee.marquee(image)
 final_result = Teaas::Turbo.turbo(marquee_result, false)
 // final_result contains an array of image blobs
 ```
 
+## Bloodify
+### From a file
+```ruby
+image_path = "image.gif"
+
+bloodify_result = Teaas::Blood.blood_from_file(image_path)
+final_result = Teaas::Turbo.turbo(blood_result, false)
+// final_result contains an array of image blobs
+```
+
+### From a `Magick::ImageList`
+```ruby
+image = Magick::Image.read("file.png")
+
+blood_result = Teaas::Blood.blood(image)
+final_result = Teaas::Turbo.turbo(marquee_result, false)
+// final_result contains an array of image blobs
+```
+
+## Fireify
+### From a file
+```ruby
+image_path = "image.gif"
+
+fireify_result = Teaas::Fire.fire_from_file(image_path)
+final_result = Teaas::Turbo.turbo(fire_result, false)
+// final_result contains an array of image blobs
+```
+
+### From a `Magick::ImageList`
+```ruby
+image = Magick::Image.read("file.png")
+
+fire_result = Teaas::Fire.fire(image)
+final_result = Teaas::Turbo.turbo(marquee_result, false)
+// final_result contains an array of image blobs
+```
+
 # Questions / PRs, etc.
 Feel free to open a GitHub issue or file a pull request if you have a question or would like something added.
 

data/lib/teaas.rb

@@ -1,5 +1,25 @@
 require 'rmagick'
 
+require 'teaas/blood.rb'
+require 'teaas/fire.rb'
+require 'teaas/got.rb'
+require 'teaas/helper.rb'
+require 'teaas/horizontal_roller.rb'
+require 'teaas/intensify.rb'
+require 'teaas/magrittify.rb'
 require 'teaas/marquee.rb'
+require 'teaas/mirror.rb'
+require 'teaas/no.rb'
+require 'teaas/overlayer.rb'
+require 'teaas/parrotify.rb'
+require 'teaas/pulse.rb'
+require 'teaas/resize.rb'
 require 'teaas/spin.rb'
 require 'teaas/turboize.rb'
+require 'teaas/vertical_roller.rb'
+
+module Teaas
+  def self.root
+    File.dirname(__FILE__) + "/.."
+  end
+end

data/lib/teaas/blood.rb

@@ -0,0 +1,25 @@
+module Teaas
+  class Blood
+    # Takes in an image, and adds blood to it. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds.
+    #
+    # @param original_img [Magick::ImageList] The image to be rotated
+    # @return [Magick::ImageList] The spinning image
+    def self.blood(original_img)
+      Overlayer.overlay(original_img, Magick::ImageList.new(Teaas.root + "/img/blood.gif"))
+    end
+
+    # Takes in a path to an image, and adds blood to it. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds. This is a wrapper around {Teaas::Spin.spin}
+    #
+    # @param path [String] Path to the image to be spun
+    # @return [Magick::ImageList] The spinning image
+    def self.blood_from_file(path)
+      img = Magick::ImageList.new
+
+      # Grab the first element in array to prevent strange things when an
+      # animated image is submitted
+      img.read(path)[0]
+
+      blood(img)
+    end
+  end
+end

data/lib/teaas/fire.rb

@@ -0,0 +1,25 @@
+module Teaas
+  class Fire
+    # Takes in an image, and adds flames to it. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds.
+    #
+    # @param original_img [Magick::ImageList] The image to be engufled in flames
+    # @return [Magick::ImageList] The image, now on fire
+    def self.fire(original_img)
+      Overlayer.overlay(original_img, Magick::ImageList.new(Teaas.root + "/img/fire.gif"))
+    end
+
+    # Takes in a path to an image, and adds flames to it. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds. This is a wrapper around {Teaas::Blood.blood}
+    #
+    # @param path [String] Path to the image to be engulfed in flames
+    # @return [Magick::ImageList] The image, now on fire
+    def self.fire_from_file(path)
+      img = Magick::ImageList.new
+
+      # Grab the first element in array to prevent strange things when an
+      # animated image is submitted
+      img.read(path)[0]
+
+      fire(img)
+    end
+  end
+end

data/lib/teaas/got.rb

@@ -0,0 +1,26 @@
+module Teaas
+  class Got
+    # Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds.
+    #
+    # @param original_img [Magick::ImageList] The original image
+    # @return [Magick::ImageList] The resulting image
+    def self.got(original_img)
+      fire_img = Overlayer.overlay(original_img, Magick::ImageList.new(Teaas.root + "/img/fire.gif"))
+      Overlayer.overlay(fire_img, Magick::ImageList.new(Teaas.root + "/img/blood.gif"), :whitelisted_animation => true)
+    end
+
+    # Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds. This is a wrapper around {Teaas::Got.got}
+    #
+    # @param path [String] Path to the image to be spun
+    # @return [Magick::ImageList] The spinning image
+    def self.got_from_file(path)
+      img = Magick::ImageList.new
+
+      # Grab the first element in array to prevent strange things when an
+      # animated image is submitted
+      img.read(path)[0]
+
+      got(img)
+    end
+  end
+end

data/lib/teaas/helper.rb

@@ -0,0 +1,16 @@
+module Teaas
+  class Helper
+    def self.prepare_for_animation(img)
+      new_img = img[0]
+      new_img.dispose = Magick::BackgroundDispose
+      new_img.format = "gif"
+      new_img.background_color = "none"
+
+      new_img
+    end
+
+    def self.animated_gif?(img)
+      img[0].format == "GIF" && img.length > 1
+    end
+  end
+end

data/lib/teaas/horizontal_roller.rb

@@ -0,0 +1,11 @@
+module Teaas
+  class HorizontalRoller
+    def self.roll(img, options)
+      if options[:reverse]
+        img.roll(options[:img_width] * ((options[:total_frames] - options[:frame].to_f) / options[:total_frames]), 0)
+      else
+        img.roll(options[:img_width] * (options[:frame].to_f / options[:total_frames]), 0)
+      end
+    end
+  end
+end

data/lib/teaas/intensify.rb

@@ -0,0 +1,46 @@
+module Teaas
+  class Intensify
+
+    GRAVITY = [
+      Magick::NorthWestGravity,
+      Magick::SouthEastGravity,
+      Magick::SouthWestGravity,
+      Magick::NorthEastGravity,
+      Magick::SouthEastGravity,
+      Magick::NorthWestGravity,
+      Magick::SouthWestGravity,
+    ]
+
+    # Takes in an image, composites a smaller version of it, then returns an animated intensified image image. Best when used with {Teaas::Turboize.turbo} to generate multiple intense speeds.
+    #
+    # @param original_img [Array] An array of [Magick::ImageList]s
+    # @return [Magick::ImageList] The intensified image
+    def self.intensify(original_img)
+      intensifty_image = Magick::ImageList.new
+      img = Teaas::Helper.prepare_for_animation(original_img)
+      final_img = Magick::Image.new(img.columns, img.rows)
+      final_img.format = "gif"
+      intensify_image = Magick::ImageList.new
+
+      img.change_geometry("95%x95%") do |cols, rows, i|
+        i.resize!(cols, rows)
+      end
+
+      GRAVITY.each do |g|
+        intensify_image << final_img.composite(img, g, Magick::OverCompositeOp)
+      end
+
+      intensify_image
+    end
+
+    # Takes in an image from a file, composites a smaller version of it, then returns an animated intensified image image. Best when used with {Teaas::Turboize.turbo} to generate multiple intense speeds. Wrapper around {Teaas::Intensifty.intensify}
+    #
+    # @param path [String] Path to the image to be created to an intensified image
+    # @return [Magick::ImageList] The intensified image
+    def self.intensify_from_file(path)
+      img = Magick::Image.read(path)
+
+      intensify(img)
+    end
+  end
+end

data/lib/teaas/magrittify.rb

@@ -0,0 +1,31 @@
+module Teaas
+  class Magrittify
+    # Takes in an image, and adds a green apple to it. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds.
+    #
+    # @param original_img [Magick::ImageList] The image
+    # @return [Magick::ImageList] The new image
+    def self.magrittify(original_img)
+      Overlayer.overlay(
+        original_img,
+        Magick::ImageList.new(Teaas.root + "/img/greenapple.png"),
+        :static_on_animated => true,
+        :gravity => Magick::CenterGravity,
+        :overlay_resize => 0.6,
+      )
+    end
+
+    # Takes in a path to an image, and adds a green apple to it. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds. This is a wrapper around {Teaas::Magrittify.magrittify}
+    #
+    # @param path [String] Path to the image
+    # @return [Magick::ImageList] The new image
+    def self.magrittify_from_file(path)
+      img = Magick::ImageList.new
+
+      # Grab the first element in array to prevent strange things when an
+      # animated image is submitted
+      img.read(path)[0]
+
+      magrittify(img)
+    end
+  end
+end

data/lib/teaas/marquee.rb

@@ -3,36 +3,94 @@ module Teaas
 
     # Takes in an image, rolls it 20%, 40%, 60%, and 80%, then returns an animated marquee image. Best when used with {Teaas::Turboize.turbo} to generate multiple marquee speeds.
     #
-    # @param original_img [Magick::ImageList] The image to be created into a marquee
+    # @param original_img [Array] An array of [Magick::ImageList]s
     # @return [Magick::ImageList] The marquee image
-    def self.marquee(original_img)
-      marquee_image = Magick::ImageList.new
-      img = original_img.flatten_images
-      img.format = "gif"
-
-      img_width = img.columns
-
-      marquee_image << img
-      marquee_image << img.roll(img_width * 0.2, 0)
-      marquee_image << img.roll(img_width * 0.4, 0)
-      marquee_image << img.roll(img_width * 0.6, 0)
-      marquee_image << img.roll(img_width * 0.8, 0)
-
-      marquee_image
+    def self.marquee(original_img, options = {})
+      if Helper.animated_gif?(original_img)
+        _marquee_animated_image(original_img, options)
+      else
+        _marquee_static_image(original_img, options)
+      end
     end
 
     # Takes in an image, rolls it 20%, 40%, 60%, and 80%, then returns an animated marquee image. Best when used with {Teaas::Turboize.turbo} to generate multiple marquee speeds. This is a wrapper around {Teaas::Marquee.marquee}
     #
     # @param path [String] Path to the image to be created to a marquee image
     # @return [Magick::ImageList] The marquee image
-    def self.marquee_from_file(path)
-      img = Magick::ImageList.new
+    def self.marquee_from_file(path, options = {})
+      img = Magick::Image.read(path)
+
+      marquee(img, options)
+    end
+
+    def self._marquee_animated_image(original_img, options)
+      img_width = original_img[0].columns
+      img_height = original_img[0].rows
+      if img_height > img_width
+        crop = true && options[:crop]
+        img_height = img_width
+      else
+        crop = false
+      end
+
+      original_img_list = Magick::ImageList.new
+      original_img.each { |img| original_img_list << img }
+
+      original_img_list = original_img_list.coalesce
+
+      frames = original_img.length
+      marquee_image = Magick::ImageList.new
 
-      # Grab the first element in array to prevent strange things when an
-      # animated image is submitted
-      img.read(path)[0]
+      original_img_list.each_with_index do |img, i|
+        img.crop!(Magick::CenterGravity, img_width, img_width) if crop
+        img.dispose = Magick::BackgroundDispose
+        roller = _roller(options)
+        marquee_image << roller.roll(
+          img,
+          :img_width => img_width,
+          :img_height => img_height,
+          :frame => i,
+          :total_frames => frames,
+          :reverse => options[:reverse],
+        )
+      end
+
+      marquee_image
+    end
+
+    def self._marquee_static_image(original_img, options)
+      marquee_image = Magick::ImageList.new
+      img = Teaas::Helper.prepare_for_animation(original_img)
+
+      img_width = img.columns
+      img_height = img.rows
+
+      if (img_height > img_width) && options[:crop]
+        img.crop_resized!(img_width, img_width, Magick::CenterGravity)
+        img_height = img_width
+      end
+
+      5.times do |i|
+        roller = _roller(options)
+        marquee_image << roller.roll(
+          img,
+          :img_width => img_width,
+          :img_height => img_height,
+          :frame => i,
+          :total_frames => 5,
+          :reverse => options[:reverse],
+        )
+      end
+
+      marquee_image
+    end
 
-      marquee(img)
+    def self._roller(options)
+      if options[:horizontal]
+        Teaas::HorizontalRoller
+      else
+        Teaas::VerticalRoller
+      end
     end
   end
 end

data/lib/teaas/mirror.rb

@@ -0,0 +1,21 @@
+module Teaas
+  class Mirror
+    def self.mirror(original_img, options = {})
+      if original_img[0].format == "GIF" && original_img.length > 1
+        mirrored_image = Magick::ImageList.new
+        original_img.each do |img|
+          mirrored_image << img.flop
+        end
+        mirrored_image
+      else
+        original_img[0].flop
+      end
+    end
+
+    def self.mirror_from_file(path, options = {})
+      img = Magick::Image.read(path)
+
+      mirror(img, options)
+    end
+  end
+end

data/lib/teaas/no.rb

@@ -0,0 +1,25 @@
+module Teaas
+  class No
+    # Takes in an image, and adds no to it. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds.
+    #
+    # @param original_img [Magick::ImageList] The image to be rotated
+    # @return [Magick::ImageList] The spinning image
+    def self.no(original_img)
+      Overlayer.overlay(original_img, Magick::ImageList.new(Teaas.root + "/img/no.png"), :static_on_animated => true, :gravity => Magick::CenterGravity)
+    end
+
+    # Takes in a path to an image, and adds no to it. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds. This is a wrapper around {Teaas::Spin.spin}
+    #
+    # @param path [String] Path to the image to be spun
+    # @return [Magick::ImageList] The spinning image
+    def self.no_from_file(path)
+      img = Magick::ImageList.new
+
+      # Grab the first element in array to prevent strange things when an
+      # animated image is submitted
+      img.read(path)[0]
+
+      no(img)
+    end
+  end
+end

data/lib/teaas/overlayer.rb

@@ -0,0 +1,66 @@
+module Teaas
+  class Overlayer
+    def self.overlay(original_img, overlay_img, options={})
+      if options[:whitelisted_animation]
+        overlay_animated_on_animated(original_img, overlay_img, options)
+      elsif options[:static_on_animated]
+        overlay_static_on_animated(original_img, overlay_img, options)
+      else
+        overlay_animated_on_static(original_img, overlay_img, options={})
+      end
+    end
+
+    def self.overlay_static_on_animated(img, overlay_img, options)
+      overlay_resize = options[:overlay_resize] || 1
+      image = Magick::ImageList.new
+      overlay_img.each do |image|
+        image.resize_to_fit!(img.columns * overlay_resize, img.rows * overlay_resize)
+      end
+      gravity = options[:gravity] || Magick::SouthGravity
+
+      overlay_img.gravity = gravity
+      img.each do |i|
+        i.composite!(overlay_img, gravity, Magick::OverCompositeOp)
+      end
+
+      img
+    end
+
+    def self.overlay_animated_on_animated(img, overlay_img, options)
+      overlay_img.each do |image|
+        image.resize_to_fit!(img.columns, img.rows)
+      end
+
+      new_image = img
+      new_overlay_img = overlay_img
+
+      total_frames = img.length * overlay_img.length
+
+      ((total_frames / img.length)-1).times do
+        new_image += img
+      end
+
+      ((total_frames / overlay_img.length)-1).times do
+        new_overlay_img += overlay_img
+      end
+      new_image.gravity = options[:gravity] ? options[:gravity] : Magick::SouthGravity
+      new_image = new_image.composite_layers(new_overlay_img)
+
+      new_image
+    end
+
+    def self.overlay_animated_on_static(original_img, overlay_img, options)
+      image = Magick::ImageList.new
+      img = Teaas::Helper.prepare_for_animation(original_img)
+      overlay_img.each do |image|
+        image.resize_to_fit!(img.columns, img.rows)
+      end
+      image << img
+
+      image.gravity = options[:gravity] ? options[:gravity] : Magick::SouthGravity
+      image = image.composite_layers(overlay_img)
+
+      image
+    end
+  end
+end

data/lib/teaas/parrotify.rb

@@ -0,0 +1,49 @@
+module Teaas
+  class Parrotify
+    OFFSETS = [
+      {:x_offset => 1, :y_offset => 1},
+      {:x_offset => 0.8857, :y_offset => 0.98},
+      {:x_offset => 0.7714, :y_offset => 0.98},
+      {:x_offset => 0.6857, :y_offset => 1.02},
+      {:x_offset => 0.6571, :y_offset => 1.04},
+      {:x_offset => 0.7428, :y_offset => 1.08},
+      {:x_offset => 0.8571, :y_offset => 1.12},
+      {:x_offset => 0.9714, :y_offset => 1.12},
+      {:x_offset => 1.0571, :y_offset => 1.1},
+      {:x_offset => 1.0857, :y_offset => 1.08}
+    ]
+
+
+    # Best when used with {Teaas::Turboize.turbo} to generate multiple intense speeds.
+    #
+    # @param original_img [Array] An array of [Magick::ImageList]s
+    # @return [Magick::ImageList] The parrotified image
+    def self.parrotify(original_img)
+      parrotify_image = Magick::ImageList.new
+      img = Teaas::Helper.prepare_for_animation(original_img)
+      width = img.columns
+      height = img.rows
+      final_img = Magick::Image.new(width, height)
+      final_img.format = "gif"
+      parrotify_image = Magick::ImageList.new
+
+      OFFSETS.each do |o|
+        x_coord = width * (1 - o[:x_offset])
+        y_coord = (height * (1 - o[:y_offset])) + (0.3 * height)
+        parrotify_image << final_img.composite(img, x_coord, y_coord, Magick::OverCompositeOp)
+      end
+
+      parrotify_image
+    end
+
+    # Best when used with {Teaas::Turboize.turbo} to generate multiple intense speeds. Wrapper around {Teaas::Parrotify.parrotify}
+    #
+    # @param path [String] Path to the image to be created to an parrotified image
+    # @return [Magick::ImageList] The parrotified image
+    def self.parrotify_from_file(path)
+      img = Magick::Image.read(path)
+
+      parrotify(img)
+    end
+  end
+end

data/lib/teaas/pulse.rb

@@ -0,0 +1,35 @@
+module Teaas
+  class Pulse
+
+    # This is a snapshot of a broken version of Spin that creates a cool pulsing image.
+    #
+    # @param original_img [Magick::ImageList] The image to be rotated
+    # @return [Magick::ImageList] The pulsing image
+    def self.pulse(original_img)
+      pulsing_image = Magick::ImageList.new
+      img = Teaas::Helper.prepare_for_animation(original_img)
+
+      increment = 360 / 8
+
+      8.times do |i|
+        pulsing_image << img.rotate(increment * i+1).resize_to_fill(original_img.columns, original_img.rows)
+      end
+
+      pulsing_image
+    end
+
+    # This is a snapshot of a broken version of Spin that creates a cool pulsing image.
+    #
+    # @param path [String] Path to the image to be spun
+    # @return [Magick::ImageList] The pulsing image
+    def self.pulse_from_file(path)
+      img = Magick::ImageList.new
+
+      # Grab the first element in array to prevent strange things when an
+      # animated image is submitted
+      img.read(path)[0]
+
+      pulse(img)
+    end
+  end
+end

data/lib/teaas/resize.rb

@@ -0,0 +1,26 @@
+module Teaas
+  class Resize
+    def self.resize(img, resize, options={})
+      img = img.coalesce
+      resize = "#{img.columns}x#{img.rows}" if resize.nil? || resize.empty?
+      img.each do |frame|
+        frame.change_geometry(resize) do |cols, rows, i|
+          if options[:sample]
+            i.sample!(cols, rows)
+          else
+            i.resize!(cols, rows)
+          end
+        end
+      end
+
+      img
+    end
+
+    def self.resize_from_file(path, resize, options={})
+      img = Magick::ImageList.new
+      img.read(path)
+
+      resize(img, resize, options)
+    end
+  end
+end

data/lib/teaas/spin.rb

@@ -1,35 +1,76 @@
 module Teaas
   class Spin
 
-    # Takes in an image, rotates it 90, 180, and 270 degrees, then returns an animated spinning image. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds.
+    # Takes in an image, rotates it based on the number of rotations specified, then returns an animated spinning image. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds.
     #
     # @param original_img [Magick::ImageList] The image to be rotated
     # @return [Magick::ImageList] The spinning image
-    def self.spin(original_img)
-      spinny_image = Magick::ImageList.new
-      img = original_img.flatten_images
-      img.format = "gif"
-
-      spinny_image << img
-      spinny_image << img.rotate(90)
-      spinny_image << img.rotate(180)
-      spinny_image << img.rotate(270)
+    def self.spin(original_img, options={})
+      rotations = options[:rotations] ? options[:rotations] : 4
+      counterclockwise = options[:counterclockwise]
 
-      spinny_image
+      if Helper.animated_gif?(original_img)
+        _spin_animated_image(original_img, rotations, counterclockwise)
+      else
+        _spin_static_image(original_img, rotations, counterclockwise)
+      end
     end
 
-    # Takes in a path to an image, rotates it 90, 180, and 270 degrees, then returns an animated spinning image. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds. This is a wrapper around {Teaas::Spin.spin}
+    # Takes in a path to an image, rotates it based on the number of rotations specified, then returns an animated spinning image. Best when used with {Teaas::Turboize.turbo} to generate multiple rotation speeds. This is a wrapper around {Teaas::Spin.spin}
     #
     # @param path [String] Path to the image to be spun
     # @return [Magick::ImageList] The spinning image
-    def self.spin_from_file(path)
+    def self.spin_from_file(path, options={})
       img = Magick::ImageList.new
 
       # Grab the first element in array to prevent strange things when an
       # animated image is submitted
       img.read(path)[0]
 
-      spin(img)
+      spin(img, options)
+    end
+
+    def self._increment(increment, i, counterclockwise, rotations)
+      if counterclockwise
+        increment * (rotations - (i+1))
+      else
+        increment * (i+1)
+      end
+    end
+
+    def self._spin_static_image(original_img, rotations, counterclockwise)
+      spinny_image = Magick::ImageList.new
+      img = Teaas::Helper.prepare_for_animation(original_img)
+
+      increment = 360 / rotations
+
+      rotations.times do |i|
+        temp_img = img.rotate(_increment(increment, i, counterclockwise, rotations)).crop(Magick::NorthWestGravity, original_img.columns, original_img.rows, true)
+        spinny_image << temp_img
+      end
+
+      spinny_image
+    end
+
+    def self._spin_animated_image(original_img, rotations, counterclockwise)
+      frames = original_img.length
+      original_img_list = Magick::ImageList.new
+
+      original_img.each { |img| original_img_list << img }
+      original_img_list = original_img.coalesce
+      spinny_image = Magick::ImageList.new
+
+      increment = 360 / rotations
+
+      rotations.times do |i|
+        original_img_list.each do |img|
+          img.dispose = Magick::BackgroundDispose
+          temp_img = img.rotate(_increment(increment, i, counterclockwise, rotations)).crop(Magick::NorthWestGravity, original_img_list.columns, original_img_list.rows, true)
+          spinny_image << temp_img
+        end
+      end
+
+      spinny_image
     end
   end
 end

data/lib/teaas/turboize.rb

@@ -7,19 +7,15 @@ module Teaas
     # @param resize [Integer or Falsey] The size of the largest dimension (eg. 32) for the image, or falsey if no resizing should occur
     # @param speeds [Array] An array of Integers that determines the ticks per second for the resulting animated image
     # @return [Array] An array of image blobs that match each specified speed
-    def self.turbo(img, resize, speeds=[2, 5, 10, 20, 30, 40])
-      if resize
-        img = img.coalesce
-        img.each do |frame|
-          frame.change_geometry(resize) do |cols, rows, i|
-            i.resize!(cols, rows)
-          end
-        end
+    def self.turbo(img, resize, speeds=[2, 5, 10, 20, 30, 40], options={})
+      speeds = [2, 5, 10, 20, 30, 40] if speeds.nil?
+      if !resize.nil? && !resize.empty?
+        img = Teaas::Resize.resize(img, resize, options)
       end
 
       image_blobs = []
       speeds.each do |turbo|
-        image_blobs << turboize_individual_image(img, turbo).to_blob
+        image_blobs << turboize_individual_image(img, turbo, options).to_blob
       end
 
       image_blobs
@@ -31,11 +27,11 @@ module Teaas
     # @param resize Truthy if the image should be resized, falsey or nil if it should not
     # @param speeds [Array] An array of Integers that determines the ticks per second for the resulting animated image
     # @return [Array] An array of image blobs that match each specified speed
-    def self.turbo_from_file(path, resize, speeds=[2, 5, 10, 20, 30, 40])
+    def self.turbo_from_file(path, resize, speeds=[2, 5, 10, 20, 30, 40], options={})
       img = Magick::ImageList.new
       img.read(path)
 
-      turbo(img, resize, speeds)
+      turbo(img, resize, speeds, options)
     end
 
     # Takes in a `Magick::ImageList` and adjusts the GIF image delay, ticks per second, and iterations.
@@ -43,8 +39,8 @@ module Teaas
     # @param img [Magick::ImageList]
     # @param turbo [Integer] the ticks per second
     # @return [Magick::ImageList]
-    def self.turboize_individual_image(img, turbo)
-      img.delay = 1
+    def self.turboize_individual_image(img, turbo, options={})
+      img.delay = options[:delay] || 1
       img.ticks_per_second = turbo
       img.iterations = 0
       img

data/lib/teaas/vertical_roller.rb

@@ -0,0 +1,11 @@
+module Teaas
+  class VerticalRoller
+    def self.roll(img, options)
+      if options[:reverse]
+        img.roll(0, options[:img_height] * ((options[:total_frames] - options[:frame].to_f) / options[:total_frames]))
+      else
+        img.roll(0, options[:img_height] * (options[:frame].to_f / options[:total_frames]))
+      end
+    end
+  end
+end

data/teaas.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'teaas'
-  s.version     = '0.2.3'
+  s.version     = '1.0.0'
   s.licenses    = ['MIT']
   s.summary     = "Total Emojis as a Service"
   s.description = "Gem to manipulate emoji-sized images"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teaas
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Bill Rastello
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2016-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rmagick
@@ -50,10 +50,28 @@ files:
 - Gemfile
 - LICENSE
 - README.md
+- img/blood.gif
+- img/fire.gif
+- img/greenapple.png
+- img/no.png
 - lib/teaas.rb
+- lib/teaas/blood.rb
+- lib/teaas/fire.rb
+- lib/teaas/got.rb
+- lib/teaas/helper.rb
+- lib/teaas/horizontal_roller.rb
+- lib/teaas/intensify.rb
+- lib/teaas/magrittify.rb
 - lib/teaas/marquee.rb
+- lib/teaas/mirror.rb
+- lib/teaas/no.rb
+- lib/teaas/overlayer.rb
+- lib/teaas/parrotify.rb
+- lib/teaas/pulse.rb
+- lib/teaas/resize.rb
 - lib/teaas/spin.rb
 - lib/teaas/turboize.rb
+- lib/teaas/vertical_roller.rb
 - teaas.gemspec
 homepage: https://www.github.com/wjr1985/teaas/
 licenses: