cem 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d56d8ba91aab41f5e12070a9f821516b8f69d626d3ffd7261dca402c41768ba
+  data.tar.gz: 513114a63b34c7375339e4eb17d931bc7925bb068495c4726a6577e98c0ebc7a
+SHA512:
+  metadata.gz: 55106e14c662cec3b4ffc68c6e0bb5775405fadbb61d1fd2d4611becd38d7cf55445e8a7872107797df5aaa4da18656419dbf0ed37eb676dc10a2184aa7168f1
+  data.tar.gz: f8f56d39752badb44074162e20452814937bd40ee44bd0e22ea777bd775f5c830e25768ec21ca104310efa84bb3679e868d99af9a674a907807e479efc43cdf8

data/.gitignore

@@ -0,0 +1,57 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+.rspec_status
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.17.3

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in cem.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 coezbek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# Cem = Christopher's Ruby Gem of Common Helpers 
+
+This gem is an assorted collection of common helpers that I use in a lot of projects.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cem'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cem
+
+## Usage
+
+    require 'cem'
+    
+Key things includes:
+
+### crequire
+
+crequire is a replacement for require for situations where bundler would be overkill. It solves the frustration of having to manually install gems to run a particular ruby script which requires other gems. 
+
+For example when you want to require 'qml' from the 'ruby-qml' gem, use the following line:
+
+```
+crequire 'qml', 'ruby-qml'
+```
+
+This will attempt to require qml and if it can't be found in the local RubyGems, then it will try to `gem install ruby-qml`
+
+### Array::with_progress
+
+Monkey patches array to return an enumeration which prints progress while lazy evaluating the enumeration.
+
+```
+require 'cem'
+[a,b,c].with_progress.each { |x|
+  puts x
+}
+```
+
+Uses the [progress bar gem](https://github.com/paul/progress_bar).
+
+### Numeric monkey patch
+
+Make all methods in Math module available as methods for numeric (e.g. 3.sqrt instead of Math.sqrt(3))
+
+### Advent of Code Puzzle Helpers
+
+Defines integer based `Point2D`, `Seg2D` (line segment), `Dir2D` (relative direction in 2D), `Point3D`, `Grid` (2D array) to help with Advent of Code puzzles, by providing commonly needed methods such as manhattan distances, string to indices conversion, enumeration of adjacent cells, etc.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/coezbek/cem.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## What's with the name?
+
+Cem is pronounced like `Jam` in Turkish, which is close enough to `Gem` and exactely short enough to type.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cem"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cem.gemspec

@@ -0,0 +1,43 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cem/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cem"
+  spec.version       = Cem::VERSION
+  spec.authors       = ["Christopher Özbek"]
+  spec.email         = ["christopher@oezbek.org"]
+
+  spec.summary       = %q{Cem = Christopher's Common Helper Gem for Ruby.}
+  spec.description   = %q{Christopher's Gem = My little helpers which I use in many projects.}
+  spec.homepage      = "https://github.com/coezbek/cem"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/coezbek/cem"
+    spec.metadata["changelog_uri"] = "https://github.com/coezbek/cem/README.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  
+  spec.add_runtime_dependency 'flammarion', '~> 0.3'
+end

data/lib/cem.rb

@@ -0,0 +1,10 @@
+
+require "cem/version"
+require "cem/ccommon"
+require "cem/cflame"
+require "cem/cruzzles"
+
+module Cem
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/cem/ccommon.rb

@@ -0,0 +1,93 @@
+
+#
+# Require the given ruby file and if loading fails, try to install the gem of the same name or given parameter
+#
+def crequire(requireName, gem_name = nil)
+  require requireName
+rescue LoadError
+  gem_name = requireName if gem_name.nil?
+  system("gem install #{gem_name}")
+  Gem.clear_paths
+  require requireName
+end
+
+class File
+
+  # Returns the first match of the given files
+  def self.exist_first?(*candidates)
+    candidates.each { |candidate|
+      if File.exist?(candidate)
+        return candidate
+      end
+    }
+    return nil
+  end
+end
+
+
+
+class Array
+	def with_progress(&block)
+  
+    crequire 'progress_bar' 
+  
+		bar = ProgressBar.new(count)
+		if block
+			each{|obj| yield(obj).tap{bar.increment!}}
+		else
+			Enumerator.new{ |yielder|
+				self.each do |obj|
+					(yielder << obj).tap{bar.increment!}
+				end
+			}
+		end
+	end
+end
+
+
+# Returns true if this script is running on the Windows Sub-System for Linux, i.e. under Linux where the host is Windows.
+#
+# If true, interoperability with Windows is possible.
+def wsl?
+  @@wsl ||= File.file?('/proc/version') && File.open('/proc/version', &:gets).downcase.include?("microsoft")
+end
+
+
+#
+# If on wsl? then the given is converted from a Windows path to a Linux path (e.g. "C:\" becomes "/mnt/c/")
+#
+# Uses the wslpath command, passes mode to wslpath:
+#
+#    -a    force result to absolute path format
+#    -u    translate from a Windows path to a WSL path (default)
+#    -w    translate from a WSL path to a Windows path
+#    -m    translate from a WSL path to a Windows path, with '/' instead of '\'
+#
+def wslpath(path, mode = "")
+  return path if !wsl? 
+  
+  return `wslpath #{mode} '#{path}'`.strip
+end
+
+def isHTML5Element(element)
+
+  # https://html.spec.whatwg.org/#elements-3
+
+  @valid_elements ||= %w(a abbr address area article aside audio b base bdi bdo blockquote body br button canvas caption cite code col colgroup data datalist dd del details dfn dialog div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hgroup hr html i iframe img input ins kbd label legend li link main map mark math menu meta meter nav noscript object ol optgroup option output p param picture pre progress q rp rt ruby s samp script section select slot small source span strong style sub summary sup svg table tbody td template textarea tfoot th thead time title tr track u ul var video wbr)
+    
+  return @valid_elements.include?(element.to_s.downcase)
+
+end
+
+module CLog
+
+  def log
+    CLog.log
+  end
+
+  # Global, memoized, lazy initialized instance of a logger
+  def self.log
+    @log ||= Logger.new(STDOUT)
+  end
+end
+

data/lib/cem/cflame.rb

@@ -0,0 +1,11 @@
+
+#
+# Christopher Flammarion extensions
+#
+
+require 'flammarion'
+
+require "cem/cflame/missing_html"
+require "cem/cflame/progress"
+require "cem/cflame/p"
+require "cem/cflame/clickable_img"

data/lib/cem/cflame/clickable_img.rb

@@ -0,0 +1,58 @@
+#
+# Clickable Image module mixin for Flammarion::Writeable
+# 
+# Features:
+#   - clickable => will call the given block when user clicks image
+#   - update() => can be replaced/updated 
+#   - src= => img src can be updated on the fly
+#
+module Flammarion::Writeable 
+
+  attr_accessor :url, :width, :height, :alt, :title
+
+  class ClickableImage
+    def initialize(url, width, height, alt, title, name, owner, block)
+      @name = name
+      @owner = owner
+      @block = block
+      @url = url
+      @width = width
+      @height = height
+      @alt = alt
+      @title = title
+    end
+      
+    def to_s
+      return @owner.callback_link(html) {
+        @block.call(self) if @block
+      }
+    end
+    
+    def html
+      %|<img id="#{@name}" width=#{@width.to_s} max-height=#{@height.to_s} src="#{@url.to_s}" alt="#{@alt}" title="#{@title}"/>|
+    end
+    
+    def update(url, width, height, alt, title)
+      @url = url
+      @width = width
+      @height = height
+      @alt = alt if alt
+      @title = title if title
+      
+      @owner.js("$( '##{@name}' ).replaceWith('#{html}');")
+    
+    end   
+    
+    def url=(value)
+      value = value.to_s
+      # puts "urlset on #{@name}"
+      @owner.js("$( '##{@name}' ).attr('src', '#{value}');")
+    end
+  
+  end
+    
+  def img_raw(url, width, height, alt, title, options = {}, &block)
+    return ClickableImage.new(url, width, height, alt, title, @engraving.make_id, self, block)    
+  end
+  
+end

data/lib/cem/cflame/missing_html.rb

@@ -0,0 +1,33 @@
+
+# Mixin for Flammarion::Writeable which provides short-cuts for common html elements
+#
+# - The method name will become the html element / tag.
+# - Any un-named parameter will become the value for the element. Several parameters will create several elements of the given tag.
+# - Any named parameter will become an attribute to all created elements.
+#
+# Parameters will not be escaped (raw)!
+#
+# Some examples:
+#   f.p                       =>     f.puts "<p/>", raw: true
+#   f.h1 "Title"              =>     f.puts "<h1>Title</h2>", raw: true
+#   f.img src: "url", width: 32 =>     f.puts '<img src="url" width="32"/>', raw: true
+#   f.p "Hello", "World"      =>     f.puts "<p>Hello</p><p>World</p>", raw: true
+#
+module Flammarion::Writeable
+
+  def method_missing(m, *args, &block)
+    
+    if !isHTML5Element(m)
+      puts "Warning: #{m} is not a valid HTML 5 Tag"
+    end    
+    
+    attribs = args.last.is_a?(Hash) ? args.pop.map { |key, value| %| #{key.to_s}="#{value}"| }.join : ""
+    
+    if args.size == 0
+      puts "<#{m} #{attribs}/>", raw: true
+    else
+      puts args.map { |value| "<#{m} #{attribs}>#{value}</#{m}>" }.join, raw: true
+    end 
+  end
+  
+end

data/lib/cem/cflame/p.rb

@@ -0,0 +1,37 @@
+
+#
+# Paragraph which can be updated easily as a mixin for Flammarion
+#
+module Flammarion::Writeable
+
+  class Paragraph
+  
+    def initialize(text, name, owner)
+      @text = text
+      @name = name
+      @owner = owner
+    end
+    
+    def html
+      %|<p id="#{@name}">#{@text}</p>|  
+    end
+    
+    def to_s
+      html
+    end
+
+    def text=(newText)
+      return if newText == @text
+      @text = newText    
+      
+      @owner.js("$( '##{@name}' ).replaceWith('#{html}');")
+    end
+  end
+  
+  def p(text)
+    object = Paragraph.new(text, @engraving.make_id, self)
+    puts object, raw:true
+    object
+  end
+  
+end

data/lib/cem/cflame/progress.rb

@@ -0,0 +1,48 @@
+
+#
+# A simple CSS-based progress bar for Flammarion.
+#
+# Use set() to set the progress as an integer in percent.
+#
+#   progress = f.progress
+#   ... # do first half
+#   progress.set(50)
+#   ... # finish work
+#   progress.set(100) # => will set to 100%
+#
+# Or use each() with an array
+#
+#   progress.each([1,2,3]) { |x| ... } 
+#
+module Flammarion::Writeable 
+
+  class Progress
+    def initialize(name, owner)
+      @name = name
+      @owner = owner
+      @owner.raw("<div id='progressBar' style='width: 100%; height: 22px; border: 1px solid #8f8f8f; background-color: #292929; border-radius: 2px; box-shadow: 0 2px 3px rgba(0, 0, 0, 0.25) inset;'><div id='progressBarInner-#{@name}' style='height: 100%; color: #fff; text-align: center; line-height: 22px; width: 0px; background-color: #0099ff;'></div></div>")
+    end
+  
+    def each(ary, &block)
+      set(0)
+      @max = ary.size
+      return if @max == 0
+      
+      ary.each_with_index { |a, i|
+        yield a
+        set(i * 100 / @max)
+      }
+      ary        
+    end
+    
+    def set(value)
+      value = value.to_s
+      @owner.js("$( '#progressBarInner-#{@name}' ).width('#{value}%').html('#{value}%');")
+    end
+  
+  end
+  
+  def progress(name = nil)
+    return Progress.new(name || @engraving.make_id, self)    
+  end
+end

data/lib/cem/cruzzles.rb

@@ -0,0 +1,516 @@
+
+##
+# cruzzles Christopher's Ruby Puzzle Utilities
+#
+# Includes:
+# - Point2D, Grid, Dirs(ections)2D
+# - Some Numeric hackery
+#
+
+def min(a, b)
+  return a <= b ? a : b
+end
+
+class Numeric
+  # Make all methods in Math module available as methods for numeric (e.g. 3.sqrt instead of Math.sqrt(3))
+  Math.methods(false).each do |method|
+    define_method method do |*args|
+      Math.send(method, self, *args)
+    end
+  end
+end
+
+Point2D = Struct.new("Point2D", :x, :y) {
+  def to_s
+    "#{x},#{y}"
+  end
+  
+  def flip
+    Point2D.new(-x,-y)
+  end
+  
+  def +(other)
+    if other.is_a? Array
+      other.map { |o| self + o }
+    else
+      Point2D.new(x + other.x, y + other.y)
+    end
+  end
+  
+  # Scalar multiplication
+  def *(other)
+    Point2D.new(x * other, y * other)    
+  end
+  
+  def manhattan(other)
+    return (x - other.x).abs + (y - other.y).abs
+  end
+  
+  # returns the euclidean distance to the given Point2D
+  def dist(other)
+    return ((x - other.x) ** 2 + (y - other.y) ** 2).sqrt
+  end
+  
+  def self.from_s(s)
+  
+    case s.upcase
+      when 'E', 'RIGHT', 'R', '>'
+        Point2D.new(+1,  0)
+      when 'N', 'UP', 'TOP', 'T', 'U', '^'
+        Point2D.new( 0, -1)
+      when 'S', 'DOWN', 'BOTTOM', 'B', 'D', 'v', 'V'
+        Point2D.new( 0, +1)
+      when 'W', 'LEFT', 'L', '<'
+        Point2D.new(-1,  0)
+    else 
+      raise s
+    end
+    
+  end
+  
+  def left 
+    return self + Dir2D.LEFT
+  end
+  
+  def left!
+    x += Dir2D.LEFT.x
+    y += Dir2D.LEFT.y
+    return self
+  end
+
+  
+  def to_dir_bitmask 
+  
+    if x == 0 && y == -1
+      return 1
+    elsif x == 1 && y == 0
+      return 2
+    elsif x == 0 && y == 1
+      return 4
+    elsif x == -1 && y == 0
+      return 8
+    else
+      raise self.p
+    end
+  end
+      
+  def self.from_dir_bitmask(v) 
+  
+    result = []
+    if v & 1 > 0
+      result << Point2D.new(0, -1)
+    end
+    if v & 2 > 0
+      result << Point2D.new(1, 0)
+    end
+    if v & 4 > 0
+      result << Point2D.new(0, 1)
+    end
+    if v & 8 > 0
+      result << Point2D.new(-1, 0)
+    end
+    return result
+  end
+  
+  # def <=>(other)
+  #   y == other.y ? x <=> other.x : y <=> other.y
+  # end
+  
+  def ==(other)
+    y == other.y && x == other.x
+  end
+}
+
+Seg2D = Struct.new("Seg2D", :p1, :p2) {
+  def to_s
+    "#{p1},#{p2}"
+  end
+  
+  def x_range
+    if p1.x < p2.x 
+      return p1.x..p2.x
+    else
+      return p2.x..p1.x
+    end
+  end
+  
+  def y_range
+    if p1.y < p2.y 
+      return p1.y..p2.y
+    else
+      return p2.y..p1.y
+    end
+  end
+  
+}
+
+Dirs2D = [Point2D.new(0, -1), Point2D.new(1, 0), Point2D.new(0, 1), Point2D.new(-1, 0)]
+
+class Dir2D < Point2D
+
+  N = UP    = Dir2D.new( 0, -1)
+  E = RIGHT = Dir2D.new( 1,  0)
+  S = DOWN  = Dir2D.new( 0,  1)
+  W = LEFT  = Dir2D.new(-1,  0)
+  
+  #
+  # Dir2D * Range = array of Dir2D
+  # E * (1..3) = [E, E*2, E*3]
+  #
+  def *(other)
+    if other.is_a? Range
+      other.to_a.map { |b| self * b }
+    else
+      super
+    end  
+  end
+  
+  def self.vert(length=1)
+    return [N * (1..length), S * (1..length)].flatten
+  end
+  
+  def self.hori(length=1)
+    return [E * (1..length), W * (1..length)].flatten
+  end
+  
+  def self.x(length=1)
+    return vert(length) + hori(length)
+  end
+
+end
+  
+
+class Grid
+
+  attr_reader :data
+
+  def initialize(x, y, default=0, &block)
+    
+    @data = []
+    
+    if block
+    
+      case block.arity
+      when 0 
+        y.times {
+          row = []
+          x.times {
+            row << block.call()
+          }
+          @data << row
+        }
+      when 2 
+        y.times { |iy|
+          row = []
+          x.times { |ix|
+            row << block.call(iy, ix)
+          }
+          @data << row
+        }
+      else
+        raise
+      end
+    
+    else # if no block given
+    
+      y.times {
+        row = []
+        x.times {
+          row << default
+        }
+        @data << row
+      }
+      # @data = [[default] * x] * y
+    end
+  end
+  
+  def initialize_copy(orig)
+    super
+    
+    @data = Marshal.load(Marshal.dump(orig.data))
+    # Do custom initialization for self
+  end
+  
+  def minmax(null=nil)
+    min = nil
+    max = nil
+    
+    @data.each_with_index { |l, y|
+      l.each_with_index { |c, x|
+       
+        if c != null
+          if min == nil || max == nil
+            min = max = Point2D.new(x,y)
+          end
+          min = Point2D.new([min.x, x].min, [min.y, y].min)
+          max = Point2D.new([max.x, x].max, [min.y, y].max)
+        end
+      }
+    }
+    
+    return min, max
+  end
+    
+  def [](y, x=nil)
+    if x == nil
+      # puts y.inspect
+      if y.respond_to?(:x) && y.respond_to?(:y)
+        return @data[y.y][y.x]
+      end
+      return @data[y]
+    end
+    
+    if y.is_a? Range
+      return @data[y].map { |row| row[x] }
+    end
+    return @data[y][x]
+  end
+  
+  #
+  # Array assignment to grid. 
+  #
+  #  grid[y,x]     = a    # Store a in row y and column x
+  #  grid[point2d] = a    # Use point2d.y and point2d.x to store a
+  #
+  def []=(y, x, assign=nil)
+    if assign == nil
+      if y.respond_to?(:x) && y.respond_to?(:y)
+        return @data[y.y][y.x] = x
+      end
+      return @data[y] = x
+    end
+    return @data[y][x] = assign
+  end
+  
+  def to_a
+    return @data.flatten
+  end  
+  
+  #
+  # Returns the Point2Ds in the directions NSEW as an array (no diagonals, see adja_index for this)
+  #
+  # Will not return Point2Ds in case we are at the boundary of the Grid
+  #
+  def nsew_index(x,y=nil)
+    
+    # puts "#{@data.size} x #{@data[0].size}"
+    
+    if y == nil
+      if x.respond_to?(:x) && x.respond_to?(:y)
+        y = x.y
+        x = x.x
+      else
+        raise "Need Point2D with :x and :y or two parameters"
+      end
+    end
+  
+    result = []
+    if x > 0
+      result << Point2D.new(x-1,y)
+    end
+    if y > 0
+      result << Point2D.new(x,y-1)
+    end
+    if y + 1 < @data.size - 1
+      result << Point2D.new(x, y+1)
+    end
+    if x + 1 < @data[0].size - 1
+      result << Point2D.new(x+1,y)
+    end
+    return result
+  end
+  
+  #
+  # Will remove all invalid indices from the array
+  # 
+  def select_valid(a)
+    a.select { |p|
+      (p.x >= 0) && (p.y >= 0) && (p.y <= @data.size-1) && (p.x <= @data[0].size-1)
+    }
+  end
+  
+  def adja_index(x,y=nil)
+    if y == nil
+      if x.respond_to?(:x) && x.respond_to?(:y)
+        y = x.y
+        x = x.x
+      else
+        raise "Need Point2D with :x and :y or two parameters"
+      end
+    end
+  
+    result = []
+    if x > 0
+      if y > 0
+        result << Point2D.new(x-1,y-1)
+      end
+      result << Point2D.new(x-1,y)
+      if y + 1 < @data.size - 1
+        result << Point2D.new(x-1, y+1)
+      end
+    end
+    if y > 0
+      result << Point2D.new(x,y-1)
+    end
+    
+    # result << Point2D.new(x,y)
+    
+    if y + 1 < @data.size - 1
+      result << Point2D.new(x, y+1)
+    end
+    if x + 1 < @data[0].size - 1
+      if y > 0
+        result << Point2D.new(x+1,y-1)
+      end
+      result << Point2D.new(x+1,y)
+      if y + 1 < @data.size - 1
+        result << Point2D.new(x+1, y+1)
+      end
+    end
+    return result
+  end
+  
+  def to_s
+    printBoard()
+  end
+  
+  
+  #
+  # returns a copy of the underlying 2D array, with linking to the content (rather than dup the content also)
+  #
+  def to_a
+    @data.map { |row| row.dup }
+  end
+  
+  def data
+    @data
+  end
+  
+  #
+  # Maps each cell of the grid by the given block. 
+  #
+  # If block has...
+  #  - one parameter, passes the cell value
+  #  - two parameters, passes y and x
+  #  - three parameteres, passes y, x and the cell value
+  #
+  def map_a(&block)
+  
+    case block.arity
+      when 1 
+        @data.map { |row| row.map { |value| block.call(value) } }
+      when 2 
+        @data.each_with_index.map { |row, y| row.each_index.map { |x| block.call(y,x) } }
+      when 3      
+        @data.each_with_index.map { |row, y| row.each_with_index.map { |cell, x| block.call(y,x,cell) } }
+      else
+        raise
+    end
+  
+  end
+  
+  def each(&block)
+    @data.each { |row|
+      row.each { |cell|
+        block.call(cell)
+      }
+    }
+  end
+  
+  def each_with_index(&block)    
+    case block.arity
+      when 2 
+        @data.each_with_index { |l, y|
+            l.each_with_index { |c, x|
+              block.call(c, Point2D.new(x,y))
+            }
+          }
+      
+      when 3      
+        @data.each_with_index { |l, y|
+            l.each_with_index { |c, x|
+              block.call(c, y, x)
+            }
+          }
+      else
+        raise
+    end
+  end
+  
+  def sum(&block)    
+    sum = 0
+    each { |cell|
+      sum += block.call(cell)
+    }
+    return sum
+  end
+    
+  def printBoard(overlay = nil)
+
+    result = ""
+    @data.each_with_index { |l, y|
+      l.each_with_index { |c, x|
+       
+        pos = Point2D.new(x,y)
+        
+        if overlay && overlay.has_key?(pos)
+          result += overlay[pos] 
+        else
+          result += c.to_s
+        end
+      }
+      
+      result += "\r\n"
+    }
+    return result
+  end
+  
+end
+
+Point3D = Struct.new("Point3D", :x, :y, :z) {
+
+  def manhattan(other=nil)
+    if other != nil
+      return (self - other).manhattan
+    end
+    return x.abs + y.abs + z.abs
+  end
+  
+  def -(other) Point3D.new(x - other.x, y - other.y, z - other.z) end
+  
+  def +(other) Point3D.new(x + other.x, y + other.y, z + other.z) end
+  
+  def to_s 
+    "#{x}, #{y}, #{z}"   
+  end
+  
+  def []=(i, v)
+    case i
+      when 0
+        self.x = v
+      when 1
+        self.y = v
+      when 2
+        self.z = v
+      else 
+        raise
+    end
+  end
+  
+  def [](i)
+    case i
+      when 0
+        x
+      when 1
+        y
+      when 2
+        z
+      else 
+        raise
+    end
+  end 
+}
+    
+    
+
+    

data/lib/cem/version.rb

@@ -0,0 +1,3 @@
+module Cem
+  VERSION = "0.1.2"
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: cem
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Christopher Özbek
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: flammarion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: Christopher's Gem = My little helpers which I use in many projects.
+email:
+- christopher@oezbek.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- cem.gemspec
+- lib/cem.rb
+- lib/cem/ccommon.rb
+- lib/cem/cflame.rb
+- lib/cem/cflame/clickable_img.rb
+- lib/cem/cflame/missing_html.rb
+- lib/cem/cflame/p.rb
+- lib/cem/cflame/progress.rb
+- lib/cem/cruzzles.rb
+- lib/cem/version.rb
+homepage: https://github.com/coezbek/cem
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/coezbek/cem
+  source_code_uri: https://github.com/coezbek/cem
+  changelog_uri: https://github.com/coezbek/cem/README.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Cem = Christopher's Common Helper Gem for Ruby.
+test_files: []