ree_lib 1.0.0

data/lib/ree_lib/packages/ree_errors/schemas/domain_errors/permission_error.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "permission_error",
+  "path": "bounded_contexts/shared/ree_errors/package/ree_errors/permission_error.rb",
+  "mount_as": "object",
+  "class": "ReeErrors::PermissionError",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_error",
+      "package_name": "ree_errors",
+      "as": "build_error",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_errors/schemas/domain_errors/validation_error.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "validation_error",
+  "path": "bounded_contexts/shared/ree_errors/package/ree_errors/validation_error.rb",
+  "mount_as": "object",
+  "class": "ReeErrors::ValidationError",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_error",
+      "package_name": "ree_errors",
+      "as": "build_error",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_errors/schemas/ree_errors/auth_error.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "auth_error",
+  "path": "packages/ree_errors/package/ree_errors/auth_error.rb",
+  "mount_as": "object",
+  "class": "ReeErrors::AuthError",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_error",
+      "package_name": "ree_errors",
+      "as": "build_error",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_errors/schemas/ree_errors/build_error.schema.json

@@ -0,0 +1,35 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "build_error",
+  "path": "packages/ree_errors/package/ree_errors/build_error.rb",
+  "mount_as": "fn",
+  "class": "ReeErrors::BuildError",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "SubclassOf[ReeErrors::Error]",
+      "args": [
+        {
+          "arg": "type",
+          "type": "Symbol"
+        },
+        {
+          "arg": "code",
+          "type": "Symbol"
+        },
+        {
+          "arg": "locale",
+          "type": "Nilor[String]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_errors/schemas/ree_errors/conflict_error.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "conflict_error",
+  "path": "packages/ree_errors/package/ree_errors/conflict_error.rb",
+  "mount_as": "object",
+  "class": "ReeErrors::ConflictError",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_error",
+      "package_name": "ree_errors",
+      "as": "build_error",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_errors/schemas/ree_errors/invalid_param_error.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "invalid_param_error",
+  "path": "packages/ree_errors/package/ree_errors/invalid_param_error.rb",
+  "mount_as": "object",
+  "class": "ReeErrors::InvalidParamError",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_error",
+      "package_name": "ree_errors",
+      "as": "build_error",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_errors/schemas/ree_errors/not_found_error.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "not_found_error",
+  "path": "packages/ree_errors/package/ree_errors/not_found_error.rb",
+  "mount_as": "object",
+  "class": "ReeErrors::NotFoundError",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_error",
+      "package_name": "ree_errors",
+      "as": "build_error",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_errors/schemas/ree_errors/payment_required_error.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "payment_required_error",
+  "path": "packages/ree_errors/package/ree_errors/payment_required_error.rb",
+  "mount_as": "object",
+  "class": "ReeErrors::PaymentRequiredError",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_error",
+      "package_name": "ree_errors",
+      "as": "build_error",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_errors/schemas/ree_errors/permission_error.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "permission_error",
+  "path": "packages/ree_errors/package/ree_errors/permission_error.rb",
+  "mount_as": "object",
+  "class": "ReeErrors::PermissionError",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_error",
+      "package_name": "ree_errors",
+      "as": "build_error",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_errors/schemas/ree_errors/validation_error.schema.json

@@ -0,0 +1,22 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "validation_error",
+  "path": "packages/ree_errors/package/ree_errors/validation_error.rb",
+  "mount_as": "object",
+  "class": "ReeErrors::ValidationError",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "build_error",
+      "package_name": "ree_errors",
+      "as": "build_error",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_errors/spec/package_schema_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe "ReeErrors" do
+  it "generates package schema" do
+    require 'fileutils'
+
+    packages_schema_path = Ree.locate_packages_schema(__dir__)
+    packages_schema_dir = Pathname.new(packages_schema_path).dirname.to_s
+
+    FileUtils.cd packages_schema_dir do
+      expect(
+        system("REE_SKIP_ENV_VARS_CHECK=true bundle exec ree gen.package_json ree_errors --silence")
+      ).to eq(true)
+    end
+  end
+end

data/lib/ree_lib/packages/ree_errors/spec/ree_errors/auth_error_spec.rb

@@ -0,0 +1,53 @@
+package_require('ree_errors/auth_error')
+
+RSpec.describe ReeErrors::AuthError do
+  link :add_load_path, from: :ree_i18n
+
+  before :all do
+    add_load_path(Dir[File.join(__dir__, 'locales/*.yml')])
+  end
+
+  it {
+    klass = described_class.build(:code, 'ree_errors_test.error')
+    error = klass.new('CUSTOM MESSAGE')
+
+    expect(klass).to be_a(Class)
+    expect(error).to be_a(ReeErrors::Error)
+    expect(error.message).to eq('test error message')
+    expect(error.code).to eq(:code)
+    expect(error.type).to eq(:auth)
+    expect(error.locale).to eq('ree_errors_test.error')
+  }
+
+  it {
+    klass = described_class.build(:code)
+
+    expect {
+      klass.new
+    }.to raise_error(ArgumentError)
+  }
+
+  it {
+    klass = described_class.build(:code)
+    error = klass.new('CUSTOM MESSAGE')
+
+    expect(klass).to be_a(Class)
+    expect(error).to be_a(ReeErrors::Error)
+    expect(error.message).to eq('CUSTOM MESSAGE')
+    expect(error.code).to eq(:code)
+    expect(error.type).to eq(:auth)
+    expect(error.locale).to eq(nil)
+  }
+
+  it {
+    klass = described_class.build(:code, 'ree_errors_test.error')
+    error = klass.new
+
+    expect(klass).to be_a(Class)
+    expect(error).to be_a(ReeErrors::Error)
+    expect(error.message).to eq('test error message')
+    expect(error.code).to eq(:code)
+    expect(error.type).to eq(:auth)
+    expect(error.locale).to eq("ree_errors_test.error")
+  }
+end

data/lib/ree_lib/packages/ree_errors/spec/ree_errors/invalid_param_error_spec.rb

@@ -0,0 +1,15 @@
+package_require('ree_errors/invalid_param_error')
+
+RSpec.describe ReeErrors::InvalidParamError do
+  it {
+    klass = described_class.build(:code)
+    error = klass.new('message')
+
+    expect(klass).to be_a(Class)
+    expect(error).to be_a(ReeErrors::Error)
+    expect(error.message).to eq('message')
+    expect(error.code).to eq(:code)
+    expect(error.type).to eq(:invalid_param)
+    expect(error.locale).to eq(nil)
+  }
+end

data/lib/ree_lib/packages/ree_errors/spec/ree_errors/locales/en.yml

@@ -0,0 +1,3 @@
+en:
+  ree_errors_test:
+    error: 'test error message'

data/lib/ree_lib/packages/ree_errors/spec/ree_errors/not_found_error_spec.rb

@@ -0,0 +1,15 @@
+package_require('ree_errors/not_found_error')
+
+RSpec.describe ReeErrors::NotFoundError do
+  it {
+    klass = described_class.build(:code)
+    error = klass.new('message')
+
+    expect(klass).to be_a(Class)
+    expect(error).to be_a(ReeErrors::Error)
+    expect(error.message).to eq('message')
+    expect(error.code).to eq(:code)
+    expect(error.type).to eq(:not_found)
+    expect(error.locale).to eq(nil)
+  }
+end

data/lib/ree_lib/packages/ree_errors/spec/ree_errors/payment_required_error_spec.rb

@@ -0,0 +1,15 @@
+package_require('ree_errors/payment_required_error')
+
+RSpec.describe ReeErrors::PaymentRequiredError do
+  it {
+    klass = described_class.build(:code)
+    error = klass.new('message')
+
+    expect(klass).to be_a(Class)
+    expect(error).to be_a(ReeErrors::Error)
+    expect(error.message).to eq('message')
+    expect(error.code).to eq(:code)
+    expect(error.type).to eq(:payment_required)
+    expect(error.locale).to eq(nil)
+  }
+end

data/lib/ree_lib/packages/ree_errors/spec/ree_errors/permission_error_spec.rb

@@ -0,0 +1,15 @@
+package_require('ree_errors/permission_error')
+
+RSpec.describe ReeErrors::PermissionError do
+  it {
+    klass = described_class.build(:code)
+    error = klass.new('message')
+
+    expect(klass).to be_a(Class)
+    expect(error).to be_a(ReeErrors::Error)
+    expect(error.message).to eq('message')
+    expect(error.code).to eq(:code)
+    expect(error.type).to eq(:permission)
+    expect(error.locale).to eq(nil)
+  }
+end

data/lib/ree_lib/packages/ree_errors/spec/ree_errors/validation_error_spec.rb

@@ -0,0 +1,15 @@
+package_require('ree_errors/validation_error')
+
+RSpec.describe ReeErrors::ValidationError do
+  it {
+    klass = described_class.build(:code)
+    error = klass.new('message')
+
+    expect(klass).to be_a(Class)
+    expect(error).to be_a(ReeErrors::Error)
+    expect(error.message).to eq('message')
+    expect(error.code).to eq(:code)
+    expect(error.type).to eq(:validation)
+    expect(error.locale).to eq(nil)
+  }
+end

data/lib/ree_lib/packages/ree_errors/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.extend Ree::RSpecLinkDSL
+end

data/lib/ree_lib/packages/ree_hash/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/lib/ree_lib/packages/ree_hash/Package.schema.json

@@ -0,0 +1,54 @@
+{
+  "schema_type": "package",
+  "ree_version": "1.0.1",
+  "name": "ree_hash",
+  "entry_path": "packages/ree_hash/package/ree_hash.rb",
+  "tags": [
+    "ree_hash"
+  ],
+  "depends_on": [
+    {
+      "name": "ree_date"
+    },
+    {
+      "name": "ree_validator"
+    }
+  ],
+  "env_vars": [
+
+  ],
+  "objects": [
+    {
+      "name": "build_filter_keys",
+      "schema": "packages/ree_hash/schemas/ree_hash/functions/build_filter_keys.schema.json"
+    },
+    {
+      "name": "except",
+      "schema": "packages/ree_hash/schemas/ree_hash/functions/except.schema.json"
+    },
+    {
+      "name": "merge",
+      "schema": "packages/ree_hash/schemas/ree_hash/functions/merge.schema.json"
+    },
+    {
+      "name": "slice",
+      "schema": "packages/ree_hash/schemas/ree_hash/functions/slice.schema.json"
+    },
+    {
+      "name": "stringify_keys",
+      "schema": "packages/ree_hash/schemas/ree_hash/functions/stringify_keys.schema.json"
+    },
+    {
+      "name": "symbolize_keys",
+      "schema": "packages/ree_hash/schemas/ree_hash/functions/symbolize_keys.schema.json"
+    },
+    {
+      "name": "transform_keys",
+      "schema": "packages/ree_hash/schemas/ree_hash/functions/transform_keys.schema.json"
+    },
+    {
+      "name": "transform_values",
+      "schema": "packages/ree_hash/schemas/ree_hash/functions/transform_values.schema.json"
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_hash/bin/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "ree"
+
+Ree.init(__dir__, irb: true)

data/lib/ree_lib/packages/ree_hash/package/ree_hash/contracts/hash_keys_contract.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class ReeHash::HashKeysContract
+  extend Ree::Contracts::Truncatable
+
+  def self.valid?(obj)
+    return false if !obj.is_a?(Array)
+    return false if obj.any? { !valid_item?(_1) }
+    true
+  end
+
+  def self.to_s
+    "[:key0, .., :keyM => [:keyN, .., :keyZ]]"
+  end
+
+  def self.message(value, name, lvl = 1)
+    "expected #{to_s}, got => #{truncate(value.inspect)}"
+  end
+
+  private
+
+  def self.valid_item?(obj)
+    return true if obj.is_a?(Symbol)
+    return false if !obj.is_a?(Hash)  
+
+    obj.each do |k, v|
+      return false if !k.is_a?(Symbol)
+      return false if !v.is_a?(Array)
+      return false if v.any? { !valid_item?(_1) }
+    end
+
+    true
+  end
+end

data/lib/ree_lib/packages/ree_hash/package/ree_hash/functions/build_filter_keys.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class ReeHash::BuildFilterKeys
+  include Ree::FnDSL
+
+  fn :build_filter_keys do
+    link 'ree_hash/contracts/hash_keys_contract', -> { HashKeysContract }
+  end
+
+  contract(HashKeysContract => HashOf[Symbol, Hash])
+  def call(keys)
+    result = {}
+
+    keys.each do |key|
+      if key.is_a?(Symbol)
+        result[key] = {}
+      elsif key.is_a?(Hash)
+        key.each do |k, key|
+          result[k] = call(key)
+        end
+      end
+    end
+
+    result
+  end
+end

data/lib/ree_lib/packages/ree_hash/package/ree_hash/functions/except.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+class ReeHash::Except
+  include Ree::FnDSL
+
+  fn :except do
+    link :build_filter_keys
+    link 'ree_hash/contracts/hash_keys_contract', -> { HashKeysContract }
+  end
+
+  doc(<<~DOC)
+    Returns a hash that includes everything except given keys.
+    You can pass a symbol or a hash with array of symbols as a key.
+    The <tt>global_except:</tt> option excepts key in a hash recursively. 
+
+      hash = { a: true, b: false, c: nil, d: { e: 'e', f: 'f' }, f: 'f', setting: { id: 1, number: 1 } }
+      except(hash, [:c])     # => { a: true, b: false, d: { e: 'e', f: 'f' }, f: 'f' , setting: { id: 1, number: 1 } }
+      except(hash, [:a, :b]) # => { c: nil, d: { e: 'e', f: 'f'}, f: 'f', setting: { id: 1, number: 1 } }
+      except(hash, [:a, :b, d: [:f]]) #=> { c: nil, d: { e: 'e' }, f: 'f', setting: { id: 1, number: 1 } }
+      except(hash, [:a, :b, d: [:f], setting: [:id]] }) #=> { c: nil, d: { e: 'e' }, f: 'f', setting: { number: 1 } }
+      except(hash, [:a], global_except: [:f]) #=> { b: false, c: nil, d: { e: 'e' }, setting: { id: 1, number: 1 } }
+  DOC
+
+  contract(
+    Hash, 
+    HashKeysContract,
+    Ksplat[
+      global_except?: ArrayOf[Symbol]
+    ] => Hash
+  )
+  def call(hash, keys = [], **opts)
+    keys = build_filter_keys(keys)
+    global_except_keys = build_filter_keys(opts[:global_except] || [])
+    recursively_except(hash, keys, global_except_keys)
+  end
+
+  private
+
+  def recursively_except(hash, except_keys, global_except_keys)
+    result = {}
+    except_keys ||= {}
+
+    result.default = hash.default
+    result.default_proc = hash.default_proc if hash.default_proc
+
+    hash.each do |k, v|
+      next if global_except_keys.has_key?(k)
+      next if except_keys.has_key?(k) && except_keys[k].empty?
+
+      if v.is_a?(Array)
+        result[k] = v.map do |item|
+          if item.is_a?(Hash)
+            recursively_except(item, except_keys[k], global_except_keys)
+          else
+            item
+          end
+        end
+      elsif v.is_a?(Hash)
+        result[k] = recursively_except(
+          v, except_keys[k], global_except_keys
+        )
+      else
+        result[k] = v
+      end
+    end
+
+    result
+  end
+end

data/lib/ree_lib/packages/ree_hash/package/ree_hash/functions/merge.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class ReeHash::Merge
+  include Ree::FnDSL
+
+  fn :merge
+
+  doc(<<~DOC)
+    Returns a new hash with +first_hash+ and +other_hash+ merged recursively.
+    
+      h1 = { a: true, b: { c: [1, 2, 3] } }
+      h2 = { a: false, b: { x: [3, 4, 5] } }
+    
+      merge(h1, h2, deep: true) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+      merge(h1, h2, deep: false) # => { a: false, b: { x: [3, 4, 5] } }
+    
+    Like with Hash#merge in the standard library, a block can be provided
+    to merge values:
+    
+      h1 = { a: 100, b: 200, c: { c1: 100 } }
+      h2 = { b: 250, c: { c1: 200 } }
+
+      merge(h1, h2) { |key, this_val, other_val| this_val + other_val }
+        => { a: 100, b: 450, c: { c1: 300 } }
+  DOC
+  contract(
+    Hash,
+    Hash,
+    Kwargs[deep: Bool],
+    Optblock => Hash
+  )
+  def call(first_hash, other_hash, deep: true, &block)
+    recursively_merge(first_hash, other_hash, deep, &block)
+  end
+
+  private
+
+  def recursively_merge(first_hash, other_hash, deep, &block)
+    first_hash.merge(other_hash) do |key, first_val, other_val|
+      if first_val.is_a?(Hash) && other_val.is_a?(Hash) && deep
+        recursively_merge(first_val, other_val, deep)
+      elsif block_given?
+        yield key, first_val, other_val
+      else
+        other_val
+      end
+    end
+  end
+end