acts_as_avatar 1.8.4

data/lib/acts_as_avatar/class_methods.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActsAsAvatar
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def acts_as_avatar(**options)
+      random_image_engine = options.delete(:random_image_engine)
+      inline_svg_engine = options.delete(:inline_svg_engine)
+
+      define_singleton_method :random_image_engine do
+        random_image_engine.presence || ActsAsAvatar.configuration.random_image_engine
+      end
+
+      define_singleton_method :inline_svg_engine do
+        inline_svg_engine.presence || ActsAsAvatar.configuration.inline_svg_engine
+      end
+
+      has_one :avatar, as: :avatarable, class_name: "ActsAsAvatar::Avatar"
+      accepts_nested_attributes_for :avatar
+      delegate :current_avatar, :default_avatar, :upload_avatar, to: :avatar
+      include InstanceMethods
+      # after_create_commit { create_avatar }
+    end
+  end
+
+  module InstanceMethods
+    def avatar
+      super || create_avatar
+    end
+  end
+end

data/lib/acts_as_avatar/configuration.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/numeric/bytes"
+
+module ActsAsAvatar
+  @mutex = Mutex.new
+
+  class << self
+    def configuration
+      @mutex.synchronize do
+        @configuration ||= Configuration.new
+      end
+    end
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  class Configuration
+    attr_accessor :uifaces_gender,
+                  :uifaces_limit,
+                  :uifaces_uri,
+                  :uifaces_api_key,
+                  :random_image_engine,
+                  :default_file_name,
+                  :upload_max_size,
+                  :class_type,
+                  :avatar_name,
+                  :inline_svg_engine,
+                  :avatar_size,
+                  :github_complexity,
+                  :github_render_method,
+                  :github_rounded_circle
+
+    def initialize
+      @uifaces_uri           = "https://api.uifaces.co"
+      @uifaces_api_key       = "72694e5b5dee4706edc0acad3d4291"
+      @uifaces_gender        = nil
+      @uifaces_limit         = 72
+      @random_image_engine   = nil
+      @default_file_name     = "default_avatar"
+      @upload_max_size       = 2.megabytes
+      @class_type            = %w[User]
+      @avatar_name           = :name
+      @inline_svg_engine     = :initial_avatar
+      @avatar_size           = 60
+      @github_complexity     = 5
+      @github_render_method  = "square"
+      @github_rounded_circle = false
+    end
+
+    def default_options
+      instance_variables.to_h do |key|
+        [key.to_s.sub("@", "").to_sym, instance_variable_get(key)]
+      end
+    end
+  end
+end

data/lib/acts_as_avatar/engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActsAsAvatar
+  class Engine < Rails::Engine
+    isolate_namespace ActsAsAvatar
+
+    initializer "acts_as_avatar.insert_into_active_record" do
+      ActiveSupport.on_load :active_record do
+        # include ActsAsAvatar::ClassMethods
+        ActiveRecord::Base.include ActsAsAvatar
+        ActiveRecord::Base.include ActsAsAvatar::ClassMethods
+      end
+
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.send(:helper, ActsAsAvatar::Helper)
+      end
+    end
+  end
+end

data/lib/acts_as_avatar/generators/install_generator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/migration"
+
+module ActsAsAvatar
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.join(__dir__, "templates")
+      desc "Install acts_as_avatar"
+
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        else
+          format("%<migration_number>.3d",
+                 migration_number: current_migration_number(dirname) + 1)
+        end
+      end
+
+      def create_initializer
+        template "initializer.rb", "config/initializers/acts_as_avatar.rb"
+      end
+
+      def create_migration_file
+        migration_template(
+          "migration.rb.erb",
+          "db/migrate/acts_as_avatar_migration.rb",
+          migration_version: migration_version
+        )
+        puts "\nPlease run this migration:\n\n    rails db:migrate"
+      end
+
+      private
+
+      def migration_version
+        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/acts_as_avatar/generators/templates/initializer.rb.tt

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+ActsAsAvatar.configure do |config|
+  #
+  # Global configuration
+  #
+  config.default_file_name = "default_avatar"
+  config.upload_max_size   = 2.megabytes
+  config.class_type        = %w[User]
+  config.avatar_name       = :fullname # Name for show letter
+  config.avatar_size       = 60
+
+  #
+  # Optional value is
+  #   :letter_avatar, :uifaces_avatar, :github_avatar, or :identicon_avatar
+  # When value is nil, disable engine
+  #
+  config.random_image_engine = :letter_avatar
+
+  #
+  # When random_image_engine is :github_avatar
+  #
+  config.github_complexity     = 5
+  config.github_render_method  = "square"
+  config.github_rounded_circle = false
+
+  #
+  # Optional value is :initial_avatar, :initials or :icodi_avatar
+  #
+  config.inline_svg_engine = :initial_avatar
+
+  #
+  # When random_image_engine is :uifaces
+  #
+  config.uifaces_limit         = 72
+  config.uifaces_gender        = nil
+  config.uifaces_uri           = "https://api.uifaces.co"
+  config.uifaces_api_key       = ""
+end

