csv_plus_plus 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0fb79a1f7a00d60f77289518fb9c6ccac6b059024d5cf66a3f083ec92e77def
-  data.tar.gz: a35796b982b01171636e27b1d1a9d19d6d414249b0e4634947d5a754cb240146
+  metadata.gz: abee03db0f21f9d8c5d3cfb4ec81dbd748568f878458f355cab6db5fc458a509
+  data.tar.gz: 6c4e95fa1c780a2d009eaeb58fd48b28c2dd96826b22be02f84d5fc8a06ad31e
 SHA512:
-  metadata.gz: 45dd804f7889d65ac5f5c63ccc131d774e7ea24097bfe9449af63a48345ca0b9f16ea9e84c17a73151c9ee8d9d90ce4b01d67b7ced817e831e66781d2e7141e0
-  data.tar.gz: 21cda263af6d05d5ee396a9d00b4c1c78f1a043d91787dcf0d822e1adb6a97a2326da836cdc3bbc3c78e43e5c342c1bdb9da966884f1d9d8df364e574f334ded
+  metadata.gz: 59f2cb756bdfd20f95f252aa1c07fb4b994def21f07d8bc4e5a976b22f0b439fb950e1723fdb34753baf23527e5950d244f1386e9231c6318b35de3974305ba4
+  data.tar.gz: 38b6d6d960aa17978adf2ee1724333754e7cdc86b8e41fa58522357448db8448d5441fb5961d3758af94d617b94b21b197b5e4d2d4eb2dba0cbc39da586c4413

data/README.md

