funcml-core 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 229952b1c47eb4c17e0cc4209f1e0226306010425713c4d1ed9d1b6a4bd0adfb
+  data.tar.gz: 7435707d489decc839bad4c3697c72534fdc7fa465b44049c9e52bd4a1899e47
+SHA512:
+  metadata.gz: 68458c9df2ec863e3030c35b082405e39c71dba66576f33f5306f0046aedd674eae5720e491ad331880f7e89e04eded00e6fc9d77b51db6af86ea8f678a2be4d
+  data.tar.gz: '08d321d32f188aad017170d3df8c8c42b45b3ad40939a3ec20294464679ecee0b8875bfde73f496ff7bac543fb6c536c1c327c24bcbeeebdfa92aa925525c6c2'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Mimopotato
+
+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,101 @@
+# funcml-core
+
+Funcml-core extends the standard Ruby classes (String, Integer, Hash, Array, etc.) to provide a framework for data structures. This framework makes it possible to perform mutations on data structures and is at the heart of the funcml-cli project.
+
+Connected to funcml-cli, funcml-core can ingest JSON and YAML files and apply prepared mutations. Funcml-cli is part of a wider project, Karist, which aims to simplify the management of Kubernetes manifests using YAML.
+
+However, funcml-core can be used in just about any project thanks to its super-simple, documented AP
+
+## Installation
+
+Ruby superior to >=2.7 is required due to pattern-matching usage.
+
+```bash
+gem install funcml-core
+```
+
+## Usage
+
+Data structures are mutated using the #mutate function, which is loaded with the funcml-core library. It is then possible to launch a mutation on any object by specifying the mutation functions as arguments to the #mutate method.
+
+```ruby
+require "funcml-core"
+
+simple_hash = {key: "$value"}
+simple_hash.mutate(value: ["a", "great", "example"])
+
+# { key: ["a", "great", "example"] }
+```
+
+Many mutations are supported. Funcml-core includes:
+
+* variables support
+* Time functions
+* Mathematics
+* Hash/dictionaries manipulations
+* Cryptography (encryption/decryption with AES)
+* Encoding (base64, SHA1, SHA256, MD5...)
+* External files inclusion
+* Arrays/lists manipulations
+* And many others !
+
+Read the doc at [Funcml.org](https://funcml.org) to learn more about what funcml-core supports.
+
+## How it works ?
+
+A #mutate method is implemented for each Ruby object. This method recursively applies the various mutations specified as arguments to the first call.
+
+Funcml-core exposes mutation functions in two ways: either through additional hash keys, determined by the prefix "_", or through strings beginning with "$".
+
+```ruby
+struct = {
+  mutations: {
+    first: "hello",
+    second: "world",
+    third: "!"
+  },
+  key: {
+    value: {
+      _if: [
+        {eq: [{_last: '$mutations'}, "!"]}
+      ],
+      _concat: {
+        items: [
+          '$mutations.first', 
+          '$mutations.second', 
+          '$mutations.third'
+        ],
+        sep: " "
+      }
+    }
+  }
+}
+
+struct[:key].mutate(struct)
+# {value: "hello world !"}
+```
+
+The implementation of funcml-core is somewhat similar in idea to LISP and you will no doubt be able to find some similarities.
+
+The functions are applied recursively: when _concat is called, all items are first mutated before _concat's own evaluation. This is relatively similar to LISP languages where "inside the code is the first part executed".
+
+## Development
+
+All functions are tested using original Ruby data structures. Take a look in the test folder to see all the funcml-core possibilities.
+
+
+You can run the tests with the following command (test-unit).
+
+```
+TESTOPTS="-v" rake test
+```
+
+Funcml-core only extends Ruby's native classes. Under no circumstances does funcml-core handle marshal, unmarshal or file read/write operations (see funcml-cli for these parts).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mimopotato/funcml-core.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: %i[test standard]

data/lib/funcml-core/patch/array.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Array
+  def mutate(mutations)
+    self.map do |el|
+      el.mutate(mutations)
+    end
+  end
+end

data/lib/funcml-core/patch/false.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class FalseClass
+  def mutate(_)
+    self
+  end
+end

data/lib/funcml-core/patch/float.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Float
+  def mutate(_)
+    self
+  end
+end

data/lib/funcml-core/patch/funcs/cast.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Hash
+  def _string(mutations)
+    self.fetch(:_string).then do |obj|
+      obj.mutate(mutations).to_s
+    end
+  end
+
+  def _int(mutations)
+    self.fetch(:_int).then do |obj|
+      obj.mutate(mutations).to_i
+    end
+  end
+
+  def _float(mutations)
+    self.fetch(:_float).then do |obj|
+      obj.mutate(mutations).to_f
+    end
+  end
+end

data/lib/funcml-core/patch/funcs/cryptography.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require "digest"
+require "openssl"
+
+class Hash
+  include Funcml
+
+  def _sha1sum(mutations)
+    self.fetch(:_sha1sum).then do |value|
+      return Digest::SHA1.hexdigest(value.mutate(mutations))
+    end
+  end
+
+  def _sha256sum(mutations)
+    self.fetch(:_sha256sum).then do |value|
+      return Digest::SHA256.hexdigest(value.mutate(mutations))
+    end
+  end
+
+  # source https://gist.github.com/wteuber/5318013
+  def _encryptAES(mutations)
+    self.fetch(:_encryptAES).then do |blk|
+      case blk
+      in {data: data, encryptionKey: encryption_key}
+        cipher = OpenSSL::Cipher.new("aes-256-cbc").encrypt
+        cipher.key = Digest::MD5.hexdigest(encryption_key.mutate(mutations))
+        s = cipher.update(data.mutate(mutations)) + cipher.final
+        s.unpack('H*')[0].upcase
+      else
+        raise  MissingEncryptionKeyException, "encryptionKey field missing in #{self.to_s}"
+      end
+    end
+  end
+
+  # source https://gist.github.com/wteuber/5318013
+  def _decryptAES(mutations)
+    self.fetch(:_decryptAES).then do |blk|
+      case blk
+      in {data: data, encryptionKey: encryption_key}
+        cipher = OpenSSL::Cipher.new("aes-256-cbc").decrypt
+        cipher.key = Digest::MD5.hexdigest(encryption_key.mutate(mutations))
+        s = [data.mutate(mutations)].pack('H*').unpack('C*').pack('c*')
+        cipher.update(s) + cipher.final
+      else
+        raise  MissingEncryptionKeyException, "encryptionKey field missing in #{self.to_s}"
+      end
+    end
+  end
+end

data/lib/funcml-core/patch/funcs/dictionary.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Hash
+  def _keys(mutations)
+    self.fetch(:_keys).mutate(mutations).then do |elems|
+      return elems.map do |elem|
+        if elem.is_a?(Hash)
+          elem.keys
+        else
+          elem
+        end
+      end.flatten
+    end
+  end
+
+  def _values(mutations)
+    self.fetch(:_values).mutate(mutations).then do |elems|
+      return elems.map do |elem|
+        if elem.is_a?(Hash)
+          elem.values
+        else
+          elem
+        end
+      end.flatten
+    end
+  end
+end

data/lib/funcml-core/patch/funcs/encoding.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require "base64"
+
+class Hash
+  def _base64encode(mutations)
+    self.fetch(:_base64encode, "").then do |value|
+      return Base64.encode64(value.mutate(mutations)).strip
+    end
+  end
+
+  def _base64decode(mutations)
+    self.fetch(:_base64decode, "").then do |value|
+      return Base64.decode64(value.mutate(mutations)).strip
+    end
+  end
+end

data/lib/funcml-core/patch/funcs/list.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Hash
+  include Funcml
+
+  def _first(mutations)
+    self.fetch(:_first).mutate(mutations).then do |elems|
+      return elems.first
+    end
+  end
+
+  def _last(mutations)
+    self.fetch(:_last).mutate(mutations).then do |elems|
+      if elems.is_a?(Hash)
+        return elems.values.last
+      else
+        return elems.last
+      end
+    end
+  end
+
+  def _tail(mutations)
+    self.fetch(:_tail).mutate(mutations).then do |elems|
+      return elems[0].last(elems[1])
+    end
+  end
+
+  def _head(mutations)
+    self.fetch(:_head).mutate(mutations).then do |elems|
+      return elems[0][0..(elems[1]-1)]
+    end
+  end
+
+  def _reverse(mutations)
+    self.fetch(:_reverse).mutate(mutations).then do |elems|
+      return elems.reverse
+    end
+  end
+
+  def _uniq(mutations)
+    self.fetch(:_uniq).mutate(mutations).then do |elems|
+      return elems.uniq
+    end
+  end
+
+  def _index(mutations)
+    self.fetch(:_index).mutate(mutations).then do |elems|
+      return elems[0].index(elems[1])
+    end
+  end
+
+  def _len(mutations)
+    self.fetch(:_len).then do |elems|
+      elems.mutate(mutations).length
+    end
+  end
+end

data/lib/funcml-core/patch/funcs/math.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Hash
+  def _add(mutations)
+    self.fetch(:_add, []).then do |numbers|
+      numbers.mutate(mutations).reduce(:+)
+    end
+  end
+
+  def _sub(mutations)
+    self.fetch(:_sub, []).then do |numbers|
+      numbers.mutate(mutations).reduce(:-)
+    end
+  end
+
+  def _div(mutations)
+    self.fetch(:_div, []).then do |numbers|
+      numbers.mutate(mutations).reduce(:/)
+    end
+  end
+
+  def _mod(mutations)
+    self.fetch(:_mod).then do |numbers|
+      first, second = numbers.mutate(mutations)
+      first % second
+    end
+  end
+
+  def _mul(mutations)
+    self.fetch(:_mul, []).then do |numbers|
+      numbers.mutate(mutations).reduce(:*)
+    end
+  end
+
+  def _min(mutations)
+    self.fetch(:_min, []).then do |numbers|
+      numbers.mutate(mutations).min
+    end
+  end
+
+  def _max(mutations)
+    self.fetch(:_max, []).then do |numbers|
+      numbers.mutate(mutations).max
+    end
+  end
+
+  def _floor(mutations)
+    self.fetch(:_floor).then do |number|
+      number.mutate(mutations).floor
+    end
+  end
+
+  def _ceil(mutations)
+    self.fetch(:_ceil).then do |number|
+      number.mutate(mutations).ceil
+    end
+  end
+
+  def _round(mutations)
+    self.fetch(:_round).then do |number|
+      number.mutate(mutations).round
+    end
+  end
+end

data/lib/funcml-core/patch/funcs/time.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "time"
+
+class Hash
+  include Funcml
+
+  def _time(mutations)
+    self.fetch(:_time).then do |blk|
+      _value = blk.fetch(:value)
+      _format = blk.fetch(:format, "%d/%m/%Y %H:%M:%S")
+
+      _value.mutate(mutations).then do |value|
+        return Time.parse(value).strftime(_format.mutate(mutations))
+      end
+    end
+  end
+
+  def _ago(mutations)
+    self.fetch(:_ago).then do |blk|
+      unless blk.is_a?(Integer)
+        raise IncorrectSecondsException, "_ago only supports seconds as value in #{self.to_s}"
+      end
+
+      (Time.now - blk).to_s
+    end
+  end
+end

data/lib/funcml-core/patch/hash.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+class Hash
+  include Funcml
+
+  def mutate(mutations = {})
+    # dup is here to avoid iteration error on #delete/#merge
+    self.dup.each do |key, value|
+      case key
+      in /^_.*$/
+        # recursive mutation of result from pattern-matched _method
+        # once recursively mutated, we return the final object by guard
+        # clause instead of mutating the current object.
+        return self.send(key, mutations)
+          .mutate(mutations)
+      else
+        # no monkey-patch method found (_ prefix), we mutate anyway
+        # in case of variables or sub-functions.
+        self[key] = value.mutate(mutations)
+      end
+    end
+
+    self
+  end
+
+  def _if(mutations)
+    _runcond = Proc.new do |cond, mutations|
+      case cond
+      in {in: [needle, haystack]}
+      haystack.mutate(mutations).include?(needle.mutate(mutations))
+      
+      in {null: vars} 
+        vars.all? {|x| x.mutate(mutations).nil? }
+  
+      in {present: vars}
+        vars.all? {|x| !x.mutate(mutations).nil? }
+  
+      in {eq: [first, second]} 
+        first.mutate(mutations).eql?(second.mutate(mutations))
+  
+      in {ne: [first, second]} 
+        !first.mutate(mutations).eql?(second.mutate(mutations))
+  
+      in {gt: [first, second]}
+        first.mutate(mutations) > second.mutate(mutations)
+  
+      in {lt: [first, second]}
+        first.mutate(mutations) < second.mutate(mutations)
+  
+      in {ge: [first, second]}
+        first.mutate(mutations) >= second.mutate(mutations)
+  
+      in {le: [first, second]}
+        first.mutate(mutations) <= second.mutate(mutations)
+      
+      # or should evaluated by top-level if as true or false. 
+      in {or: or_conds}
+        or_conds.any? do |cond|
+          _runcond.call(cond, mutations)
+        end
+
+      else
+        raise UnknownConditionException, "#{cond.to_s} is not a valid condition"
+      end
+    end
+
+    self.fetch(:_if).then do |conditions|
+      all_conditions_state = conditions.all? do |cond|
+        _runcond.call(cond, mutations)
+      end
+
+      
+      if all_conditions_state
+        self.delete(:_if)
+        self.delete(:_else)
+        return self
+      else
+        return self[:_else] # returns nil if nothing has been set.
+      end
+
+      nil
+    end
+  end
+
+  def _loop(mutations)
+    self.fetch(:_loop).then do |_loop|
+      items = _loop.fetch(:items, []).mutate(mutations)
+      _results = []
+      
+      # guard clause related to allowed types
+      unless items.is_a?(Array)
+        raise LoopTypeException, "_loop only supports Array as items"
+      end
+
+      # always mutate all items as they could be variable calling hashes.
+      # when caller is a string, will be callable as $item for String
+      # when caller is a Hash, will be callable as $item.path.to.value for String
+      items.each do |item|
+        _results <<  _loop[:block]
+          .dup          # required to avoid duplicates in code
+          .mutate(mutations.merge(item: item))
+      end
+
+      return _results
+    end
+  end
+
+  def _until(mutations)
+    _results = []
+    amount = self.fetch(:_until)
+    amount.times do |i|
+      _results << self.dup.select{|k, v| k != :_until}
+        .mutate(mutations.merge(item: i))
+    end
+
+    return _results
+  end
+
+  # _sum takes and mutates all elements in array and
+  # sums them.
+  # eg: {_sum: [1, 2, 3]} = 6
+  def _sum(mutations)
+    self.fetch(:_sum).map do |item|
+      item.mutate(mutations)
+    end.sum
+  end
+
+  # _merge merges a hash found at mutation path with caller hash
+  # and removes the _merge reference.
+  # eg: {key: value, _merge: path.to_mutation } = {key: value, imported_key: value}
+  def _merge(mutations)
+    self.fetch(:_merge).mutate(mutations).then do |result|
+      self.merge!(result).then do
+        self.delete(:_merge)
+      end
+    end
+
+    self
+  end
+
+  # _concat concatenates items elements as a string with sep as separator.
+  # eg: {_concat: {items: ["a", "b", "c"], sep: " "}} = "a b c"
+  def _concat(mutations)
+    self.fetch(:_concat).then do |concat|
+      return concat.fetch(:items, [])
+        .mutate(mutations)
+        .join(concat.fetch(:sep, "").mutate(mutations))
+    end
+  end
+  
+  def _readfile(mutations)
+    self.fetch(:_readfile).then do |path|
+      File.read(path)
+    end
+  end
+
+  def dig_from_str(path, mutations)
+    path_array_sym = path.split('.').map do |sub|
+      sub.to_sym
+    end
+
+    self.dig(*path_array_sym).mutate(mutations)
+  end
+
+end

data/lib/funcml-core/patch/integer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Integer
+  def mutate(_)
+    self
+  end
+end

data/lib/funcml-core/patch/nil.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class NilClass
+  def mutate(_)
+    self
+  end
+end

data/lib/funcml-core/patch/string.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require "securerandom"
+
+class String
+  include Funcml
+
+  def mutate(mutations)
+    if self.start_with?('$')
+
+      return Time.now.to_s if self.eql?('$now')
+      return SecureRandom.uuid if self.eql?('$uuidv4')
+
+      mutations.dig_from_str(self.gsub('$', ''), mutations).then do |value|
+        raise MutationException, "`#{self}` not found in mutations, available mutations: #{mutations.to_s}" if value.nil?
+        return value.mutate(mutations)
+      end
+    end
+
+    self
+  end
+
+  def dig(_)
+    self
+  end
+end

data/lib/funcml-core/patch/symbol.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Symbol
+  def mutate(_)
+    self
+  end
+end

data/lib/funcml-core/patch/true.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class TrueClass
+  def mutate(_)
+    self
+  end
+end

data/lib/funcml-core/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Funcml
+  VERSION = "0.9.0"
+end

data/lib/funcml-core.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "funcml-core/version"
+require_relative "funcml-core/patch/hash"
+require_relative "funcml-core/patch/string"
+require_relative "funcml-core/patch/nil"
+require_relative "funcml-core/patch/false"
+require_relative "funcml-core/patch/true"
+require_relative "funcml-core/patch/array"
+require_relative "funcml-core/patch/integer"
+require_relative "funcml-core/patch/symbol"
+require_relative "funcml-core/patch/float"
+
+require_relative "funcml-core/patch/funcs/encoding"
+require_relative "funcml-core/patch/funcs/cryptography"
+require_relative "funcml-core/patch/funcs/time"
+require_relative "funcml-core/patch/funcs/dictionary"
+require_relative "funcml-core/patch/funcs/list"
+require_relative "funcml-core/patch/funcs/math"
+require_relative "funcml-core/patch/funcs/cast"
+
+module Funcml
+  class Error < StandardError; end
+  class MutationException < Error; end
+  class LoopTypeException < Error; end
+  class UnknownConditionException < Error; end
+  class MissingEncryptionKeyException < Error; end
+  class IncorrectSecondsException < Error; end
+  # Your code goes here...
+end

data/sig/funcml.rbs

@@ -0,0 +1,4 @@
+module Funcml
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: funcml-core
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Mimopotato
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-07-14 00:00:00.000000000 Z
+dependencies: []
+description: A library that implements mutations on data-structures
+email:
+- 173955441+mimopotato@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/funcml-core.rb
+- lib/funcml-core/patch/array.rb
+- lib/funcml-core/patch/false.rb
+- lib/funcml-core/patch/float.rb
+- lib/funcml-core/patch/funcs/cast.rb
+- lib/funcml-core/patch/funcs/cryptography.rb
+- lib/funcml-core/patch/funcs/dictionary.rb
+- lib/funcml-core/patch/funcs/encoding.rb
+- lib/funcml-core/patch/funcs/list.rb
+- lib/funcml-core/patch/funcs/math.rb
+- lib/funcml-core/patch/funcs/time.rb
+- lib/funcml-core/patch/hash.rb
+- lib/funcml-core/patch/integer.rb
+- lib/funcml-core/patch/nil.rb
+- lib/funcml-core/patch/string.rb
+- lib/funcml-core/patch/symbol.rb
+- lib/funcml-core/patch/true.rb
+- lib/funcml-core/version.rb
+- sig/funcml.rbs
+homepage: https://github.com/mimopotato/funcml-lang
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/mimopotato/funcml-lang
+  source_code_uri: https://github.com/mimopotato/funcml-core
+  changelog_uri: https://github.com/mimopotato/funcml-core
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: funcml-core
+test_files: []