flex-cartesian 1.3.0 → 2.0.0.beta

data/lib/flex-cartesian/flex-cartesian-io.rb

@@ -0,0 +1,192 @@
+module FlexCartesianIO
+
+# unified wrapper method for output
+def output(rows = nil, **opts)
+  if rows == nil
+    cartesian_output(**opts)
+  else
+    table_output(rows, **opts)
+  end
+end
+
+  # internal method
+  def separator(sep, format:)
+    case format
+    when :csv
+      [";", ","].include?(sep) ? sep : ";"
+    when :markdown
+      "|"
+    else
+      sep
+    end
+  end
+
+  # internal method for printing headers
+  def output_headers(headers:, format:, widths:, stream:, colorize:, separator:, file:)
+    case format
+    when :markdown
+      stream.print separator
+      cells = headers.map.with_index do |h,i|
+        cell = h.ljust(widths[i])
+        fmt_cell(cell, file: file, colorize: colorize, header: true)
+      end
+      stream.puts cells.join(separator) + separator
+      stream.puts separator + headers.map.with_index { |h,i| "-" * widths[i] }.join(separator) + separator
+    when :csv
+      stream.puts headers.map.with_index { |h,i| fmt_cell(h, file: file, colorize: colorize, header: true, width: widths[i]) }.join(separator)
+    else
+      stream.puts separator + headers.map.with_index { |h,i| fmt_cell(h, file: file, colorize: colorize, header: true, width: widths[i]) }.join(separator) + separator
+    end
+  end
+
+# internal method for output from space
+def cartesian_output(separator: "|", colorize: true, format: :plain, limit: nil, file: nil)
+
+  # output stream
+  out = file ? File.open(file, "w") : STDOUT
+
+  # column separator
+  sep = separator(separator, format: format)
+
+  # table headers
+  visible_func_names = @derived.keys - (@function_hidden || Set.new).to_a
+  headers = @names.map(&:to_s) + visible_func_names.map(&:to_s)
+
+  # column widths
+  widths = headers.map { |h| @dimension_widths[h.to_sym] == nil ? @default_width : @dimension_widths[h.to_sym] }
+
+  # print headers
+  output_headers(file: file, headers: headers, format: format, widths: widths, stream: out, colorize: colorize, separator: sep)
+
+  # print rows
+  cartesian do |vector|
+    values = vector.members.map { |m| vector.send(m) } + visible_func_names.map { |f| @function_results&.dig(vector_to(vector, :hash), f) }
+    line = headers.zip(values).map.with_index { |(dim, val), i| fmt_cell(val, file: file, colorize: colorize, width: widths[i]) }.join(sep)
+    case format
+    when :plain
+      out.puts sep + line + sep
+    when :markdown
+      out.puts sep + line + sep
+    when :csv
+      out.puts line
+    end
+  end
+
+  out.close if out.is_a?(File)
+end
+
+def import(path, format: :json)
+  data = case format
+  when :json
+    JSON.parse(File.read(path), symbolize_names: true)
+  when :yaml
+    YAML.safe_load(File.read(path), symbolize_names: true)
+  else
+    raise ArgumentError, "Unsupported format: #{format}. Only :json and :yaml are supported."
+  end
+
+  raise TypeError, "Expected parsed data to be a Hash" unless data.is_a?(Hash)
+
+  @dimensions = data
+  self
+end
+
+def export(path, format: :json)
+  case format
+  when :json
+    File.write(path, JSON.pretty_generate(@dimensions))
+  when :yaml
+    File.write(path, YAML.dump(@dimensions))
+  else
+    raise ArgumentError, "Unsupported format: #{format}. Only :json and :yaml are supported."
+  end
+end
+
+
+  def from_json(path)
+    data = JSON.parse(File.read(path), symbolize_names: true)
+    @dimensions = data
+  end
+
+  def from_yaml(path)
+    data = YAML.safe_load(File.read(path), symbolize_names: true)
+    @dimensions = data
+  end
+
+  # internal method
+  def fmt_cell(value, file:, colorize: false, header: false, width: nil)
+    str = case value
+          when String then value
+          else value.inspect
+          end
+    str = str.ljust(width) if width
+
+    # output to file must NOT be colorized to avoid special characters in file
+    return str if file
+
+    if not colorize
+      str
+    elsif header
+      str.colorize(:yellow)
+    else
+      str.colorize(:cyan)
+    end
+  end
+
+# THIS NEEDS TO BE MERGED INTO standard output method
+def table_output(rows, separator: "|", colorize: true, format: :plain, file: nil)
+  return if rows.nil? || rows.empty?
+
+  # output stream
+  out = file ? File.open(file, "w") : STDOUT
+
+  # column separator
+  sep = separator(separator, format: format)
+
+  # table headers
+  headers = rows.first.keys.map(&:to_s)
+
+  # column widths
+  widths = headers.to_h do |h|
+            values = rows.map { |row| row[h.to_sym].to_s.size }
+            [h, [h.size, *values].max]
+          end
+
+  # print headers
+  output_headers(file: file, headers: headers, format: format, widths: widths.values, stream: out, colorize: colorize, separator: sep)
+
+  rows.each do |row|
+    line = headers.map { |h| fmt_cell(row[h.to_sym], file: file, colorize: colorize, width: widths[h]) }.join(sep)
+    case format
+    when :plain
+      out.puts sep + line + sep
+    when :markdown
+      out.puts sep + line + sep
+    when :csv
+      out.puts line + sep
+    end
+  end
+
+  out.close if out.is_a?(File)
+end
+
+end
+
+module FlexOutput
+  def cartesian_output(separator: "|", colorize: true)
+    return puts "(empty struct)" unless respond_to?(:members) && respond_to?(:values)
+
+    values_list = members.zip(values.map { |v| v.inspect })
+
+    widths = values_list.map { |k, v| [k.to_s.size, v.size].max }
+
+    line = values_list.each_with_index.map do |(_, val), i|
+      str = val.to_s
+      str = str.ljust(widths[i])
+      colorize ? str.colorize(:cyan) : str
+    end
+
+    puts line.join(separator)
+  end
+end
+