data/lib/acts_as_avatar/generators/templates/migration.rb.erb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class CreateActsAsAvatars < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :acts_as_avatars do |t|
+      t.references :avatarable, polymorphic: true, index: true, null: false
+
+      t.timestamps
+    end
+  end
+end

data/lib/acts_as_avatar/github_avatar.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module ActsAsAvatar
+  class GithubAvatar
+    include Singleton
+
+    #
+    # Default options:
+    #
+    #   complexity: 16
+    #
+    #   redner_method: squad
+    #
+    def random_svg_avatar(size:, github_complexity:, github_render_method:, github_rounded_circle:)
+      source = File.join(File.expand_path("../../", File.dirname(__FILE__)), "github_avatar.js")
+      js = File.read(source)
+      context = ExecJS.compile(js)
+      context.call("getRandomAvatar", github_complexity, github_render_method, size, github_rounded_circle)
+    end
+  end
+end

data/lib/acts_as_avatar/helper.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "initials"
+require "execjs"
+require "initial_avatar"
+require "icodi"
+require "nokogiri"
+
+module ActsAsAvatar
+  module Helper
+    include ActsAsAvatar::Scrubber
+
+    def acts_as_avatar_tag(object, name: nil, size: nil, **options)
+      size = size.presence || ActsAsAvatar.configuration.avatar_size
+
+      current_avatar = object.current_avatar
+      blob = current_avatar.blob
+
+      if current_avatar.attached?
+        if blob.content_type == "image/svg+xml"
+          render_svg blob, size, options
+        else
+          image_tag current_avatar.variant(resize_to_fill: [size, size]), **options
+        end
+      else
+        inline_avatar_tag(object, name: name, size: size, **options)
+      end
+    rescue StandardError => e
+      puts e.inspect
+      puts e.backtrace.inspect
+      "".html_safe
+    end
+
+    def inline_avatar_tag(object, size:, name: nil, **options)
+      name = name.presence || ActsAsAvatar.configuration.avatar_name
+      text = object.send(name.to_sym)
+
+      inline_svg_engine = object.class.inline_svg_engine.to_sym
+
+      case inline_svg_engine.to_sym
+      when :initial_avatar
+        initial_avatar_tag(text, size: size, **options)
+      when :icodi_avatar
+        icodi_avatar_tag(text, size: size, **options)
+      when :initials
+        initials_tag(text, size: size, **options)
+      end
+    end
+
+    def initial_avatar_tag(text, size:, **options)
+      opts = options.extract!(:colors, :text_color, :font_weight, :font_family).compact
+
+      limit = options[:limit] || 1
+
+      image_tag InitialAvatar.avatar_data_uri(text.first(limit), size: size, **opts), **options
+    end
+
+    def initials_tag(text, size:, **options)
+      #
+      # number of different colors, default: 12
+      # maximal initials length, default: 3
+      # background shape, default: :cirlce
+      #
+      opts = options.extract!(:colors, :limit, :shape).compact
+
+      Initials.svg text, size: size, **opts
+    end
+
+    def github_avatar_tag(size:, **options)
+      opts = options.extract!(:github_complexity, :github_render_method, :github_rounded_circle).compact
+
+      opts = ActsAsAvatar.configuration.default_options.merge(opts)
+
+      ActsAsAvatar::GithubAvatar.instance.random_svg_avatar(
+        size: size,
+        github_complexity: opts[:github_complexity],
+        github_render_method: opts[:github_render_method],
+        github_rounded_circle: opts[:github_rounded_circle]
+      ).html_safe
+    end
+
+    def icodi_avatar_tag(text, size:, **options)
+      #
+      # https://github.com/DannyBen/icodi
+      #
+      # Default value:
+      #
+      # custom attribute:
+      #
+      #   rounded_circle: nil
+      #
+      # pixels: 5
+      # mirror: :x
+      # color:
+      # density: 0.5
+      # stroke: 0.1
+      # jitter: 0
+      # background: #fff
+      # id: icodi
+      #
+      # SVG template to use.
+      # Can be :default, :html or a path to a file. Read more on Victor SVG Templates.
+      #
+      # template: default
+      opts = options.extract!(:pixels,
+                              :density,
+                              :mirror,
+                              :color,
+                              :stroke,
+                              :jitter,
+                              :id,
+                              :template,
+                              :rounded_circle,
+                              :background)
+
+      pixels = opts[:pixels] || 8
+      density = opts[:density] || 0.33
+
+      svg = Icodi.new text, size: size, pixels: pixels, density: density, **opts
+      svg.render.html_safe
+    end
+
+    private
+
+    def render_svg(blob, size, options)
+      doc = Nokogiri::XML::Document.parse blob.download.to_s
+      svg = doc.root
+
+      title = options.delete(:title)
+      svg.add_child("<title>#{title}</title>") if title
+
+      svg[:width] = size
+      svg[:height] = size
+
+      options.each do |key, value|
+        svg[key] = value
+      end
+
+      sanitize(svg.to_s).html_safe
+    end
+  end
+end

