rails_imager 0.0.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4c248058b9c9a017897c2e1fd52700bd58510a11
+  data.tar.gz: dc53d7c0db172e315f661f2af858b10eaf83c20c
+SHA512:
+  metadata.gz: bf9a71fd2e691b4ec05addd493aaaa3f37e94976a683a3946470c33ab0a3c84d27e1137c635485d93e45a76510e40288c096ab5c6088e72131d30756052ff245
+  data.tar.gz: b4fb1dbe754b95503e4e23837174991cdc9d8d6dcc2fcab4d10509c7176ad3c93ea3abba418bc49504479359e566196f6290201d1822da3f7ee11bdc38ddb13d

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RailsImager'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/rails_imager/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/javascripts/rails_imager/images.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/app/assets/stylesheets/rails_imager/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/assets/stylesheets/rails_imager/images.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/controllers/rails_imager/application_controller.rb

@@ -0,0 +1,4 @@
+module RailsImager
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/rails_imager/images_controller.rb

@@ -0,0 +1,33 @@
+require_dependency "rails_imager/application_controller"
+
+class RailsImager::ImagesController < ApplicationController
+  def show
+    rimger = RailsImager::ImageHandler.new
+    
+    image_params = params[:image] || {}
+    
+    # Check for invalid parameters.
+    image_params.each do |key, val|
+      raise ArgumentError, "Invalid parameter: '#{key}'." unless RailsImager::ImageHandler::PARAMS_ARGS.map{ |param| param.to_s }.include?(key)
+    end
+    
+    image_path = "#{Rails.public_path}/#{params[:id]}"
+    image_path = File.realpath(image_path)
+    validate_path(image_path)
+    
+    image = Magick::Image.read(image_path).first
+    image = rimger.img_from_params(:image => image, :params => image_params)
+    
+    response.headers["Expires"] = 2.hours.from_now.httpdate
+    response.headers["Last-Modified"] = File.mtime(image_path).httpdate
+    
+    send_data image.to_blob, :type => "image/png", :disposition => "inline"
+  end
+  
+private
+  
+  def validate_path(image_path)
+    raise "No such file: '#{image_path}'." unless File.exists?(image_path)
+    raise "Image wasn't in the public folder: '#{image_path}'." unless image_path.start_with?(Rails.public_path.to_s)
+  end
+end

data/app/helpers/rails_imager/application_helper.rb

@@ -0,0 +1,4 @@
+module RailsImager
+  module ApplicationHelper
+  end
+end

data/app/helpers/rails_imager/images_helper.rb

@@ -0,0 +1,26 @@
+require "uri"
+
+module RailsImager::ImagesHelper
+  def rails_imager_p(path, args = {})
+    newpath = "/rails_imager/images/"
+    newpath << URI.encode(path)
+    newpath << "/?"
+    
+    first = true
+    args.each do |key, val|
+      if first
+        first = false
+      else
+        newpath << "&"
+      end
+      
+      realkey = "image[#{key}]"
+      
+      newpath << URI.encode(realkey.to_s)
+      newpath << "="
+      newpath << URI.encode(val.to_s)
+    end
+    
+    return newpath
+  end
+end

data/app/views/layouts/rails_imager/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>RailsImager</title>
+  <%= stylesheet_link_tag    "rails_imager/application", media: "all" %>
+  <%= javascript_include_tag "rails_imager/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/rails_imager/images/show.html.erb

@@ -0,0 +1,2 @@
+<h1>Images#show</h1>
+<p>Find me in app/views/rails_imager/images/show.html.erb</p>

data/config/routes.rb

@@ -0,0 +1,3 @@
+RailsImager::Engine.routes.draw do
+  resources :images, :constraints => { :id => /.*/ }, :only => :show
+end

data/lib/rails_imager.rb

@@ -0,0 +1,17 @@
+require "rails_imager/engine"
+
+module RailsImager
+  def self.const_missing(name)
+    if name.to_s.end_with?("Controller")
+      path = "#{File.dirname(__FILE__)}/../app/controllers/rails_imager/#{StringCases.camel_to_snake(name)}"
+    elsif name.to_s.end_with?("Helper")
+      path = "#{File.dirname(__FILE__)}/../app/helpers/rails_imager/#{StringCases.camel_to_snake(name)}"
+    else
+      path = "#{File.dirname(__FILE__)}/rails_imager/#{StringCases.camel_to_snake(name)}"
+    end
+    
+    require path
+    raise LoadError, "Not autoloaded: #{name}" unless const_defined?(name)
+    return const_get(name)
+  end
+end

