rubohash 0.1.1

data/lib/rubohash/factory.rb

@@ -0,0 +1,207 @@
+require 'fileutils'
+
+# Rubohash namespace
+module Rubohash
+  # The factory which builds robots
+  class Factory
+    attr_accessor :my_hash_array, :my_digest, :remove_extensions, :my_format, :string
+
+    # Setup defaults for the factory
+    def initialize(string = nil, my_format = nil)
+      self.string            = string
+      self.remove_extensions = true
+      self.my_format         = my_format
+      self.my_format ||= Rubohash.default_format
+      self.my_digest = make_digest(string)
+      self.my_hash_array = create_hashes([], my_digest, 11)
+    end
+
+    # Build the SHA512 checksum based on string
+    def make_digest(string)
+      string = remove_extensions(string)
+      Digest::SHA512.hexdigest(string)
+    end
+
+    # Strip out the specified extensions from string
+    def remove_extensions(string)
+      Rubohash.default_extensions.any? do |ext|
+        if string.end_with?(ext)
+          return string[0...string.rindex('.')]
+        else
+          return string
+        end
+      end
+    end
+
+    # Breaks up our hash into slots, so we can pull them out later.
+    # Essentially, it splits our SHA/MD5/etc into X parts.
+    def create_hashes(my_hash_array, digest, kount)
+      blocksize = (digest.length / kount).to_i
+      (0...kount.to_i).each do |iter|
+        currentstart = (1 + iter) * blocksize - blocksize
+        currentend = (1 + iter) * blocksize
+        digest_subset = digest[currentstart...currentend]
+        range = digest_subset.to_i(16)
+        my_hash_array.push(range)
+      end
+      my_hash_array
+    end
+
+    # List directories for the given path
+    def list_directories(path)
+      Dir.entries(path).select do |entry|
+        next if %w[. ..].include?(entry)
+        File.directory?(File.join(path, entry))
+      end.sort
+    end
+
+    # List files from the given path
+    def list_files(path)
+      Dir.glob("#{path}/**").reject do |entry|
+        next if %w[. ..].include?(entry)
+        File.directory?(entry)
+      end.sort
+    end
+
+    # Get the random parts for the robot
+    # eyes, ears, etc...
+    def get_list_of_files(path)
+      # Get all subdirectories
+      # sets/set1/blue
+      directories = Dir.glob("#{path}/**").select do |entry|
+        next if %w[. ..].include?(entry)
+        File.directory?(entry)
+      end.sort
+
+      # This is to index into the proper place in the hash array
+      iter = 4
+      directories.map do |dir|
+        files = Dir.entries(dir).reject { |k| %w[. ..].include?(k) }.sort
+        sample = files[my_hash_array[iter] % files.length]
+        iter += 1
+        [dir, sample].join('/')
+      end
+    end
+
+    # Default asset path
+    def resource_dir
+      File.expand_path('../assets', File.dirname(__FILE__))
+    end
+
+    # Where are the sets located
+    def sets
+      list_directories("#{resource_dir}/sets")
+    end
+
+    # Where are the background sets located
+    def bg_sets
+      list_directories("#{resource_dir}/backgrounds")
+    end
+
+    # Where are the color sets located for set1
+    def colors
+      list_directories("#{resource_dir}/sets/set1")
+    end
+
+    # Assemble our robot from elements from the hash_array
+    # TODO: see if this file already exists
+    def assemble
+      # Find Our sets
+      # IF it is set1, pick a random color
+      robot = Rubohash::Robot.new(build_robot_attrs)
+
+      roboparts = get_list_of_files(robot.my_set).sort_by { |k| k.split('#')[1] }
+      robot.parts = roboparts
+
+      image = MiniMagick::Image.open(roboparts.first)
+      image = image.resize('1024x1024')
+
+      roboparts.each do |part|
+        img = MiniMagick::Image.open(part)
+        img = img.resize('1024x1024')
+        image = image.composite(img) do |c|
+          c.compose 'Over'
+        end
+      end
+
+      if Rubohash.use_background
+        # use the hash bits to get the actual sample
+        background_files = list_files(robot.my_background_set)
+
+        # Set background itself from hash bits
+        background_hash_key = my_hash_array[3] % background_files.size
+        background = background_files[background_hash_key]
+
+        bg = MiniMagick::Image.open(background)
+        bg = bg.resize('1024x1024')
+        image = image.composite(bg) do |c|
+          c.compose 'Dst_Over'
+          c.resize '300x300'
+        end
+      else
+        image = image.resize('300x300')
+      end
+
+      robot.name = string
+      robot.my_digest = my_digest
+
+      if Rubohash.mounted
+        # Just return the image
+        image
+      else
+        FileUtils.mkdir_p(Rubohash.robot_output_path)
+        path = File.join(Rubohash.robot_output_path, "#{robot.name}.#{self.my_format}")
+        puts "Writing Robot: '#{path}'"
+        image.write path
+        robot
+      end
+    end
+
+    private
+
+    # Build out robot attributes
+    def build_robot_attrs
+      if Rubohash.use_default_set
+        set = Rubohash.default_set
+        set_hash_key = nil
+      else
+        # Pull the set from the hash bits
+        set_hash_key = my_hash_array[1] % sets.length
+        set = sets[set_hash_key]
+      end
+
+      if Rubohash.use_default_bg_set
+        bg_sample       = Rubohash.default_bg_set
+        bg_set_hash_key = nil
+      else
+        # Pull the background Set from the hash bits
+        bg_set_hash_key = my_hash_array[2] % bg_sets.length
+        bg_sample       = bg_sets[bg_set_hash_key]
+      end
+
+      color = if set == 'set1'
+                # Pull the color for the hash bits
+                color_hash_key = my_hash_array[0] % colors.length
+                color_sample = colors[color_hash_key]
+
+                set = "set1/#{color_sample}"
+                color_sample
+              end
+
+      # Used to build the robot
+      {
+        my_set: [resource_dir, 'sets', set].join('/'),
+        my_color: color,
+        my_background_set: [resource_dir, 'backgrounds', bg_sample].join('/'),
+        set_hash_key: set_hash_key,
+        bg_set_hash_key: bg_set_hash_key,
+        color_hash_key: color_hash_key,
+        random: {
+          set: set,
+          color: color,
+          bg_sample: bg_sample
+        }
+      }
+    end
+  end
+end

