ree_lib 1.0.0

data/lib/ree_lib/packages/ree_hash/spec/ree_hash/functions/except_spec.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+RSpec.describe :except do
+  link :except, from: :ree_hash
+
+  let(:hash) {
+    {
+      name: {
+        first_name: "John",
+        last_name:  "Doe"
+      },
+      address: "Home",
+      projects: [1, 2, { id: 1 }],
+      settings: {id: 1, number: 25},
+      age: 35,
+      pets: {
+        dog: {
+          name: "Dog"
+        }
+      }
+    }
+  }
+
+  context "global except only" do 
+    it {
+      result = except(hash, global_except: [:id])
+
+      expected = {
+        name: {
+          first_name: "John",
+          last_name:  "Doe"
+        },
+        address: "Home",
+        projects: [1, 2, {}],
+        settings: {number: 25},
+        age: 35,
+        pets: {
+          dog: {
+            name: "Dog"
+          }
+        }
+      }
+
+      expect(result).to eq(expected)
+    }
+  end
+
+  context "with options" do
+    it {
+      result = except(hash, [:address, :age], global_except: [:name])
+      
+      expected = {
+        projects: [1, 2, { id: 1 }],
+        settings: {id: 1, number: 25},
+        pets: {
+          dog: {}
+        }
+      }
+
+      expect(result).to eq(expected)
+    }
+
+    it {
+      result = except(hash, global_except: [:name])
+      
+      expected = {
+        address: "Home",
+        projects: [1, 2, { id: 1 }],
+        settings: {id: 1, number: 25},
+        age: 35,
+        pets: {
+          dog: {}
+        }
+      }
+
+      expect(result).to eq(expected)
+    }
+
+    it {
+      result = except(hash, [:age], global_except: [:name, :address])
+      
+      expected = {
+        projects: [1, 2, { id: 1 }],
+        settings: {id: 1, number: 25},
+        pets: {
+          dog: {}
+        }
+      }
+
+      expect(result).to eq(expected)
+    }
+
+    it {
+      result = except(hash, [:address, pets: [dog: [:name]]])
+
+      expected = {
+        name: {
+          first_name: "John",
+          last_name:  "Doe"
+        },
+        projects: [1, 2, { id: 1 }],
+        settings: {id: 1, number: 25},
+        age: 35,
+        pets: {
+          dog: {}
+        }
+      }
+
+      expect(result).to eq(expected)
+    }
+    
+    it {
+      result = except(
+        hash, [:address, {settings: [:id, :number]}],
+        global_except: [:name]
+      )
+
+      expected = {
+        projects: [1, 2, { id: 1 }],
+        settings: {},
+        age: 35,
+        pets: {
+          dog: {}
+        }
+      }
+
+      expect(result).to eq(expected)
+    }
+
+    it {
+      result = except(hash, [:address, {name: [:last_name]}])
+      
+      expected = {
+        name: {
+          first_name: "John"
+        },
+        projects: [1, 2, { id: 1 }],
+        settings: {id: 1, number: 25},
+        age: 35,
+        pets: {
+          dog: {
+            name: "Dog"
+          }
+        }
+      }
+      
+      expect(result).to eq(expected)
+    }
+
+    it {
+      result = except(
+        hash, [:address, {name: [:last_name], settings: [:number]}]
+      )
+      
+      expected = {
+        name: {
+          first_name: "John"
+        },
+        projects: [1, 2, { id: 1 }],
+        settings: {id: 1},
+        age: 35,
+        pets: {
+          dog: {
+            name: "Dog"
+          }
+        }
+      }
+      
+      expect(result).to eq(expected)
+    }
+  end
+
+  context "general" do
+    it {
+      result = except(hash, [:name])
+
+      expected = {
+        address: "Home",
+        projects: [1, 2, { id: 1 }],
+        settings: {id: 1, number: 25},
+        age: 35,
+        pets: {
+          dog: {
+            name: "Dog"
+          }
+        }
+      }
+
+      expect(result).to eq(expected)
+    }
+  end
+
+  context "invalid contract" do
+    it {
+      expect {
+        except(hash, ['key'])
+      }.to raise_error do |e|
+        expect(e).to be_a(Ree::Contracts::ContractError)
+        expect(e.message).to eq(
+          "Contract violation for ReeHash::Except#call\n\t - keys: expected [:key0, .., :keyM => [:keyN, .., :keyZ]], got => [\"key\"]"
+        )
+      end
+    }
+  end
+end

