picture_handler 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 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/README.rdoc

@@ -0,0 +1,3 @@
+= PictureHandler
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,32 @@
+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    = 'PictureHandler'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+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/lib/picture_handler/configuration.rb

@@ -0,0 +1,11 @@
+module PictureHandler
+    class Configuration
+
+      attr_accessor :file_sys, :s3_bucket, :region
+
+      def initialize
+        @file_sys      = :file
+      end
+
+     end
+end

data/lib/picture_handler/exceptions.rb

@@ -0,0 +1,61 @@
+module PictureHandler
+  module Exceptions
+
+    class CustomMessage < StandardError
+      alias :orig_to_s :to_s
+      def to_s
+        @data
+      end
+
+      def message
+        @data
+      end
+
+    end
+
+    class CustomError < CustomMessage
+      def initialize(error_description)
+        @data = "#{error_description}"
+      end
+    end
+
+    class VersionError < CustomMessage
+      def initialize(version_name)
+        @data = "The Version: \"#{version_name}\" is use as a FROM but doesn't exist."
+      end
+    end
+
+    class InitError < CustomMessage
+      def initialize(uploader_name)
+        @data = "The Uploader: \"#{uploader_name}\" have not been initialized."
+      end
+    end
+
+    class WrongArgument < CustomMessage
+      def initialize(method)
+        @data = "The argument(s) you provided for the method: \"#{method}\" are incomplete or wrong."
+      end
+    end
+
+    class NoMethodError < CustomMessage
+      def initialize(method)
+        @data = "The minimagick method: \"#{method}\" is not a minimagick supported method."
+      end
+    end
+
+    class OpenError < CustomMessage
+      def initialize(source)
+        @data = "The image at source: \"#{source}\" could not be open."
+      end
+    end
+
+    class WriteError < CustomMessage
+      def initialize(path)
+        @data = "The image could not be write at \"#{path}\" path."
+      end
+    end
+
+  end
+end
+
+

data/lib/picture_handler/mounter.rb

@@ -0,0 +1,124 @@
+module PictureHandler
+
+  module Mounter
+
+    def self.included(base)
+
+      base.extend		ClassMethods
+      base.class_eval do
+        cattr_accessor :column
+        cattr_reader :uploaders
+
+        attr_accessor :remote_path
+        attr_reader :model_filename, :uploader, :old_record, :populated
+      end
+      base.class_variable_set('@@uploaders', {})
+
+    end
+
+
+    module ClassMethods
+
+      # Choose the field to action the image with
+      def storage_field(column, picture_handler)
+
+        before_save :picture_store
+        before_destroy :picture_delete
+
+        # Save the COLUMN !
+        self.column = column
+
+        # Put this uploader in the uploader list
+        self.uploaders[column] = picture_handler
+
+        # Inside this class_eval, we are in the instance so you can access Model.picture
+        class_eval <<-RUBY
+
+          # Overwrite the field 'storage field' so you can return a formated object instead
+          def #{column}
+            get_object_or_string(self[__method__.to_sym], __method__)
+          end
+
+        RUBY
+
+      end
+
+    end # ClassMethod
+
+    private  # -------- #
+
+    # Every time model.picture is called
+    def get_object_or_string(attribute, column)
+
+      build_picture_handler_object(attribute, column) if !@uploader
+      @uploader
+
+    end
+
+    # CREATE an instance of PictureUploader::Base if the Object has not been created yet
+    def build_picture_handler_object(attribute, column)
+
+      @populated = false
+      @column = self.class.column.to_s
+      attribute = self.class.uploaders[column].new(self)
+      @uploader = attribute
+      @model_filename = ""
+
+      @old_record = !self.id.blank?
+      # If the record already exist, populate the name
+      if @old_record
+        # Active Record, write as attribute for Model.#{column}
+        @model_filename = read_attribute(@column)
+      end
+
+    end
+
+
+    def register_active_record_attribute
+
+      # If there is no image, it means it is an old record that haven't changed yet (not populated yet)
+      raise PictureHandler::Exceptions::CustomError.new(
+                "Trying to save ActiveRecord attribute, but there is no image populated yet.") if !@populated || @uploader.image.nil?
+
+      # This return either the filename chosen by the dev or the default filename of PictureUploader::Base class method filename
+      @model_filename = @uploader.real_filename + "." + @uploader.image.type.downcase
+
+      # Active Record, write as attribute for Model.#{column}
+      write_attribute(@column, @model_filename)
+      @model_filename
+
+    end
+
+    # Trigger when ActiveRecord Model.destroy
+    def picture_delete
+
+      # Call Model.column field
+      column = self.class.column.to_s
+      self.send(column) if @uploader.nil?
+
+      @uploader.delete_all
+
+    end
+
+    # Trigger when ActiveRecord Model.save
+    def picture_store
+
+      # Call Model.column field
+      column = self.class.column.to_s
+      self.send(column) if @uploader.nil?
+
+      # If we are in an already existing record a no remote_path have been given prior to save
+      return if @old_record && self.remote_path.blank?
+
+      # STORE IT
+      @uploader.store
+      @populated = true
+
+      # Ask for a write inside the ActiveRecord Attribute field
+      register_active_record_attribute
+
+    end
+
+  end
+
+end

