cellar 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 549bf01d6e8d969ae15c0a3a683c562a372a6916e2b73a4d98b4b215471cbc6d
+  data.tar.gz: 0df9839f7a98c0659100e9c431168ccaa27dd4c18e978d9e74a3d1996a95bbc4
+SHA512:
+  metadata.gz: 854e6884861eaa8d3b94cd82ae618e61b791fe64ec11d6aa1d97c1bd7938ff2f722607293428b47270866b376f9d2d23329891ac5252190cfe043aa546700362
+  data.tar.gz: a8ab03f030093ac6d20da412fb60480b558c23f0227b4145533bf3439dd9e1a5eb9483436025e1446f3e4e38e8bddd97de1b224310339f3b70d0c566e69064de

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,32 @@
+# cellar
+Ruby gem to deal with cells of data in rows and columns (CSV, spreadsheets, etc.)
+
+### Example
+
+Sample code:
+
+```ruby
+# read CSV
+data = DATA.read
+rows = data.split("\n").map {|line| line.split(",") }
+
+# show output
+info = Cellar.new(rows)
+info.each do
+  p info[:id, 4, "name", "gym".."age", 6..4, :color, "CaNdY"]
+end
+
+__END__
+id,name,age,school,gym,color,candy,pet
+1,joe,13,Rockville,Gold's,yellow,gum,bird
+2,sally,8,Melville,24 Hour Fitness,pink,skittles,pig
+3,curly,44,Vegas,Couch,purple,Snicker's,lizard
+```
+
+Sample output:
+
+```text
+["1", "Gold's", "joe", "Gold's", "Rockville", "13", "gum", "yellow", "Gold's", "yellow", "gum"]
+["2", "24 Hour Fitness", "sally", "24 Hour Fitness", "Melville", "8", "skittles", "pink", "24 Hour Fitness", "pink", "skittles"]
+["3", "Couch", "curly", "Couch", "Vegas", "44", "Snicker's", "purple", "Couch", "purple", "Snicker's"]
+```

data/cellar.gemspec

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+  s.name        = "cellar"
+  s.version     = `grep -m 1 '^\s*VERSION' lib/cellar.rb | head -1 | cut -f 2 -d '"'`
+  s.author      = "Steve Shreeve"
+  s.email       = "steve.shreeve@gmail.com"
+  s.summary     =  "A " +
+  s.description = "Ruby gem to deal with cells of data in rows and columns"
+  s.homepage    = "https://github.com/shreeve/cellar"
+  s.license     = "MIT"
+  s.platform    = Gem::Platform::RUBY
+  s.files       = `git ls-files`.split("\n") - %w[.gitignore]
+  s.required_ruby_version = Gem::Requirement.new(">= 3.0") if s.respond_to? :required_ruby_version=
+end

data/lib/cellar.rb

