tina4ruby 0.4.0

data/lib/tina4/testing.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+require "json"
+require "stringio"
+
+module Tina4
+  module Testing
+    class << self
+      def suites
+        @suites ||= []
+      end
+
+      def results
+        @results ||= { passed: 0, failed: 0, errors: 0, tests: [] }
+      end
+
+      def reset!
+        @suites = []
+        @results = { passed: 0, failed: 0, errors: 0, tests: [] }
+      end
+
+      def describe(name, &block)
+        suite = TestSuite.new(name)
+        suite.instance_eval(&block)
+        suites << suite
+      end
+
+      def run_all
+        reset_results
+        suites.each do |suite|
+          run_suite(suite)
+        end
+        print_results
+        results
+      end
+
+      private
+
+      def reset_results
+        @results = { passed: 0, failed: 0, errors: 0, tests: [] }
+      end
+
+      def run_suite(suite)
+        puts "\n  #{suite.name}"
+        suite.tests.each do |test|
+          run_test(suite, test)
+        end
+      end
+
+      def run_test(suite, test)
+        suite.run_before_each
+        context = TestContext.new
+        context.instance_eval(&test[:block])
+        results[:passed] += 1
+        results[:tests] << { name: test[:name], status: :passed, suite: suite.name }
+        puts "    \e[32m✓\e[0m #{test[:name]}"
+      rescue TestFailure => e
+        results[:failed] += 1
+        results[:tests] << { name: test[:name], status: :failed, suite: suite.name, message: e.message }
+        puts "    \e[31m✗\e[0m #{test[:name]}: #{e.message}"
+      rescue => e
+        results[:errors] += 1
+        results[:tests] << { name: test[:name], status: :error, suite: suite.name, message: e.message }
+        puts "    \e[33m!\e[0m #{test[:name]}: #{e.message}"
+      ensure
+        suite.run_after_each
+      end
+
+      def print_results
+        total = results[:passed] + results[:failed] + results[:errors]
+        puts "\n  #{total} tests: \e[32m#{results[:passed]} passed\e[0m, " \
+             "\e[31m#{results[:failed]} failed\e[0m, " \
+             "\e[33m#{results[:errors]} errors\e[0m\n"
+      end
+    end
+
+    class TestFailure < StandardError; end
+
+    class TestSuite
+      attr_reader :name, :tests
+
+      def initialize(name)
+        @name = name
+        @tests = []
+        @before_each = nil
+        @after_each = nil
+      end
+
+      def it(description, &block)
+        @tests << { name: description, block: block }
+      end
+
+      def before_each(&block)
+        @before_each = block
+      end
+
+      def after_each(&block)
+        @after_each = block
+      end
+
+      def run_before_each
+        @before_each&.call
+      end
+
+      def run_after_each
+        @after_each&.call
+      end
+    end
+
+    class TestContext
+      def assert(condition, message = "Assertion failed")
+        raise TestFailure, message unless condition
+      end
+
+      def assert_equal(expected, actual, message = nil)
+        msg = message || "Expected #{expected.inspect}, got #{actual.inspect}"
+        raise TestFailure, msg unless expected == actual
+      end
+
+      def assert_not_equal(expected, actual, message = nil)
+        msg = message || "Expected #{actual.inspect} to not equal #{expected.inspect}"
+        raise TestFailure, msg if expected == actual
+      end
+
+      def assert_nil(value, message = nil)
+        msg = message || "Expected nil, got #{value.inspect}"
+        raise TestFailure, msg unless value.nil?
+      end
+
+      def assert_not_nil(value, message = nil)
+        msg = message || "Expected non-nil value"
+        raise TestFailure, msg if value.nil?
+      end
+
+      def assert_includes(collection, item, message = nil)
+        msg = message || "Expected #{collection.inspect} to include #{item.inspect}"
+        raise TestFailure, msg unless collection.include?(item)
+      end
+
+      def assert_raises(exception_class, message = nil)
+        yield
+        raise TestFailure, message || "Expected #{exception_class} to be raised"
+      rescue exception_class
+        true
+      end
+
+      def assert_match(pattern, string, message = nil)
+        msg = message || "Expected #{string.inspect} to match #{pattern.inspect}"
+        raise TestFailure, msg unless pattern.match?(string)
+      end
+
+      def assert_json(response_body)
+        JSON.parse(response_body)
+      rescue JSON::ParserError => e
+        raise TestFailure, "Invalid JSON: #{e.message}"
+      end
+
+      def assert_status(response, expected_status)
+        actual = response.is_a?(Array) ? response[0] : response.status
+        assert_equal(expected_status, actual, "Expected status #{expected_status}, got #{actual}")
+      end
+
+      # HTTP test helpers
+      def simulate_request(method, path, body: nil, headers: {}, params: {})
+        env = build_test_env(method, path, body: body, headers: headers, params: params)
+        app = Tina4::RackApp.new
+        app.call(env)
+      end
+
+      def get(path, headers: {}, params: {})
+        simulate_request("GET", path, headers: headers, params: params)
+      end
+
+      def post(path, body: nil, headers: {})
+        simulate_request("POST", path, body: body, headers: headers)
+      end
+
+      def put(path, body: nil, headers: {})
+        simulate_request("PUT", path, body: body, headers: headers)
+      end
+
+      def delete(path, headers: {})
+        simulate_request("DELETE", path, headers: headers)
+      end
+
+      private
+
+      def build_test_env(method, path, body: nil, headers: {}, params: {})
+        query_string = params.empty? ? "" : URI.encode_www_form(params)
+        body_str = body.is_a?(Hash) ? JSON.generate(body) : (body || "")
+        input = StringIO.new(body_str)
+
+        env = {
+          "REQUEST_METHOD" => method.upcase,
+          "PATH_INFO" => path,
+          "QUERY_STRING" => query_string,
+          "CONTENT_TYPE" => body.is_a?(Hash) ? "application/json" : "text/plain",
+          "CONTENT_LENGTH" => body_str.length.to_s,
+          "REMOTE_ADDR" => "127.0.0.1",
+          "rack.input" => input,
+          "rack.errors" => StringIO.new,
+          "rack.url_scheme" => "http"
+        }
+
+        headers.each do |key, value|
+          env_key = "HTTP_#{key.upcase.gsub('-', '_')}"
+          env[env_key] = value
+        end
+
+        env
+      end
+    end
+  end
+end

