flex-cartesian 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96675f38efe3e792ac84749a93c495b5770de5b0b918331274b9f53999940a7a
-  data.tar.gz: 0313d03ed02f6e568a803403628fdf1dedf5af9b883575d702b15a12dbf166dd
+  metadata.gz: 7f3e10474552a7bfa80b189b46769b1dc621468b9a068918e42cce44d14879ab
+  data.tar.gz: 1dd5bea186d416ebb39bc6f74d268d271516cbbf945a9c3fbfa97d4682bf85bc
 SHA512:
-  metadata.gz: 6bd8c8a7dca528707bb800b7f2fed94c6fe0fbcd1fcc2e114eb00d66505f8928a0afd88e7e38794d21cbe1c2be3813d9d43d7232b3e1d37583d0d19910ff1694
-  data.tar.gz: 16049ce389e509ca7264ea1b5752c6bd539270d63f211cf95e08a386bf9a3f6d67ba5615cb6fc4efca9033a01a70b1bd631b083f2f2ad6614f29850d2fe68ea7
+  metadata.gz: eefbe47d1db3cf1e4316502de159d68963c633d72ea84fc38a378eefa235747845b8d7496d26534eeed6986e2e16cf9728366a1b3015e6e509f0c57a8ace5b3a
+  data.tar.gz: d4eaf78c1280145ad57841a984bde38b0f5f25b69845a59300877ed04ad6c48a2f325a144b6ff97aad6933fb9ed0b36bdc9b6c0c8156126fffd4a8c1d55aca32

data/README.md

@@ -24,10 +24,10 @@
 
 ## Installation
 
-Install dependencies:
-
 ```bash
 bundle install
+gem build flex-cartesian.gemspec
+gem install flex-cartesian-*.gem
 ```
 
 ## Usage
