picguard 1.0.0 → 1.0.1

data/lib/guard_validator.rb

@@ -0,0 +1,58 @@
+require 'picguard'
+require 'active_model'
+
+class GuardValidator < ActiveModel::EachValidator
+
+  def validate_each(record, attribute, value)
+    image_path = fetch_image_path(record, attribute)
+    return if valid?(image_path)
+    record.errors.add(attribute, @message, options.merge(value: value))
+  end
+
+  private
+
+  def fetch_image_path(record, attribute)
+    arr = [attribute].push(*Array(options[:method_name]))
+    arr.inject(record, :public_send)
+  end
+
+  def valid?(image_path)
+    return false unless path_exists?(image_path)
+    result = Picguard.analyze(
+      image_path:
+        image_path,
+      safe_search:
+        options[:safe_search] || false,
+      face_detection:
+        options[:face_detection] || false,
+      threshold_adult:
+        options[:threshold_adult] || Picguard.configuration.threshold_adult,
+      threshold_violence:
+        options[:threshold_violence] || Picguard.configuration.threshold_violence,
+      threshold_face:
+        options[:threshold_face] || Picguard.configuration.threshold_face,
+    )
+
+    return false if options[:safe_search] && safety_violated?(result)
+    return false if options[:face_detection] && !face_recognised?(result)
+    true
+  end
+
+  def safety_violated?(result)
+    return false if (!result[:safe_search][:adult] && !result[:safe_search][:violence])
+    @message = 'Picture shows inappropriate content.'
+    true
+  end
+
+  def path_exists?(image_path)
+    return true if image_path && File.exist?(image_path)
+    @message = 'Picture doesn\'t exist.'
+    false
+  end
+
+  def face_recognised?(result)
+    return true if options[:face_detection] && result[:face_recognised]
+    @message = 'Face could not be recognised on given picture.'
+    false
+  end
+end

data/lib/picguard.rb

@@ -0,0 +1,40 @@
+require "picguard/version"
+require "json"
+# require "picguard_init"
+require "guard_validator"
+require "configuration"
+require "services/builders/request"
+require "services/analyzer"
+require "services/image_preparator"
+
+
+module Picguard
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  def self.analyze(image_path:,
+                   safe_search: true,
+                   face_detection: true,
+                   threshold_adult: Picguard.configuration.threshold_adult,
+                   threshold_violence: Picguard.configuration.threshold_violence,
+                   threshold_face: Picguard.configuration.threshold_face
+                   )
+
+    prepared_image_path = Services::ImagePreparator.new(image_path, face_detection, safe_search).call
+
+    Services::Analyzer.new(
+      Services::Builders::Request.new(
+        prepared_image_path, safe_search, face_detection
+      ).call,
+      threshold_adult,
+      threshold_violence,
+      threshold_face
+    ).call
+  end
+end

data/lib/picguard/version.rb

@@ -0,0 +1,3 @@
+module Picguard
+  VERSION = "1.0.1"
+end

data/lib/services/analyzer.rb

@@ -0,0 +1,40 @@
+require 'services/validators/likelihood'
+
+module Services
+  class Analyzer
+    def initialize(result, threshold_adult, threshold_violence, threshold_face)
+      @result = result
+      @threshold_adult = threshold_adult
+      @threshold_violence = threshold_violence
+      @threshold_face = threshold_face
+    end
+
+    def call
+      result_hash = {}
+      unless @result[:safe_search_annotation].nil?
+        result_hash[:safe_search] = analyze_safe_search_annotation(@result[:safe_search_annotation])
+      end
+
+      unless @result[:face_annotations].nil?
+        detection_confidence = @result[:face_annotations].first[:detection_confidence]
+      end
+      detection_confidence ||= 0
+
+      result_hash[:face_recognised] = analyze_face_annotation(detection_confidence)
+      result_hash
+    end
+
+    private
+
+    def analyze_safe_search_annotation(hash_result)
+      {
+        violence: Validators::Likelihood.new(hash_result[:violence], @threshold_violence).call,
+        adult: Validators::Likelihood.new(hash_result[:adult], @threshold_adult).call,
+      }
+    end
+
+    def analyze_face_annotation(float_result)
+      float_result > @threshold_face
+    end
+  end
+end