data/lib/tina4/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tina4
+  VERSION = "0.4.0"
+end

data/lib/tina4/webserver.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Tina4
+  class WebServer
+    def initialize(app, host: "0.0.0.0", port: 7145)
+      @app = app
+      @host = host
+      @port = port
+    end
+
+    def start
+      require "webrick"
+      require "stringio"
+      Tina4.print_banner
+      Tina4::Debug.info("Starting Tina4 WEBrick server on http://#{@host}:#{@port}")
+      @server = WEBrick::HTTPServer.new(
+        BindAddress: @host,
+        Port: @port,
+        Logger: WEBrick::Log.new(File::NULL),
+        AccessLog: []
+      )
+
+      # Use a custom servlet that passes ALL methods (including OPTIONS) to Rack
+      rack_app = @app
+      servlet = Class.new(WEBrick::HTTPServlet::AbstractServlet) do
+        define_method(:initialize) do |server, app|
+          super(server)
+          @app = app
+        end
+
+        %w[GET POST PUT DELETE PATCH HEAD OPTIONS].each do |http_method|
+          define_method("do_#{http_method}") do |webrick_req, webrick_res|
+            handle_request(webrick_req, webrick_res)
+          end
+        end
+
+        define_method(:handle_request) do |webrick_req, webrick_res|
+          env = build_rack_env(webrick_req)
+          status, headers, body = @app.call(env)
+
+          webrick_res.status = status
+          headers.each do |key, value|
+            if key.downcase == "set-cookie"
+              Array(value.split("\n")).each { |c| webrick_res.cookies << WEBrick::Cookie.parse_set_cookie(c) }
+            else
+              webrick_res[key] = value
+            end
+          end
+
+          response_body = ""
+          body.each { |chunk| response_body += chunk }
+          webrick_res.body = response_body
+        end
+
+        define_method(:build_rack_env) do |req|
+          input = StringIO.new(req.body || "")
+          env = {
+            "REQUEST_METHOD" => req.request_method,
+            "PATH_INFO" => req.path,
+            "QUERY_STRING" => req.query_string || "",
+            "SERVER_NAME" => webrick_req_host,
+            "SERVER_PORT" => webrick_req_port,
+            "CONTENT_TYPE" => req.content_type || "",
+            "CONTENT_LENGTH" => (req.content_length rescue 0).to_s,
+            "REMOTE_ADDR" => req.peeraddr&.last || "127.0.0.1",
+            "rack.input" => input,
+            "rack.errors" => $stderr,
+            "rack.url_scheme" => "http",
+            "rack.version" => [1, 3],
+            "rack.multithread" => true,
+            "rack.multiprocess" => false,
+            "rack.run_once" => false
+          }
+
+          req.header.each do |key, values|
+            env_key = "HTTP_#{key.upcase.gsub('-', '_')}"
+            env[env_key] = values.join(", ")
+          end
+
+          env
+        end
+      end
+
+      # Store host/port for the servlet's build_rack_env
+      host = @host
+      port = @port.to_s
+      servlet.define_method(:webrick_req_host) { host }
+      servlet.define_method(:webrick_req_port) { port }
+
+      @server.mount("/", servlet, rack_app)
+
+      trap("INT") { @server.shutdown }
+      trap("TERM") { @server.shutdown }
+      @server.start
+    end
+
+    def stop
+      @server&.shutdown
+    end
+  end
+end