@@ -29,7 +29,6 @@ And can be compiled into a `.xlsx` file by:
 $ csv++ -n 'My Stock Tracker' -o mystocks.xlsx mystocks.csvpp
 ```
 
-
 See the [Language Reference](./docs/LANGUAGE_REFERENCE.md) for a full explanation of features.
 
 ## Installing
@@ -38,7 +37,7 @@ Just install it via rubygems (homebrew and debian packages are in the works):
 
 `$ gem install csv_plus_plus`
 
-or if you want the very latest changes, clone the repository and run:
+or if you want the very latest changes, clone this repository and run:
 
 `$ rake gem:install`
 

data/{CHANGELOG.md → docs/CHANGELOG.md}

@@ -1,3 +1,12 @@
+## v0.1.3
+
+- Proper scoping of variables defined within an expand modifier
+- Types via Sorbet
+- Fix formula insertion on Excel
+- Fix modifier string quoting
+- Fix broken Yard doc generation
+- Fix: multiple modifiers on the same row weren't being handled 
+
 ## v0.1.2
 
 - var=... modifier which allows binding a variable to a cell

data/lib/csv_plus_plus/benchmarked_compiler.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -5,57 +6,106 @@ module CSVPlusPlus
   #
   # @attr_reader timings [Array<Benchmark::Tms>] +Benchmark+ timings that have been accumulated by each step of
   #   compilation
-  # @attr_reader benchmark [Benchmark] A +Benchmark+ instance
-  module BenchmarkedCompiler
-    attr_reader :benchmark, :timings
+  # @attr_reader benchmark [Benchmark::Report] A +Benchmark+ instance
+  class BenchmarkedCompiler < ::CSVPlusPlus::Compiler
+    extend ::T::Sig
 
-    # Wrap a +Compiler+ with our instance methods that add benchmarks
-    def self.with_benchmarks(compiler, &block)
-      ::Benchmark.benchmark(::Benchmark::CAPTION, 25, ::Benchmark::FORMAT, '> Total') do |x|
-        # compiler = new(options:, runtime:, benchmark: x)
-        compiler.extend(self)
-        compiler.benchmark = x
+    sig { returns(::Benchmark::Report) }
+    attr_reader :benchmark
 
-        block.call(compiler)
+    sig { returns(::T::Array[::Benchmark::Tms]) }
+    attr_reader :timings
 
+    sig do
+      params(
+        options: ::CSVPlusPlus::Options,
+        runtime: ::CSVPlusPlus::Runtime::Runtime,
+        block: ::T.proc.params(compiler: ::CSVPlusPlus::Compiler).void
+      ).void
+    end
+    # Instantiate a +::Compiler+ that can benchmark (time) it's stages. For better or worse, the only way that they
+    # Benchmark library exposes it's +::Benchmark::Report+ is via a block, so this code also has to wrap with one
+    #
+    # @param options [Options]
+    # @param runtime [Runtime]
+    def self.with_benchmarks(options:, runtime:, &block)
+      ::Benchmark.benchmark(::Benchmark::CAPTION, 25, ::Benchmark::FORMAT, '> Total') do |x|
+        # compiler.extend(self)
+        compiler = new(benchmark: x, options:, runtime:)
+        block.call(compiler)
         [compiler.timings.reduce(:+)]
       end
     end
 
-    # @param benchmark [Benchmark] A +Benchmark+ instance
-    def benchmark=(benchmark)
-      @benchmark = benchmark
-      @timings = []
+    sig do
+      params(
+        benchmark: ::Benchmark::Report,
+        options: ::CSVPlusPlus::Options,
+        runtime: ::CSVPlusPlus::Runtime::Runtime
+      ).void
     end
+    # @param benchmark [::Benchmark::Report]
+    def initialize(benchmark:, options:, runtime:)
+      super(options:, runtime:)
 
+      @benchmark = ::T.let(benchmark, ::Benchmark::Report)
+      @timings = ::T.let([], ::T::Array[::Benchmark::Tms])
+    end
+
+    sig { override.params(block: ::T.proc.params(runtime: ::CSVPlusPlus::Runtime::Runtime).void).void }
     # Time the Compiler#outputting! stage
-    def outputting!
-      time_stage('Writing the spreadsheet') { super }
+    # rubocop:disable Naming/BlockForwarding
+    def outputting!(&block)
+      time_stage('Writing the spreadsheet') { super(&block) }
     end
+    # rubocop:enable Naming/BlockForwarding
 
     protected
 
+    sig { override.void }
     def parse_code_section!
       time_stage('Parsing code section') { super }
     end
 
+    sig { override.returns(::T::Array[::CSVPlusPlus::Row]) }
     def parse_csv_section!
       time_stage('Parsing CSV section') { super }
     end
 
-    def expanding
-      time_stage('Expanding rows') { super }
+    sig { override.params(block: ::T.proc.void).void }
+    # rubocop:disable Naming/BlockForwarding
+    def expanding!(&block)
+      time_stage('Expanding rows') { super(&block) }
+    end
+    # rubocop:enable Naming/BlockForwarding
+
+    sig { override.params(block: ::T.proc.void).void }
+    # rubocop:disable Naming/BlockForwarding
+    def bind_all_vars!(&block)
+      time_stage('Binding [[var=]]') { super(&block) }
     end
+    # rubocop:enable Naming/BlockForwarding
 
+    sig do
+      override
+        .params(template: ::CSVPlusPlus::Template)
+        .returns(::T::Array[::T::Array[::CSVPlusPlus::Entities::Entity]])
+    end
     def resolve_all_cells!(template)
       time_stage('Resolving each cell') { super(template) }
     end
 
     private
 
+    sig do
+      type_parameters(:R).params(
+        stage: ::String,
+        block: ::T.proc.returns(::T.type_parameter(:R))
+      ).returns(::T.nilable(::T.type_parameter(:R)))
+    end
     def time_stage(stage, &block)
-      ret = nil
-      @timings << @benchmark.report(stage) { ret = block.call }
+      ret = ::T.let(nil, ::T.nilable(::T.type_parameter(:R)))
+      @timings << ::T.unsafe(@benchmark.report(stage) { ret = block.call })
       ret
     end
   end

data/lib/csv_plus_plus/cell.rb

@@ -1,8 +1,6 @@
+# typed: strict
 # frozen_string_literal: true
 
-require_relative 'modifier'
-require_relative 'parser/cell_value.tab'
-
 module CSVPlusPlus
   # A cell of a template
   #
@@ -11,9 +9,27 @@ module CSVPlusPlus
   # @attr_reader index [Integer] The cell's index (starts at 0)
   # @attr_reader modifier [Modifier] The modifier for this cell
   class Cell
-    attr_accessor :ast, :row_index
-    attr_reader :index, :modifier
+    extend ::T::Sig
+
+    sig { returns(::T.nilable(::CSVPlusPlus::Entities::Entity)) }
+    attr_accessor :ast
+
+    sig { returns(::Integer) }
+    attr_accessor :row_index
+
+    sig { returns(::Integer) }
+    attr_reader :index
 
+    sig { returns(::CSVPlusPlus::Modifier::Modifier) }
+    attr_reader :modifier
+
+    sig do
+      params(
+        value: ::T.nilable(::String),
+        runtime: ::CSVPlusPlus::Runtime::Runtime,
+        modifier: ::CSVPlusPlus::Modifier::Modifier
+      ).returns(::CSVPlusPlus::Cell)
+    end
     # Parse a +value+ into a Cell object.
     #
     # @param value [String] A string value which should already have been processed through a CSV parser
@@ -23,45 +39,51 @@ module CSVPlusPlus
     # @return [Cell]
     def self.parse(value, runtime:, modifier:)
       new(value:, row_index: runtime.row_index, index: runtime.cell_index, modifier:).tap do |c|
-        c.ast = ::CSVPlusPlus::Parser::CellValue.new.parse(value, runtime)
+        c.ast = ::T.unsafe(::CSVPlusPlus::Parser::CellValue.new).parse(value, runtime)
       end
     end
 
-    # @param row_index [Integer] The cell's row index (starts at 0)
+    sig do
+      params(
+        index: ::Integer,
+        modifier: ::CSVPlusPlus::Modifier::Modifier,
+        row_index: ::Integer,
+        value: ::T.nilable(::String)
+      ).void
+    end
     # @param index [Integer] The cell's index (starts at 0)
-    # @param value [String] A string value which should already have been processed through a CSV parser
     # @param modifier [Modifier] A modifier to apply to this cell
-    def initialize(row_index:, index:, value:, modifier:)
+    # @param row_index [Integer] The cell's row index (starts at 0)
+    # @param value [String] A string value which should already have been processed through a CSV parser
+    def initialize(index:, modifier:, row_index:, value:)
       @value = value
       @modifier = modifier
       @index = index
       @row_index = row_index
     end
 
+    sig { returns(::T.nilable(::String)) }
     # The +@value+ (cleaned up some)
     #
-    # @return [String]
+    # @return [::String]
+    # TODO: is this used?
     def value
-      return if @value.nil? || @value.strip.empty?
+      stripped = @value&.strip
 
-      @value.strip
+      stripped&.empty? ? nil : stripped
     end
 
-    # @return [String]
-    def to_s
-      "Cell(index: #{@index}, row_index: #{@row_index}, value: #{@value}, modifier: #{@modifier})"
-    end
-
-    # A compiled final representation of the cell.  This can only happen after all cell have had
-    # variables and functions resolved.
+    sig { params(runtime: ::CSVPlusPlus::Runtime::Runtime).returns(::T.nilable(::String)) }
+    # A compiled final representation of the cell.  This can only happen after all cell have had variables and functions
+    # resolved.
+    #
+    # @param runtime [Runtime]
     #
-    # @return [String]
-    def to_csv
+    # @return [::String]
+    def evaluate(runtime)
       return value unless @ast
 
-      # This looks really simple but we're relying on each node of the AST to define #to_s such that calling
-      # this at the top will recursively print the tree (as a well-formatted spreadsheet formula)
-      "=#{@ast}"
+      "=#{@ast.evaluate(runtime)}"
     end
   end
 end

data/lib/csv_plus_plus/cli.rb

@@ -1,32 +1,42 @@
+# typed: strict
 # frozen_string_literal: true
 
-require 'optparse'
-
 module CSVPlusPlus
   # Handle running the application with the given CLI flags
   #
   # @attr options [Options, nil] The parsed CLI options
   class CLI
+    extend ::T::Sig
+
+    sig { returns(::CSVPlusPlus::Options) }
     attr_accessor :options
 
+    sig { void }
     # Handle CLI flags and launch the compiler
     #
     # @return [CLI]
     def self.launch_compiler!
       cli = new
-      cli.parse_options!
       cli.main
     rescue ::StandardError => e
-      cli.handle_error(e)
+      ::T.must(cli).handle_error(e)
       exit(1)
     end
 
+    sig { void }
+    # Initialize and parse the CLI flags provided to the program
+    def initialize
+      @options = ::T.let(::CSVPlusPlus::Options.new, ::CSVPlusPlus::Options)
+      parse_options!
+    end
+
+    sig { void }
     # Compile the given template using the given CLI flags
     def main
-      parse_options! unless @options
       ::CSVPlusPlus.apply_template_to_sheet!(::ARGF.read, ::ARGF.filename, @options)
     end
 
+    sig { params(error: ::StandardError).void }
     # Nicely handle a given error.  How it's handled depends on if it's our error and if @options.verbose
     #
     # @param error [CSVPlusPlus::Error, Google::Apis::ClientError, StandardError]
@@ -44,22 +54,18 @@ module CSVPlusPlus
       end
     end
 
+    private
+
+    sig { void }
     # Handle the supplied command line options, setting +@options+ or throw an error if anything is invalid
     def parse_options!
-      @options = ::CSVPlusPlus::Options.new
       option_parser.parse!
       validate_options
     rescue ::OptionParser::InvalidOption => e
       raise(::CSVPlusPlus::Error::Error, e.message)
     end
 
-    # @return [::String]
-    def to_s
-      "CLI(options: #{options})"
-    end
-
-    private
-
+    sig { params(error: ::StandardError).void }
     # An error was thrown that we weren't planning on
     def unhandled_error(error)
       warn(
@@ -74,6 +80,7 @@ module CSVPlusPlus
       warn("Cause: #{error.cause}") if error.cause
     end
 
+    sig { params(error: ::CSVPlusPlus::Error::Error).void }
     def handle_internal_error(error)
       case error
       when ::CSVPlusPlus::Error::SyntaxError
@@ -83,6 +90,7 @@ module CSVPlusPlus
       end
     end
 
+    sig { params(error: ::Google::Apis::ClientError).void }
     def handle_google_error(error)
       warn("Error making Google Sheets API request: #{error.message}")
       return unless @options.verbose
@@ -90,6 +98,7 @@ module CSVPlusPlus
       warn("#{error.status_code} Error making Google API request [#{error.message}]: #{error.body}")
     end
 
+    sig { void }
     def validate_options
       error_message = @options.validate
       return if error_message.nil?
@@ -98,6 +107,7 @@ module CSVPlusPlus
       raise(::CSVPlusPlus::Error::Error, error_message)
     end
 
+    sig { returns(::OptionParser) }
     def option_parser
       ::OptionParser.new do |parser|
         parser.on('-h', '--help', 'Show help information') do

data/lib/csv_plus_plus/cli_flag.rb

@@ -1,7 +1,6 @@
+# typed: true
 # frozen_string_literal: true
 
-require_relative './google_options'
-
 module CSVPlusPlus
   # Individual CLI flags that a user can supply
   #

data/lib/csv_plus_plus/color.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module CSVPlusPlus
@@ -7,25 +8,49 @@ module CSVPlusPlus
   # attr_reader green_hex [String] The green value in hex ("FF", "00", "AF", etc)
   # attr_reader red_hex [String] The red value in hex ("FF", "00", "AF", etc)
   class Color
-    attr_reader :red_hex, :green_hex, :blue_hex
+    extend ::T::Sig
+
+    sig { returns(::String) }
+    attr_reader :red_hex
+
+    sig { returns(::String) }
+    attr_reader :green_hex
+
+    sig { returns(::String) }
+    attr_reader :blue_hex
 
     HEX_STRING_REGEXP = /^#?([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})/i
     public_constant :HEX_STRING_REGEXP
 
+    sig { params(hex_string: ::String).returns(::T::Boolean) }
+    # Is +hex_string+ a valid hexadecimal color code? This function will accept input like the 6-digit format: #FF00FF,
+    # 00AABB and the shorter 3-digit format: #FFF, 0FA.
+    #
+    # @param hex_string [::String] The string to see if it's valid hex string
+    #
     # @return [boolean]
     def self.valid_hex_string?(hex_string)
       !(hex_string.strip =~ ::CSVPlusPlus::Color::HEX_STRING_REGEXP).nil?
     end
 
+    sig { params(hex_string: ::String).void }
     # Create an instance from a string like "#FFF" or "#FFFFFF"
     #
     # @param hex_string [String] The hex string input to parse
+    # rubocop:disable Metrics/CyclomaticComplexity
     def initialize(hex_string)
-      @red_hex, @green_hex, @blue_hex = hex_string.strip.match(::CSVPlusPlus::Color::HEX_STRING_REGEXP)
+      red_hex, green_hex, blue_hex = hex_string.strip.match(::CSVPlusPlus::Color::HEX_STRING_REGEXP)
                                         &.captures
                                         &.map { |s| s.length == 1 ? s + s : s }
+      raise(::CSVPlusPlus::Error::Error, "Invalid color: #{hex_string}") unless red_hex && green_hex && blue_hex
+
+      @red_hex = ::T.let(red_hex, ::String)
+      @green_hex = ::T.let(green_hex, ::String)
+      @blue_hex = ::T.let(blue_hex, ::String)
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
+    sig { returns(::Float) }
     # The percent (decimal between 0-1) of red
     #
     # @return [Numeric]
@@ -33,6 +58,7 @@ module CSVPlusPlus
       hex_to_percent(@red_hex)
     end
 
+    sig { returns(::Float) }
     # The percent (decimal between 0-1) of green
     #
     # @return [Numeric]
@@ -40,6 +66,7 @@ module CSVPlusPlus
       hex_to_percent(@green_hex)
     end
 
+    sig { returns(::Float) }
     # The percent (decimal between 0-1) of blue
     #
     # @return [Numeric]
@@ -47,6 +74,7 @@ module CSVPlusPlus
       hex_to_percent(@blue_hex)
     end
 
+    sig { returns(::String) }
     # Create a hex representation of the color (without a '#')
     #
     # @return [::String]
@@ -54,11 +82,7 @@ module CSVPlusPlus
       [@red_hex, @green_hex, @blue_hex].join
     end
 
-    # @return [::String]
-    def to_s
-      "Color(r: #{@red_hex}, g: #{@green_hex}, b: #{@blue_hex})"
-    end
-
+    sig { params(other: ::Object).returns(::T::Boolean) }
     # @return [boolean]
     def ==(other)
       other.is_a?(self.class) &&
@@ -69,6 +93,7 @@ module CSVPlusPlus
 
     private
 
+    sig { params(hex: ::String).returns(::Float) }
     def hex_to_percent(hex)
       hex.to_i(16) / 255.0
     end