pixelflut 0.0.13 → 0.2.1

data/lib/pixelflut/canvas.rb

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

data/lib/pixelflut/canvas/base.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Pixelflut
-  module Canvas
-    class Base
-      attr_accessor :offset_x, :offset_y
-
-      def initialize
-        clear!
-      end
-
-      def clear!
-        @offset_x = @offset_y = 0
-        @color = 'ffffffff'
-      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

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

data/lib/pixelflut/canvas/streamed.rb

@@ -1,20 +0,0 @@
-# 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/client.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'client/socket'
-
-module Pixelflut
-  class Client
-    def initialize(host, port, data, socket_count)
-      @sockets = create_sockets(Addrinfo.tcp(host, port), sliced(data, socket_count))
-    end
-
-    def run
-      loop{ break if call }
-    end
-
-    def call
-      @sockets.size == @sockets.count do |socket|
-        socket.call
-        socket.state == :closed
-      end
-    end
-
-    private
-
-    def sliced(data, count)
-      data = data.split("\n") if data.is_a?(String)
-      data = data.each_slice(data.size / count).to_a
-      data[-2] += data.pop unless (data.size % count).zero?
-      data.map!(&:join)
-    end
-
-    def create_sockets(address, slices)
-      slices.map{ |data| NonblockSocket.new(address, data) }
-    end
-  end
-end

data/lib/pixelflut/client/socket.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'socket'
-
-module Pixelflut
-  class Client
-    class Socket < ::Socket
-      def initialize(address)
-        super(address.ipv6? ? :INET6 : :INET, :STREAM)
-        @addr = ::Socket.pack_sockaddr_in(address.ip_port, address.ip_address)
-        configure
-      end
-
-      def write_with_timout(data, timeout)
-        return true if write_nonblock(data, exception: false) == data.bytesize
-        return false unless wait_writable(timeout)
-        write_nonblock(data, exception: false) == data.bytesize
-      end
-
-      def readline_with_timeout(timeout)
-        deadline = Time.now + timeout
-        ret = ''
-        loop do
-          got = read_nonblock(16, exception: false)
-          if got == :wait_readable
-            remaining_time = deadline - Time.now
-            return nil if remaining_time <= 0 || wait_readable(remaining_time).nil?
-            next
-          end
-          idx = got.index("\n")
-          next ret += got unless idx
-          return ret + got[0, idx]
-        end
-      end
-
-      def connect?
-        :wait_writable != connect_nonblock(@addr, exception: false)
-      end
-
-      private
-
-      def configure
-        self.sync = true
-        setsockopt(:TCP, :NODELAY, 1)
-        setsockopt(:SOCKET, :KEEPALIVE, 0)
-        self.do_not_reverse_lookup = true
-      end
-    end
-
-    class NonblockSocket < Socket
-      attr_reader :state
-
-      def initialize(address, data)
-        super(address)
-        @state = :not_connected
-        @data = data
-        @size = data.bytesize
-      end
-
-      def call
-        case @state
-        when :not_connected
-          do_connect
-        when :wait_connect
-          do_wait_for_connect
-        when :write
-          do_write
-        else
-          close
-          @state = :closed
-        end
-      end
-
-      private
-
-      def do_connect
-        @state = connect? ? :write : :wait_connect
-      end
-
-      def do_wait_for_connect
-        @state = :not_connected unless wait_writable(0.1).nil?
-      end
-
-      def do_write
-        written = write_nonblock(@data, exception: false)
-        return written if Symbol === written
-        @size -= written
-        return @state = :write_finished if @size <= 0
-        @data = @data.byteslice(written, @data.bytesize - written)
-      end
-    end
-  end
-end

data/lib/pixelflut/converter.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Pixelflut
-  class Converter
-    Error = Class.new(RuntimeError)
-  end
-
-  begin
-    require 'rmagick'
-
-    class Converter
-      AVAIL = true
-
-      def initialize(file_name)
-        @images = load_images(file_name)
-      end
-
-      def resize_to(width, height = nil)
-        @images.each{ |image| image.resize_to_fit!(width, height) }
-      end
-
-      def each_pixel
-        return to_enum(__method__) unless block_given?
-        @images.each do |image|
-          image.each_pixel{ |color, x, y| yield(x, y, color) }
-        end
-      end
-
-      def each_rgba_pixel
-        return to_enum(__method__) unless block_given?
-        each_pixel{ |x, y, color| yield(x, y, as_rgba(color)) unless 0xffff == color.opacity }
-      end
-
-      def draw(canvas)
-        each_rgba_pixel{ |x, y, rgba| canvas[x, y] = rgba }
-      end
-
-      def as_rgba(color)
-        color.to_color(Magick::AllCompliance, true, 8, true)[1, 8]
-      end
-
-      private
-
-      def load_images(file_name)
-        Magick::ImageList.new(file_name)
-      rescue Magick::ImageMagickError => e
-        raise(Error, e.message)
-      end
-    end
-  rescue LoadError
-    Converter::AVAIL = false
-  end
-end

