csv_plus_plus 0.0.2

data/lib/csv_plus_plus/language/syntax_error.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  module Language
+    ##
+    # An error that can be thrown for various syntax errors
+    class SyntaxError < StandardError
+      # initialize
+      def initialize(message, bad_input, runtime, wrapped_error: nil)
+        @bad_input = bad_input.to_s
+        @runtime = runtime
+        @wrapped_error = wrapped_error
+        @message = message
+
+        super(message)
+      end
+
+      # to_s
+      def to_s
+        to_trace
+      end
+
+      # Output a verbose user-helpful string that references the current runtime
+      def to_verbose_trace
+        warn(@wrapped_error.full_message)
+        warn(@wrapped_error.backtrace)
+        to_trace
+      end
+
+      # Output a user-helpful string that references the runtime state
+      def to_trace
+        "#{message_prefix}#{cell_index} #{message_postfix}"
+      end
+
+      private
+
+      def cell_index
+        row_index = @runtime.row_index
+        if @runtime.cell_index
+          "[#{row_index},#{@runtime.cell_index}]"
+        elsif row_index
+          "[#{row_index}]"
+        else
+          ''
+        end
+      end
+
+      def message_prefix
+        line_number = @runtime.line_number
+        filename = @runtime.filename
+
+        line_str = line_number ? ":#{line_number}" : ''
+        "csv++ #{filename}#{line_str}"
+      end
+
+      def message_postfix
+        "#{@message}: \"#{@bad_input}\""
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/lexer/lexer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module CSVPlusPlus
+  # Common methods to be mixed into our Racc parsers
+  module Lexer
+    # initialize
+    def initialize
+      @tokens = []
+    end
+
+    # Used by racc to iterate each token
+    def next_token
+      @tokens.shift
+    end
+
+    # parse
+    def parse(input, runtime)
+      return if input.nil?
+
+      return return_value unless anything_to_parse?(input)
+
+      tokenize(input, runtime)
+      do_parse
+      return_value
+    rescue ::Racc::ParseError => e
+      runtime.raise_syntax_error("Error parsing #{parse_subject}", e.message, wrapped_error: e)
+    end
+
+    protected
+
+    def tokenize(input, runtime)
+      return if input.nil?
+
+      t = tokenizer(input)
+
+      until t.scanner.empty?
+        next if t.matches_ignore?
+
+        return if t.stop?
+
+        t.scan_tokens!
+        consume_token(t, runtime)
+      end
+
+      @tokens << %i[EOL EOL]
+    end
+
+    def e(type, *entity_args)
+      ::CSVPlusPlus::Language::TYPES[type].new(*entity_args)
+    end
+
+    private
+
+    def consume_token(tokenizer, runtime)
+      if tokenizer.last_token
+        @tokens << [tokenizer.last_token, tokenizer.last_match]
+      elsif tokenizer.scan_catchall
+        @tokens << [tokenizer.last_match, tokenizer.last_match]
+      else
+        runtime.raise_syntax_error("Unable to parse #{parse_subject} starting at", tokenizer.peek)
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/lexer/tokenizer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module CSVPlusPlus
+  module Lexer
+    # A class that contains the use-case-specific regexes for parsing
+    class Tokenizer
+      attr_reader :last_token, :scanner
+
+      # initialize
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(input:, tokens:, catchall: nil, ignore: nil, alter_matches: {}, stop_fn: nil)
+        @scanner = ::StringScanner.new(input.strip)
+        @last_token = nil
+
+        @catchall = catchall
+        @ignore = ignore
+        @tokens = tokens
+        @stop_fn = stop_fn
+        @alter_matches = alter_matches
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Scan tokens and see if any match
+      def scan_tokens!
+        m = @tokens.find { |t| @scanner.scan(t.first) }
+        @last_token = m ? m[1] : nil
+      end
+
+      # Scan input against the catchall pattern
+      def scan_catchall
+        @scanner.scan(@catchall) if @catchall
+      end
+
+      # Scan input against the ignore pattern
+      def matches_ignore?
+        @scanner.scan(@ignore) if @ignore
+      end
+
+      # The value of the last token matched
+      def last_match
+        return @alter_matches[@last_token].call(@scanner.matched) if @alter_matches.key?(@last_token)
+
+        @scanner.matched
+      end
+
+      # Peek the input
+      def peek
+        @scanner.peek(100)
+      end
+
+      # Scan for our stop token (if there is one - some parsers stop early and some don't)
+      def stop?
+        @stop_fn ? @stop_fn.call(@scanner) : false
+      end
+
+      # The rest of the un-parsed input.  The tokenizer might not need to
+      # parse the entire input
+      def rest
+        @scanner.rest
+      end
+    end
+  end
+end