data/lib/tina4/websocket.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+require "socket"
+require "digest"
+require "base64"
+
+module Tina4
+  class WebSocket
+    GUID = "258EAFA5-E914-47DA-95CA-5AB5DC11AD37"
+
+    attr_reader :connections
+
+    def initialize
+      @connections = {}
+      @handlers = {
+        open: [],
+        message: [],
+        close: [],
+        error: []
+      }
+    end
+
+    def on(event, &block)
+      @handlers[event.to_sym] << block if @handlers.key?(event.to_sym)
+    end
+
+    def upgrade?(env)
+      upgrade = env["HTTP_UPGRADE"] || ""
+      upgrade.downcase == "websocket"
+    end
+
+    def handle_upgrade(env, socket)
+      key = env["HTTP_SEC_WEBSOCKET_KEY"]
+      return unless key
+
+      accept = Base64.strict_encode64(
+        Digest::SHA1.digest("#{key}#{GUID}")
+      )
+
+      response = "HTTP/1.1 101 Switching Protocols\r\n" \
+                 "Upgrade: websocket\r\n" \
+                 "Connection: Upgrade\r\n" \
+                 "Sec-WebSocket-Accept: #{accept}\r\n\r\n"
+
+      socket.write(response)
+
+      conn_id = SecureRandom.hex(16)
+      connection = WebSocketConnection.new(conn_id, socket)
+      @connections[conn_id] = connection
+
+      emit(:open, connection)
+
+      Thread.new do
+        begin
+          loop do
+            frame = connection.read_frame
+            break unless frame
+
+            case frame[:opcode]
+            when 0x1 # Text
+              emit(:message, connection, frame[:data])
+            when 0x8 # Close
+              break
+            when 0x9 # Ping
+              connection.send_pong(frame[:data])
+            end
+          end
+        rescue => e
+          emit(:error, connection, e)
+        ensure
+          @connections.delete(conn_id)
+          emit(:close, connection)
+          socket.close rescue nil
+        end
+      end
+    end
+
+    def broadcast(message, exclude: nil)
+      @connections.each do |id, conn|
+        next if exclude && id == exclude
+        conn.send_text(message)
+      end
+    end
+
+    private
+
+    def emit(event, *args)
+      @handlers[event]&.each { |h| h.call(*args) }
+    end
+  end
+
+  class WebSocketConnection
+    attr_reader :id
+
+    def initialize(id, socket)
+      @id = id
+      @socket = socket
+    end
+
+    def send_text(message)
+      data = message.encode("UTF-8")
+      frame = build_frame(0x1, data)
+      @socket.write(frame)
+    rescue IOError
+      # Connection closed
+    end
+
+    def send_pong(data)
+      frame = build_frame(0xA, data || "")
+      @socket.write(frame)
+    rescue IOError
+      # Connection closed
+    end
+
+    def close(code: 1000, reason: "")
+      payload = [code].pack("n") + reason
+      frame = build_frame(0x8, payload)
+      @socket.write(frame) rescue nil
+      @socket.close rescue nil
+    end
+
+    def read_frame
+      first_byte = @socket.getbyte
+      return nil unless first_byte
+
+      opcode = first_byte & 0x0F
+      second_byte = @socket.getbyte
+      return nil unless second_byte
+
+      masked = (second_byte & 0x80) != 0
+      length = second_byte & 0x7F
+
+      if length == 126
+        length = @socket.read(2).unpack1("n")
+      elsif length == 127
+        length = @socket.read(8).unpack1("Q>")
+      end
+
+      mask_key = masked ? @socket.read(4).bytes : nil
+      data = @socket.read(length) || ""
+
+      if masked && mask_key
+        data = data.bytes.each_with_index.map { |b, i| b ^ mask_key[i % 4] }.pack("C*")
+      end
+
+      { opcode: opcode, data: data }
+    rescue IOError, EOFError
+      nil
+    end
+
+    private
+
+    def build_frame(opcode, data)
+      frame = [0x80 | opcode].pack("C")
+      length = data.bytesize
+
+      if length < 126
+        frame += [length].pack("C")
+      elsif length < 65536
+        frame += [126, length].pack("Cn")
+      else
+        frame += [127, length].pack("CQ>")
+      end
+
+      frame + data
+    end
+  end
+end