data/lib/rails_imager/engine.rb

@@ -0,0 +1,5 @@
+module RailsImager
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsImager
+  end
+end

data/lib/rails_imager/image_handler.rb

@@ -0,0 +1,241 @@
+require "RMagick"
+require "knjrbfw"
+require "tmpdir"
+
+class RailsImager::ImageHandler
+  PARAMS_ARGS = [:width, :height, :smartsize, :maxwidth, :maxheight, :rounded_corners, :border, :border_color]
+  
+  #This is the default cache which is plased in the temp-directory, so it will be cleared on every restart. It should always exist.
+  DEFAULT_CACHE_DIR = "#{Dir.tmpdir}/rails-imager-cache"
+  Dir.mkdir(DEFAULT_CACHE_DIR) if !Dir.exists?(DEFAULT_CACHE_DIR)
+  
+  #Default arguments unless something else is given in constructor.
+  DEFAULT_ARGS = {
+    :cache_dir => DEFAULT_CACHE_DIR
+  }
+  
+  INITIALIZE_ALLOWED_ARGS = [:cache_dir]
+  #Initializes the RailsImager.
+  def initialize(args = {})
+    args.each do |key, val|
+      raise "Invalid argument: '#{key}'." unless INITIALIZE_ALLOWED_ARGS.include?(key)
+    end
+    
+    @args = DEFAULT_ARGS.merge(args)
+  end
+  
+  IMG_FROM_PARAMS_ALLOWED_ARGS = [:image, :params]
+  #Create a new image-object based on the given image-object and the parameters.
+  def img_from_params(args)
+    args.each do |key, val|
+      raise "Invalid argument: '#{key}'." unless IMG_FROM_PARAMS_ALLOWED_ARGS.include?(key)
+    end
+    
+    #Set up vars.
+    img = args[:image]
+    raise "No image given." unless img
+    raise "Wrong image-object given: '#{img.class.name}'." unless img.is_a?(Magick::Image)
+    
+    params = args[:params]
+    raise "No params given." unless params
+    
+    img_width = img.columns
+    img_height = img.rows
+    
+    width = img_width
+    height = img_height
+    
+    width = params[:width].to_i if params[:width].to_i > 0
+    height = params[:height].to_i if params[:height].to_i > 0
+    
+    #Check arguments and manipulate image.
+    if params[:smartsize]
+      if img_width > img_height
+        width = params[:smartsize].to_i
+        height = (img_height.to_f / (img_width.to_f / width.to_f)).to_i
+      else
+        height = params[:smartsize].to_i
+        width = (img_width.to_f / (img_height.to_f / height.to_f)).to_i
+      end
+    end
+    
+    if params[:maxwidth]
+      maxwidth = params[:maxwidth].to_i
+      
+      if width > maxwidth
+        height = (img_height.to_f / (img_width.to_f / maxwidth.to_f)).to_i
+        width = maxwidth
+      end
+    end
+    
+    if params[:maxheight]
+      maxheight = params[:maxheight].to_i
+      
+      if height > maxheight
+        width = (img_width.to_f / (img_height.to_f / maxheight.to_f)).to_i
+        height = maxheight
+      end
+    end
+    
+    if params[:width] && !params[:height]
+      height = (img_height.to_f / (img_width.to_f / width.to_f)).to_i
+    elsif params[:height] && !params[:width]
+      width = (img_width.to_f / (img_height.to_f / height.to_f)).to_i
+    elsif params[:width] && params[:height]
+      width = params[:width].to_i
+      height = params[:height].to_i
+    end
+    
+    if width != img_width || height != img_height
+      img = img.resize(width, height)
+    end
+    
+    if params[:rounded_corners]
+      img = img.clone
+      args = {:img => img, :radius => params[:rounded_corners].to_i}
+      
+      if params[:border] && params[:border_color]
+        args[:border] = params[:border].to_i
+        args[:border_color] = params[:border_color]
+      end
+      
+      Knj::Image.rounded_corners(args)
+    end
+    
+    return img
+  end
+  
+  CACHENAME_FROM_PARAMS_ALLOWED_ARGS = [:params, :image, :fpath]
+  #Returns the path to a cached object based on the given filepath, image and request-parameters.
+  def cachename_from_params(args)
+    args.each do |key, val|
+      raise "Invalid argument: '#{key}'." unless CACHENAME_FROM_PARAMS_ALLOWED_ARGS.include?(key)
+    end
+    
+    params = args[:params]
+    raise "No params was given." unless params
+    
+    if args[:image] && !args[:image].filename.to_s.strip.empty?
+      name = Knj::Strings.sanitize_filename(args[:image].filename)
+    elsif args[:fpath]
+      name = Knj::Strings.sanitize_filename(args[:fpath])
+    else
+      raise "No image or fpath was given."
+    end
+    
+    name << "__ARGS__"
+    
+    PARAMS_ARGS.each do |val|
+      name += "_" unless name.empty?
+      name += "#{val}-#{params[val]}"
+    end
+    
+    return name
+  end
+  
+  FORCE_CACHE_FROM_PARAMS_ALLOWED_ARGS = [:fpath, :image, :request, :params]
+  #Checks if a cache-file is created for the given filepath or image. If not then it will be created. If the cache-object is too old, then it will updated. Then returns the path to the cache-object in the end.
+  def force_cache_from_request(args)
+    args.each do |key, val|
+      raise "Invalid argument: '#{key}'." if !FORCE_CACHE_FROM_PARAMS_ALLOWED_ARGS.include?(key)
+    end
+    
+    img = nil
+    
+    if args[:fpath] && !args[:fpath].to_s.strip.empty?
+      fpath = args[:fpath]
+    elsif args[:image] && !args[:image].filename.to_s.strip.empty?
+      fpath = args[:image].filename
+      img = args[:image]
+    else
+      raise "No image or filename was given."
+    end
+    
+    request = args[:request]
+    raise "Invalid request: '#{request.class.name}'." if !request
+    params = args[:params]
+    raise "No parameters on that request: '#{params.class.name}'." if !params
+    
+    mod_time = File.mtime(fpath)
+    cachename = self.cachename_from_params(:fpath => fpath, :params => params)
+    cachepath = "#{@args[:cache_dir]}/#{cachename}"
+    not_modified = false
+    headers = request.headers
+    
+    if !File.exists?(cachepath) || File.mtime(cachepath) < File.mtime(fpath)
+      should_generate = true
+    else
+      should_generate = false
+    end
+    
+    if should_generate
+      img = Magick::Image.read(fpath).first unless img
+      img = self.img_from_params(:image => img, :params => params)
+      img.write(cachepath)
+    else
+      if_mod_since_time = nil
+      if headers["HTTP_IF_MODIFIED_SINCE"]
+        if_mod_since_time = Datet.in(headers["HTTP_IF_MODIFIED_SINCE"]).time
+      else
+        if_mod_since_time = request.if_modified_since
+      end
+      
+      not_modified = true if if_mod_since_time && if_mod_since_time.utc.to_s == mod_time.utc.to_s
+    end
+    
+    return {
+      :cachepath => cachepath,
+      :generated => should_generate,
+      :not_modified => not_modified,
+      :mod_time => mod_time
+    }
+  end
+  
+  HANDLE_ALLOWED_ARGS = [:fpath, :image, :controller, :params]
+  #Automatically handles the image with generation, cache control and more.
+  def handle(args)
+    args.each do |key, val|
+      raise "Invalid argument: '#{key}'." if !HANDLE_ALLOWED_ARGS.include?(key)
+    end
+    
+    controller = args[:controller]
+    raise "No controller was given." if !controller
+    request = controller.request
+    params = args[:params]
+    raise "No params was given." if !params
+    
+    if args[:image]
+      fpath = args[:image].filename
+    elsif args[:fpath]
+      fpath = args[:fpath]
+    end
+    
+    raise "No filepath was given." if !fpath
+    res = self.force_cache_from_request(fpath: fpath, request: request, params: params)
+    
+    if res[:not_modified]
+      controller.render :nothing => true, :status => "304 Not Modified"
+    else
+      controller.expires_in 1.weeks, public: true
+      controller.response.header["Last-Modified"] = res[:mod_time].to_s
+      controller.send_file res[:cachepath], type: "image/png", disposition: "inline", filename: "picture.png"
+    end
+  end
+  
+  #Yields every cache-file to the block. If the block returns true, then the cache-file will be deleted. If no block is given all the cache will be deleted.
+  def clear_cache(&blk)
+    Dir.foreach(@args[:cache_dir]) do |file|
+      next if file == "." || file == ".."
+      fn = "#{@args[:cache_dir]}/#{file}"
+      next if !File.file?(fn)
+      
+      if blk == nil
+        res = true
+      else
+        res = yield(fn)
+      end
+      
+      File.unlink(fn) if res == true
+    end
+  end
+end