data/lib/rubohash/robot.rb

@@ -0,0 +1,14 @@
+# Rubohash namespace
+module Rubohash
+  # A Robot
+  class Robot
+    attr_accessor :my_set, :my_color, :my_background_set, :name, :parts, :my_digest
+
+    # Default the robot params
+    def initialize(params = {})
+      self.my_set        = params.fetch(:my_set, nil)
+      self.my_color      = params.fetch(:my_color, nil)
+      self.my_background_set = params.fetch(:my_background_set, nil)
+    end
+  end
+end

data/lib/rubohash/version.rb

@@ -0,0 +1,5 @@
+# Rubohash namespace
+module Rubohash
+  # The version number of this gem
+  VERSION = '0.1.1'.freeze
+end

data/lib/rubohash.rb

@@ -0,0 +1,139 @@
+require 'rubohash/version'
+
+require 'securerandom'
+require 'digest'
+require 'logger'
+require 'mini_magick'
+
+require 'rubohash/factory'
+require 'rubohash/robot'
+MiniMagick.logger.level = Logger::WARN
+
+# Rubohash namespace
+module Rubohash
+  @default_extensions = %w[.png .gif .jpg .bmp .jpeg .ppm .datauri]
+  @default_set        = 'set1'
+  @use_default_set    = false
+  @robot_output_path  = File.expand_path('output', Dir.pwd)
+  @default_format     = 'png'
+  @default_bg_set     = 'bg1'
+  @use_default_bg_set = false
+  @use_background     = true
+  @mounted            = false
+
+  def self.inspect
+    %i[
+      default_extensions
+      default_set
+      use_default_set
+      robot_output_path
+      default_format
+      default_bg_set
+      use_default_bg_set
+      use_background
+      mounted
+    ].each_with_object({}) do |k, obj|
+      obj[k] = Rubohash.instance_variable_get("@#{k}")
+    end
+  end
+
+  # Set the default extensions to strip out
+  def self.default_extensions=(my_default_extensions)
+    @default_extensions = my_default_extensions
+  end
+
+  # The default extensions to strip out
+  def self.default_extensions
+    @default_extensions
+  end
+
+  # Se the default image set to use
+  def self.default_set=(my_default_set)
+    @default_set = my_default_set
+  end
+
+  # Get the default image set to use
+  def self.default_set
+    @default_set
+  end
+
+  # Set whether we should use the default set?
+  def self.use_default_set=(my_use_default_set)
+    @use_default_set = my_use_default_set
+  end
+
+  # Are we using the default image set?
+  def self.use_default_set
+    @use_default_set
+  end
+
+  # Set where is the robot image going to be written to
+  def self.robot_output_path=(my_robot_output_path)
+    @robot_output_path = my_robot_output_path
+  end
+
+  # Where is the robot image going to be written to
+  def self.robot_output_path
+    @robot_output_path
+  end
+
+  # Set the default image output format
+  def self.default_format=(my_default_format)
+    @default_format = my_default_format
+  end
+
+  # Get the default image output format
+  def self.default_format
+    @default_format
+  end
+
+  # Set the default background set
+  def self.default_bg_set=(my_default_bg_set)
+    @default_bg_set = my_default_bg_set
+  end
+
+  # Get the default background set
+  def self.default_bg_set
+    @default_bg_set
+  end
+
+  # Set whether we should use the default background set
+  def self.use_default_bg_set=(my_use_default_bg_set)
+    @use_default_bg_set = my_use_default_bg_set
+  end
+
+  # Get whether we are using the default background set
+  def self.use_default_bg_set
+    @use_default_bg_set
+  end
+
+  # Set whether we should composite a background
+  def self.use_background=(my_use_background)
+    @use_background = my_use_background
+  end
+
+  # Get whether we should composite a background
+  def self.use_background
+    @use_background
+  end
+
+  # Set mounted to rails engine
+  def self.mounted=(my_mounted)
+    @mounted = my_mounted
+  end
+
+  # Get Mounted to rails engine
+  def self.mounted
+    @mounted
+  end
+
+  # Assemble a new robot based on string
+  def self.assemble!(string)
+    Rubohash::Factory.new(string).assemble
+  end
+
+  # Yield to a block to configure the gem
+  def self.configure
+    yield self
+  end
+end

data/rubohash.gemspec

@@ -0,0 +1,36 @@
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rubohash/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rubohash'
+  spec.version       = Rubohash::VERSION
+  spec.authors       = ['Mark Holmberg']
+  spec.email         = ['mark.holmberg@icentris.com']
+
+  spec.summary       = 'It generates SHA512 Robot Images.'
+  spec.description   = 'Ruby adaptation of robohash.org'
+  spec.homepage      = 'https://github.com/nedzib/rubohash'
+  spec.license       = 'MIT'
+
+  spec.metadata = { 'homepage_uri' => spec.homepage }
+  spec.required_ruby_version = '>= 2.7'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'mini_magick', '~> 4.9.4'
+
+  spec.add_development_dependency 'bundler', '~> 2.4'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'yard', '~> 0.9', '>= 0.9.20'
+  spec.add_development_dependency 'rubocop', '>= 1.60', '< 2.0'
+end