data/lib/csv_plus_plus/lexer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative './lexer/lexer'
+require_relative './lexer/tokenizer'
+
+module CSVPlusPlus
+  module Lexer
+    END_OF_CODE_SECTION = '---'
+    public_constant :END_OF_CODE_SECTION
+
+    VARIABLE_REF = '$$'
+    public_constant :VARIABLE_REF
+  end
+end

data/lib/csv_plus_plus/modifier.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative './color'
+require_relative './expand'
+require_relative './language/syntax_error'
+
+module CSVPlusPlus
+  ##
+  # A container representing the operations that can be applied to a cell or row
+  class Modifier
+    attr_reader :bordercolor, :borders, :color, :fontcolor, :formats
+    attr_writer :borderstyle
+    attr_accessor :expand, :fontfamily, :fontsize, :note, :numberformat, :row_level, :validation
+
+    # initialize
+    def initialize(row_level: false)
+      @row_level = row_level
+      @freeze = false
+      @align = ::Set.new
+      @borders = ::Set.new
+      @formats = ::Set.new
+    end
+
+    # Set an align format. +direction+ must be 'center', 'left', 'right', 'bottom'
+    def align=(direction)
+      @align << direction
+    end
+
+    # Is it aligned to a given direction?
+    def aligned?(direction)
+      @align.include?(direction)
+    end
+
+    # Set the color.  hex_value is a String
+    def color=(hex_value)
+      @color = ::CSVPlusPlus::Color.new(hex_value)
+    end
+
+    # Assign a border.  +side+ must be 'top', 'left', 'bottom', 'right' or 'all'
+    def border=(side)
+      @borders << side
+    end
+
+    # Does this have a border along +side+?
+    def border_along?(side)
+      border_all? || @borders.include?(side)
+    end
+
+    # Does this have a border along all sides?
+    def border_all?
+      @borders.include?('all')
+    end
+
+    # Set the bordercolor
+    def bordercolor=(hex_value)
+      @bordercolor = ::CSVPlusPlus::Color.new(hex_value)
+    end
+
+    # Are there any borders set?
+    def any_border?
+      !@borders.empty?
+    end
+
+    # Set the fontcolor
+    def fontcolor=(hex_value)
+      @fontcolor = ::CSVPlusPlus::Color.new(hex_value)
+    end
+
+    # Set a format.  +type+ must be 'bold', 'italic', 'underline' or 'strikethrough'
+    def format=(value)
+      @formats << value
+    end
+
+    # Is the given format set?
+    def formatted?(type)
+      @formats.include?(type)
+    end
+
+    # Freeze the row from edits
+    def freeze!
+      @frozen = true
+    end
+
+    # Is the row forzen?
+    def frozen?
+      @frozen
+    end
+
+    # Mark this modifer as row-level
+    def row_level!
+      @row_level = true
+    end
+
+    # Is this a row-level modifier?
+    def row_level?
+      @row_level
+    end
+
+    # Is this a cell-level modifier?
+    def cell_level?
+      !@row_level
+    end
+
+    # Style of border
+    def borderstyle
+      @borderstyle || 'solid'
+    end
+
+    # to_s
+    def to_s
+      # TODO... I dunno, not sure how to manage this
+      "Modifier(row_level: #{@row_level} align: #{@align} format: #{@formats} font_size: #{@font_size})"
+    end
+
+    # Create a new modifier instance, with all values defaulted from +other+
+    def take_defaults_from!(other)
+      instance_variables.each do |property|
+        value = other.instance_variable_get(property)
+        instance_variable_set(property, value.clone)
+      end
+    end
+  end
+end