data/lib/flex-cartesian/flex-cartesian-utilities.rb

@@ -0,0 +1,126 @@
+require 'set'
+
+module FlexCartesianUtilities
+
+  # TODO: .index is O(N), better optimize it using intermediate Hash
+  # vector commands
+  def vector(command:, vector:, dimension: nil, offset: 1)
+    case command
+    when :index
+      unless dimension
+        @names.map { |dim| vector(command: command, vector: vector, dimension: dim) }
+      else
+        levels = @dimensions[dimension]
+        raise "Incorrect dimension name" unless levels
+        levels.index(vector[dimension])
+      end
+    when :shift
+      # vector = vector_to(v, :hash)
+      return nil if dimension.nil?
+      index = vector(command: :index, vector: vector, dimension: dimension)
+      index ? @dimensions[dimension][index + offset] : nil
+    else
+      raise "Incorrect vector command #{command}"
+    end
+  end
+
+# obtain value of the given function on a given vector from parameter space
+# modes:
+# :enforce - recompute function value
+# :reuse - fetch previously computed value or drop error if there isn't one
+# :lazy - recompute if there's no precomputed value or reuse if there's one
+def value(v, function:, mode: :lazy)
+  v_struct = vector_to(v, :struct)
+  v_hash = vector_to(v, :hash)
+
+  res = @results[v_struct][function]
+
+  case mode
+  when :reuse
+    raise "Value of #{function} function is missing on #{v_hash.inspect} vector" if res.nil?
+    return res
+  when :enforce
+    new_res = @derived[function].call(v_struct)
+    @results[v_struct][function] = new_res
+    return new_res
+  when :lazy
+    new_res = res.nil? ? @derived[function].call(v_struct) : res
+    @results[v_struct][function] = new_res
+    return new_res
+  else
+    raise "Incorrect function recompute mode: #{mode}"
+  end
+  res
+end
+
+# NOTE: BAD CONFLICT OF NAME "DIMENSIONS"
+#def dimensions(data = @dimensions, raw: false, separator: ', ', dimensions: true, values: true, lazy: false)
+#  return nil if !dimensions && !values
+
+#  unless data.is_a?(Struct) || data.is_a?(Hash)
+#    raise ArgumentError, "Incorrect type of dimensions: #{data.class}"
+#  end
+
+#  if data.is_a?(Struct)
+#    return nil unless valid?(data)
+
+#    return data.each_pair.map { |k, val|
+#      (dimensions ? "#{k}" : "") +
+#      ((dimensions && values) ? "=" : "") +
+#      (values ? "#{val}" : "")
+#    }.join(separator)
+#  end
+
+#  enum = Enumerator.new do |y|
+#    cartesian(data, lazy: lazy) do |v|
+#      next unless valid?(v)
+#      y << dimensions(v, raw: raw, separator: separator, dimensions: dimensions, values: values, lazy: lazy)
+#    end
+#  end
+
+#  return enum if lazy
+#  enum.to_a.join("\n")
+#end
+
+  # Return number of combinations in parameter space, with respect to conditions
+  def size
+    return 0 unless @dimensions.is_a?(Hash)
+
+    return @plan.size if @plan # TODO: dead code
+
+    if @conditions.empty?
+      values = @dimensions.values.map { |dim| dim.is_a?(Enumerable) ? dim.to_a : [dim] }
+      return 0 if values.any?(&:empty?)
+      values.map(&:size).inject(1, :*)
+    else
+      size = 0
+      cartesian do |v|
+        next if @conditions.any? { |cond| !cond.call(v) }
+        size += 1
+      end
+      size
+    end
+  end
+
+  # Convert first `limit` combinations of parameter space to array
+  # or convert vector in parameter space to array
+  # with respect to conditions
+  def to_a(data = nil, limit: nil)
+
+    # if no `data` given we assume the data is parameter space
+    if data.nil?
+      result = []
+      cartesian do |v|
+        result << v.to_a
+        break if limit && result.size >= limit
+      end
+      return result
+    end
+
+    # otherwise, it's a single vector
+    valid?(data)
+    data.values
+  end
+
+end
+