data/lib/picture_handler/uploader/base.rb

@@ -0,0 +1,162 @@
+module PictureHandler
+  module Uploader
+
+    class Base
+
+      include PictureHandler::Uploader::MiniMagick
+      include PictureHandler::Uploader::ImgVersion
+      include ('PictureHandler::Uploader::FileSystem::' + PictureHandler.configuration.file_sys.to_s.camelize).constantize
+
+      attr_accessor :image, :model, :versions
+      attr_reader :real_filename
+
+      def initialize(model=nil)
+        # Set once
+        @image = nil
+        @model = model
+        @versions = {}
+        register_versions
+
+        # Changing runtime
+        @current_version = nil
+        @info_built = false
+        @infos = {}
+        @real_filename
+      end
+
+      def filename
+        "unamed"
+      end
+
+      def store_dir
+        "public/ph_pictures/"
+      end
+
+      def remote_path
+        nil
+      end
+
+      def register_versions
+        # Create different versions of your uploaded files:
+        version :thumbnail do
+          process resize_to_fill: [200, 200], quality: 80
+        end
+      end
+
+      # ----------------------------- #
+      # ------ Public Method -------- #
+      # ----------------------------- #
+
+      def info
+        build_infos unless @info_built
+        @infos
+      end
+
+      # When a Model.save is done
+      def store
+
+        # Get the filename once and will use the same for all futur save
+        @real_filename = filename
+        # Is the model new ? delete old record if true
+        delete_all if @model.old_record
+
+        process_original_image
+        apply_versions
+
+      end
+
+      def delete_all
+        delete_all_with_file_system
+      end
+
+      private
+
+      # -------------------------- #
+      # ------    INFOS     ------ #
+      # -------------------------- #
+
+      # At creation or called once before .info ?
+      def build_infos
+        model_filename = @model.model_filename
+        infos = @infos
+
+        infos[:filename] = model_filename
+        infos[:position] = model_filename.split('_').first.to_i
+        infos[:store_dir] = store_dir
+        infos[:original_path] = store_dir + model_filename
+        infos[:versions] = []
+        infos[:paths] = []
+        infos[:paths] << { key: infos[:original_path] }
+        # Get infos for each version
+        @versions.each_key do |version|
+          infos[:versions] << version
+          version_path = store_dir + version.to_s + '_' + model_filename
+          infos[:paths] << { key: version_path }
+          infos[version] = version_path
+        end
+
+        @info_built = true
+      end
+
+
+      # -------------------------- #
+      # ------   CREATE     ------ #
+      # -------------------------- #
+
+
+      def process_original_image
+
+        # Call the "SpecialUploader" remote_path method or the Uploader::Base one as default
+        source_path = remote_path
+        @image = self.class.open_source(source_path)
+
+        path_to_original = store_dir + @real_filename + "." + @image.type.downcase
+        write_file(@image, path_to_original)
+
+      end
+
+      def apply_versions
+
+        # Get the different wanted versions
+        @versions.each do |key, value|
+          @current_version = key
+          create_image_and_process( &(value[:block]) )
+        end
+
+      end
+
+      # Create a new image for each versions or inherit it from the "from" if specified
+      def create_image_and_process
+
+        # Get if there is a from_version for this version
+        from = @versions[@current_version][:from_version]
+
+        # create a new image from original OR from another to be used for this version
+        if from
+          raise PictureHandler::Exceptions::VersionError.new(from) if @versions[from].blank? || @versions[from][:image].blank?
+          # Put the version_image to our version also so both reference the same one
+          image = @versions[from][:image]
+          @versions[@current_version].merge!( {image: image} )
+
+        else # Else create a new instance for this version
+          # Open a new image from the local tmp location
+          local_path = @image.path
+          image = self.class.open_source(local_path)
+          # Add the Image to this @versions[:version_name][:image]
+          @versions[@current_version].merge!( {image: image} )
+        end
+
+        # Apply the options through the 'process' method
+        yield if block_given?
+
+        # Save the current version
+        version_path = store_dir + @current_version.to_s + "_" + @real_filename + "." + image.type.downcase
+        # Write this file new version
+        write_file(image, version_path)
+      end
+
+    end
+
+  end
+
+end