data/lib/services/builders/annotate_image.rb

@@ -0,0 +1,16 @@
+require "google/apis/vision_v1"
+
+module Services
+  module Builders
+    class AnnotateImage
+      def initialize(image, features)
+        @image = image
+        @features = features
+      end
+
+      def call
+        Google::Apis::VisionV1::AnnotateImageRequest.new(image: @image, features: @features)
+      end
+    end
+  end
+end

data/lib/services/builders/batch.rb

@@ -0,0 +1,15 @@
+require "google/apis/vision_v1"
+
+module Services
+  module Builders
+    class BatchAnnotateImages
+      def initialize(image_requests)
+        @image_requests = image_requests
+      end
+
+      def call
+        Google::Apis::VisionV1::BatchAnnotateImagesRequest.new(requests: @image_requests)
+      end
+    end
+  end
+end

data/lib/services/builders/feature.rb

@@ -0,0 +1,16 @@
+require "google/apis/vision_v1"
+
+module Services
+  module Builders
+    class Feature
+      def initialize(type, max_results = '1')
+        @type = type
+        @max_results = max_results
+      end
+
+      def call
+        Google::Apis::VisionV1::Feature.new(max_results: @max_results, type: @type)
+      end
+    end
+  end
+end

data/lib/services/builders/image.rb

@@ -0,0 +1,15 @@
+require "google/apis/vision_v1"
+
+module Services
+  module Builders
+    class Image
+      def initialize(image_path)
+        @image_path = image_path
+      end
+
+      def call
+        Google::Apis::VisionV1::Image.new(content: open(@image_path).to_a.join)
+      end
+    end
+  end
+end

data/lib/services/builders/request.rb

@@ -0,0 +1,27 @@
+require "google/apis/vision_v1"
+%w[annotate_image batch feature image vision].each do |serv|
+  require "services/builders/#{serv}"
+end
+
+module Services
+  module Builders
+    class Request
+      def initialize(image_path, safe_search, face_detection)
+        @image_path = image_path
+        @safe_search = safe_search
+        @face_detection = face_detection
+        @features = []
+      end
+
+      def call
+        vision = Services::Builders::Vision.new.call
+        @features << Services::Builders::Feature.new("SAFE_SEARCH_DETECTION").call if @safe_search
+        @features << Services::Builders::Feature.new("FACE_DETECTION").call if @face_detection
+        image = Services::Builders::Image.new(@image_path).call
+        annotate_image = Services::Builders::AnnotateImage.new(image, @features).call
+        batch_annotate = Services::Builders::BatchAnnotateImages.new([annotate_image]).call
+        vision.annotate_image(batch_annotate).to_h[:responses].first
+      end
+    end
+  end
+end

data/lib/services/builders/vision.rb

@@ -0,0 +1,17 @@
+require "google/apis/vision_v1"
+
+module Services
+  module Builders
+    class Vision
+      def initialize
+        @key = Picguard.configuration.google_api_key
+      end
+
+      def call
+        vision = Google::Apis::VisionV1::VisionService.new
+        vision.key = @key
+        vision
+      end
+    end
+  end
+end

data/lib/services/image_preparator.rb

@@ -0,0 +1,46 @@
+require "mini_magick"
+
+module Services
+  class ImagePreparator
+    def initialize(image_path, face_detection, safe_search)
+      @image_path = image_path
+      @face_detection = face_detection
+      @safe_search = safe_search
+    end
+
+    RECOMMENDED_SIZES = {
+      face_detection: %w(1600x1200 1200x1600),
+      safe_search: %w(640x480 480x640)
+    }.freeze
+
+    private_constant :RECOMMENDED_SIZES
+
+    def call
+      image = MiniMagick::Image.open(@image_path)
+      return @image_path unless oversized?(image)
+      resize_image(image)
+    end
+
+    private
+
+    def oversized?(image)
+      dimensions = image.dimensions
+      dimensions.any? { |dimension| dimension > 1600 }
+    end
+
+    def resize_image(image)
+      image.resize(resize_dimensions(image)).path
+    end
+
+    def resize_resolution(filter, order)
+      RECOMMENDED_SIZES.fetch(filter.to_sym)[order]
+    end
+
+    def resize_dimensions(image)
+      width, height = image.dimensions
+      resize_to = @face_detection ? "face_detection" : "safe_search"
+      order = width > height ? 0 : 1
+      resize_resolution(resize_to, order)
+    end
+  end
+end