@@ -0,0 +1,265 @@
+# ============================================================================
+# cellar - Ruby gem to deal with cells of data in rows and columns
+#
+# Author: Steve Shreeve (steve.shreeve@gmail.com)
+#   Date: October 2, 2024
+#
+# TODO:
+# • Should we failover to empty strings like this: (value || "")
+# ============================================================================
+
+class Object
+  def val?
+    !nil?
+  end unless defined? val?
+
+  def blank?
+    respond_to?(:empty?) or return !self
+    empty? or respond_to?(:strip) && strip.empty?
+  end unless defined? blank?
+
+  def if_blank?(val)
+    blank? ? val : self
+  end unless defined? if_blank?
+end
+
+class Cellar
+  VERSION="0.1.0"
+
+  attr_reader   :fields
+  attr_reader   :values
+  attr_accessor :strict
+
+  def initialize(obj=nil, header: true, strict: true)
+    @fields = []
+    @values = []
+    @finder = {}
+    @seeker = {}
+    @index  = nil
+    @widest = 0
+
+    if obj.is_a?(Array)
+      if obj.first.is_a?(Array)
+        self.fields = obj.shift if header
+        @rows = obj unless obj.empty?
+      elsif !obj.empty?
+        header ? (self.fields = obj) : (@rows = obj)
+      end
+    end
+
+    @strict = strict.nil? ? !@fields.empty? : !!strict
+  end
+
+  def add_field(field)
+    field = field.to_s
+    index = @fields.size
+    @fields << field
+    finders = @finder.size
+    @finder[field.downcase.gsub(/\W/,'_')] ||= index
+    @finder.size == finders + 1 or warn "field clash for #{field.inspect}"
+    @finder[field] ||= index
+    @widest = field.length if field.length > @widest
+    index
+  end
+
+  def index(field)
+    case field
+    when String, Symbol
+      field = field.to_s
+      index = @finder[field] || @finder[field.downcase.gsub(/\W/,'_')]
+      raise "no field #{field.inspect}" if !index && @strict
+      index
+    when Integer
+      raise "no field at index #{field}" if field >= @fields.size && @strict
+      field < 0 ? field % @fields.size : field
+    when Range
+      from = field.begin
+      till = field.end
+      from = from.blank? ?  0 : index(from)
+      till = till.blank? ? -1 : index(till)
+      case from <=> till
+      when  1 then field.exclude_end? ? [*(till+1)..from].reverse : [*till..from].reverse
+      when  0 then from
+      when -1 then field.exclude_end? ? from...till : from..till
+      else "no fields match #{field.inspect}"
+      end
+    else
+      raise "unable to index fields by #{field.class.inspect} [#{field.inspect}]"
+    end
+  end
+
+  def clear
+    @values = []
+    self
+  end
+
+  def [](*fields)
+    case fields.size
+    when 0
+      []
+    when 1
+      index = index(fields.first)
+      value = @values[index] if index
+    else
+      fields.inject([]) do |values, field|
+        index = index(field)
+        value = case index
+          when nil   then nil
+          when Array then @values.values_at(*index)
+          else            @values[index]
+        end
+        if Array === value
+          values.concat(value)
+        else
+          values.push(value)
+        end
+      end
+    end
+  end
+
+  def []=(*fields)
+    values = Array(fields.pop).dup
+    fields = fields.map {|field| Array(index(field) || add_field(field))}.flatten
+
+    if fields.empty?
+      @values.replace(values)
+    elsif values.size > fields.size
+      raise "unable to assign #{values.size} values to #{fields.size} fields for values=#{values.inspect}"
+    else
+      fields.each_with_index do |field, pos|
+        @values[field] = values[pos]
+      end
+    end
+
+    @values
+  end
+
+  def fields=(*list)
+    @fields.clear
+    @finder.clear
+    @widest = 0
+
+    list.flatten.each {|field| add_field(field)}
+  end
+
+  def values=(*list)
+    @values = list.flatten
+  end
+
+  def field(pos)
+    @fields[pos]
+  end
+
+  def method_missing(field, *args)
+    field = field.to_s
+    equal = field.chomp!("=")
+    index = index(field)
+    if equal
+      index ||= add_field(field)
+      value = @values[index] = args.first
+    elsif index
+      raise "variable lookup ignores arguments" unless args.empty?
+      value = @values[index]
+    else
+      value = ""
+    end
+    value
+  end
+
+  # ==[ Row handling ]==
+
+  def rows=(rows)
+    rows or raise "no rows defined"
+    @rows = rows
+    row(0) # returns self
+  end
+
+  def row=(row)
+    @rows or raise "no rows defined"
+    row(row) # returns self
+  end
+
+  def rows
+    @rows
+  end
+
+  def row(row=nil)
+    @rows or raise "no rows defined"
+    @values = row ? @rows[@row = row] : []
+    self
+  end
+
+  def <<(data)
+    @rows ||= []
+    @row = row = @rows.size
+    @rows << @values = []
+    raise "unable to << #{data.class} objects" unless self.class === data.class
+    self[*data.fields] = data.values
+    if @index
+      block = @index if @index.is_a?(Proc)
+      field = @index unless block
+      index = index(field) or raise "unknown index #{field.inspect}" if field
+      if key = block ? block.call(self) : @values[index]
+        @seeker[key] and raise "duplicate index: #{key.inspect}"
+        @seeker[key] = row
+      end
+    end
+    self
+  end
+
+  def index!(field=nil, &block)
+    @rows ||= []
+    @index = field || block or raise "index needs a field or a block"
+    index = index(field) or raise "unknown index #{field.inspect}" if field && @rows.size > 0
+    @seeker.clear
+    @rows.each_with_index do |values, row|
+      if key = block ? yield(row(row)) : values[index]
+        @seeker[key] and raise "duplicate index: #{key.inspect}"
+        @seeker[key] = row
+      end
+    end
+    self
+  end
+
+  def seek!(seek)
+    @rows or raise "no rows defined"
+    @seeker.empty? and raise "not indexed"
+
+    if row = @seeker[seek]
+      row(row)
+    else
+      @values = []
+      @row = nil
+    end
+  end
+
+  def each
+    @rows or raise "no rows defined"
+    @rows.each_with_index {|values, row| yield(row(row)) }
+  end
+
+  def map
+    @rows or raise "no rows defined"
+    @rows.map.with_index {|values, row| yield(row(row)) }
+  end
+
+  def from_array(list)
+    clear
+    @values = list.map {|v| v.to_s.strip if v }
+    self
+  end
+
+  def from_hash(hash)
+    clear
+    hash.each {|k,v| self[k] = v.to_s if v }
+    self
+  end
+
+  def to_hash!
+    @fields.size.times.inject({}) do |h, i|
+      v = @values[i]
+      h[@fields[i].downcase.gsub(/\W/,'_')] = v if !v.blank?
+      h
+    end
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: cellar
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Steve Shreeve
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-03 00:00:00.000000000 Z
+dependencies: []
+description: Ruby gem to deal with cells of data in rows and columns
+email: steve.shreeve@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- cellar.gemspec
+- lib/cellar.rb
+homepage: https://github.com/shreeve/cellar
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.19
+signing_key:
+specification_version: 4
+summary: A Ruby gem to deal with cells of data in rows and columns
+test_files: []