pixelflut 0.0.13 → 0.1.2

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

data/lib/pixelflut/text_image.rb

@@ -1,89 +0,0 @@
-# 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)
-    #   @@to_blob[(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)) % @to_blob.size
-      pattern = color * (x2 - x1 + 1)
-      (y2 - y1 + 1).times do
-        @to_blob[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