carrierwave-blitline 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bcdab1946c051e221bdf9f7327168fa69d69a0ef
+  data.tar.gz: d8a451c3dba65f7e20090e7aa1479404d521781f
+SHA512:
+  metadata.gz: 0f1ea11ece56e432a29ba8e2dac504453a23c8f24c2081d0e4be48d158166e984907dc3dfee535ca57c4a12ca1475a73179bc76476e341e0c3a9270778f7a979
+  data.tar.gz: e278d95e4367a0df37580083ec3a76d8534a55aa504ce3ed2a4af5d720e18c5ea7be28cb3af71bfab6c93fee566db54f47f7d46a5f0a9a517bf88fa63b315f49

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in carrierwave-blitline.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Bodacious
+
+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.md

@@ -0,0 +1,125 @@
+# Carrierwave::Blitline
+
+This gem is still under construction but it basically works in its current form.
+
+## Installation
+
+Install it with these other Carrierwave gems:
+
+    gem "carrierwave"
+
+    gem "carrierwave-aws"
+
+    gem "carrierwave-blitline"
+
+Then execute
+
+     $ bundle install
+
+Add this to your Carrierwave Uploader files:
+
+    class ImageUploader < CarrierWave::Uploader::Base
+
+      # NOTE: We're using MiniMagick here...
+      include CarrierWave::MiniMagick
+
+      require "carrierwave/blitline"
+      include CarrierWave::Blitline
+
+
+      # This macro lets your uploader know you're using Carrierwave
+      process_via_blitline
+
+
+      # other stuff ...
+
+    end
+
+## CONFIGURE
+
+### Your Carrierwave setup should be something like this
+
+    CarrierWave.configure do |config|
+
+      if Rails.env.test?
+        config.storage           = :file
+        config.enable_processing = false
+        config.asset_host        = 'http://test.host'
+
+      else
+        config.aws_credentials = {
+          :access_key_id     => ENV["AWS_ACCESS_KEY"],
+          :secret_access_key => ENV["AWS_SECRET_ACCESS_KEY"],
+          :region            => ENV["S3_BUCKET_REGION"]
+        }
+        config.storage            :aws
+        config.aws_bucket                       = ENV["S3_BUCKET_NAME"]
+        config.aws_acl                          = 'public-read'
+        config.aws_attributes                   = {
+          expires: 1.week.from_now.httpdate, cache_control: 'max-age=315576000' }
+
+        config.asset_host = "https://%s" % ENV["ASSET_HOST"]
+        config.enable_processing                = true
+        config.aws_authenticated_url_expiration = 60 * 60 * 24 * 7
+      end
+
+    end
+
+### ENV Variables
+The following env variables must be set for this to work properly.
+
+    ENV["BLITLINE_APPLICATION_ID"]
+    ENV["S3_BUCKET_NAME"]
+    ENV["S3_BUCKET_REGION"]
+
+## Usage
+
+Define your carrierwave versions as you normally would.
+
+Basic functions (`resize_to_fit`, `resize_to_fill`, etc.) are dealt with automagically.
+
+For other functions, you need to write two methods in your uploader: 1) The local processing method, 2) the params for Blitline. For example
+
+    # Images will be cropped, and then resized to fill
+    version :cropped do
+      process :crop
+      process :resize_to_fill => [200, 200]
+    end
+
+    # Use this when processing locally
+    def crop
+      manipulate! do |img|
+        img = img.crop "#{model.photo_crop_x}x#{model.photo_crop_y}+#{model.photo_crop_width}+#{model.photo_crop_height}"
+        img
+      end
+    end
+
+    # Use this when processing on Blitline
+    def params_for_crop(*)
+      return {
+        x: model.photo_crop_x,
+        y: model.photo_crop_y,
+        width: model.photo_crop_width,
+        height: model.photo_crop_height
+      }
+    end
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/katanacode/carrierwave-blitline.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Created by
+
+[Katana — web developers based in Edinburgh, Scotland](https://katanacode.com/)

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "carrierwave/blitline"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/carrierwave-blitline.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'carrierwave/blitline/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "carrierwave-blitline"
+  spec.version       = Carrierwave::Blitline::VERSION
+  spec.authors       = ["Bodacious"]
+  spec.email         = ["team@katanacode.com"]
+
+  spec.summary       = %q{Integrates Blitline image processing with Carrierwave}
+  spec.description   = %q{Integrates the carrierwave gem with Blitline image API. (Still under development)}
+  spec.homepage      = "https://github.com/KatanaCode/carrierwave-blitline"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "blitline", "~> 2.8"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/carrierwave/blitline.rb

@@ -0,0 +1,143 @@
+# From the Blitline gem
+module CarrierWave
+  module Blitline
+
+    require "blitline"
+
+    require "carrierwave/blitline/version"
+    require "carrierwave/blitline/class_methods"
+    require "carrierwave/blitline/image_version"
+    require "carrierwave/blitline/function"
+    require "carrierwave/blitline/image_version_function_presenter"
+
+    extend ActiveSupport::Concern
+
+    # Does the version name come at the start (carrierwave default) or at the
+    # end of the filename
+    RIP_VERSION_NAMES_AT_START = true
+
+    # Blitline API version
+    BLITLINE_VERSION = 1.21
+
+
+    # Extends the including class with ClassMethods, add an after_store callback
+    # and includes ImageMagick if required.
+    included do
+      after :store, :rip_process_images
+    end
+
+
+    # =============
+    # = Delegates =
+    # =============
+
+    delegate :blitline_image_versions, to: :class
+
+    delegate :process_via_blitline?,   to: :class
+
+    # Send a request to Blitline to optimize the original file and create any
+    # required versions.
+    #
+    #   This is called by an after_store macro and because Carrier creates virtual
+    #   instancies for each version would be called 4 times for an image with three
+    #   versions.
+    #
+    #   Because we only want to do this on completion we check all the versions
+    #   have been called by testing it is OK to begin processing
+    #
+    #   A hash is created (job_hash) with Blitline's required commands and sent using the
+    #   Blitline gem.
+    #
+    #  file - not used within the method, but required for the callback to function
+    def rip_process_images(file)
+      return unless rip_can_begin_processing?
+      Rails.logger.tagged("Blitline") { |l| l.debug(job_hash.to_json) }
+      blitline_service.add_job_via_hash(job_hash)
+      begin
+        blitline_service.post_jobs
+      rescue => e
+        Rails.logger.tagged("Blitline") do |logger|
+          logger.error "ERROR: Blitline processing error for #{model.class.name}"
+        end
+      end
+    end
+
+    # Returns a Hash of params posted off to Blitline API
+    def job_hash
+      {
+        "application_id": ENV["BLITLINE_APPLICATION_ID"],
+        "src": url,
+        "v": BLITLINE_VERSION,
+        "functions": functions
+      }.with_indifferent_access
+    end
+
+    # Returns a Hash for each function included in the Blitline API post
+    def functions
+      blitline_image_versions.map { |version|
+        ImageVersionFunctionPresenter.new(version, self).to_hash
+      }
+    end
+
+    # sends a request to Blitline to re-process themain image and all versions
+    def optimize!
+      rip_process_images(true) if process_via_blitline?
+    end
+
+    # Can we post the images to Blitline for processing?
+    #   CarrierWave creates virtual Uploaders for each version of an image. These
+    #   versions are processed before the original, so the only way to tell if the
+    #   versions are all complete is to check the classname for the current call
+    #   and if there is no '::' it is the original class.
+    #
+    # Returns a boolean
+    def rip_can_begin_processing?
+      process_via_blitline? and not self.class.name.include? "::"
+    end
+
+    def filename
+      if file
+        "#{model.class.to_s.underscore}.#{file.extension}"
+      end
+    end
+
+    def unique_identifier
+      @unique_identifier ||= "#{Rails.application.class.name}_#{Rails.env}_#{SecureRandom.base64(10)}"
+    end
+
+    def file_name_for_version(version)
+      file_name, file_type  = filename.split('.')
+      name_components       = [version.name, file_name].compact
+      name_components.reverse! unless RIP_VERSION_NAMES_AT_START
+      file_namewith_version = name_components.join("_") + ".#{file_type}"
+      File.join(store_dir, file_namewith_version).to_s
+    end
+
+    def params_for_function(function_name, *args)
+      send("params_for_#{function_name}", *args)
+    end
+
+    def params_for_no_op(*args)
+      return {}
+    end
+
+    def params_for_resize_to_fill(*args)
+      args.flatten!
+      return { width: args.first, height: args.last }
+    end
+
+    def params_for_resize_to_fit(*args)
+      args.flatten!
+      return { width: args.first, height: args.last }
+    end
+
+
+    private
+
+
+    def blitline_service
+      @blitline_service ||= ::Blitline.new
+    end
+
+  end
+end

data/lib/carrierwave/blitline/class_methods.rb

@@ -0,0 +1,33 @@
+# Class methods to be included in Blitline module
+module CarrierWave
+  module Blitline
+
+    module ClassMethods
+
+      def version(name, &block)
+        blitline_image_versions << ImageVersion.new(name, &block)
+        # If process_via_blitline? is true, we still want to register the version with
+        #  the Uploader, but we don't want to define the conversions.
+        if process_via_blitline?
+          super(name) {}
+        else
+          super(name, &block)
+        end
+      end
+
+      def blitline_image_versions
+        @blitline_versions ||= [ImageVersion.new(nil)]
+      end
+
+      def process_via_blitline(value = true)
+        @@process_via_blitline = value
+      end
+
+      def process_via_blitline?
+        defined?(@@process_via_blitline) && @@process_via_blitline == true
+      end
+
+    end
+  end
+
+end

data/lib/carrierwave/blitline/function.rb

@@ -0,0 +1,10 @@
+module CarrierWave
+  module Blitline
+
+    # A Struct class for storing name and params for each function parameter.
+    #   See also: ImageVersionFunctionPresenter
+    class Function < Struct.new(:name, :params)
+    end
+
+  end
+end

data/lib/carrierwave/blitline/image_version.rb

@@ -0,0 +1,71 @@
+module CarrierWave
+  module Blitline
+
+    # An instance of an ImageVersion for Blitline API.
+    #
+    #   When the process() version is called in an Uploader class, we store the version
+    #     name, and the block to create that version as an ImageVersion
+    #
+    #   So, a 'small' image version that's resized to fit 200x200 looks like:
+    #
+    #     ImageVersion.new("small") do
+    #       process :resize_to_fit => [200, 200]
+    #     end
+    #
+    #  NOTE: We need a 'default' image version too. This is created automatically, and
+    #    the name for the version is 'nil'.
+    class ImageVersion
+
+      attr_accessor :primary_function
+
+      attr_accessor :secondary_functions
+
+      attr_reader :name
+
+      def initialize(name = nil, &block)
+        @name                = name
+        @primary_function    = nil
+        @secondary_functions = []
+        instance_exec(&block) if block_given?
+      end
+
+      # Hijacks the process() method that's called within a CarrierWave uploader.
+      #
+      # Example:
+      #
+      #   version :thumb do
+      #     process :crop            => [10, 10, 200, 200]
+      #     process :process_to_fill => [500, 500]
+      #   end
+      #
+      #  This stores the crop function as the "primary" function, and the process_to_fill
+      #    function as a "secondary" function.
+      def process(function_hash)
+        function_hash   = { function_hash => nil } unless function_hash.is_a?(Hash)
+        function_name   = function_hash.keys.first
+        function_params = function_hash.values.first
+        function = Function.new(function_name, function_params)
+        if primary_function.nil?
+          self.primary_function    = function
+        else
+          self.secondary_functions << function
+        end
+      end
+
+      # Returns a String of the name of the primary function for this version
+      #   (default: "no_op")
+      def primary_function_name
+        primary_function.nil? ? "no_op" : primary_function.name
+      end
+
+      # Returns a Hash of the params of the primary function for this
+      #   version (default: {})
+      def primary_function_params
+        primary_function.nil? ? {} : primary_function.params
+      end
+
+    end
+
+  end
+
+end

data/lib/carrierwave/blitline/image_version_function_presenter.rb

@@ -0,0 +1,82 @@
+module CarrierWave
+  module Blitline
+
+    # A presenter class for converting an image version to a JSON param for the Blitline
+    #   API.
+    class ImageVersionFunctionPresenter
+
+
+      ##
+      # The ImageVersion we're presenting
+      attr_accessor :version
+
+      ##
+      # The Uploader instance we're processing an image for.
+      attr_accessor :uploader
+
+
+      # =============
+      # = Delegates =
+      # =============
+
+      delegate :params_for_function, to: :uploader
+
+      delegate :file_name_for_version, to: :uploader
+
+      delegate :unique_identifier, to: :uploader
+
+      delegate :primary_function_name, to: :version
+
+      delegate :primary_function_params, to: :version
+
+      delegate :secondary_functions, to: :version
+
+
+      # Creates a new presenter.
+      #
+      # version  - The ImageVersion to use
+      # uploader - The CarrierWave uploader instance
+      def initialize(version, uploader)
+        @version  = version
+        @uploader = uploader
+      end
+
+      # The Hash to be converted to JSON for the Blitline API
+      def to_hash
+        {
+          "name":   primary_function_name,
+          "params": params_for_function(primary_function_name, primary_function_params),
+          "save": {
+            "image_identifier": unique_identifier,
+            "s3_destination": {
+              "bucket": {
+                "name":     ENV["S3_BUCKET_NAME"],
+                "location": ENV["S3_BUCKET_REGION"],
+              },
+              "key": file_name_for_version(version)
+            }
+          },
+          "functions": secondary_functions.map { |function|
+            {
+              "name": function.name,
+              "params": params_for_function(function.name,function.params),
+              "save": {
+                "image_identifier": unique_identifier,
+                "s3_destination": {
+                  "bucket": {
+                    "name":     ENV["S3_BUCKET_NAME"],
+                    "location": ENV["S3_BUCKET_REGION"],
+                  },
+                  "key": file_name_for_version(version)
+                }
+              }
+            }
+          }
+        }
+      end
+
+    end
+
+  end
+
+end

data/lib/carrierwave/blitline/version.rb

@@ -0,0 +1,5 @@
+module Carrierwave
+  module Blitline
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: carrierwave-blitline
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bodacious
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: blitline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Integrates the carrierwave gem with Blitline image API. (Still under
+  development)
+email:
+- team@katanacode.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- carrierwave-blitline.gemspec
+- lib/carrierwave/blitline.rb
+- lib/carrierwave/blitline/class_methods.rb
+- lib/carrierwave/blitline/function.rb
+- lib/carrierwave/blitline/image_version.rb
+- lib/carrierwave/blitline/image_version_function_presenter.rb
+- lib/carrierwave/blitline/version.rb
+homepage: https://github.com/KatanaCode/carrierwave-blitline
+licenses:
+- MIT
+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.6.3
+signing_key: 
+specification_version: 4
+summary: Integrates Blitline image processing with Carrierwave
+test_files: []