data/lib/flex-cartesian.rb

@@ -5,343 +5,25 @@ require 'json'
 require 'yaml'
 require 'method_source'
 require 'set'
+require 'logger'
 
-module FlexOutput
-  def output(separator: " | ", colorize: false, align: true)
-    return puts "(empty struct)" unless respond_to?(:members) && respond_to?(:values)
+require_relative 'flex-cartesian/flex-cartesian-core'
+require_relative 'flex-cartesian/flex-cartesian-io'
+require_relative 'flex-cartesian/flex-cartesian-utilities'
+require_relative 'flex-cartesian/flex-cartesian-analyzer'
+require_relative 'flex-cartesian/flex-cartesian-deprecations'
+require_relative 'visualization/html'
 
-    values_list = members.zip(values.map { |v| v.inspect })
 
-    widths = align ? values_list.map { |k, v| [k.to_s.size, v.size].max } : []
-
-    line = values_list.each_with_index.map do |(_, val), i|
-      str = val.to_s
-      str = str.ljust(widths[i]) if align
-      colorize ? str.colorize(:cyan) : str
-    end
-
-    puts line.join(separator)
-  end
-end
 
 class FlexCartesian
 
-  def initialize(dimensions = nil, path: nil, format: :json)
-    if dimensions && path
-      puts "Please specify either dimensions or path to dimensions"
-      exit
-    end
-    @dimensions = dimensions
-    @conditions = []
-    @derived = {}
-    @order = { first: nil, last: nil }
-    @function_results = {}  # key: Struct instance.object_id => { fname => value }
-    @function_hidden = Set.new
-    import(path, format: format) if path
-  end
-
-  def dimensions(data = @dimensions, raw: false, separator: ', ', dimensions: true, values: true)
-    return data.inspect if raw # by default, with no data speciaifed, we assume dimensions of Cartesian
-    return nil if not dimensions and not values
-
-    if data.is_a?(Struct) or data.is_a?(Hash) # vector in Cartesian or entire Cartesian
-      data.each_pair.map { |k, v| (dimensions ? "#{k}" : "") + ((dimensions and values) ? "=" : "") + (values ? "#{v}" : "") }.join(separator)
-    else
-      puts "Incorrect type of dimensions: #{data.class}"
-      exit
-    end
-  end
-
-  def cond(command = :print, index: nil, &block)
-    case command
-    when :set
-      raise ArgumentError, "Block required" unless block_given?
-      @conditions << block
-      self
-    when :unset
-      raise ArgumentError, "Index of the condition required" unless index
-      @conditions.delete_at(index)
-    when :clear 
-      @conditions.clear
-      self
-    when :print 
-      return if @conditions.empty?
-      @conditions.each_with_index { |cond, idx| puts "#{idx} | #{cond.source.gsub(/^.*?\s/, '')}" }
-    else
-      raise ArgumentError, "unknown condition command: #{command}"
-    end
-  end
-
-def func(command = :print, name = nil, hide: false, progress: false, title: "calculating functions", order: nil, &block)
-  case command
-  when :add
-    raise ArgumentError, "Function name and block required for :add" unless name && block_given?
-    add_function(name, order: order, &block)
-    @function_hidden.delete(name.to_sym)
-    @function_hidden << name.to_sym if hide
-
-  when :del
-    raise ArgumentError, "Function name required for :del" unless name
-    remove_function(name)
-
-  when :print
-    if @derived.empty?
-      puts "(no functions defined)"
-    else
-      @derived.each do |fname, fblock|
-        source = fblock.source rescue '(source unavailable)'
-        body = source.sub(/^.*?\s(?=(\{|\bdo\b))/, '').strip
-        order = ""
-        if @order.value?(fname.to_sym)
-          case @order.key(fname.to_sym)
-          when :first
-            order = " [FIRST]"
-          when :last
-            order = " [LAST]"
-          end
-        end
-        puts "  #{fname.inspect.ljust(12)}| #{body}#{@function_hidden.include?(fname) ? ' [HIDDEN]' : ''}#{order}"
-      end
-    end
-
-  when :run
-    @function_results = {}
-
-    if progress
-    bar = ProgressBar.create(title: title, total: size, format: '%t [%B] %p%% %e')
-
-    cartesian do |v|
-      @function_results[v] ||= {}
-      @derived.each do |fname, block|
-        @function_results[v][fname] = block.call(v)
-      end
-      bar.increment if progress
-    end
-
-  else
-    cartesian do |v|
-      @function_results[v] ||= {}
-      @derived.each do |fname, block|
-        @function_results[v][fname] = block.call(v)
-      end
-    end
-  end
-
-  else
-    raise ArgumentError, "Unknown command for function: #{command.inspect}"
-  end
-end
-
-  def add_function(name, order: nil , &block)
-    raise ArgumentError, "Block required" unless block_given?
-    if reserved_function_names.include?(name.to_sym)
-      raise ArgumentError, "Function name '#{name}' has been already added"
-    elsif reserved_struct_names.include?(name.to_sym)
-      raise ArgumentError, "Name '#{name}' has been reserved for internal method, you can't use it for a function"
-    end
-    if order == :last
-      @derived[name.to_sym] = block # add to the tail of the hash
-      @order[:last] = name.to_sym
-    elsif order == :first
-      @derived = { name.to_sym => block }.merge(@derived) # add to the head of the hash
-      @order[:first] = name.to_sym
-    elsif order == nil
-      if @order[:last] != nil
-        last_name = @order[:last]
-        last_body = @derived[last_name]
-        @derived.delete(@order[:last]) # remove the tail of the hash
-        @derived[name.to_sym] = block # add new function to the tail of the hash
-        @derived[last_name] = last_body # restore :last function in the tail of the hash
-      else
-        @derived[name.to_sym] = block
-      end
-    else
-      raise ArgumentError, "unknown function order '#{order}'"
-    end
-  end
-
-  def remove_function(name)
-    @derived.delete(name.to_sym)
-    @order[:last] = nil if @order[:last] == name.to_sym
-    @order[:first] = nil if @order[:first] == name.to_sym
-  end
-
-  def cartesian(dims = nil, lazy: false)
-  dimensions = dims || @dimensions
-  return nil unless dimensions.is_a?(Hash)
-
-  names = dimensions.keys
-  values = dimensions.values.map { |dim| dim.is_a?(Enumerable) ? dim.to_a : [dim] }
-
-  return to_enum(:cartesian, dims, lazy: lazy) unless block_given?
-  return if values.any?(&:empty?)
-
-  struct_class = Struct.new(*names).tap { |sc| sc.include(FlexOutput) }
-
-  base = values.first.product(*values[1..])
-  enum = lazy ? base.lazy : base
-
-  enum.each do |combo|
-    struct_instance = struct_class.new(*combo)
-
-    @derived&.each do |name, block|
-      struct_instance.define_singleton_method(name) { block.call(struct_instance) }
-    end
-
-  next if @conditions.any? { |cond| !cond.call(struct_instance) }
-
-    yield struct_instance
-  end
-end
-
-  def size
-    return 0 unless @dimensions.is_a?(Hash)
-    if @conditions.empty?
-      values = @dimensions.values.map { |dim| dim.is_a?(Enumerable) ? dim.to_a : [dim] }
-      return 0 if values.any?(&:empty?)
-      values.map(&:size).inject(1, :*)
-    else
-      size = 0
-      cartesian do |v|
-        next if @conditions.any? { |cond| !cond.call(v) }
-        size += 1
-      end
-      size
-    end
-  end
-
-  def to_a(limit: nil)
-    result = []
-    cartesian do |v|
-      result << v
-      break if limit && result.size >= limit
-    end
-    result
-  end
-
-  def progress_each(lazy: false, title: "Processing")
-    bar = ProgressBar.create(title: title, total: size, format: '%t [%B] %p%% %e')
-
-    cartesian(@dimensions, lazy: lazy) do |v|
-      yield v
-      bar.increment
-    end
-  end
-
-def output(separator: " | ", colorize: false, align: true, format: :plain, limit: nil, file: nil)
-  rows = if @function_results && !@function_results.empty?
-           @function_results.keys
-         else
-           result = []
-           cartesian do |v|
-             result << v
-             break if limit && result.size >= limit
-           end
-           result
-         end
-
-  return if rows.empty?
-
-  visible_func_names = @derived.keys - (@function_hidden || Set.new).to_a
-  headers = rows.first.members.map(&:to_s) + visible_func_names.map(&:to_s)
-
-  widths = align ? headers.to_h { |h|
-    values = rows.map do |r|
-      val = if r.members.map(&:to_s).include?(h)
-              r.send(h)
-            else
-              @function_results&.dig(r, h.to_sym)
-            end
-      fmt_cell(val, false).size
-    end
-    [h, [h.size, *values].max]
-  } : {}
-
-  lines = []
-
-  # Header
-  case format
-  when :markdown
-    lines << "| " + headers.map { |h| h.ljust(widths[h] || h.size) }.join(" | ") + " |"
-    lines << "|-" + headers.map { |h| "-" * (widths[h] || h.size) }.join("-|-") + "-|"
-  when :csv
-    lines << headers.join(",")
-  else
-    lines << headers.map { |h| fmt_cell(h, colorize, widths[h]) }.join(separator)
-  end
-
-  # Rows
-  rows.each do |row|
-    values = row.members.map { |m| row.send(m) } +
-             visible_func_names.map { |fname| @function_results&.dig(row, fname) }
-
-    line = headers.zip(values).map { |(_, val)| fmt_cell(val, colorize, widths[_]) }
-    lines << (format == :csv ? line.join(",") : line.join(separator))
-  end
-
-  # Output to console or file
-  if file
-    File.write(file, lines.join("\n") + "\n")
-  else
-    lines.each { |line| puts line }
-  end
-end
-
-def import(path, format: :json)
-  data = case format
-  when :json
-    JSON.parse(File.read(path), symbolize_names: true)
-  when :yaml
-    YAML.safe_load(File.read(path), symbolize_names: true)
-  else
-    raise ArgumentError, "Unsupported format: #{format}. Only :json and :yaml are supported."
-  end
-
-  raise TypeError, "Expected parsed data to be a Hash" unless data.is_a?(Hash)
-
-  @dimensions = data
-  self
-end
-
-def export(path, format: :json)
-  case format
-  when :json
-    File.write(path, JSON.pretty_generate(@dimensions))
-  when :yaml
-    File.write(path, YAML.dump(@dimensions))
-  else
-    raise ArgumentError, "Unsupported format: #{format}. Only :json and :yaml are supported."
-  end
-end
-
-
-  def from_json(path)
-    data = JSON.parse(File.read(path), symbolize_names: true)
-    @dimensions = data
-  end
-
-  def from_yaml(path)
-    data = YAML.safe_load(File.read(path), symbolize_names: true)
-    @dimensions = data
-  end
-
-private
-
-  def reserved_struct_names
-    (base_struct_methods = Struct.new(:dummy).methods(false) + Struct.new(:dummy).instance_methods(false)).uniq
-  end
-
-  def reserved_function_names
-    (self.methods + self.class.instance_methods(false)).uniq
-  end
+  include FlexCartesianCore
+  include FlexCartesianIO
+  include FlexCartesianUtilities
+  include FlexCartesianAnalyzer
+  include FlexCartesianDeprecations
+  include FlexCartesianVisualization
 
-  def fmt_cell(value, colorize, width = nil)
-    str = case value
-          when String then value
-          else value.inspect
-          end
-    str = str.ljust(width) if width
-    colorize ? str.colorize(:cyan) : str
-  end
 end
 

data/lib/version.rb

@@ -0,0 +1,3 @@
+module FlexCartesian
+  VERSION = "2.0.0.beta"
+end