spoolprint 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a2f4545b0e4027268e5bbea35a3035fc2fc2ccdb62ec0965cd6b2b876be28824
+  data.tar.gz: 2948b28e7b18a59d0ad34dcaa435c570f340b1122e69aba1e392409501f28da6
+SHA512:
+  metadata.gz: e18186ec2decc3ab8403ad882c275dda627c527c5ca3af819ee9bea8186101ad9ca67aa57f2f4e1b9c19d704700fb68a138faba0fbfc0767d143cd9cfb194517
+  data.tar.gz: 93316b19d646dd32b6bbd2a5d36b97377367a989d96a9483f7feefae75c04e577dca158c6c063db3daed7bd7c88a7af9e659ef9e01dc050aaaed71e7877c118d

data/.github/workflows/.rubygems.yml

@@ -0,0 +1,30 @@
+name: Rubygems
+
+on:
+  release
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby 2.6
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.x
+
+    - name: Publish to RubyGems
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push *.gem
+      env:
+        GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task default: :test

data/ext/native/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+have_library("winspool")
+create_makefile("spoolprint")

data/ext/native/server.c

@@ -0,0 +1,147 @@
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <mswsock.h>
+#include <ruby.h>
+
+#define PANJANG_NAMA 1024
+// #define PANJANG_JUKIR_AWAL 2;
+
+typedef struct {
+  SOCKET hantar;
+  struct sockaddr_in addr;
+  FD_SET jukir;
+  SOCKET* akhirSentuh;
+  SOCKET* bergulir;
+  // size_t panjang_lantai;
+} server_ket, *serv_ket;
+
+void server_free(void* keterangan) {
+  serv_ket serv = keterangan;
+  while(serv->akhirSentuh != serv->jukir.fd_array) {
+    closesocket(*serv->akhirSentuh--);
+  }
+  FD_ZERO(&serv->jukir);
+	closesocket(serv->hantar);
+  free(serv);
+}
+
+size_t server_size(const void* keterangan) {
+	return sizeof(server_ket);
+}
+
+static const rb_data_type_t server_type = {
+	.wrap_struct_name = "server", 
+	.function = {
+		.dmark = NULL, 
+		.dfree = server_free, 
+		.dsize = server_size
+	}, 
+	.data = NULL, 
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE server_alloc(VALUE self) {
+  char nama[PANJANG_NAMA];
+  serv_ket keterangan;
+  struct hostent* host;
+  struct in_addr* ipAddr;
+
+  gethostname(nama, PANJANG_NAMA);
+  host = gethostbyname(nama);
+  ipAddr = host->h_addr;
+
+  keterangan = malloc(sizeof(server_ket));
+  memset(keterangan, 0, sizeof(server_ket));
+  keterangan->hantar = socket(AF_INET, SOCK_STREAM, 0);
+  keterangan->addr.sin_family = AF_INET;
+  keterangan->addr.sin_addr.s_addr = ipAddr->s_addr;
+  //keterangan->jukir = malloc(sizeof(FD_SET * PANJANG_JUKIR_AWAL);
+  keterangan->akhirSentuh = keterangan->jukir.fd_array;
+  keterangan->bergulir = keterangan->akhirSentuh;
+  // keterangan->panjang_pelanggan = PANJANG_JUKIR_AWAL;
+  return TypedData_Wrap_Struct(self, &server_type, keterangan);
+}
+
+#define MUAT_DATA(var) TypedData_Get_Struct(self, server_ket, \
+  &server_type, var)
+
+VALUE server_init(VALUE self, VALUE port) {
+  serv_ket ket;
+  u_long mode = 1;
+
+  MUAT_DATA(ket);
+  ket->addr.sin_port = htons(FIX2INT(port));
+  bind(ket->hantar, (struct sockaddr*)&ket->addr, sizeof(struct sockaddr_in));
+  listen(ket->hantar, 20);
+  ioctlsocket(ket->hantar, FIONBIO, &mode);
+  return Qnil;
+}
+
+VALUE server_recvpoll(VALUE self) {
+  VALUE resp;
+  serv_ket ket;
+  struct sockaddr_in pelanggan;
+  struct timeval tm;
+  SOCKET pelangganFd;
+  byte flag;
+  int sisa, panjang;
+  FD_SET siap_dibaca;
+
+  MUAT_DATA(ket);
+  rb_need_block();
+
+  memcpy(&siap_dibaca, &ket->jukir, sizeof(FD_SET));
+  timerclear(&tm);
+  sisa = select(siap_dibaca.fd_count, &siap_dibaca, NULL, NULL, &tm);
+  for (size_t i = 0; i < sisa; i++) {
+    ket->bergulir = siap_dibaca.fd_array + i;
+    pelangganFd = *ket->bergulir;
+    read(pelangganFd, &flag, 1);
+    if (flag != 0x9f) {
+      sisa = 0;
+      resp = rb_yield(rb_str_new_frozen(rb_str_new2((char*)&flag)));
+      write(pelangganFd, RSTRING_PTR(resp), RSTRING_LEN(resp));
+    } else {
+      closesocket(pelangganFd);
+      *ket->bergulir = *ket->akhirSentuh;
+      ket->akhirSentuh--;
+      ket->jukir.fd_count--;
+    }
+  }
+
+  memset(&pelanggan, 0, sizeof(pelanggan));
+  panjang = sizeof(pelanggan);
+  pelangganFd = accept(ket->hantar, (struct sockaddr*)&pelanggan, &panjang);
+  if (pelangganFd != -1) {
+    ket->akhirSentuh++;
+    *ket->akhirSentuh = pelangganFd;
+    ket->jukir.fd_count++;
+  }
+}
+
+VALUE server_readdriver(VALUE self, VALUE panjang) {
+  serv_ket ket;
+  MUAT_DATA(ket);
+  char* pandang;
+  int panj, panjDap;
+  VALUE dapat;
+
+  panj = FIX2INT(panjang);
+  pandang = malloc(panj);
+  panjDap = read(ket->bergulir, pandang, panj);
+  dapat = rb_str_new(pandang, panjDap);
+  free(pandang);
+  return dapat;
+}
+
+void Init_server(VALUE wrap) {
+  VALUE cServer = rb_define_class_under(wrap, "Server", rb_cObject);
+  rb_define_alloc_func(cServer, server_alloc);
+  rb_define_method(cServer, "initialize", server_init, 1);
+  rb_define_method(cServer, "receiver_poll", server_recvpoll, 0);
+  rb_define_method(cServer, "read_driver", server_readdriver, 0);
+  // atexit(Finalize_server);
+}
+
+void Finalize_server() {
+}

