ruby-latex 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c77fd912c5a1fd4c97cd6c3df883bb8e0241df501f1a18cc7dfb1d4029ee161d
+  data.tar.gz: e4b334a03b8ea96a2af93d09196732c09e5f4ded4971a5070ad2a4b27224dea3
+SHA512:
+  metadata.gz: 1ca80bf37a1866eb4ee26555d209f2cbeb79600bc9a146b41f7edfbc9bacc0deb1eab09b15c310c23a57febea4a59bea680673f6d48049f32e95f5955bd32f6a
+  data.tar.gz: 86cb4a25cfb183d97ee1f0b3c1318c05d66cbfb588242da37bddb2c7956fdcda0ab40777cb92ab1f836f3605d54a0b0978d80057028bfbbd4cec8a3db41fc72a

data/lib/ruby-latex.rb

@@ -0,0 +1,411 @@
+require 'code-assertions'
+
+module Latex
+    class Table
+        attr_accessor   :caption
+        attr_accessor   :label
+        
+        def initialize(caption = nil, label = nil)
+            @caption = caption
+            @label = label
+            @tabulars = []
+        end
+        
+        def auto_resize
+            @resize = true
+            
+            return self
+        end
+        
+        def add_tabular(tabular)
+            raise TypeError, "No implicit conversion from #{tabular.class} to Latex::Tabular" unless tabular.is_a?(Tabular)
+            
+            @tabulars << tabular
+            
+            return self
+        end
+        
+        def tabular=(tabular)
+            @tabulars.clear
+            add_tabular(tabular)
+            
+            return nil
+        end
+        
+        def to_tex
+            out = []
+            out << "\\begin{table}"
+            out << self.caption_string
+            @tabulars.each do |tabular|
+                out << tabular.to_tex
+            end
+            out << "\\end{table}"
+            
+            return out.join("\n")
+        end
+        
+        private
+        def caption_string
+            out = []
+            out << "  \\caption{#@caption}"  if @caption
+            out << "  \\label{#@label}"      if @caption && @label
+            
+            return out.join("\n")
+        end
+    end
+
+    class Tabular
+        def initialize(cols)
+            @header = nil
+            
+            if cols.is_a? Array
+                @columns        = cols.map { |e| e.to_sym }
+                @columns_info   = cols.map { |e| [e, Column.new] }.to_h
+                
+            elsif cols.is_a? Hash
+                keys = cols.keys
+                @columns_info   = cols.clone
+                @columns        = keys.map { |k| k.to_sym }
+                
+                if @columns_info.values.any? { |c| c.header }
+                    headers_row = @columns.map { |c| [c, @columns_info[c].header.to_s] }.to_h
+                    @header = HeaderRowFamily.new(@columns_info, Row.new(headers_row))
+                end
+                
+            else
+                raise "Invalid argument: expected Array or Hash"
+            end
+            
+            @rows   = RowFamily.new(@columns_info)
+        end
+        
+        def header_style(&block)
+            raise "Block expected" unless block_given?
+            raise "No header to style" unless @header
+            @header.styler = block
+            
+            return self
+        end
+        
+        def content_style(&block)
+            raise "Block expected" unless block_given?
+            @rows.styler = block
+            
+            return self
+        end
+                
+        def header=(row)
+            @header = HeaderRowFamily.new(@columns_info, Row.new(row))
+        end
+        
+        def add_row(row)
+            @rows << Row.new(row)
+        end
+        alias :<< :add_row
+        
+        def add_separator(type="\\midrule")
+            @rows << RowSeparator.new(type)
+        end
+        
+        def to_tex
+            sizes = self.column_sizes
+            
+            out = []
+            out << "  \\begin{tabular}{#{self.align_string}}"
+            out << "    \\toprule"
+            if @header
+                out << "    " + @header.row.to_tex(sizes)
+                out << "    \\midrule"
+            end
+            out += @rows.rows.map { |row| "    " + row.to_tex(sizes) }
+            out << "    \\bottomrule"
+            out << "  \\end{tabular}"
+            
+            return out.join("\n")
+        end
+        
+        def column_sizes
+            header_sizes = @header ? [ @header.row.sizes ] : []
+            sizes = @rows.rows.map { |row| row.sizes } + header_sizes
+            @columns.map { |col| [col, (sizes.map { |e| e[col] }).max] }.to_h 
+        end
+        
+        def align_string
+            @columns.map { |col| @columns_info[col].is_a?(Column) ? @columns_info[col].align : auto_align(col) }.join(" ")
+        end
+        
+        def auto_align(col)
+            @rows.rows.map { |row| row[col] }.all? { |e| e.is_a?(Numeric) } ? 'r' : 'l'
+        end
+    end
+
+    class RowFamily
+        attr_reader :rows
+        attr_reader :columns
+        
+        def initialize(columns)
+            @columns = columns
+            @rows = []
+            
+            @styler     = proc { |e| e }
+        end
+        
+        def columns
+            @columns.keys
+        end
+        
+        def format(element, col)
+            @columns[col].formatter.call(element)
+        end
+        
+        def style(element)
+            @styler.call(element)
+        end
+        
+        def <<(row)
+            row.family = self
+            
+            @rows << row
+        end
+        
+        def formatter=(formatter)
+            @formatter = formatter
+        end
+        
+        def styler=(styler)
+            @styler = styler
+        end
+    end
+    
+    class SingleRowFamily < RowFamily
+        def initialize(columns, row)
+            super(columns)
+            
+            row.family = self
+            @rows = [row]
+        end
+        
+        def row
+            @rows.first
+        end
+        
+        def <<(row)
+            raise "Unable to add new rows to a SingleRowFamily"
+        end
+    end
+    
+    class HeaderRowFamily < SingleRowFamily
+        def initialize(columns, row)
+            super(columns, row)
+            
+            @formatter = Formatters::StringFormatter.new
+        end
+        
+        def format(element, col)
+            @formatter.call(element)
+        end
+    end
+    
+    class Row
+        attr_accessor   :family
+        
+        def initialize(hash)
+            raise(WrongRowException, "Hash expected") unless hash.is_a?(Hash)
+            
+            @row     = hash
+        end
+        
+        def family=(family)
+            raise(WrongRowException, "The row must have the following headers: #{family.columns}") unless @row.keys.sort == family.columns.sort
+            
+            @family = family
+        end
+        
+        def row
+            @row
+        end
+        
+        def [](col)
+            @row[col]
+        end
+        
+        def sizes
+            styled = self.styled
+            @family.columns.map { |col| [col, styled[col].length] }.to_h 
+        end
+        
+        def formatted
+            @family.columns.map { |col| [col, @family.format(row[col], col) ] }.to_h
+        end
+        
+        def styled
+            self.formatted.map { |col, content| [col, @family.style(content) ] }.to_h
+        end
+        
+        def to_tex(column_sizes)
+            self.styled.map { |col, content| (" " * (column_sizes[col] - content.length)) + content }.join(" & ") + " \\\\"
+        end
+        
+        class WrongRowException < Exception
+        end
+    end
+    
+    class Column
+        attr_reader     :align
+        attr_reader     :formatter
+        attr_reader     :header
+        
+        def initialize
+            @formatter = Formatters::StringFormatter.new
+            
+            self.with_left_align
+        end
+        
+        def with_left_align
+            self.with_align('l')
+        end
+        
+        def with_right_align
+            self.with_align('r')
+        end
+        
+        def with_center_align
+            self.with_align('c')
+        end
+        
+        def with_integer_formatter(comma=true)
+            self.with_formatter(Formatters::IntegerFormatter.new(comma))
+        end
+        
+        def with_decimal_formatter(n=2, comma=true)
+            self.with_formatter(Formatters::DecimalFormatter.new(n, comma))
+        end
+        
+        def with_align(align)
+            @align = align
+            return self
+        end
+        
+        def with_header(header)
+            @header = header
+            return self
+        end
+        
+        def with_formatter(formatter)
+            @formatter = formatter
+            return self
+        end
+    end
+    
+    class RowSeparator        
+        def initialize(type)
+            @content = type
+        end
+        
+        def family=(family)
+            @columns = family.columns
+        end
+        
+        def row
+            nil
+        end
+        
+        def sizes
+            @columns.map { |e| [e, 0] }.to_h
+        end
+        
+        def formatted
+            @content
+        end
+        
+        def styled
+            @content
+        end
+        
+        def to_tex(*args)
+            @content
+        end
+    end
+    
+    module Parsers
+        class TableParser
+            def self.parse(text)
+                table_space = ['\\begin{table}', '\\end{table}'].map { |s| text.index(s) }
+                table_space[0] += 13 # length of '\begin{table}'
+                
+                table_text = text[*table_space]
+                
+                caption = table_text.scan(/\\caption\{([^}]*)\}/).flatten[0]
+                label   = table_text.scan(/\\label\{([^}]*)\}/).flatten[0]
+                
+                self.parse_tabular(table_text)
+            end
+            
+            def self.parse_tabular(text)
+                tabular_space = ['\\begin{tabular}', '\\end{tabular}'].map { |s| text.index(s) }
+                tabular_space[0] += 15 # length of '\begin{tabular}'
+                
+                tabular_text = text[*tabular_space]
+                
+                align_string = tabular_text.scan(/\{([^}]*)\}/).flatten[0]
+                align = self.parse_align_string(align_string)
+                
+                content_text = tabular_text[tabular_text.index('}') + 1, content_text.length]
+                content_text.lines.each do |line|
+                    
+                end
+            end
+            
+            def self.parse_align_string(text)
+                # TODO implement
+                warn "Ignoring align string #{text}"
+                return nil
+            end
+        end
+    end
+    
+    module Formatters
+        class StringFormatter
+            def call(object)
+                object.to_s
+            end
+        end
+        
+        class IntegerFormatter
+            def initialize(comma=true, nums=nil)
+                @format = "%#{nums}d"
+                @comma = comma
+            end
+            
+            def call(object)
+                result = @format % [object.to_i]
+                result = result.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,") if @comma
+                return result
+            end
+        end
+        
+        class DecimalFormatter
+            def initialize(decimals=2, comma=true, nums=nil)
+                @format = "%#{nums}.#{decimals}f"
+                @comma = comma
+            end
+            
+            def call(object)
+                result = @format % [object.to_f]
+                result = result.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,") if @comma
+                return result
+            end
+        end
+        
+        class CustomFormatter
+            def initialize(&block)
+                raise "Block required" unless block_given?
+                @block = block
+            end
+            
+            def call(object)
+                @block.call(object)
+            end
+        end
+    end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: ruby-latex
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Simone Scalabrino
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: code-assertions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+description: This library allows to easily generate LaTeX content (e.g., tables) directly
+  from Ruby.
+email: s.scalabrino9@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ruby-latex.rb
+homepage: https://github.com/intersimone999/ruby-latex
+licenses:
+- GPL-3.0-only
+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.1.4
+signing_key:
+specification_version: 4
+summary: Generate LaTeX content from Ruby
+test_files: []