data/lib/services/validators/likelihood.rb

@@ -0,0 +1,31 @@
+require 'picguard'
+
+module Services
+  module Validators
+    class Likelihood
+      RESPONSES = {
+        unknown:        0,
+        very_unlikely:  1,
+        unlikely:       2,
+        possible:       3,
+        likely:         4,
+        very_likely:    5,
+      }.freeze
+      private_constant :RESPONSES
+
+      def initialize(response, threshold)
+        @response, @threshold = response, threshold
+      end
+
+      def call
+        value_for(@response) > value_for(@threshold)
+      end
+
+      private
+
+      def value_for(response)
+        RESPONSES.fetch(response.downcase.to_sym)
+      end
+    end
+  end
+end

data/picguard.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'picguard/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "picguard"
+  spec.version       = Picguard::VERSION
+  spec.authors       = ["Szymon Baranowski", "Tomasz Jaśkiewicz"]
+  spec.email         = ["szymon.baranowski@netguru.pl", "tomasz.jaskiewicz@netguru.pl"]
+
+  spec.summary       = %q{A gem for filtering a pictures that are being uploaded to your server.}
+  spec.description   = %q{Picguard guards your application by filtering out the pictures containing inappropriate content.}
+  spec.homepage      = "https://github.com/netguru/picguard"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "google-api-client"
+  spec.add_dependency "mini_magick"
+  spec.add_dependency "activemodel"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/spec/guard_validator_spec.rb

@@ -0,0 +1,72 @@
+require 'active_model'
+require 'spec_helper'
+
+class ImageStruct
+  def initialize(path)
+    @path = path
+  end
+
+  def img_path
+    @path
+  end
+end
+
+class ModelStruct
+  include ActiveModel::Validations
+  def initialize(image_struct)
+    @image = image_struct
+  end
+
+  attr_accessor :image
+
+  validates :image, guard: {
+    safe_search: true,
+    face_detection: true,
+    method_name: :img_path }
+end
+
+describe GuardValidator do
+  before(:all) do
+    Picguard.configure do |config|
+      config.google_api_key = ENV['GCLOUD_KEY']
+      config.threshold_adult = "POSSIBLE"
+      config.threshold_violence = "UNLIKELY"
+      config.threshold_face = 0.8
+    end
+  end
+  subject { ModelStruct.new(image_struct) }
+
+  context 'with valid picture' do
+    let(:image_struct) { ImageStruct.new("spec/support/img/face-example.jpg") }
+    it 'is valid' do
+      expect(subject).to be_valid
+    end
+  end
+
+  context 'face unrecognised' do
+    let(:image_struct) { ImageStruct.new("spec/support/img/cat.jpg") }
+    it 'is invalid' do
+      expect(subject).not_to be_valid
+      expect(subject.errors[:image].size).to eq(1)
+      expect(subject.errors.messages[:image].first).to eq("Face could not be recognised on given picture.")
+    end
+  end
+
+  context 'violent content' do
+    let(:image_struct) { ImageStruct.new("spec/support/img/gun-violence.jpg") }
+    it 'is invalid' do
+      expect(subject).not_to be_valid
+      expect(subject.errors[:image].size).to eq(1)
+      expect(subject.errors.messages[:image].first).to eq("Picture shows inappropriate content.")
+    end
+  end
+
+  context 'path to picture invalid' do
+    let(:image_struct) { ImageStruct.new("") }
+    it 'is invalid' do
+      expect(subject).not_to be_valid
+      expect(subject.errors[:image].size).to eq(1)
+      expect(subject.errors.messages[:image].first).to eq ("Picture doesn't exist.")
+    end
+  end
+end