reorganize repo to more standard format

.github/workflows/CI.yml

@@ -0,0 +1,74 @@
+name: CI
+# Run on master, tags, or any pull request
+on:
+  schedule:
+    - cron: '0 2 * * *'  # Daily at 2 AM UTC (8 PM CST)
+  push:
+    branches: [master]
+    tags: ["*"]
+  pull_request:
+concurrency:
+  # Skip intermediate builds: always.
+  # Cancel intermediate builds: only if it is a pull request build.
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
+jobs:
+  test:
+    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - "1.6"  # Earliest supported release
+          - "1"    # Latest release
+        os:
+          - ubuntu-latest
+          - macOS-latest
+          - windows-latest
+        arch:
+          - x64
+          - x86
+        exclude:
+          # Test 32-bit only on Linux
+          - os: macOS-latest
+            arch: x86
+          - os: windows-latest
+            arch: x86
+        include:
+          # Add specific version used to run the reference tests.
+          # Must be kept in sync with version check in `test/runtests.jl`,
+          # and with the branch protection rules on the repository which
+          # require this specific job to pass on all PRs
+          # (see Settings > Branches > Branch protection rules).
+          - os: ubuntu-latest
+            version: 1.10.0
+            arch: x64
+    steps:
+      - uses: actions/checkout@v4
+      - uses: julia-actions/setup-julia@v1
+        with:
+          version: ${{ matrix.version }}
+          arch: ${{ matrix.arch }}
+      - uses: actions/cache@v4
+        env:
+          cache-name: cache-artifacts
+        with:
+          path: ~/.julia/artifacts
+          key: ${{ runner.os }}-${{ matrix.arch }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-${{ matrix.arch }}-test-${{ env.cache-name }}-
+            ${{ runner.os }}-${{ matrix.arch }}-test-
+            ${{ runner.os }}-${{ matrix.arch }}-
+            ${{ runner.os }}-
+      - uses: julia-actions/julia-buildpkg@latest
+      - run: |
+          git config --global user.name Tester
+          git config --global user.email [email protected]
+      - uses: julia-actions/julia-runtest@latest
+      - uses: julia-actions/julia-processcoverage@v1
+      - uses: codecov/codecov-action@v4
+        with:
+          files: lcov.info
+          token: ${{ secrets.CODECOV_TOKEN }}
+          fail_ci_if_error: false

.github/workflows/CompatHelper.yml

@@ -0,0 +1,18 @@
+name: CompatHelper
+on:
+  schedule:
+    - cron: '0 0 * * *'  # Everyday at midnight
+  workflow_dispatch:
+jobs:
+  CompatHelper:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Pkg.add("CompatHelper")
+        run: julia -e 'using Pkg; Pkg.add("CompatHelper")'
+      - name: CompatHelper.main()
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          COMPATHELPER_PRIV: ${{ secrets.DOCUMENTER_KEY }}
+        run: julia -e 'using CompatHelper; CompatHelper.main()'

.github/workflows/TagBot.yml

@@ -0,0 +1,15 @@
+name: TagBot
+on:
+  issue_comment:
+    types:
+      - created
+  workflow_dispatch:
+jobs:
+  TagBot:
+    if: github.event_name == 'workflow_dispatch' || github.actor == 'JuliaTagBot'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: JuliaRegistries/TagBot@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          ssh: ${{ secrets.DOCUMENTER_KEY }}

Project.toml

@@ -4,5 +4,14 @@ authors = ["codegodz <[email protected]>"]
 version = "0.1.0"
 
 [deps]
-StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 StringViews = "354b36f9-a18e-4713-926e-db85100087ba"
+
+[compat]
+julia = "1.6"
+StringViews = "1.3"
+
+[extras]
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["Test"]

README.md

@@ -22,13 +22,13 @@ To install use:
 
 ### Features
 Currently we only have some basic features like reading a line and splitting it.
-For examples on how to generate test data and run the codes below see [`src/test.jl`](https://github.com/JuliaStrings/ViewReader.jl/blob/master/src/test.jl)
+For examples on how to generate test data and run the codes below see [`test/runtest.jl`](https://github.com/JuliaStrings/ViewReader.jl/blob/master/test/runtest.jl)
 
 #### 1. eachlineV
-**`eachlineV(file_path::String; buffer_size::Int64=10_000)`**
+**`eachlineV(file_path::String; buffer_size::Int=10_000)`**
 
 
-This function can be used just like the base[ `eachline` ](https://docs.julialang.org/en/v1/base/io-network/#Base.eachline " `eachline` ") in Julia. The argument `buffer_size` determines the size of the underlaying UInt8 vector. The `buffer_size` should be bigger than the longest line in a file. If this is uknown just use a big number like 1M. This function will throw a warning if no new line is found when the eof is not reached yet - giving a clue to increase the `buffer_size`. 
+This function can be used just like the base[ `eachline` ](https://docs.julialang.org/en/v1/base/io-network/#Base.eachline " `eachline` ") in Julia. The argument `buffer_size` determines the size of the underlaying UInt8 vector. The `buffer_size` should be bigger than the longest line in a file. If this is uknown just use a big number like 1M. This function will throw a warning if no new line is found when the eof is not reached yet - giving a clue to increase the `buffer_size`.
 
 **Example**
 
@@ -48,16 +48,16 @@ Similar to the base [`split`](https://docs.julialang.org/en/v1/base/strings/#Bas
 
 **Example**
 
-For example to check how often we see the string "TARGET" at column 3 in a given file 
+For example to check how often we see the string "TARGET" at column 3 in a given file
 ```Julia
 
 c = 0
 for line in eachlineV("../data/test.txt")
-    data = splitV(line, '\t') 
+    data = splitV(line, '\t')
     if data[1] == "TARGET"
-        c +=1 
+        c +=1
     end
-end 
+end
 println(c)
 ```
 
@@ -82,13 +82,13 @@ c = 0
 for line in eachlineV("../data/numbs.txt")
     for item in splitV(line, '\t')
         c += parseV(UInt32, item)
-    end 
+    end
 end
 println(c)
 ```
 
 ### Benchmark
-We added a simple benchmark in [`src/test.jl`](https://github.com/JuliaStrings/ViewReader.jl/blob/master/src/test.jl), for my computer with:
+We added a simple benchmark in [`test/runtest.jl`](https://github.com/JuliaStrings/ViewReader.jl/blob/master/src/test.jl), for my computer with:
 - `gen_string_data(10_000)`
 - `gen_numb_data(10_000)`
 - and a buffer_size of `10_000`
@@ -113,7 +113,5 @@ so the best is just to try some buffer sizes and see where it works optimally
 
 To make this a bit more visual, we compared the base reader to the view reader.
 On the:
-- **x-axis** is the nubmer of lines in a file and 
+- **x-axis** is the nubmer of lines in a file and
 - **y-axis** the time in seconds to iterate over them
-
-![BenchmarkImage](https://www.linkpicture.com/q/reader_benchmark.png)

src/FileReader.jl

@@ -1,20 +1,19 @@
 
 using StringViews
-using StaticArrays
 
 ###########################################################################
-#  Code to read from a file 
+#  Code to read from a file
 ###########################################################################
 
 struct BufferedReader{IOT <: IO}
     io::IOT
-    buffer::Int64
-    tot_alloc::Int64
+    buffer::Int
+    tot_alloc::Int
     arr::Vector{UInt8}
 end
 
 # Function to flip elements in an array to a specified offset(buffer size here)
-function flip!(arr::Vector{UInt8}, buffer::Int64)
+function flip!(arr::Vector{UInt8}, buffer::Int)
     @inbounds @simd for i in 1:buffer
         arr[i] = arr[i+buffer]
     end
@@ -24,50 +23,50 @@ function read_next_chunk!(reader::BufferedReader)
     # Move last read chunk to front of the array
     # (except in first iter)
     flip!(reader.arr, reader.buffer)
-    
+
     # Store new chunk in second part of the array
-    bytes_read::Int = readbytes!(reader.io, view(reader.arr, reader.buffer+1:reader.tot_alloc), reader.buffer)  
+    bytes_read::Int = readbytes!(reader.io, view(reader.arr, reader.buffer+1:reader.tot_alloc), reader.buffer)
 
     # If we read less than the buffer size we have to reset the array
     # values after "bytes_read" as this is old data (previous read)
     if bytes_read < reader.buffer
         @inbounds for i in reader.buffer+bytes_read+1:reader.tot_alloc
             reader.arr[i] = 0x00
-        end   
-    end   
+        end
+    end
 end
 
-function find_newline(reader::BufferedReader, state::Int64)
+function find_newline(reader::BufferedReader, state::Int)
     cur_stop = copy(state) + 1
-       
-    @inbounds for i in (state + 1):reader.tot_alloc 
-        if reader.arr[i] == 0x0a   
-            return cur_stop:i-1, i 
-        end 
-    end 
-    
+
+    @inbounds for i in (state + 1):reader.tot_alloc
+        if reader.arr[i] == 0x0a
+            return cur_stop:(i > 1 && reader.arr[i-1] == 0x0d ? i-2 : i-1), i
+        end
+    end
+
     return 0:0, cur_stop
 end
 
-function eachlineV(io::IO; buffer_size::Int64=10_000)
+function eachlineV(io::IO; buffer_size::Int=10_000)
     # Allocate buffer array
     tot_alloc = buffer_size * 2
-    buffer_arr = zeros(UInt8, tot_alloc) 
-    
-    # We will set up a buffered reader through which we 
+    buffer_arr = zeros(UInt8, tot_alloc)
+
+    # We will set up a buffered reader through which we
     # stream the file bytes, >4x as fast as a regular reader
     reader = BufferedReader(io, buffer_size, buffer_size*2, buffer_arr)
 
-    # Also populate the reader with the first chunk already 
+    # Also populate the reader with the first chunk already
     read_next_chunk!(reader)
     return reader
 end
 
-function eachlineV(file_path::String; buffer_size::Int64=10_000)
+function eachlineV(file_path::String; buffer_size::Int=10_000)
     io = open(file_path, "r")
     return eachlineV(io, buffer_size=buffer_size)
 end
-    
+
 
 # Override in case we want to reuse buffers and handles
 function eachlineV(io::IO, buffer_arr::Vector{UInt8})
@@ -79,28 +78,25 @@ function eachlineV(io::IO, buffer_arr::Vector{UInt8})
 end
 
 @inline function Base.iterate(reader::BufferedReader)
-    # This is the first iter so only the last half of the array is filled now 
+    # This is the first iter so only the last half of the array is filled now
     # hence start reading from buffer + 1
     r, state = find_newline(reader, reader.buffer)
     return StringView(view(reader.arr, r)), state
 end
 
-@inline function Base.iterate(reader::BufferedReader, state::Int64)
+@inline function Base.iterate(reader::BufferedReader, state::Int)
     r, state = find_newline(reader, state)
     if r.start == 0
         if !eof(reader.io)
             read_next_chunk!(reader)
             r, state = find_newline(reader, state - reader.buffer - 1)
         else
             close(reader.io)
-            return nothing  
-        end 
+            return nothing
+        end
     end
-    # I twould be odd to not reach EOF but still not find 
+    # I twould be odd to not reach EOF but still not find
     # a full line, throw warning
     r.stop == 0 && @warn ("Buffer probably too small")
     return StringView(view(reader.arr, r)), state
 end
-
-
-