data/lib/ree_lib/packages/ree_hash/spec/ree_hash/functions/merge_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+RSpec.describe :merge do
+  link :merge, from: :ree_hash
+
+  context "deep" do
+    it {
+      first_hash = {:name => "John", :pets => { :dog => "Dog"}}
+      other_hash = {:name => "Steven", :pets => { :cat => "Cat"}}
+      merged_hash = {:name => "Steven", :pets => { :dog => "Dog", :cat => "Cat"}}
+      result = merge(first_hash, other_hash)
+
+      expect(result).to eq(merged_hash)
+      expect(result.object_id).to_not eq(first_hash.object_id)
+      expect(result.object_id).to_not eq(other_hash.object_id)
+    }
+  end
+
+  context "deep = false" do
+    it {
+      first_hash = {:name => "John", :pets => { :dog => "Dog"}}
+      other_hash = {:name => "Steven", :pets => { :cat => "Cat"}}
+      merged_hash = {:name => "Steven", :pets => { :cat => "Cat"}}
+      result =  merge(first_hash, other_hash, deep: false)
+
+      expect(result).to eq(merged_hash)
+      expect(result.object_id).to_not eq(first_hash.object_id)
+      expect(result.object_id).to_not eq(other_hash.object_id)
+    }
+  end
+
+  context "with block" do
+    it {
+      first_hash = {:name => "John", :pets => { :dog => "Dog"}}
+      other_hash = {:name => "Steven", :pets => { :cat => "Cat"}}
+      merged_hash = {:name => "John", :pets => { :dog => "Dog", :cat => "Cat"}}
+
+      result =  merge(first_hash, other_hash) do |key, first_val, other_val|
+        if first_val == "John"
+          "John"
+        end
+      end
+
+      expect(result).to eq(merged_hash)
+    }
+  end
+end

data/lib/ree_lib/packages/ree_hash/spec/ree_hash/functions/slice_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+RSpec.describe :slice do
+  link :slice, from: :ree_hash
+
+  let(:hash) {
+    {
+      id: 1,
+      uuid: 'qwerty-qwerty-qwerty',
+      list: [1, 2, 3],
+      user: {
+        name: 'John',
+        last_name: 'Doe'
+      },
+      info: {
+        balance: {
+          money: 1337,
+          currency: 0
+        },
+        age: 1337
+      },
+      skills: {
+        math: 100,
+        coding: 1337
+      },
+      users: [
+        {
+          id: 1,
+          name: 'John'
+        },
+        {
+          id: 2,
+          name: 'Adam'
+        }
+      ]
+    }
+  }
+
+  it {
+    result = slice(hash, [users: [:id]])
+
+    expected = {
+      users: [{id: 1}, {id: 2}]
+    }
+
+    expect(result).to eq(expected)
+  }
+
+  it {
+    result = slice(hash, [users: []])
+
+    expected = {
+      users: [
+        {
+          id: 1,
+          name: 'John'
+        },
+        {
+          id: 2,
+          name: 'Adam'
+        }
+      ]
+    }
+
+    expect(result).to eq(expected)
+  }
+
+  it {
+    h = hash.dup
+    h[:users].push(Object.new)
+
+    expect {
+      slice(h, [users: [:id]])
+    }.to raise_error(ReeHash::Slice::InvalidFilterKey) 
+  }
+
+  it {
+    expect {
+      slice(hash, [id: [:name]])
+    }.to raise_error(ReeHash::Slice::InvalidFilterKey) 
+  }
+
+  it {
+    result = slice(hash, [:id, :uuid])
+
+    expected = {
+      id: 1,
+      uuid: 'qwerty-qwerty-qwerty'
+    }
+
+    expect(result).to eq(expected)
+  }
+
+  it {
+    result = slice(
+      hash, [
+        :user, info: [:age, balance: [:money]], skills: [:math]
+      ]
+    )
+
+    expected = {
+      user: {
+        name: 'John',
+        last_name: 'Doe'
+      },
+      info: {
+        balance: {
+          money: 1337
+        },
+        age: 1337
+      },
+      skills: {
+        math: 100
+      }
+    }
+
+    expect(result).to eq(expected)
+  }
+
+  it {
+    expect {
+      slice(
+        hash, [user: [:full_name]], raise: true
+      )
+    }.to raise_error(ReeHash::Slice::MissingKeyErr, "missing key `:full_name`")
+  }
+
+  it {
+    expect {
+      slice(hash, [:test], raise: true)
+    }.to raise_error(ReeHash::Slice::MissingKeyErr, "missing key `:test`")
+  }
+end