data/lib/pixelflut/server.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'socket'
-require_relative 'server/connection'
-require_relative 'server/configuration'
-
-module Pixelflut
-  class Server
-    attr_reader :config
-
-    def initialize(canvas, config = Configuration.default)
-      @canvas, @config = canvas, config
-      @socket, @connections = nil, {}
-      @peers = Hash.new{ |h, k| h[k] = 0 }
-      @ccfg = Connection::Configuration.new(
-        keep_alive_time: config.keep_alive_time,
-        read_buffer_size: config.read_buffer_size,
-        command_limit: config.command_limit,
-        canvas: canvas,
-        size_result: "SIZE #{canvas.width} #{canvas.height}\n".freeze,
-        on_end: ->(conn){ @peers[conn.peeraddr] -= 1 if @connections.delete(conn) }
-      ).freeze
-    end
-
-    def connection_count
-      @connections.size
-    end
-
-    def update
-      return create_socket unless @socket
-      incoming = @socket.accept_nonblock(exception: false)
-      create_connection(incoming) unless Symbol === incoming
-      @connections.keys.each(&:update)
-    end
-
-    def run
-      Thread.new do
-        loop{ update }
-      end
-    end
-
-    private
-
-    def create_connection(socket)
-      peeraddr = socket.peeraddr(false)[-1]
-      count = @peers[peeraddr] + 1
-      return socket.close if count > @config.peer_limit
-      @peers[peeraddr] = count
-      con = Connection.new(socket, peeraddr, @ccfg)
-      @connections[con] = con
-    end
-
-    def create_socket
-      @socket = @config.host ? TCPServer.new(@config.host, @config.port) : TCPServer.new(@config.port)
-      @socket.listen(255)
-    end
-  end
-end

data/lib/pixelflut/server/configuration.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Pixelflut
-  class Server
-    Configuration = Struct.new(
-      :host,
-      :port,
-      :keep_alive_time,
-      :read_buffer_size,
-      :command_limit,
-      :peer_limit
-    ) do
-      def self.default
-        new(nil, 1234, 1, 1024, 10, 8)
-      end
-
-      def to_s
-        "bind: #{host}:#{port}"\
-          ", keep-alive-time: #{keep_alive_time}"\
-          ", read-buffer-size: #{read_buffer_size}"\
-          ", command-limit: #{command_limit}"\
-          ", peer-limit: #{peer_limit}"
-      end
-    end
-  end
-end

data/lib/pixelflut/server/connection.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require 'socket'
-
-module Pixelflut
-  class Server
-    class Connection
-      Configuration = Struct.new(
-        :keep_alive_time,
-        :read_buffer_size,
-        :command_limit,
-        :canvas,
-        :size_result,
-        :on_end,
-        keyword_init: true
-      )
-
-      attr_reader :peeraddr
-
-      def initialize(socket, peeraddr, config)
-        @socket, @peeraddr, @config = socket, peeraddr, config
-        @last_tm, @buffer = Time.now.to_f, ''
-      end
-
-      def close(_reason)
-        socket, @socket = @socket, nil
-        return unless socket
-        socket.close
-        @config.on_end.call(self)
-        false
-      end
-
-      def update
-        index = @buffer.index("\n")
-        return process_loop(index) 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)
-        now = Time.now.to_f
-        return (now - @last_tm > @config.keep_alive_time ? close(:timeout) : nil) if Symbol === str
-        return close(:closed_by_peer) if str.size.zero?
-        @buffer += str
-        @last_tm = now
-      rescue Errno::ECONNRESET
-        close(:closed_by_peer)
-      end
-
-      private
-
-      def next_command(index)
-        @buffer = @buffer[index, @buffer.size - index]
-        @last_tm = Time.now.to_f
-        true
-      end
-
-      def command_size(index)
-        @socket.sendmsg_nonblock(@config.size_result)
-        next_command(index)
-      end
-
-      def command_px(command, index)
-        _, x, y, color = command.split(' ', 4)
-        return close(:color_expected) unless color
-        @config.canvas[x.to_i, y.to_i] = color
-        next_command(index)
-      end
-
-      def command_rc(command, index)
-        _, x1, y1, x2, y2, color = command.split(' ', 6)
-        return close(:color_expected) unless color
-        @config.canvas.draw_rect(x1.to_i, y1.to_i, x2.to_i, y2.to_i, color)
-        next_command(index)
-      end
-
-      def process_loop(index)
-        command_count = @config.command_limit
-        while process_buffer(index)
-          index = @buffer.index("\n") or return
-          command_count -= 1
-          break if command_count <= 0
-        end
-      end
-
-      def process_buffer(index)
-        return close(:max_command_size_exceeded) if index > 31 # 'RC 9999 9999 9999 9999 RRGGBBAA'.size
-        command = @buffer[0, index]
-        index += 1
-        return command_px(command, index) if command.start_with?('PX ')
-        return command_rc(command, index) if command.start_with?('RC ')
-        return close(:quit) if command == 'QUIT'
-        return command_size(index) if command == 'SIZE'
-        close(:bad_command)
-      end
-    end
-
-    private_constant(:Connection)
-  end
-end