data/lib/acts_as_avatar/request.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "forwardable"
+require "http"
+require "uri"
+
+module ActsAsAvatar
+  class Request
+    # private_class_method :new
+    include Singleton
+
+    URL = ActsAsAvatar.configuration.uifaces_uri
+    API_KEY = ActsAsAvatar.configuration.uifaces_api_key
+
+    %w[uifaces_gender uifaces_limit].each do |method_name|
+      attr_writer method_name.to_sym
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        #
+        # def uifaces_gender
+        #   @uifaces_gender ||= ActsAsAvatar.configuration.instance_variable_get("@uifaces_gender")
+        # end
+        #
+        def #{method_name}
+          @#{method_name} ||= ActsAsAvatar.configuration.instance_variable_get("@#{method_name}")
+        end
+      RUBY
+    end
+
+    class << self
+      extend Forwardable
+      delegate %i[read_image] => :instance
+    end
+
+    def params
+      if uifaces_gender.nil?
+        "popular&limit=#{uifaces_limit}"
+      else
+        "gender%5B%5D=#{uifaces_gender}&limit=#{uifaces_limit}"
+      end
+    end
+
+    # Get a random image
+    #
+    # @example
+    #   ActsAsAvatar::Request.read_image
+    #
+    #   ActsAsAvatar::Request.read_image uifaces_limit: 20, uifaces_gender: "female"
+    #
+    #   instance = ActsAsAvatar::Request.instance
+    #   instance.uifaces_gender = "male"
+    #   instance.uifaces_limit  = 20
+    #   instance.read_image
+    #
+    # @param [String] uifaces_gender
+    #   the gender is male or female
+    # @param [Integer] uifaces_limit
+    #   the count of the image records
+    #
+    # @api public
+    def read_image(options={})
+      # configuration = {
+      #   uifaces_gender: ActsAsAvatar.configuration.uifaces_gender,
+      #   uifaces_limit: ActsAsAvatar.configuration.uifaces_limit
+      # }
+      #
+      # configuration.update(options) if options.is_a?(Hash)
+
+      opts = ActsAsAvatar.configuration.default_options.merge(options)
+
+      @uifaces_gender = opts[:uifaces_gender]
+      @uifaces_limit = opts[:uifaces_limit]
+
+      URI.parse(image_url).open if image_url
+    end
+
+    private
+
+    def request
+      { success: true, res: HTTP.headers("x-api-key": API_KEY).get("#{URL}?#{params}") }
+    rescue StandardError => e
+      { success: false, message: e.to_s }
+    end
+
+    def image_url
+      return unless request[:success] && request[:res].status.success?
+
+      result = request[:res].parse(:json)
+      result[rand(uifaces_limit.to_i - 1)]["photo"]
+    end
+  end
+end

data/lib/acts_as_avatar/scrubber.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "loofah"
+
+module ActsAsAvatar
+  module Scrubber
+    #
+    # rails: sanitize(svg.to_s, scrubber: scrubber).html_safe
+    #
+    def sanitize(unsafe_xml)
+      unsafe_xml = unsafe_xml.to_s
+      unsafe_xml.force_encoding "UTF-8"
+      return Loofah.xml_document(unsafe_xml).scrub!(scrubber).to_s if document?(unsafe_xml)
+
+      Loofah.xml_fragment(unsafe_xml).scrub!(scrubber).to_s
+    end
+
+    private
+
+    def scrubber
+      Loofah::Scrubber.new do |node|
+        node.remove if node.name == "script"
+      end
+    end
+
+    def document?(unsafe)
+      unsafe.include?("<?xml") || unsafe.include?("<!DOCTYPE")
+    end
+  end
+end

data/lib/acts_as_avatar/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActsAsAvatar
+  VERSION = "1.8.4"
+end

data/lib/acts_as_avatar.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "acts_as_avatar/generators/install_generator"
+
+module ActsAsAvatar
+  autoload :VERSION, "acts_as_avatar/version"
+  autoload :Request, "acts_as_avatar/request"
+  autoload :GithubAvatar, "acts_as_avatar/github_avatar"
+  autoload :Scrubber, "acts_as_avatar/scrubber"
+
+  require_relative "acts_as_avatar/configuration"
+  require_relative "acts_as_avatar/class_methods"
+  require_relative "acts_as_avatar/helper"
+  require_relative "acts_as_avatar/engine" if defined? Rails::Engine
+end