data/lib/ree_lib/packages/ree_hash/spec/ree_hash/functions/stringify_keys_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+RSpec.describe :stringify_keys do
+  link :stringify_keys, from: :ree_hash
+
+  it {
+    result = stringify_keys({name: "John", "age": 25, nil: "nothing"})
+
+    expect(result).to eq({"name" => "John", "age" => 25, "nil" => "nothing"})
+  }
+  
+end

data/lib/ree_lib/packages/ree_hash/spec/ree_hash/functions/symbolize_keys_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe :symbolize_keys do
+  link :symbolize_keys, from: :ree_hash
+
+  it {
+    result = symbolize_keys({ name: "John", "age": 25, nil: "nothing"})
+
+    expect(result).to eq({ :name => "John", :age => 25, :nil => "nothing"})
+  }
+end

data/lib/ree_lib/packages/ree_hash/spec/ree_hash/functions/transform_keys_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+RSpec.describe :transform_keys do
+  link :transform_keys, from: :ree_hash
+
+  context "deep" do
+    it {
+      hash = {id: 1, name: 'John', array: [1,2,3], hash: {id: 1, name: 'Doe'}}
+
+      result = transform_keys(hash) { _1.to_s }
+
+      expect(result).to eq(
+        {'id' => 1, 'name' => 'John', 'array' => [1,2,3], 'hash' => {'id' => 1, 'name' => 'Doe'}}
+      )
+    }
+  end
+
+  context "deep = false" do
+    it {
+      hash = {id: 1, name: 'John', array: [1,2,3], hash: {id: 1, name: 'Doe'}}
+
+      result = transform_keys(hash, deep: false) { _1.to_s }
+
+      expect(result).to eq(
+        {'id' => 1, 'name' => 'John', 'array' => [1,2,3], 'hash' => {id: 1, name: 'Doe'}}
+      )
+    }
+  end
+
+  context "default" do
+    it {
+      hash = {id: 1, name: 'John', array: [1,2,3], hash: {id: 1, name: 'Doe'}}
+      hash.default = 1
+
+      result = transform_keys(hash, deep: false) { _1.to_s }
+
+      expect(result.default).to eq(1)
+      expect(result['hash'].default).to eq(nil)
+    }
+
+    it {
+      hash = {id: 1, name: 'John', array: [1,2,3], hash: {id: 1, name: 'Doe'}}
+      hash.default_proc = Proc.new { 1 }
+
+      result = transform_keys(hash, deep: false) { _1.to_s }
+
+      expect(result.default_proc).to eq(hash.default_proc)
+      expect(result['hash'].default).to eq(nil)
+    }
+
+    it {
+      obj = {id: 1, name: 'Doe'}
+      obj.default = 2
+
+      hash = {id: 1, name: 'John', array: [1,2,3], hash: obj}
+      hash.default = 1
+
+      result = transform_keys(hash, deep: false) { _1.to_s }
+
+      expect(result.default).to eq(1)
+      expect(result['hash'].default).to eq(2)
+    }
+
+    it {
+      obj = {id: 1, name: 'Doe'}
+      obj.default_proc = Proc.new { 2 }
+
+      hash = {id: 1, name: 'John', array: [1,2,3], hash: obj}
+      hash.default = 1
+
+      result = transform_keys(hash, deep: false) { _1.to_s }
+
+      expect(result.default).to eq(1)
+      expect(result['hash'].default_proc).to eq(obj.default_proc)
+    }
+  end
+end