@@ -77,6 +77,108 @@ s.output(format: :markdown, align: true)
 s.output(format: :csv)
 ```
 
+## API Overview
+
+### Initialization
+```ruby
+FlexCartesian.new(dimensions_hash)
+```
+- `dimensions_hash`: a hash with named dimensions; each value can be an `Enumerable` (e.g., arrays, ranges).
+
+Example:
+```ruby
+dimensions = {
+  dim1: [1, 2],
+  dim2: ['x', 'y'],
+  dim3: [true, false]
+}
+
+FlexCartesian.new(dimensions)
+```
+
+---
+
+### Iterate Over All Combinations
+```ruby
+# With block
+cartesian(dims = nil, lazy: false) { |vector| ... }
+
+# Without block: returns Enumerator
+cartesian(dims = nil, lazy: false)
+```
+- `dims`: optional dimensions hash (default is the one provided at initialization).
+- `lazy`: if true, returns a lazy enumerator.
+
+Each combination is passed as a `Struct` with fields matching the dimension names:
+```ruby
+s.cartesian { |v| puts "#{v.dim1} - #{v.dim2}" }
+```
+
+---
+
+### Count Total Combinations
+```ruby
+size(dims = nil) → Integer
+```
+Returns the number of possible combinations.
+
+---
+
+### Convert to Array
+```ruby
+to_a(limit: nil) → Array
+```
+- `limit`: maximum number of combinations to collect.
+
+---
+
+### Iterate with Progress Bar
+```ruby
+progress_each(dims = nil, lazy: false, title: "Processing") { |v| ... }
+```
+Displays a progress bar using `ruby-progressbar`.
+
+---
+
+### Print Table to Console
+```ruby
+output(
+  separator: " | ",
+  colorize: false,
+  align: false,
+  format: :plain  # or :markdown, :csv
+  limit: nil
+)
+```
+Prints all combinations in table form (plain/markdown/CSV).  
+Markdown example:
+```
+| dim1 | dim2 |
+|------|------|
+|  1   | "a"  |
+|  2   | "b"  |
+```
+
+---
+
+### Load from JSON or YAML
+```ruby
+FlexCartesian.from_json("file.json")
+FlexCartesian.from_yaml("file.yaml")
+```
+
+---
+
+### Output from Vectors
+Each yielded combination is a `Struct` extended with:
+```ruby
+output(separator: " | ", colorize: false, align: false)
+```
+Example:
+```ruby
+s.cartesian { |v| v.output(colorize: true, align: true) }
+```
+
 ## License
 
 This project is licensed under the terms of the GNU General Public License v3.0.  

data/lib/golden.rb

@@ -0,0 +1,137 @@
+require 'ostruct'
+require 'progressbar'
+require 'colorize'
+require 'json'
+require 'yaml'
+
+module FlexOutput
+  def output(separator: " | ", colorize: false, align: false)
+    return puts "(empty struct)" unless respond_to?(:members) && respond_to?(:values)
+
+    values_list = members.zip(values.map { |v| v.inspect })
+
+    # calculate widths, if align required
+    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
+  attr :dimensions
+
+  def initialize(dimensions = nil)
+    @dimensions = dimensions
+  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|
+      yield struct_class.new(*combo)
+    end
+  end
+
+  def size(dims = nil)
+    dimensions = dims || @dimensions
+    return 0 unless dimensions.is_a?(Hash)
+
+    values = dimensions.values.map { |dim| dim.is_a?(Enumerable) ? dim.to_a : [dim] }
+    return 0 if values.any?(&:empty?)
+
+    values.map(&:size).inject(1, :*)
+  end
+
+  def to_a(limit: nil)
+    result = []
+    cartesian do |v|
+      result << v
+      break if limit && result.size >= limit
+    end
+    result
+  end
+
+  def progress_each(dims = nil, lazy: false, title: "Processing")
+    total = size(dims)
+    bar = ProgressBar.create(title: title, total: total, format: '%t [%B] %p%% %e')
+
+    cartesian(dims, lazy: lazy) do |v|
+      yield v
+      bar.increment
+    end
+  end
+
+def output(separator: " | ", colorize: false, align: false, format: :plain, limit: nil)
+  rows = []
+  cartesian do |v|
+    rows << v
+    break if limit && rows.size >= limit
+  end
+  return if rows.empty?
+
+  headers = rows.first.members.map(&:to_s)
+
+  # Get widths
+  widths = align ? headers.to_h { |h|
+    [h, [h.size, *rows.map { |r| fmt_cell(r[h], false).size }].max]
+  } : {}
+
+  # Title
+  case format
+  when :markdown
+    puts "| " + headers.map { |h| h.ljust(widths[h] || h.size) }.join(" | ") + " |"
+    puts "|-" + headers.map { |h| "-" * (widths[h] || h.size) }.join("-|-") + "-|"
+  when :csv
+    puts headers.join(",")
+  else
+    puts headers.map { |h| fmt_cell(h, colorize, widths[h]) }.join(separator)
+  end
+
+  # Rows
+  rows.each do |row|
+    line = headers.map { |h| fmt_cell(row[h], colorize, widths[h]) }
+    puts format == :csv ? line.join(",") : line.join(separator)
+  end
+end
+
+  def self.from_json(path)
+    data = JSON.parse(File.read(path), symbolize_names: true)
+    new(data)
+  end
+
+  def self.from_yaml(path)
+    data = YAML.safe_load(File.read(path), symbolize_names: true)
+    new(data)
+  end
+
+private
+
+def fmt_cell(value, colorize, width = nil)
+  str = case value
+        when String then value  # rows - without inspect
+        else value.inspect      # the rest is good to inspect
+        end
+  str = str.ljust(width) if width
+  colorize ? str.colorize(:cyan) : str
+end
+
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flex-cartesian
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Yury Rassokhin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-02 00:00:00.000000000 Z
+date: 2025-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -52,69 +52,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: yaml
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: |
-  Flexible and human-friendly Cartesian product enumerator for Ruby.
-  Supports dimension-agnostic iteration, named dimensions, structured output,
+description: Supports dimension-agnostic iterators, named dimensions, tabular output,
   lazy/eager evaluation, progress bar, JSON/YAML loading, and export to Markdown/CSV.
-
-  Example:
-
-  require 'flex-cartesian'
-
-  # Define Cartesian space with named dimensions:
-  example = {
-    dim1: [1, 2],
-    dim2: ['x', 'y'],
-    dim3: [true, false]
-  }
-  s = FlexCartesian.new(example)
-
-  # Iterate over all combinations and calculate function on each combination:
-  s.cartesian { |v| puts "#{v.dim1}-#{v.dim2}" if v.dim3 }
-
-  # Get number of Cartesian combinations:
-  puts "Total size: #{s.size}"
-
-  # Convert Cartesian space to array of combinations
-  array = s.to_a(limit: 3)
-  puts array.inspect
-
-  def do_something(v)
-  end
-
-  # Display progress bar (useful for large Cartesian spaces)
-  s.progress_each { |v| do_something(v) }
-
-  # Print Cartesian space as table
-  s.output(align: true)
-
-  # Lazy evaluation without materializing entire Cartesian product in memory:
-  s.cartesian(lazy: true).take(2).each { |v| puts v.inspect }
-
-  # Load from JSON or YAML
-  File.write('example.json', JSON.pretty_generate(example))
-  s = FlexCartesian.from_json('example.json')
-  s.output
-
-  # Export to Markdown
-  s.output(format: :markdown, align: true)
-
-  # Export to CSV
-  s.output(format: :csv)
 email:
 - yuri.rassokhin@gmail.com
 executables: []
@@ -125,6 +64,7 @@ files:
 - LICENSE
 - README.md
 - lib/flex-cartesian.rb
+- lib/golden.rb
 homepage: https://github.com/Yuri-Rassokhin/flex-cartesian
 licenses:
 - GPL-3.0