ree_lib 1.0.0

data/lib/ree_lib/packages/ree_logger/schemas/ree_logger/config.schema.json

@@ -0,0 +1,38 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "config",
+  "path": "packages/ree_logger/package/ree_logger/config.rb",
+  "mount_as": "object",
+  "class": "ReeLogger::Config",
+  "factory": "build",
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "is_blank",
+      "package_name": "ree_object",
+      "as": "is_blank",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "to_obj",
+      "package_name": "ree_object",
+      "as": "to_obj",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "validate_inclusion",
+      "package_name": "ree_validator",
+      "as": "validate_inclusion",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_logger/schemas/ree_logger/formatters/colorized_formatter.schema.json

@@ -0,0 +1,30 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "colorized_formatter",
+  "path": "packages/ree_logger/package/ree_logger/formatters/colorized_formatter.rb",
+  "mount_as": "object",
+  "class": "ReeLogger::ColorizedFormatter",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "not_blank",
+      "package_name": "ree_object",
+      "as": "not_blank",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "now",
+      "package_name": "ree_datetime",
+      "as": "now",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_logger/schemas/ree_logger/formatters/default_formatter.schema.json

@@ -0,0 +1,30 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "default_formatter",
+  "path": "packages/ree_logger/package/ree_logger/formatters/default_formatter.rb",
+  "mount_as": "object",
+  "class": "ReeLogger::DefaultFormatter",
+  "factory": null,
+  "methods": [
+
+  ],
+  "links": [
+    {
+      "target": "not_blank",
+      "package_name": "ree_object",
+      "as": "not_blank",
+      "imports": [
+
+      ]
+    },
+    {
+      "target": "now",
+      "package_name": "ree_datetime",
+      "as": "now",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_logger/schemas/ree_logger/functions/build_logger.schema.json

@@ -0,0 +1,39 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "build_logger",
+  "path": "packages/ree_logger/package/ree_logger/functions/build_logger.rb",
+  "mount_as": "fn",
+  "class": "ReeLogger::BuildLogger",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "ReeLogger::MultiLogger",
+      "args": [
+        {
+          "arg": "appenders",
+          "type": "ArrayOf[ReeLogger::Appender]"
+        },
+        {
+          "arg": "progname",
+          "type": "Nilor[String]"
+        },
+        {
+          "arg": "rate_limiter",
+          "type": "Nilor[ReeLogger::RateLimiter]"
+        },
+        {
+          "arg": "filter_words",
+          "type": "ArrayOf[String]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

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

@@ -0,0 +1,14 @@
+RSpec.describe "ReeLogger" 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_logger --silence")
+      ).to eq(true)
+    end
+  end
+end

data/lib/ree_lib/packages/ree_logger/spec/ree_logger/appenders/appender_spec.rb

@@ -0,0 +1,15 @@
+#frozen_string_literal = true
+
+package_require('ree_logger/appenders/appender')
+
+RSpec.describe ReeLogger::Appender do
+  let(:appender) { described_class }
+
+  it {
+    appender = described_class.new(:level, nil)
+
+    expect { appender.append({}) }.to raise_error(NotImplementedError) do |e|
+      expect(e.message).to eq("should be implemented in derived class")
+    end
+  }
+end

data/lib/ree_lib/packages/ree_logger/spec/ree_logger/appenders/file_appender_spec.rb

@@ -0,0 +1,72 @@
+#frozen_string_literal = true
+
+package_require('ree_logger/appenders/file_appender')
+
+RSpec.describe ReeLogger::FileAppender do
+  link :is_blank, from: :ree_object
+
+  let(:file_appender) { described_class }
+
+  let(:log_event) {
+    ReeLogger::LogEvent.new(
+      :info,
+      "Some message",
+      nil,
+      {}
+    )
+  }
+
+  let(:log_file_path) { ENV['LOG_FILE_PATH'] }
+
+  before(:all) do
+    tmp_file_log = ENV['LOG_FILE_PATH']
+      
+    if !is_blank(tmp_file_log)
+      File.open(tmp_file_log, 'w') {|file| file.truncate(0) }
+    end
+  end
+
+  after(:all) do
+    tmp_file_log = ENV['LOG_FILE_PATH']
+      
+    if !is_blank(tmp_file_log)
+      File.open(tmp_file_log, 'w') {|file| file.truncate(0) }
+    end
+  end
+
+  let(:custom_formatter) {
+    Class.new(ReeLogger::Formatter) do
+      def format(event, progname = nil)
+        event.message.upcase
+      end
+    end
+  }
+
+  it "with default formatter" do
+    appender = file_appender.new(
+      :info,
+      nil,
+      log_file_path,
+      auto_flush: true
+    )
+
+    expect(appender).to respond_to(:append)
+
+    appender.append(log_event)
+    expect(File.read(log_file_path)).to match(log_event.message)
+  end
+
+  it "with custom formatter" do
+    appender = file_appender.new(
+      :info,
+      custom_formatter.new,
+      log_file_path,
+      auto_flush: true
+    )
+
+    expect(appender).to respond_to(:append)
+
+    appender.append(log_event)
+    expect(File.read(log_file_path)).to match(log_event.message.upcase)
+  end
+end

data/lib/ree_lib/packages/ree_logger/spec/ree_logger/appenders/stdout_appender_spec.rb

@@ -0,0 +1,44 @@
+#frozen_string_literal = true
+
+package_require('ree_logger/appenders/stdout_appender')
+
+RSpec.describe ReeLogger::StdoutAppender do
+  let(:stdout_appender) { described_class }
+
+  let(:log_event) {
+    ReeLogger::LogEvent.new(
+      :info,
+      "Some message",
+      nil,
+      {}
+    )
+  }
+
+  let(:custom_formatter) {
+    Class.new(ReeLogger::Formatter) do
+      def format(event, progname = nil)
+        event.message.upcase
+      end
+    end
+  }
+
+  it "with default formatter" do
+    appender = stdout_appender.new(
+      :info,
+      nil
+    )
+
+    expect(appender).to respond_to(:append)
+    expect { appender.append(log_event) }.to output(/#{log_event.message}/).to_stdout
+  end
+
+  it "with custom formatter" do
+    appender = stdout_appender.new(
+      :info,
+      custom_formatter.new
+    )
+
+    expect(appender).to respond_to(:append)
+    expect { appender.append(log_event) }.to output(/#{log_event.message.upcase}/).to_stdout
+  end
+end

data/lib/ree_lib/packages/ree_logger/spec/ree_logger/beans/logger_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal = true
+
+package_require('ree_logger/beans/logger')
+
+RSpec.describe :logger do
+  link :logger, from: :ree_logger
+  link :is_blank, from: :ree_object
+
+  before(:all) do
+    tmp_file_log = ENV['LOG_FILE_PATH']
+    
+    if !is_blank(tmp_file_log)
+      File.open(tmp_file_log, 'w') {|file| file.truncate(0) }
+    end
+  end
+
+  let(:log_file_path) { ENV['LOG_FILE_PATH'] }
+
+  let(:exception) {
+    StandardError.new('Some Exception')
+  }
+
+  it {
+    expect { logger.info('hello world') }.to output(/hello world/).to_stdout
+    expect(File.read(log_file_path)).to match("hello world")
+  }
+
+  it {
+    expect { logger.info('hello world', { param: 1, another_param: { name: 'John'} }) }.to output(/John/).to_stdout
+    expect(File.read(log_file_path)).to match("John")
+  }
+  
+  it {
+    expect { logger.debug('debug message') }.to_not output(/debug message/).to_stdout
+    expect(File.read(log_file_path)).to_not match("debug")
+  }
+
+  it {
+    expect { logger.warn('warning message') }.to output(/warning message/).to_stdout
+    expect(File.read(log_file_path)).to match("warning message")
+  }
+
+  it {
+    output = with_captured_stdout {
+      logger.error('some error message', {}, exception, false)
+    }
+    expect(output).to match(/some error message/)
+    expect(output).to_not match(/method|args/)
+    expect(File.read(log_file_path)).to match("some error message")
+    expect(File.read(log_file_path)).to_not match("PARAMETERS: {:method=>{:name=>:call, :args=>{:block=>{}}}}")
+  }
+
+  it {
+    expect { logger.fatal('some fatal message', {}, exception) }.to output(/some fatal message/).to_stdout
+    expect(File.read(log_file_path)).to match("some fatal message")
+  }
+
+  it {
+    expect { logger.unknown('unknown message') }.to output(/unknown message/).to_stdout
+    expect(File.read(log_file_path)).to match("unknown message")
+  }
+end

data/lib/ree_lib/packages/ree_logger/spec/ree_logger/formatters/colorized_formatter_spec.rb

@@ -0,0 +1,48 @@
+#frozen_string_literal = true
+
+require 'timecop'
+package_require('ree_logger/formatters/colorized_formatter')
+
+RSpec.describe ReeLogger::ColorizedFormatter do
+  link :parse, from: :ree_datetime
+
+  let(:formatter) { described_class.new }
+
+  let(:info_log_event) {
+    ReeLogger::LogEvent.new(
+      :info,
+      "Some message",
+      nil,
+      {}
+    )
+  }
+
+  let(:error_log_event) {
+    ReeLogger::LogEvent.new(
+      :error,
+      "Some error message",
+      StandardError.new('Help me, I am error'),
+      { some_error: "params" }
+    )
+  }
+
+  before { Timecop.travel(parse('1605-11-05 00:00:00')) }
+  after { Timecop.return }
+
+  it { expect(formatter).to respond_to(:format) }
+
+  it {
+    expected = "[05/11/05 00:00:00] \e[36minfo:\e[0m Some message"
+    expect(formatter.format(info_log_event, nil)).to eq(expected)
+  }
+
+  it {
+    expected = "[SomeCoolApp] [05/11/05 00:00:00] \e[36minfo:\e[0m Some message"
+    expect(formatter.format(info_log_event, "SomeCoolApp")).to eq(expected)
+  }
+
+  it {
+    expected = "[05/11/05 00:00:00] \e[31merror:\e[0m Some error message\n\e[34mPARAMETERS:\e[0m {:some_error=>\"params\"}\n\e[31mEXCEPTION:\e[0m StandardError (Help me, I am error)\n"
+    expect(formatter.format(error_log_event, nil)).to eq(expected)
+  }
+end

data/lib/ree_lib/packages/ree_logger/spec/ree_logger/formatters/default_formatter_spec.rb

@@ -0,0 +1,48 @@
+#frozen_string_literal = true
+
+require 'timecop'
+package_require('ree_logger/formatters/default_formatter')
+
+RSpec.describe ReeLogger::DefaultFormatter do
+  link :parse, from: :ree_datetime
+
+  let(:formatter) { described_class.new }
+
+  let(:info_log_event) {
+    ReeLogger::LogEvent.new(
+      :info,
+      "Some message",
+      nil,
+      {}
+    )
+  }
+
+  let(:error_log_event) {
+    ReeLogger::LogEvent.new(
+      :error,
+      "Some error message",
+      StandardError.new('Help me, I am error'),
+      { some_error: "params" }
+    )
+  }
+
+  before { Timecop.travel(parse('1605-11-05 00:00:00')) }
+  after { Timecop.return }
+
+  it { expect(formatter).to respond_to(:format) }
+
+  it {
+    expected = "[05/11/05 00:00:00] INFO: Some message"
+    expect(formatter.format(info_log_event, nil)).to eq(expected)
+  }
+
+  it {
+    expected = "[SomeCoolApp] [05/11/05 00:00:00] INFO: Some message"
+    expect(formatter.format(info_log_event, "SomeCoolApp")).to eq(expected)
+  }
+
+  it {
+    expected = "[05/11/05 00:00:00] ERROR: Some error message\nPARAMETERS: {:some_error=>\"params\"}\nEXCEPTION: StandardError (Help me, I am error)\n"
+    expect(formatter.format(error_log_event, nil)).to eq(expected)
+  }
+end

data/lib/ree_lib/packages/ree_logger/spec/ree_logger/formatters/formatter_spec.rb

@@ -0,0 +1,13 @@
+#frozen_string_literal = true
+
+package_require('ree_logger/formatters/formatter')
+
+RSpec.describe ReeLogger::Formatter do
+  let(:formatter) { described_class.new }
+
+  it {
+    expect { formatter.format({})}.to raise_error(NotImplementedError) do |e|
+      expect(e.message).to eq("should be implemented in derived class")
+    end
+  }
+end

data/lib/ree_lib/packages/ree_logger/spec/ree_logger/multi_logger_spec.rb

@@ -0,0 +1,117 @@
+#frozen_string_literal = true
+
+package_require('ree_logger/multi_logger')
+package_require('ree_logger/appenders/stdout_appender')
+package_require('ree_logger/appenders/file_appender')
+
+RSpec.describe ReeLogger::MultiLogger do
+  link :is_blank, from: :ree_object
+
+  before(:all) do
+    tmp_file_log = ENV['LOG_FILE_PATH']
+    
+    if !is_blank(tmp_file_log)
+      File.open(tmp_file_log, 'w') {|file| file.truncate(0) }
+    end
+  end
+
+  let(:multi_logger) { described_class }
+  let(:log_file_path) { ENV['LOG_FILE_PATH'] }
+  let(:exception) {
+    StandardError.new('Some Exception')
+  }
+
+  let(:file_appender) {
+    ReeLogger::FileAppender.new(
+      :info,
+      nil,
+      log_file_path,
+      auto_flush: true
+    )
+  }
+
+  let(:stdout_appender) {
+    ReeLogger::StdoutAppender.new(
+      :info,
+      nil
+    )
+  }
+
+  let(:logger) {
+    multi_logger.new(
+      'SomeCoolApp',
+      nil,
+      ['password']
+    )
+  }
+
+  let(:logger_with_appenders) {
+    [file_appender, stdout_appender].map { logger.add_appender(_1) }
+
+    logger
+  }
+
+  it {
+    expect { logger.add_appender(stdout_appender) }.to change { logger.appenders }
+  }
+
+  it {
+    expect { logger.info('any message') }.to_not output(/any message/).to_stdout
+    expect(File.read(log_file_path)).to_not match('any message') 
+  }
+
+  it {
+    expect { logger_with_appenders.info('hello world') }.to output(/hello world/).to_stdout
+    expect(File.read(log_file_path)).to match("hello world") 
+  }
+
+  it {
+    expect { logger_with_appenders.info('hello world', { param: 1, another_param: { name: 'John'} }) }.to output(/John/).to_stdout
+    expect(File.read(log_file_path)).to match("John")
+  }
+  
+  it {
+    expect { logger_with_appenders.debug('debug message') }.to_not output(/debug message/).to_stdout
+    expect(File.read(log_file_path)).to_not match("debug")
+  }
+
+  it {
+    expect { logger_with_appenders.warn('warning message') }.to output(/warning message/).to_stdout
+    expect(File.read(log_file_path)).to match("warning message")
+  }
+
+  it {
+    output = with_captured_stdout {
+      logger_with_appenders.error('some error message', {}, exception, false)
+    }
+    expect(output).to match(/some error message/)
+    expect(output).to_not match(/method|args/)
+    expect(File.read(log_file_path)).to match("some error message")
+    expect(File.read(log_file_path)).to_not match("PARAMETERS: {:method=>{:name=>:call, :args=>{:block=>{}}}}")
+  }
+
+  it {
+    expect { logger_with_appenders.fatal('some fatal message', {}, exception) }.to output(/some fatal message/).to_stdout
+    expect(File.read(log_file_path)).to match("some fatal message")
+  }
+
+  it {
+    expect { logger_with_appenders.unknown('unknown message') }.to output(/unknown message/).to_stdout
+    expect(File.read(log_file_path)).to match("unknown message")
+  }
+
+  it {
+    expect { logger_with_appenders.silence }.to change { logger_with_appenders.silenced }
+  }
+
+  it {
+    expect {
+      logger_with_appenders.silence do
+        logger_with_appenders.info('hush')
+        logger_with_appenders.info('I will keep my mouth shut')
+      end
+    }.to_not output.to_stdout
+  }
+
+  
+end

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

@@ -0,0 +1,19 @@
+RSpec.configure do |config|
+  config.extend Ree::RSpecLinkDSL
+end
+
+def with_captured_stdout
+  original_stdout = $stdout
+  $stdout = StringIO.new
+  yield
+  $stdout.string
+ensure
+  $stdout = original_stdout
+end
+
+ENV['LOG_FILE_PATH'] = '/tmp/ree_logger.log'
+ENV['LOG_FILE_AUTO_FLUSH'] = 'true'
+ENV['LOG_LEVEL_FILE'] = 'info'
+ENV['LOG_LEVEL_STDOUT'] = 'info'
+ENV['LOG_RATE_LIMIT_INTERVAL'] = '60'
+ENV['LOG_RATE_LIMIT_COUNT'] = '600'

data/lib/ree_lib/packages/ree_mapper/.rspec

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

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

@@ -0,0 +1,34 @@
+{
+  "schema_type": "package",
+  "ree_version": "1.0.1",
+  "name": "ree_mapper",
+  "entry_path": "packages/ree_mapper/package/ree_mapper.rb",
+  "tags": [
+    "ree_mapper"
+  ],
+  "depends_on": [
+    {
+      "name": "ree_datetime"
+    },
+    {
+      "name": "ree_string"
+    }
+  ],
+  "env_vars": [
+
+  ],
+  "objects": [
+    {
+      "name": "build_mapper_factory",
+      "schema": "packages/ree_mapper/schemas/ree_mapper/functions/build_mapper_factory.schema.json"
+    },
+    {
+      "name": "build_mapper_strategy",
+      "schema": "packages/ree_mapper/schemas/ree_mapper/functions/build_mapper_strategy.schema.json"
+    },
+    {
+      "name": "default_factory",
+      "schema": "packages/ree_mapper/schemas/ree_mapper/default_factory.schema.json"
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_mapper/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_mapper/package/ree_mapper/default_factory.rb

@@ -0,0 +1,19 @@
+class ReeMapper::DefaultFactory
+  include Ree::BeanDSL
+
+  bean :default_factory do
+    link :build_mapper_factory
+    link :build_mapper_strategy
+
+    factory :build
+  end
+
+  def build
+    build_mapper_factory(strategies: [
+      build_mapper_strategy(method: :cast, output: :symbol_key_hash),
+      build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
+      build_mapper_strategy(method: :db_dump, output: :symbol_key_hash),
+      build_mapper_strategy(method: :db_load, output: :object, always_optional: true)
+    ])
+  end
+end