data/lib/tina4/wsdl.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Tina4
+  module WSDL
+    class Service
+      attr_reader :name, :namespace, :operations
+
+      def initialize(name:, namespace: "http://tina4.com/wsdl")
+        @name = name
+        @namespace = namespace
+        @operations = {}
+      end
+
+      def add_operation(name, input_params: {}, output_params: {}, &handler)
+        @operations[name.to_s] = {
+          input: input_params,
+          output: output_params,
+          handler: handler
+        }
+      end
+
+      def generate_wsdl(endpoint_url)
+        xml = '<?xml version="1.0" encoding="UTF-8"?>'
+        xml += "\n<definitions xmlns=\"http://schemas.xmlsoap.org/wsdl/\""
+        xml += " xmlns:soap=\"http://schemas.xmlsoap.org/wsdl/soap/\""
+        xml += " xmlns:tns=\"#{@namespace}\""
+        xml += " xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\""
+        xml += " name=\"#{@name}\" targetNamespace=\"#{@namespace}\">\n"
+
+        # Types
+        xml += "  <types>\n    <xsd:schema targetNamespace=\"#{@namespace}\">\n"
+        @operations.each do |op_name, op|
+          xml += generate_elements(op_name, op[:input], "Request")
+          xml += generate_elements(op_name, op[:output], "Response")
+        end
+        xml += "    </xsd:schema>\n  </types>\n"
+
+        # Messages
+        @operations.each_key do |op_name|
+          xml += "  <message name=\"#{op_name}Request\">\n"
+          xml += "    <part name=\"parameters\" element=\"tns:#{op_name}Request\"/>\n"
+          xml += "  </message>\n"
+          xml += "  <message name=\"#{op_name}Response\">\n"
+          xml += "    <part name=\"parameters\" element=\"tns:#{op_name}Response\"/>\n"
+          xml += "  </message>\n"
+        end
+
+        # PortType
+        xml += "  <portType name=\"#{@name}PortType\">\n"
+        @operations.each_key do |op_name|
+          xml += "    <operation name=\"#{op_name}\">\n"
+          xml += "      <input message=\"tns:#{op_name}Request\"/>\n"
+          xml += "      <output message=\"tns:#{op_name}Response\"/>\n"
+          xml += "    </operation>\n"
+        end
+        xml += "  </portType>\n"
+
+        # Binding
+        xml += "  <binding name=\"#{@name}Binding\" type=\"tns:#{@name}PortType\">\n"
+        xml += "    <soap:binding style=\"document\" transport=\"http://schemas.xmlsoap.org/soap/http\"/>\n"
+        @operations.each_key do |op_name|
+          xml += "    <operation name=\"#{op_name}\">\n"
+          xml += "      <soap:operation soapAction=\"#{@namespace}/#{op_name}\"/>\n"
+          xml += "      <input><soap:body use=\"literal\"/></input>\n"
+          xml += "      <output><soap:body use=\"literal\"/></output>\n"
+          xml += "    </operation>\n"
+        end
+        xml += "  </binding>\n"
+
+        # Service
+        xml += "  <service name=\"#{@name}\">\n"
+        xml += "    <port name=\"#{@name}Port\" binding=\"tns:#{@name}Binding\">\n"
+        xml += "      <soap:address location=\"#{endpoint_url}\"/>\n"
+        xml += "    </port>\n"
+        xml += "  </service>\n"
+        xml += "</definitions>"
+        xml
+      end
+
+      def handle_soap_request(xml_body)
+        # Simple SOAP envelope parser
+        op_name = nil
+        params = {}
+
+        @operations.each_key do |name|
+          if xml_body.include?(name)
+            op_name = name
+            break
+          end
+        end
+
+        return soap_fault("Unknown operation") unless op_name
+
+        operation = @operations[op_name]
+
+        # Extract parameters from XML
+        operation[:input].each_key do |param_name|
+          if xml_body =~ /<#{param_name}>(.*?)<\/#{param_name}>/m
+            params[param_name.to_s] = Regexp.last_match(1)
+          end
+        end
+
+        # Execute handler
+        result = operation[:handler].call(params)
+
+        # Build SOAP response
+        build_soap_response(op_name, result)
+      rescue => e
+        soap_fault(e.message)
+      end
+
+      private
+
+      def generate_elements(op_name, params, suffix)
+        xml = "      <xsd:element name=\"#{op_name}#{suffix}\">\n"
+        xml += "        <xsd:complexType><xsd:sequence>\n"
+        params.each do |name, type|
+          xsd_type = ruby_to_xsd_type(type)
+          xml += "          <xsd:element name=\"#{name}\" type=\"xsd:#{xsd_type}\"/>\n"
+        end
+        xml += "        </xsd:sequence></xsd:complexType>\n"
+        xml += "      </xsd:element>\n"
+        xml
+      end
+
+      def ruby_to_xsd_type(type)
+        case type.to_s.downcase
+        when "string" then "string"
+        when "integer", "int" then "int"
+        when "float", "double" then "double"
+        when "boolean", "bool" then "boolean"
+        when "date" then "date"
+        when "datetime" then "dateTime"
+        else "string"
+        end
+      end
+
+      def build_soap_response(op_name, result)
+        xml = '<?xml version="1.0" encoding="UTF-8"?>'
+        xml += '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"'
+        xml += " xmlns:tns=\"#{@namespace}\">"
+        xml += "<soap:Body>"
+        xml += "<tns:#{op_name}Response>"
+        if result.is_a?(Hash)
+          result.each { |k, v| xml += "<#{k}>#{v}</#{k}>" }
+        else
+          xml += "<result>#{result}</result>"
+        end
+        xml += "</tns:#{op_name}Response>"
+        xml += "</soap:Body></soap:Envelope>"
+        xml
+      end
+
+      def soap_fault(message)
+        '<?xml version="1.0" encoding="UTF-8"?>' \
+        '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">' \
+        "<soap:Body><soap:Fault>" \
+        "<faultcode>soap:Server</faultcode>" \
+        "<faultstring>#{message}</faultstring>" \
+        "</soap:Fault></soap:Body></soap:Envelope>"
+      end
+    end
+  end
+end