data/lib/picture_handler/uploader/file_system/file.rb

@@ -0,0 +1,52 @@
+module PictureHandler
+  module Uploader
+    module FileSystem
+      module File
+
+        # -------------------------- #
+        # ------   WRITE      ------ #
+        # -------------------------- #
+
+          def write_file(image, path_to_write)
+
+            # Create path if it doesn't exist
+            self.class.create_directories_for_path( self.class.split_dirname_path(path_to_write) )
+
+            image.write(path_to_write)
+
+            # Raise an exception if the image is not written at the expected location
+            unless ::File.exist?(path_to_write)
+              raise PictureHandler::Exceptions::WriteError.new(path_to_write)
+            end
+          end
+
+        # -------------------------- #
+        # ------   DELETE     ------ #
+        # -------------------------- #
+
+        def delete_all_with_file_system
+
+          infos = info
+
+          #Delete files and directory
+          infos[:paths].each { |hash| delete_from_path(hash[:key]) }
+          # Delete directory
+          Dir.rmdir(infos[:store_dir])
+
+        end
+
+        private
+
+        def delete_from_path(path)
+          path = (Rails.root + path).to_s
+          if ::File.exist?(path)
+            ::File.delete(path)
+          else
+            puts "ErrorDeletingFile: The file at path: '#{path}' could not be found."
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/picture_handler/uploader/file_system/s3.rb

@@ -0,0 +1,39 @@
+module PictureHandler
+  module Uploader
+    module FileSystem
+      module S3
+
+        require 'aws-sdk'
+
+        # -------------------------- #
+        # ------   WRITE      ------ #
+        # -------------------------- #
+
+        def write_file(image, path_to_write)
+
+          s3_client = Aws::S3::Client.new
+          s3_resource = Aws::S3::Resource.new( client: s3_client )
+
+          s3_resource.bucket(PictureHandler.configuration.s3_bucket).object(path_to_write).upload_file(image.path)
+
+        end
+
+        # -------------------------- #
+        # ------   DELETE     ------ #
+        # -------------------------- #
+
+        def delete_all_with_file_system
+
+          infos = info
+          s3_client = Aws::S3::Client.new
+
+          # Get all the objects to delete and delete then in ONE http request
+          paths_to_delete = infos[:paths]
+          s3_client.delete_objects( bucket: PictureHandler.configuration.s3_bucket, delete: { objects: paths_to_delete } )
+
+        end
+
+      end
+    end
+  end
+end

data/lib/picture_handler/uploader/img_version.rb

@@ -0,0 +1,78 @@
+module PictureHandler
+  module Uploader
+    module ImgVersion
+      extend ActiveSupport::Concern
+
+      def version(sym, options={}, &block)
+        # If the version already exist, the new one will overwrite the old one
+        p "You already have a version named \"#{sym.to_s}\". Old one is being replaced" if @versions[sym] && @versions[sym][:block]
+
+        # Fill the versions[:version_name][:block] with the block to be executed later
+        @versions[sym] = { block: block } if block_given?
+
+        # Fill the versions[:version_name][:from_version] with the symbol of the version from witch it should inherit
+        @versions[sym].merge!( {from_version: options[:from_version]} )
+      end
+
+      # The process is the function called inside the versions declared by the user
+      def process(args)
+        image = @versions[@current_version][:image]
+
+        args.each do |key, value|
+          case key
+            when :resize_to_fill
+              self.class.resize_to_fill(image, value)
+            when :quality
+              self.class.quality(image, value)
+            # when :rounded
+            # self.class.rounded(image, value)
+            else
+              raise PictureHandler::Exceptions::NoMethodError.new(key)
+          end
+        end
+      end
+
+      module ClassMethods
+
+        # -------------------------------------------------------------- #
+        # ------------- Method accepted into a version  ---------------- #
+        # -------------------------------------------------------------- #
+
+        def resize_to_fill(image, value)
+          width = value.first
+          height = value.last
+          gravity = 'Center'
+          raise PictureHandler::Exceptions::WrongArgument.new(key),
+                "You need to specify a width and height as argument of 'resize_to_fill' method." if width.blank? || height.blank?
+
+          cols, rows = image[:dimensions]
+          image.combine_options do |cmd|
+            if width != cols || height != rows
+              scale_x = width/cols.to_f
+              scale_y = height/rows.to_f
+              if scale_x >= scale_y
+                cols = (scale_x * (cols + 0.5)).round
+                rows = (scale_x * (rows + 0.5)).round
+                cmd.resize "#{cols}"
+              else
+                cols = (scale_y * (cols + 0.5)).round
+                rows = (scale_y * (rows + 0.5)).round
+                cmd.resize "x#{rows}"
+              end
+            end
+            cmd.gravity gravity
+            cmd.background "rgba(255,255,255,0.0)"
+            cmd.extent "#{width}x#{height}" if cols != width || rows != height
+          end
+          # image = yield(image) if block_given?
+        end
+
+        def quality(image, value)
+          image.quality(value)
+        end
+
+      end # ClassMethod
+
+    end
+  end
+end