data/ext/native/spool_print_dalam.c

@@ -0,0 +1,30 @@
+#include <windows.h>
+#include <winspool.h>
+#include <stdio.h>
+
+int spoolprint_dalam(char* namaJob, byte* resi, size_t panjang)
+{
+  CHAR namaPrinter[1024];
+  DWORD ukuran;
+
+  *namaPrinter = 0;
+  ukuran = 1024;
+  GetDefaultPrinter((LPSTR)namaPrinter, (LPDWORD)&ukuran);
+
+  DOC_INFO_1 docInfo;
+  HANDLE kendali;
+  DWORD tertulis;
+
+  ZeroMemory(&docInfo, sizeof(docInfo));
+  docInfo.pDocName = namaJob;
+  docInfo.pDatatype = "RAW";
+
+  OpenPrinter(namaPrinter, &kendali, NULL);
+  StartDocPrinter(kendali, 1, (LPBYTE)&docInfo);
+  StartPagePrinter(kendali);
+  WritePrinter(kendali, resi, panjang, &tertulis);
+  EndPagePrinter(kendali);
+  EndDocPrinter(kendali);
+  ClosePrinter(kendali);
+  return tertulis;
+}

data/ext/native/spoolprint.c

@@ -0,0 +1,117 @@
+#include <ruby.h>
+#include <stdlib.h>
+
+#define ASAL_NAMA_DOC "Resi Toko"
+#define PANJANG_TEKS 4096
+#define NAMA_JOB_MAX 255
+
+extern int spoolprint_dalam(char*, void*, size_t);
+
+typedef struct {
+	char teks[PANJANG_TEKS];
+	byte panjangNamaJob;
+	char* tumpuan;
+	void* sambungan;
+} spoolprint_keterangan, *sp_ket;
+
+void spoolprint_free(void* keterangan) {
+	sp_ket sambungan;
+	while (keterangan != NULL) {
+		sambungan = ((sp_ket)keterangan)->sambungan;
+		free(keterangan);
+		keterangan = sambungan;
+	}
+}
+
+size_t spoolprint_size(const void* keterangan) {
+	return sizeof(spoolprint_keterangan);
+}
+
+static const rb_data_type_t spoolprint_type = {
+	.wrap_struct_name = "spoolprint", 
+	.function = {
+		.dmark = NULL, 
+		.dfree = spoolprint_free, 
+		.dsize = spoolprint_size
+	}, 
+	.data = NULL, 
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+#define MUAT_DATA(var) TypedData_Get_Struct(self, spoolprint_keterangan, \
+	&spoolprint_type, var)
+
+VALUE spoolprint_alloc(VALUE self) {
+	sp_ket keterangan = malloc(sizeof(spoolprint_keterangan));
+	memset(keterangan, 0, sizeof(spoolprint_keterangan));
+	keterangan->tumpuan = keterangan->teks;
+	return TypedData_Wrap_Struct(self, &spoolprint_type, keterangan);
+}
+
+VALUE spoolprintInit(int argc, VALUE* argv, VALUE self) {
+	VALUE namaDoc;
+	sp_ket ket;
+	char* nama = "\0";
+	size_t tempuh = 0;
+	MUAT_DATA(ket);
+
+	rb_scan_args(argc, argv, "01", &namaDoc);
+	if (argc > 0) {
+		Check_Type(namaDoc, RUBY_T_STRING);
+		nama = RSTRING_PTR(namaDoc);
+	}
+
+	while(*nama != 0 && ++tempuh < NAMA_JOB_MAX) {
+		*ket->tumpuan++ = *nama++;
+	}
+	ket->panjangNamaJob = ket->tumpuan - ket->teks;
+	*ket->tumpuan++ = 0;
+}
+
+VALUE spoolprintCetak(VALUE self) {
+	char *nDoc = ASAL_NAMA_DOC, *dicetak;
+	size_t panjang;
+	sp_ket ket;
+	MUAT_DATA(ket);
+
+	if (ket->panjangNamaJob > 0) {
+		nDoc = ket->teks;
+		dicetak = ket->teks + ket->panjangNamaJob + 2;
+	} else {
+		dicetak = ket->teks + 1;
+	}
+	
+	if (*dicetak != 0x1b || *(dicetak + 1) != 0x40) return Qnil;
+	panjang = ket->tumpuan - dicetak;
+	return INT2FIX(spoolprint_dalam(nDoc, dicetak, panjang));
+}
+
+VALUE spoolprintRaw(VALUE self, VALUE raw) {
+	char* jukir;
+	size_t panjang;
+	sp_ket ket;
+
+	MUAT_DATA(ket);
+	Check_Type(raw, RUBY_T_STRING);
+	jukir = RSTRING_PTR(raw);
+	panjang = RSTRING_LEN(raw);
+
+	if (ket->tumpuan - ket->teks + panjang < PANJANG_TEKS) {
+		while (panjang--) *ket->tumpuan++ = *jukir++;
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+extern void Init_server(VALUE);
+
+void Init_spoolprint() {
+	VALUE mSpoolprint = rb_define_module("Spoolprint");
+	VALUE cSpoolPrint = rb_define_class_under(mSpoolprint, "SpoolPrint", rb_cObject);
+	rb_define_alloc_func(cSpoolPrint, spoolprint_alloc);
+	rb_define_method(cSpoolPrint, "initialize", spoolprintInit, -1);
+	rb_define_method(cSpoolPrint, "taruh_raw", spoolprintRaw, 1);
+	rb_define_method(cSpoolPrint, "cetak", spoolprintCetak, 0);
+	Init_server(mSpoolprint);
+}

data/lib/spoolprint/server/receiver_manager.rb

@@ -0,0 +1,53 @@
+module Spoolprint
+  class ReceiverManager
+    FLAG_SUCCESS = [0x80, 0x00].collect(&:chr).join
+
+    class RemoteServer
+      def initialize(meth)
+        @meth = meth
+      end
+
+      def use(length)
+        return @meth.call(length)
+      end
+    end
+
+    class Request
+      attr_accessor :flag, :length, :message
+
+      def perfect?
+        return false if length.nil?
+        return false if length.zero?
+        return false if message.nil?
+        return false if message.empty?
+        return true
+      end
+
+      def self.urai(flag)
+        instance = self.new
+        if flag == 0x93
+          instance.flag = flag
+          instance.length = yield(1)
+          instance.message = yield(instance.length)
+        end
+        return instance
+      end
+    end
+
+    class Response
+      attr_accessor :success, :for_print
+    end
+
+    def initialize(remote_meth)
+      @remote = RemoteServer.new(remote_meth)
+    end
+
+    def make_response(req_raw)
+      req = Request.urai(req_raw) { |length| @remote.use(length) }
+      resp = Response.new
+      resp.success = FLAG_SUCCESS
+      resp.for_print = req.message
+      return resp
+    end
+  end
+end

data/lib/spoolprint/server_receipt.rb

@@ -0,0 +1,39 @@
+require "spoolprint/server/receiver_manager"
+
+module Spoolprint
+  class ServerReceipt < Server
+    ASAL_SERVER_PORT = 7776
+
+    def initialize(spool)
+      super(ASAL_SERVER_PORT)
+      @spool = spool
+      @manager = ReceiverManager.new(method(:read_driver))
+      @server_zone = Thread.new { server_bergulir }
+      @bergulir = false
+    end
+
+    def start
+      @bergulir = true
+      @server_zone.run if @server_zone.stop?
+    end
+
+    def stop
+      @bergulir = false
+    end
+
+    private
+    def server_bergulir
+      while true
+        @bergulir ? server_receive : Thread.stop
+      end
+    end
+    
+    def server_receive
+      receiver_poll do |r|
+        resp = @manager.make_response(r)
+        @spool << resp.for_print
+        next resp.success
+      end
+    end
+  end
+end

data/lib/spoolprint/version.rb

@@ -0,0 +1,3 @@
+module Spoolprint
+  VERSION = "1.0.0"
+end

data/lib/spoolprint.rb

@@ -0,0 +1,37 @@
+require 'spoolprint.so'
+require 'escpos'
+require 'spoolprint/server_receipt'
+
+module Spoolprint
+  class ReceiptPrintEasy < Escpos::Printer
+    attr_reader :interface
+
+    def initialize(job = nil)
+      super()
+      @interface = create_interface(job)
+      @server = ServerReceipt.new(self)
+    end
+
+    def start_server
+      @server.start
+    end
+
+    def stop_server
+      @server.stop
+    end
+
+    def to_escpos
+      @interface.taruh_raw(super)
+      return @interface.cetak
+    end
+
+    private
+    def create_interface(job)
+      if (job.nil?)
+        return SpoolPrint.new
+      else
+        return SpoolPrint.new(job)
+      end
+    end
+  end
+end

data/spoolprint.gemspec

@@ -0,0 +1,17 @@
+require File.expand_path('../lib/spoolprint/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "spoolprint"
+  s.version = Spoolprint::VERSION
+  s.license = "MIT"
+  s.authors = ["Reckordp"]
+  s.summary = "Library for printing to Esc/Eps printer"
+  s.description = "Ruby/Spoolprint provides way to connecting printer on Windows"
+  s.email = "paksaambil@gmail.com"
+  s.homepage = "https://github.com/Reckordp/spoolprint"
+  s.add_dependency(%q(escpos), [">= 0"])
+  s.require_paths = ["lib"]
+  s.date = "2022-09-08"
+  s.files = `git ls-files`.split($\)
+  s.extensions = "ext/native/extconf.rb"
+end

data/test/test_print.rb

@@ -0,0 +1,5 @@
+require 'spoolprint'
+
+receipt = Spoolprint::ReceiptPrintEasy.new
+receipt << "Z" + Escpos.sequence(Escpos::CTL_LF)
+receipt.to_escpos

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: spoolprint
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Reckordp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: escpos
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby/Spoolprint provides way to connecting printer on Windows
+email: paksaambil@gmail.com
+executables: []
+extensions:
+- ext/native/extconf.rb
+extra_rdoc_files: []
+files:
+- ".github/workflows/.rubygems.yml"
+- Rakefile
+- ext/native/extconf.rb
+- ext/native/server.c
+- ext/native/spool_print_dalam.c
+- ext/native/spoolprint.c
+- lib/spoolprint.rb
+- lib/spoolprint/server/receiver_manager.rb
+- lib/spoolprint/server_receipt.rb
+- lib/spoolprint/version.rb
+- spoolprint.gemspec
+- test/test_print.rb
+homepage: https://github.com/Reckordp/spoolprint
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Library for printing to Esc/Eps printer
+test_files: []