pixelflut 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9baf1f1bc33ff7224d647d35d142a7688c9bdc98d3c1195fbc247dfa0bd1c68f
+  data.tar.gz: 98056e9d11872f5856de38e2fcfe3677d55a117cf9850e0ff62c0f862a8fdd73
+SHA512:
+  metadata.gz: 5faac48d602c1d8bdc07b1786b5f74732a34c79370f140769ff3dcbc48156d8f433d05c7a62fbc353ca7bee88d697a820dc192c00a694f2f43df9dfe0c606fe7
+  data.tar.gz: e337ed50dfe5e2192f0ee6c16568b8dba2b93a6376ba2e090df8f249a46390e3101797ba7c63f3ebeeeca054453191540a08b27d2c531b107b0338f982961189

data/.gitignore

@@ -0,0 +1,4 @@
+_local/
+tmp/
+pkg/
+gems.locked

data/README.md

@@ -0,0 +1,56 @@
+# Pixelflut
+
+A Pixelflut server written in Ruby.
+
+## Description
+
+Based on the idea of a simple server protocol to collaborate on a shared canvas named [Pixel Flut](https://cccgoe.de/wiki/Pixelflut) this gem implements a Ruby version.
+
+This gem is an open experiment to write a fast server and canvas in Ruby. You are welcome to fork or create pull requests to find the fastest solution!
+
+The gem includes some tools to develop Pixelflut clients and pre-processors.
+
+### Installation
+
+Use [Bundler](http://gembundler.com/) to install the gem:
+
+```bash
+$ gem install pixelflut
+```
+
+Now the `pxf` command offers the complete functionality.
+
+### General Help
+
+You'll find some help on the command line:
+
+```bash
+$ pxf
+usage: pxf command [options]
+
+valid commands:
+generate   Execute given generator FILEs.
+help       Print help for given COMMAND.
+server     Start Pixelflut server.
+version    Print version information.
+```
+
+### Start a server
+
+Starting the server on default port `1234` and open a drawing screen is quite simple:
+
+```bash
+$ pxf server
+```
+
+With these options you can configure the server:
+
+```
+-b, --bind ADDR          bind to given address
+-p, --port PORT          select port(default: 1234)
+-k, --keep-alive         set maximum keep-alive time
+-r, --read_buffer SIZE   set read buffer size (default: 1024)
+-w, --width WIDTH        set canvas width (default: 800)
+-h, --height HEIGHT      set canvas height (default: 600)
+-f, --[no-]fullscreen    run in fullscreen mode
+```

data/bin/pxf

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+def bin_root
+  File.realdirpath('../', __FILE__).freeze
+end
+
+def find_commands
+  Hash[Dir.glob(File.join(bin_root, 'pxf-*')).map!{ |cmd| [File.basename(cmd)[4..-1], cmd] }]
+end
+
+def err(msg)
+  $stderr.puts("pxf: #{msg}")
+  exit 1
+end
+
+def general_help
+  puts('usage: pxf command [options]', nil, 'valid commands:')
+  map = find_commands.transform_values!{ |cmd| %x(#{cmd} --short-help) }
+  cmds = map.keys.sort!
+  len = cmds.max_by(&:size).size + 3
+  cmds.each do |cmd|
+    print cmd.ljust(len)
+    puts(map[cmd])
+  end
+  exit
+end
+
+general_help if ARGV.empty? || ARGV[0] == '--help' || ARGV[0] == '-h'
+cmd = ARGV.shift
+fname = File.join(bin_root, 'pxf-' + cmd)
+err("no such command - #{cmd}") unless File.executable?(fname)
+exec(fname, *ARGV)

data/bin/pxf-generate

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+def help(short)
+  puts('usage: pxf generate FILE [FILE2, ...]', nil) unless short
+  puts('Execute given generator FILEs.')
+end
+
+def extract_options(args)
+  files, options = [], {}
+  while !args.empty?
+    arg = args.shift
+    next files << arg unless arg[0] == '-'
+    next options.merge!(Hash[arg[1..-1].chars.map!{ |c| [c.to_sym, true] }]) unless arg[1] == '-'
+    options[arg[2..-1].to_sym] = args.shift
+  end
+  args[0, 0] = files
+  options
+end
+
+case ARGV[0]
+when '--help'
+  help(false)
+when '--short-help'
+  help(true)
+else
+  $options = extract_options(ARGV)
+  require File.realdirpath('../../lib/pixelflut/canvas/streamed.rb', __FILE__)
+  begin
+    ARGV.each{ |file| Pixelflut::Canvas::Streamed.new.instance_eval(IO.read(file), file, 0) }
+    print "QUIT\n"
+  rescue Interrupt
+    exit
+  end
+end

data/bin/pxf-help

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+def help(short)
+  puts('usage: pxf help COMMAND', nil) unless short
+  puts('Print help for given COMMAND.')
+end
+
+def err(msg)
+  $stderr.puts("pxf: #{msg}")
+  exit 1
+end
+
+case ARGV[0]
+when '--help'
+  help(false)
+when '--short-help'
+  help(true)
+else
+  root = File.realdirpath('../', __FILE__).freeze
+  exec(File.join(root, 'pxf')) if ARGV.empty?
+  ARGV.each do |cmd|
+    fname = File.join(root, 'pxf-' + cmd)
+    err("no such command - #{cmd}") unless File.executable?(fname)
+    system(fname, '--help')
+  end
+end

data/bin/pxf-server

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+def options(cfg)
+  require 'optparse'
+  OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.banner = 'usage: pxf server [options]'
+    opts.separator(nil)
+    opts.separator('valid options:')
+    opts.on('-b', '--bind ADDR', String, 'bind to given address'){ |v| cfg.server.host = v }
+    opts.on('-p', '--port PORT', Integer, 'select port(default: 1234)'){ |v| cfg.server.port = v }
+    opts.on('-k', '--keep-alive', Float, 'set maximum keep-alive time'){ |v| cfg.server.keep_alive_time = v }
+    opts.on('-r', '--read_buffer SIZE', Integer, 'set read buffer size (default: 1024)'){ |v| cfg.server.read_buffer_size = v }
+    opts.on('-w', '--width WIDTH', Integer, 'set canvas width (default: 800)'){ |v| cfg.width = v }
+    opts.on('-h', '--height HEIGHT', Integer, 'set canvas height (default: 600)'){ |v| cfg.height = v }
+    opts.on('-f', '--[no-]fullscreen', 'run in fullscreen mode'){ |v| cfg.fullscreen = v }
+  end
+end
+
+def help(short)
+  puts(options(nil), nil) unless short
+  puts('Start Pixelflut server.')
+  exit
+end
+
+help(false) if ARGV[0] == '--help'
+help(true) if ARGV[0] == '--short-help'
+
+def create_configuration
+  cfg = Pixelflut::App::Configuration.default
+  options(cfg).parse!
+  cfg
+rescue OptionParser::ParseError => e
+  $stderr.puts("pxf: #{e}")
+  exit 1
+end
+
+begin
+  require 'optparse'
+  require File.realdirpath('../../lib/pixelflut.rb', __FILE__)
+  Pixelflut::App.run(create_configuration)
+rescue Interrupt
+  exit
+end

data/bin/pxf-version

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+def help(short)
+  puts('usage: pxf version', nil) unless short
+  puts('Print version information.')
+end
+
+case ARGV[0]
+when '--help'
+  help(false)
+when '--short-help'
+  help(true)
+else
+  require File.realdirpath('../../lib/pixelflut/version.rb', __FILE__).freeze
+  puts("pxf #{Pixelflut::VERSION}")
+end

data/gems.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+source('https://rubygems.org'){ gemspec }

data/lib/pixelflut.rb

@@ -0,0 +1,7 @@
+module Pixelflut
+  LibDir = File.realdirpath('../pixelflut', __FILE__).freeze
+  autoload :App, File.join(LibDir, 'app.rb')
+  autoload :Server, File.join(LibDir, 'server.rb')
+  autoload :Canvas, File.join(LibDir, 'canvas.rb')
+  autoload :VERSION, File.join(LibDir, 'version.rb')
+end

data/lib/pixelflut/app.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'gosu'
+require_relative 'server'
+require_relative 'text_image'
+
+module Pixelflut
+  class App < Gosu::Window
+    Configuration = Struct.new(:width, :height, :fullscreen, :server) do
+      def self.default
+        new(nil, nil, false, Server::Configuration.default)
+      end
+    end
+
+    def self.run(configuration = Configuration.default)
+      new(configuration).show
+    end
+
+    def initialize(configuration)
+      if configuration.fullscreen
+        super(configuration.width || Gosu.screen_width, configuration.height || Gosu.screen_height, fullscreen: true)
+      else
+        super(configuration.width || 800, configuration.height || 600)
+      end
+      Process.setproctitle('pxflut')
+      @image = TextImage.new(width, height)
+      @server = Server.new(@image, configuration.server)
+      log(self.caption = "Pixelflut@#{configuration.server.host}:#{configuration.server.port}")
+      reset!
+    end
+
+    def show
+      @server.run
+      super
+    end
+
+    def reset!
+      @image.clear
+      log("clean image: #{@image.width}x#{@image.height}")
+    end
+
+    def update
+      @draw_image = nil unless 0 == @image.changes
+    end
+
+    def draw
+      (@draw_image ||= Gosu::Image.new(@image.changed, tileable: true, retro: true)).draw(0, 0, 0)
+    end
+
+    def log(*args)
+      print("[#{Time.now}] ")
+      puts(*args)
+    end
+
+    def button_down(id)
+      return close! if Gosu::Button::KbEscape == id
+      return reset! if Gosu::Button::KbSpace == id
+      return log("connections: #{@server.connection_count}") if Gosu::Button::KbC == id
+    end
+
+    def close
+      close!
+    end
+
+    def needs_redraw?
+      nil == @draw_image
+    end
+
+    def needs_cursor?
+      false
+    end
+  end
+end
+
+begin
+  Pixelflut::App.run
+rescue Interrupt
+  exit
+end if __FILE__ == $PROGRAM_NAME

data/lib/pixelflut/canvas.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'canvas/streamed'
+require_relative 'canvas/buffered'

data/lib/pixelflut/canvas/base.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative 'color'
+
+module Pixelflut
+  module Canvas
+    class Base
+      attr_accessor :offset_x, :offset_y
+
+      def initialize
+        clear!
+      end
+
+      def clear!
+        @offset_x = @offset_y = 0
+        @color = Color::Black
+      end
+
+      def translate(x, y)
+        ox, oy = @offset_x, @offset_y
+        @offset_x += x
+        @offset_y += y
+        yield
+      ensure
+        @offset_x, @offset_y = ox, oy
+      end
+
+      def color(color)
+        oc = @color
+        @color = color
+        yield
+      ensure
+        @color = oc
+      end
+
+      def []=(x, y, color)
+        out("PX #{x(x)} #{y(y)} #{color}\n")
+      end
+
+      def pix(x, y, color = @color)
+        out("PX #{x(x)} #{y(y)} #{color}\n")
+      end
+
+      def rect(x1, y1, x2, y2, color = @color)
+        out("RC #{x(x1)} #{y(y1)} #{x(x2)} #{y(y2)} #{color}\n")
+      end
+
+      def line(x1, y1, x2, y2, color = @color)
+        return rect(x1, y1, x2, y2, color) if x1 == x2 || y1 == y2
+        x, y, curpixel = x1, y1, 0
+        deltax = (x2 - x1).abs
+        deltay = (y2 - y1).abs
+        xinc1 = xinc2 = x2 >= x1 ? 1 : -1
+        yinc1 = yinc2 = y2 >= y1 ? 1 : -1
+        if deltax >= deltay
+          xinc1 = yinc2 = 0
+          den, numadd, numpixels, num = deltax, deltay, deltax, deltax / 2
+        else
+          xinc2 = yinc1 = 0
+          den, numadd, numpixels, num = deltay, deltax, deltay, deltay / 2
+        end
+        while curpixel <= numpixels
+          num += numadd
+          if num >= den
+            num -= den
+            x += xinc1
+            y += yinc1
+          end
+          x += xinc2
+          y += yinc2
+          pix(x, y, color)
+          curpixel += 1
+        end
+      end
+
+      def ascii(x, y, dim = 10, color = @color, pic = nil)
+        pic ||= yield
+        sx = x
+        pic.each_line do |line|
+          line.chomp!
+          line.each_char do |c|
+            rect(x, y, x + dim, y + dim, color) if ' ' != c && '_' != c
+            x += dim
+          end
+          x = sx
+          y += dim
+        end
+      end
+
+      protected
+
+      def x(x)
+        x + @offset_x
+      end
+
+      def y(y)
+        y + @offset_y
+      end
+    end
+  end
+end

data/lib/pixelflut/canvas/buffered.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Pixelflut
+  module Canvas
+    class Buffered < Base
+      def clear!
+        @lines = []
+      end
+
+      def each(&block)
+        return to_enum(__method__) unless block
+        @lines.each(&block)
+        yield "QUIT\n"
+      end
+
+      def to_s
+        @lines.join + "QUIT\n"
+      end
+
+      private
+
+      def out(str)
+        @lines << str
+      end
+    end
+  end
+end

data/lib/pixelflut/canvas/color.rb

@@ -0,0 +1,32 @@
+module Pixelflut
+  module Canvas
+    class Base
+      module Color
+        class << self
+          def from_rgb(r, g, b)
+            from_rgba(r, g, b, 0xff)
+          end
+
+          def from_rgba(r, g, b, a)
+            as_hex(r) + as_hex(g) + as_hex(b) + as_hex(a)
+          end
+
+          private
+
+          def as_hex(int)
+            ret = int.to_s(16)
+            ret = '0' + ret if 1 == ret.size
+            ret
+          end
+        end
+
+        Black = from_rgba(0, 0, 0, 0xff)
+        White = from_rgba(0xff, 0xff, 0xff, 0xff)
+        Red = from_rgba(0xff, 0, 0, 0xff)
+        Green = from_rgba(0, 0xff, 0, 0xff)
+        Blue = from_rgba(0, 0, 0xff, 0xff)
+        Yellow = from_rgba(0xff, 0xff, 0, 0xff)
+      end
+    end
+  end
+end

data/lib/pixelflut/canvas/streamed.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Pixelflut
+  module Canvas
+    class Streamed < Base
+      def initialize(stream = $stdout)
+        super()
+        @stream = stream
+      end
+
+      private
+
+      def out(str)
+        @stream.print(str)
+      end
+    end
+  end
+end

data/lib/pixelflut/server.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module Pixelflut
+  class Server
+    Configuration = Struct.new(
+      :host,
+      :port,
+      :keep_alive_time,
+      :read_buffer_size
+    ) do
+      def self.default
+        new(nil, 1234, 1, 1024)
+      end
+    end
+
+    attr_reader :config
+
+    def initialize(canvas, config = Configuration.default)
+      @canvas, @config = canvas, config
+      @socket, @connections = nil, {}
+      @on_end = ->(conn){ @connections.delete(conn) }
+      @size = "SIZE #{canvas.width} #{canvas.height}\n".freeze
+    end
+
+    def connection_count
+      @connections.size
+    end
+
+    def update
+      return create_socket unless @socket
+      now = Time.now.to_f
+      incoming = @socket.accept_nonblock(exception: false)
+      create_connection(incoming, now) unless Symbol === incoming
+      @connections.keys.each{ |con| con.update(now) }
+    end
+
+    def run
+      Thread.new do
+        loop{ update }
+      end
+    end
+
+    private
+
+    def create_connection(incoming, now)
+      con = Connection.new(incoming, now, @config, @canvas, @size, @on_end)
+      @connections[con] = con
+    end
+
+    def create_socket
+      @socket = @config.host ? TCPServer.new(@config.host, @config.port) : TCPServer.new(@config.port)
+      @socket.listen(255)
+    end
+
+    class Connection
+      def initialize(socket, now, config, canvas, size, on_end)
+        @socket, @last_tm, @config, @canvas, @size, @on_end = socket, now, config, canvas, size, on_end
+        # @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        @buffer = ''
+      end
+
+      def close(_reason)
+        socket, @socket = @socket, nil
+        return unless socket
+        socket.close
+        @on_end.call(self)
+      end
+
+      def update(now)
+        index = @buffer.index("\n")
+        return process_buffer(index, now) if index
+        read_size = @config.read_buffer_size - @buffer.size
+        return close(:buffer_exceeded) if read_size <= 0
+        str = @socket.recv_nonblock(read_size, exception: false)
+        return (now - @last_tm > @config.keep_alive_time ? close(:timeout) : nil) if Symbol === str
+        return close(:closed_by_peer) if 0 == str.size
+        @buffer += str
+        @last_tm = now
+      end
+
+      private
+
+      def next_command(index, now)
+        @buffer = @buffer[index, @buffer.size - index]
+        @last_tm = now
+      end
+
+      def command_size(index, now)
+        @socket.sendmsg_nonblock(@size)
+        next_command(index, now)
+      end
+
+      def command_px(command, index, now)
+        _, x, y, color = command.split(' ', 4)
+        return close(:color_expected) unless color
+        @canvas[x.to_i, y.to_i] = color
+        next_command(index, now)
+      end
+
+      def command_rc(command, index, now)
+        _, x1, y1, x2, y2, color = command.split(' ', 6)
+        return close(:color_expected) unless color
+        @canvas.draw_rect(x1.to_i, y1.to_i, x2.to_i, y2.to_i, color)
+        next_command(index, now)
+      end
+
+      def process_buffer(index, now)
+        return close(:max_command_size_exceeded) if index > 31 # 'RC 9999 9999 9999 9999 RRGGBBAA'.size
+        command = @buffer[0, index]
+        index += 1
+        return command_size(index, now) if command == 'SIZE'
+        return close(:quit) if command == 'QUIT'
+        return command_px(command, index, now) if command.start_with?('PX ')
+        return command_rc(command, index, now) if command.start_with?('RC ')
+        close(:bad_command)
+      end
+    end
+  end
+end

data/lib/pixelflut/text_image.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Pixelflut
+  class TextImage
+    attr_reader :columns, :rows, :to_blob, :changes
+
+    def initialize(width, height)
+      @columns, @rows = width, height
+      @row_inc = width * 4
+      clear
+    end
+
+    alias width columns
+    alias height rows
+
+    def clear
+      @to_blob = Black * (@columns * @rows)
+      @changes = 1
+    end
+
+    def changed
+      @changes = 0
+      self
+    end
+
+    # def [](x, y)
+    #   @data[(4 * (x + @columns * y)) % @data.size, 4].bytes.map! do |b|
+    #     b = b.to_s(16)
+    #     b = '0' + b if b.size == 1
+    #     b
+    #   end.join
+    # end
+
+    def []=(x, y, rrggbbaa)
+      @to_blob[(4 * (x + @columns * y)) % @to_blob.size, 4] = as_color(rrggbbaa)
+      @changes += 1
+    end
+
+    def draw_rect(x1, y1, x2, y2, rrggbbaa)
+      x1, x2 = x2, x1 if x1 > x2
+      y1, y2 = y2, y1 if y1 > y2
+      color = as_color(rrggbbaa)
+      pos = (4 * (x1 + @columns * y1)) % @data.size
+      pattern = color * (x2 - x1 + 1)
+      (y2 - y1 + 1).times do
+        @data[pos, pattern.size] = pattern
+        pos += @row_inc
+      end
+      @changes += 1
+    end
+
+    private
+
+    ZZ = 0.chr.freeze
+    FF = 0xff.chr.freeze
+    Black = (ZZ + ZZ + ZZ + FF).freeze
+
+    def as_color(rrggbbaa)
+      case rrggbbaa.size
+      when 3 # RGB
+        (rrggbbaa[0] * 2).to_i(16).chr +
+        (rrggbbaa[1] * 2).to_i(16).chr +
+        (rrggbbaa[2] * 2).to_i(16).chr +
+        FF
+      when 4 # RGBA
+        (rrggbbaa[0] * 2).to_i(16).chr +
+        (rrggbbaa[1] * 2).to_i(16).chr +
+        (rrggbbaa[2] * 2).to_i(16).chr +
+        (rrggbbaa[3] * 2).to_i(16).chr
+      when 6 # RRGGBB
+        (rrggbbaa[0, 2]).to_i(16).chr +
+        (rrggbbaa[2, 2]).to_i(16).chr +
+        (rrggbbaa[4, 2]).to_i(16).chr +
+        FF
+      when 8 # RRGGBBAA
+        (rrggbbaa[0, 2]).to_i(16).chr +
+        (rrggbbaa[2, 2]).to_i(16).chr +
+        (rrggbbaa[4, 2]).to_i(16).chr +
+        (rrggbbaa[6, 2]).to_i(16).chr
+      else
+        Black
+      end
+    end
+
+    # def pos(x, y)
+    #   (4 * (x + @columns * y)) % @data.size
+    # end
+  end
+end

data/lib/pixelflut/version.rb

@@ -0,0 +1,3 @@
+module Pixelflut
+  VERSION = '0.0.4'.freeze
+end

data/rakefile.rb

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+
+task :default do
+  exec 'rake --tasks'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: pixelflut
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Mike Blumtritt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.16.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.16.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.0
+description: |
+  Based on the idea of a simple server protocol to collaborate on a shared canvas named
+  [Pixel Flut](https://cccgoe.de/wiki/Pixelflut) this gem implements a Ruby version.
+email: mike.blumtritt@invision.de
+executables:
+- pxf
+- pxf-generate
+- pxf-server
+- pxf-help
+- pxf-version
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- README.md
+- bin/pxf
+- bin/pxf-generate
+- bin/pxf-help
+- bin/pxf-server
+- bin/pxf-version
+- gems.rb
+- lib/pixelflut.rb
+- lib/pixelflut/app.rb
+- lib/pixelflut/canvas.rb
+- lib/pixelflut/canvas/base.rb
+- lib/pixelflut/canvas/buffered.rb
+- lib/pixelflut/canvas/color.rb
+- lib/pixelflut/canvas/streamed.rb
+- lib/pixelflut/server.rb
+- lib/pixelflut/text_image.rb
+- lib/pixelflut/version.rb
+- pixelflut.gemspec
+- rakefile.rb
+homepage: https://github.com/mblumtritt/pixelflut
+licenses: []
+metadata:
+  issue_tracker: https://github.com/mblumtritt/pixelflut/issues
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: pixelflut
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A Pixelflut server written in Ruby.
+test_files: []