data/lib/picture_handler/uploader/mini_magick.rb

@@ -0,0 +1,51 @@
+module PictureHandler
+  module Uploader
+    module MiniMagick
+      extend ActiveSupport::Concern
+
+      def self.included(base)
+        base.extend		ClassMethods
+        base.class_eval do
+          begin
+            require "mini_magick"
+          rescue LoadError => e
+            e.message << " (You may need to install the mini_magick gem)"
+            raise e
+          end
+        end
+      end
+
+      # Common method for all file_system
+      module ClassMethods
+
+        # Open the source File/path/ or URL, raise an error if blank
+        def open_source(source_path)
+          raise PictureHandler::Exceptions::OpenError.new("nil") if source_path.blank?
+
+          image = ::MiniMagick::Image.open(source_path)
+          if image.blank?
+            raise PictureHandler::Exceptions::OpenError.new(source_path)
+          end
+          image
+        end
+
+        def create_directories_for_path(dir_tokens)
+          1.upto(dir_tokens.size) do |n|
+            dir = dir_tokens[0...n]
+            dir_str = dir.join("/")
+            Dir.mkdir(dir_str) unless Dir.exist?(dir_str)
+          end
+        end
+
+        # Works for Windows C:\Files\etc or Linux /usr/app/etc
+        def split_dirname_path(some_path)
+          dirname = File.dirname(some_path)
+          tokens = dirname.split(/[\/\\]/)
+          tokens
+        end
+
+      end # ClassMethods
+
+    end
+  end
+end

data/lib/picture_handler/version.rb

@@ -0,0 +1,3 @@
+module PictureHandler
+  VERSION = "0.0.1"
+end

data/lib/picture_handler.rb

@@ -0,0 +1,31 @@
+require 'picture_handler/version'
+
+module PictureHandler
+  autoload :Exceptions, 'picture_handler/exceptions'
+  autoload :Configuration, 'picture_handler/configuration'
+  autoload :Mounter,  'picture_handler/mounter'
+  module Uploader
+    autoload :Base, 'picture_handler/uploader/base'
+    autoload :MiniMagick, 'picture_handler/uploader/mini_magick'
+    autoload :ImgVersion, 'picture_handler/uploader/img_version'
+    module FileSystem
+      autoload :File, 'picture_handler/uploader/file_system/file'
+      autoload :S3, 'picture_handler/uploader/file_system/s3'
+    end
+  end
+
+  class << self
+
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: picture_handler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Flavien Hello
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This module will push it to a S3 bucket, crop, resize and keep track
+  of all the different version available for a single image.
+email:
+- flavien@prettyfuntherapy.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/picture_handler/configuration.rb
+- lib/picture_handler/exceptions.rb
+- lib/picture_handler/mounter.rb
+- lib/picture_handler/uploader/base.rb
+- lib/picture_handler/uploader/file_system/file.rb
+- lib/picture_handler/uploader/file_system/s3.rb
+- lib/picture_handler/uploader/img_version.rb
+- lib/picture_handler/uploader/mini_magick.rb
+- lib/picture_handler/version.rb
+- lib/picture_handler.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+homepage: http://prettyfuntherapy.com
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Handle the upload and retrieving of your pictures for you.
+test_files: []
+has_rdoc: