ruby2d 0.11.3 → 0.12.0

data/lib/ruby2d/color.rb

@@ -1,23 +1,45 @@
+# frozen_string_literal: true
+
 # Ruby2D::Color
 
 module Ruby2D
+  # Colors are represented by the Color class. Colors can be created from keywords
+  # (based on css), a hexadecimal value or an array containing a collection of
+  # red, green, blue, and alpha (transparency) values expressed as a Float from 0.0 to 1.0.
   class Color
-
-    # Color::Set represents an array of colors
+    # Color::Set represents an array of colors.
     class Set
+      include Enumerable
+
       def initialize(colors)
         @colors = colors.map { |c| Color.new(c) }
       end
 
-      def [](i)
-        @colors[i]
+      def [](index)
+        @colors[index]
       end
 
       def length
         @colors.length
       end
 
-      def opacity; @colors[0].opacity end
+      alias count length
+
+      def each(&block)
+        @colors.each(&block)
+      end
+
+      def first
+        @colors.first
+      end
+
+      def last
+        @colors.last
+      end
+
+      def opacity
+        @colors.first.opacity
+      end
 
       def opacity=(opacity)
         @colors.each do |color|
@@ -29,106 +51,140 @@ module Ruby2D
     attr_accessor :r, :g, :b, :a
 
     # Based on clrs.cc
-    @@colors = {
-      'navy'    => '#001F3F',
-      'blue'    => '#0074D9',
-      'aqua'    => '#7FDBFF',
-      'teal'    => '#39CCCC',
-      'olive'   => '#3D9970',
-      'green'   => '#2ECC40',
-      'lime'    => '#01FF70',
-      'yellow'  => '#FFDC00',
-      'orange'  => '#FF851B',
-      'red'     => '#FF4136',
-      'brown'   => '#663300',
+    NAMED_COLORS = {
+      'navy' => '#001F3F',
+      'blue' => '#0074D9',
+      'aqua' => '#7FDBFF',
+      'teal' => '#39CCCC',
+      'olive' => '#3D9970',
+      'green' => '#2ECC40',
+      'lime' => '#01FF70',
+      'yellow' => '#FFDC00',
+      'orange' => '#FF851B',
+      'red' => '#FF4136',
+      'brown' => '#663300',
       'fuchsia' => '#F012BE',
-      'purple'  => '#B10DC9',
-      'maroon'  => '#85144B',
-      'white'   => '#FFFFFF',
-      'silver'  => '#DDDDDD',
-      'gray'    => '#AAAAAA',
-      'black'   => '#111111',
-      'random'  => ''
-    }
-
-    def initialize(c)
-      if !self.class.is_valid? c
-        raise Error, "`#{c}` is not a valid color"
-      else
-        case c
-        when String
-          if c == 'random'
-            @r, @g, @b, @a = rand, rand, rand, 1.0
-          elsif self.class.is_hex?(c)
-            @r, @g, @b, @a = hex_to_f(c)
-          else
-            @r, @g, @b, @a = hex_to_f(@@colors[c])
-          end
-        when Array
-          @r, @g, @b, @a = [c[0], c[1], c[2], c[3]]
-        when Color
-          @r, @g, @b, @a = [c.r, c.g, c.b, c.a]
-        end
+      'purple' => '#B10DC9',
+      'maroon' => '#85144B',
+      'white' => '#FFFFFF',
+      'silver' => '#DDDDDD',
+      'gray' => '#AAAAAA',
+      'black' => '#111111',
+      'random' => ''
+    }.freeze
+
+    def initialize(color)
+      raise Error, "`#{color}` is not a valid color" unless self.class.valid? color
+
+      case color
+      when String
+        init_from_string color
+      when Array
+        @r = color[0]
+        @g = color[1]
+        @b = color[2]
+        @a = color[3]
+      when Color
+        @r = color.r
+        @g = color.g
+        @b = color.b
+        @a = color.a
       end
     end
 
-    # Return a color set if an array of valid colors
-    def self.set(colors)
-      # If a valid array of colors, return a `Color::Set` with those colors
-      if colors.is_a?(Array) && colors.all? { |el| Color.is_valid? el }
-        Color::Set.new(colors)
-      # Otherwise, return single color
-      else
-        Color.new(colors)
+    class << self
+      # Return a color set if an array of valid colors
+      def set(colors)
+        # If a valid array of colors, return a `Color::Set` with those colors
+        if colors.is_a?(Array) && colors.all? { |el| Color.valid? el }
+          Color::Set.new(colors)
+        # Otherwise, return single color
+        else
+          Color.new(colors)
+        end
       end
-    end
 
-    # Check if string is a proper hex value
-    def self.is_hex?(s)
-      # MRuby doesn't support regex, otherwise we'd do:
-      #   !(/^#[0-9A-F]{6}$/i.match(a).nil?)
-      s.class == String && s[0] == '#' && s.length == 7
-    end
+      # Check if string is a proper hex value
+      def hex?(color_string)
+        # MRuby doesn't support regex, otherwise we'd do:
+        #   !(/^#[0-9A-F]{6}$/i.match(a).nil?)
+        color_string.instance_of?(String) &&
+          color_string[0] == '#' &&
+          color_string.length == 7
+      end
 
-    # Check if the color is valid
-    def self.is_valid?(c)
-      c.is_a?(Color)   ||  # color object
-      @@colors.key?(c) ||  # keyword
-      self.is_hex?(c)  ||  # hexadecimal value
+      # Check if the color is valid
+      def valid?(color)
+        color.is_a?(Color) ||             # color object
+          NAMED_COLORS.key?(color) ||     # keyword
+          hex?(color) ||                  # hexadecimal value
+          (                               # Array of Floats from 0.0..1.0
+            color.instance_of?(Array) &&
+            color.length == 4 &&
+            color.all? { |el| el.is_a?(Numeric) }
+          )
+      end
 
-      # Array of Floats from 0.0..1.0
-      c.class == Array && c.length == 4 &&
-      c.all? { |el| el.is_a?(Numeric) }
+      #
+      # Backwards compatibility
+      alias is_valid? valid?
+      alias is_hex? valid?
     end
 
     # Convenience methods to alias `opacity` to `@a`
-    def opacity; @a end
-    def opacity=(opacity); @a = opacity end
+    def opacity
+      @a
+    end
+
+    def opacity=(opacity)
+      @a = opacity
+    end
+
+    # Return colour components as an array +[r, g, b, a]+
+    def to_a
+      [@r, @g, @b, @a]
+    end
 
     private
 
+    def init_from_string(color)
+      if color == 'random'
+        init_random_color
+      elsif self.class.hex?(color)
+        @r, @g, @b, @a = hex_to_f(color)
+      else
+        @r, @g, @b, @a = hex_to_f(NAMED_COLORS[color])
+      end
+    end
+
+    def init_random_color
+      @r = rand
+      @g = rand
+      @b = rand
+      @a = 1.0
+    end
+
     # Convert from Fixnum (0..255) to Float (0.0..1.0)
-    def to_f(a)
+    def i_to_f(color_array)
       b = []
-      a.each do |n|
+      color_array.each do |n|
         b.push(n / 255.0)
       end
-      return b
+      b
     end
 
     # Convert from hex value (e.g. #FFF000) to Float (0.0..1.0)
-    def hex_to_f(h)
-      h = (h[1..-1]).chars.each_slice(2).map(&:join)
+    def hex_to_f(hex_color)
+      hex_color = (hex_color[1..]).chars.each_slice(2).map(&:join)
       a = []
 
-      h.each do |el|
+      hex_color.each do |el|
         a.push(el.to_i(16))
       end
 
       a.push(255)
-      return to_f(a)
+      i_to_f(a)
     end
-
   end
 
   # Allow British English spelling of color

data/lib/ruby2d/core.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Ruby2D module and native extension loader
+
+unless RUBY_ENGINE == 'mruby'
+  require 'ruby2d/cli/colorize'
+  require 'ruby2d/exceptions'
+  require 'ruby2d/renderable'
+  require 'ruby2d/color'
+  require 'ruby2d/window'
+  require 'ruby2d/dsl'
+  require 'ruby2d/quad'
+  require 'ruby2d/line'
+  require 'ruby2d/circle'
+  require 'ruby2d/rectangle'
+  require 'ruby2d/square'
+  require 'ruby2d/triangle'
+  require 'ruby2d/pixel'
+  require 'ruby2d/pixmap'
+  require 'ruby2d/pixmap_atlas'
+  require 'ruby2d/image'
+  require 'ruby2d/sprite'
+  require 'ruby2d/tileset'
+  require 'ruby2d/font'
+  require 'ruby2d/text'
+  require 'ruby2d/canvas'
+  require 'ruby2d/sound'
+  require 'ruby2d/music'
+  require 'ruby2d/texture'
+  require 'ruby2d/vertices'
+  require 'ruby2d/ruby2d' # load native extension
+end

data/lib/ruby2d/dsl.rb

@@ -1,46 +1,52 @@
-# Ruby2D::DSL
+# frozen_string_literal: true
 
-module Ruby2D::DSL
+module Ruby2D
+  # Ruby2D::DSL
+  module DSL
+    @window = Ruby2D::Window.new
 
-  @window = Ruby2D::Window.new
+    def self.window
+      @window
+    end
 
-  def self.window; @window end
-  def self.window=(w); @window = w end
+    def self.window=(window)
+      @window = window
+    end
 
-  def get(sym, opts = nil)
-    DSL.window.get(sym, opts)
-  end
+    def get(sym, opts = nil)
+      DSL.window.get(sym, opts)
+    end
 
-  def set(opts)
-    DSL.window.set(opts)
-  end
+    def set(opts)
+      DSL.window.set(opts)
+    end
 
-  def on(event, &proc)
-    DSL.window.on(event, &proc)
-  end
+    def on(event, &proc)
+      DSL.window.on(event, &proc)
+    end
 
-  def off(event_descriptor)
-    DSL.window.off(event_descriptor)
-  end
+    def off(event_descriptor)
+      DSL.window.off(event_descriptor)
+    end
 
-  def update(&proc)
-    DSL.window.update(&proc)
-  end
+    def update(&proc)
+      DSL.window.update(&proc)
+    end
 
-  def render(&proc)
-    DSL.window.render(&proc)
-  end
+    def render(&proc)
+      DSL.window.render(&proc)
+    end
 
-  def clear
-    DSL.window.clear
-  end
+    def clear
+      DSL.window.clear
+    end
 
-  def show
-    DSL.window.show
-  end
+    def show
+      DSL.window.show
+    end
 
-  def close
-    DSL.window.close
+    def close
+      DSL.window.close
+    end
   end
-
 end

data/lib/ruby2d/exceptions.rb

@@ -1,6 +1,7 @@
-# Ruby2D::Error
+# frozen_string_literal: true
 
 module Ruby2D
+  # Ruby2D::Error
   class Error < StandardError
   end
 end

data/lib/ruby2d/font.rb

@@ -1,27 +1,33 @@
+# frozen_string_literal: true
+
 # Ruby2D::Font
 
 module Ruby2D
+  #
+  # Font represents a single typeface in a specific size and style.
+  # Use +Font.load+ to load/retrieve a +Font+ instance by path, size and style.
   class Font
     FONT_CACHE_LIMIT = 100
 
-    @@loaded_fonts = {}
-
     attr_reader :ttf_font
 
-    def initialize(path, size, style=nil)
-      @ttf_font = Font.ext_load(path, size, style.to_s)
-    end
+    # Cache loaded fonts in a class variable
+    @loaded_fonts = {}
 
     class << self
-      def load(path, size, style=nil)
-        unless File.exist? path
-          raise Error, "Cannot find font file `#{path}`"
-        end
-
-        (@@loaded_fonts[[path, size, style]] ||= Font.new(path, size, style)).tap do |font|
-          if @@loaded_fonts.size > FONT_CACHE_LIMIT
-            @@loaded_fonts.shift
-          end
+      # Return a font by +path+, +size+ and +style+, loading the font if not already in the cache.
+      #
+      # @param path [#to_s] Full path to the font file
+      # @param size [Numeric] Size of font to setup
+      # @param style [String] Font style
+      #
+      # @return [Font]
+      def load(path, size, style = nil)
+        path = path.to_s
+        raise Error, "Cannot find font file `#{path}`" unless File.exist? path
+
+        (@loaded_fonts[[path, size, style]] ||= Font.send(:new, path, size, style)).tap do |_font|
+          @loaded_fonts.shift if @loaded_fonts.size > FONT_CACHE_LIMIT
         end
       end
 
@@ -30,76 +36,105 @@ module Ruby2D
         all_paths.map { |path| path.split('/').last.chomp('.ttf').downcase }.uniq.sort
       end
 
-      # Find a font file path from its name
+      # Find a font file path from its name, if it exists in the platforms list of fonts
+      # @return [String] full path if +font_name+ is known
+      # @return [nil] if +font_name+ is unknown
       def path(font_name)
         all_paths.find { |path| path.downcase.include?(font_name) }
       end
 
-      # Get all fonts with full file paths
-      def all_paths
-        # MRuby does not have `Dir` defined
-        if RUBY_ENGINE == 'mruby'
-          fonts = `find #{directory} -name *.ttf`.split("\n")
-        # If MRI and/or non-Bash shell (like cmd.exe)
+      # Get full path to the default font
+      def default
+        if all.include? 'arial'
+          path 'arial'
         else
-          fonts = Dir["#{directory}/**/*.ttf"]
+          all_paths.first
         end
+      end
 
-        fonts = fonts.reject do |f|
-          f.downcase.include?('bold')    ||
-          f.downcase.include?('italic')  ||
-          f.downcase.include?('oblique') ||
-          f.downcase.include?('narrow')  ||
-          f.downcase.include?('black')
-        end
+      # Font cannot be instantiated directly; use +Font.load+ instead.
+      private :new
+
+      private
+
+      # Get all fonts with full file paths
+      def all_paths
+        # memoize so we only calculate once
+        @all_paths ||= platform_font_paths
+      end
 
+      # Compute and return all platform font file paths, removing variants by style
+      def platform_font_paths
+        fonts = find_os_font_files.reject do |f|
+          f.downcase.include?('bold') ||
+            f.downcase.include?('italic')  ||
+            f.downcase.include?('oblique') ||
+            f.downcase.include?('narrow')  ||
+            f.downcase.include?('black')
+        end
         fonts.sort_by { |f| f.downcase.chomp '.ttf' }
       end
 
-      # Get the default font
-      def default
-        if all.include? 'arial'
-          path 'arial'
+      # Return all font files in the platform's font location
+      def find_os_font_files
+        if RUBY_ENGINE == 'mruby'
+          # MRuby does not have `Dir` defined
+          `find #{directory} -name *.ttf`.split("\n")
         else
-          all_paths.first
+          # If MRI and/or non-Bash shell (like cmd.exe)
+          Dir["#{directory}/**/*.ttf"]
         end
       end
 
+      # Mapping of OS names to platform-specific font file locations
+      OS_FONT_PATHS = {
+        macos: '/Library/Fonts',
+        linux: '/usr/share/fonts',
+        windows: 'C:/Windows/Fonts',
+        openbsd: '/usr/X11R6/lib/X11/fonts'
+      }.freeze
+
       # Get the fonts directory for the current platform
       def directory
-        macos_font_path   = '/Library/Fonts'
-        linux_font_path   = '/usr/share/fonts'
-        windows_font_path = 'C:/Windows/Fonts'
-        openbsd_font_path = '/usr/X11R6/lib/X11/fonts'
-
         # If MRI and/or non-Bash shell (like cmd.exe)
-        if Object.const_defined? :RUBY_PLATFORM
-          case RUBY_PLATFORM
-          when /darwin/  # macOS
-            macos_font_path
-          when /linux/
-            linux_font_path
-          when /mingw/
-            windows_font_path
-          when /openbsd/
-            openbsd_font_path
-          end
-        # If MRuby
-        else
-          uname = `uname`
-          if uname.include? 'Darwin'  # macOS
-            macos_font_path
-          elsif uname.include? 'Linux'
-            linux_font_path
-          elsif uname.include? 'MINGW'
-            windows_font_path
-          elsif uname.include? 'OpenBSD'
-            openbsd_font_path
-          end
+        # memoize so we only calculate once
+        @directory ||= OS_FONT_PATHS[ruby_platform_osname || sys_uname_osname]
+      end
+
+      # Uses RUBY_PLATFORM to identify OS
+      def ruby_platform_osname
+        return unless Object.const_defined? :RUBY_PLATFORM
+
+        case RUBY_PLATFORM
+        when /darwin/ # macOS
+          :macos
+        when /linux/
+          :linux
+        when /mingw/
+          :windows
+        when /openbsd/
+          :openbsd
         end
       end
 
+      # Uses uname command to identify OS
+      def sys_uname_osname
+        uname = `uname`
+        if uname.include? 'Darwin' # macOS
+          :macos
+        elsif uname.include? 'Linux'
+          :linux
+        elsif uname.include? 'MINGW'
+          :windows
+        elsif uname.include? 'OpenBSD'
+          :openbsd
+        end
+      end
     end
 
+    # Private constructor, called internally using +Font.send(:new,...)+
+    def initialize(path, size, style = nil)
+      @ttf_font = Font.ext_load(path.to_s, size, style.to_s)
+    end
   end
 end