data/lib/ree_lib/packages/ree_hash/spec/ree_hash/functions/transform_values_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal = true
+
+RSpec.describe :transform_values do
+  link :transform_values, from: :ree_hash
+
+  it {
+    obj = {name: 'John', password: 'PASSWORD'}
+
+    result = transform_values(obj) do |key, value|
+      if key.to_s.include?('password')
+        'FILTERED'
+      else
+        value
+      end
+    end
+
+    expect(result).to eq({name: 'John', password: 'FILTERED'})
+  }
+
+  it {
+    obj = {name: 'John', password: 'PASSWORD', list: [1, {password: 'PASSWORD'}]}
+
+    result = transform_values(obj) do |key, value|
+      if key.to_s.include?('password')
+        'FILTERED'
+      else
+        value
+      end
+    end
+
+    expect(result).to eq(
+      {
+        name: 'John',
+        password: 'FILTERED',
+        list: [1, {password: 'FILTERED'}]
+      }
+    )
+  }
+end

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

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

data/lib/ree_lib/packages/ree_http/.rspec

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

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

@@ -0,0 +1,69 @@
+{
+  "schema_type": "package",
+  "ree_version": "1.0.1",
+  "name": "ree_http",
+  "entry_path": "packages/ree_http/package/ree_http.rb",
+  "tags": [
+    "ree_http"
+  ],
+  "depends_on": [
+    {
+      "name": "ree_hash"
+    },
+    {
+      "name": "ree_json"
+    },
+    {
+      "name": "ree_object"
+    }
+  ],
+  "env_vars": [
+
+  ],
+  "objects": [
+    {
+      "name": "build_request",
+      "schema": "packages/ree_http/schemas/ree_http/functions/build_request.schema.json"
+    },
+    {
+      "name": "build_request_executor",
+      "schema": "packages/ree_http/schemas/ree_http/functions/build_request_executor.schema.json"
+    },
+    {
+      "name": "execute_request",
+      "schema": "packages/ree_http/schemas/ree_http/functions/execute_request.schema.json"
+    },
+    {
+      "name": "http_delete",
+      "schema": "packages/ree_http/schemas/ree_http/functions/http_delete.schema.json"
+    },
+    {
+      "name": "http_exec",
+      "schema": "packages/ree_http/schemas/ree_http/functions/http_exec.schema.json"
+    },
+    {
+      "name": "http_get",
+      "schema": "packages/ree_http/schemas/ree_http/functions/http_get.schema.json"
+    },
+    {
+      "name": "http_head",
+      "schema": "packages/ree_http/schemas/ree_http/functions/http_head.schema.json"
+    },
+    {
+      "name": "http_options",
+      "schema": "packages/ree_http/schemas/ree_http/functions/http_options.schema.json"
+    },
+    {
+      "name": "http_patch",
+      "schema": "packages/ree_http/schemas/ree_http/functions/http_patch.schema.json"
+    },
+    {
+      "name": "http_post",
+      "schema": "packages/ree_http/schemas/ree_http/functions/http_post.schema.json"
+    },
+    {
+      "name": "http_put",
+      "schema": "packages/ree_http/schemas/ree_http/functions/http_put.schema.json"
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_http/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_http/package/ree_http/constants.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ReeHttp
+  module Constants
+    DEFAULT_TIMEOUT = 60
+    DEFAULT_WRITE_TIMEOUT = 30
+    DEFAULT_FORCE_SSL = false
+    HTTPS = 'https'
+    HTTP = 'http'
+    HTTPS_PORT = 443
+    HTTP_PORT = 80
+  end
+end