ree_lib 1.0.0

data/lib/ree_lib/packages/ree_datetime/spec/ree_datetime/functions/years_since_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe :years_since do
+  link :years_since, from: :ree_datetime
+
+  it {
+    result = years_since(DateTime.new(2022, 3, 4, 13, 20, 40), 5)
+
+    expect(result).to eq(DateTime.new(2027, 3, 4, 13, 20, 40))
+  }
+
+  it {
+    result = years_since(5)
+
+    expect(result).to be_a(DateTime)
+  }
+end

data/lib/ree_lib/packages/ree_datetime/spec/ree_datetime/functions/yesterday_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe :yesterday do
+  link :yesterday, from: :ree_datetime
+
+  it {
+    result  = yesterday(DateTime.new(2022, 5, 23, 13, 15, 10))
+
+    expect(result).to eq(DateTime.new(2022, 5, 22, 13, 15, 10))
+  }
+
+  it {
+    result = yesterday()
+
+    expect(result).to be_a(DateTime)
+  }
+end

data/lib/ree_lib/packages/ree_datetime/spec/ree_datetime/functions/zone_offset_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe :zone_offset do
+  link :zone_offset, from: :ree_datetime
+
+  it {
+    expect(zone_offset("Europe/Moscow")).to be_a(String)
+  }
+end

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

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

data/lib/ree_lib/packages/ree_dto/.rspec

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

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

@@ -0,0 +1,18 @@
+{
+  "schema_type": "package",
+  "ree_version": "1.0.1",
+  "name": "ree_dto",
+  "entry_path": "packages/ree_dto/package/ree_dto.rb",
+  "tags": [
+    "ree_dto"
+  ],
+  "depends_on": [
+
+  ],
+  "env_vars": [
+
+  ],
+  "objects": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_dto/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_dto/package/ree_dto/entity_dsl.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module ReeDto::EntityDSL
+  def self.included(base)
+    base.include(InstanceMethods)
+    base.extend(ClassMethods)
+  end
+
+  def self.extended(base)
+    base.include(InstanceMethods)
+    base.extend(ClassMethods)
+  end
+
+  module InstanceMethods
+    def to_s
+      variables = self
+        .instance_variables
+        .map(&:to_s)
+        .map { |v| v.gsub('@', '') }
+        .sort
+
+      max_length = variables.sort_by(&:size).last.size
+      result     = "\n#{self.class}\n"
+
+      result << variables
+        .map { |variable|
+          name = variable.to_s
+          extra_spaces = ' ' * (max_length - name.size)
+          %Q(  #{name}#{extra_spaces} = #{instance_variable_get("@#{variable}")})
+        }
+        .join("\n")
+
+      result
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  module ClassMethods
+    include Ree::Contracts::Core
+    include Ree::Contracts::ArgContracts
+
+    contract(Ksplat[RestKeys => Any] => nil)
+    def properties(**args)
+      args.each do |name, contract_class|
+        contract None => contract_class
+        class_eval %Q(
+          def #{name}
+            @#{name}
+          end
+        )
+      end
+
+      contract Kwargs[**args] => Any
+      class_eval %Q(
+        def initialize(#{args.keys.map {|k| "#{k}: nil"}.join(',')})
+          #{
+            args.map {|k, v|
+              "@#{k} = #{k}"
+            }.join("\n")
+          }
+        end
+
+        contract self => Bool
+        def ==(val)
+          #{
+            args.map {|k, _|
+              "@#{k} == val.#{k}"
+            }.join(" && ")
+          }
+        end
+
+        def to_h
+          {
+            #{args.map {|k, _| "#{k}: #{k}" }.join(", ")}
+          }
+        end
+
+        def values_for(*args)
+          args.map do |arg|
+            variable = ("@" + arg.to_s).to_sym
+
+            if !instance_variables.include?(variable)
+              raise ArgumentError.new("variable :" + arg.to_s + " not found in dto")
+            end
+
+            instance_variable_get(variable)
+          end
+        end
+
+        class << self
+          def import_from(other_dto)
+            self.new(
+              #{
+                args.map {|k, v|
+                  "#{k}: other_dto.#{k}"
+                }.join(",")
+              }
+            )
+          end
+        end
+      )
+
+      nil
+    end
+  end
+end

data/lib/ree_lib/packages/ree_dto/package/ree_dto.rb

@@ -0,0 +1,7 @@
+module ReeDto
+  include Ree::PackageDSL
+	
+  package
+end
+
+require_relative 'ree_dto/entity_dsl'

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

@@ -0,0 +1,14 @@
+RSpec.describe "ReeDto" 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("bundle exec ree gen.package_json ree_dto --silence")
+      ).to eq(true)
+    end
+  end
+end

data/lib/ree_lib/packages/ree_dto/spec/ree_dto/entity_dsl_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal = true
+
+package_require('ree_dto/entity_dsl')
+
+RSpec.describe ReeDto::EntityDSL do
+  before :all do
+    class TestDTO
+      include ReeDto::EntityDSL
+
+      properties(
+        id: Nilor[Integer],
+        name: String,
+        email: Nilor[String]
+      )
+    end
+
+    @test_dto = TestDTO.new(
+      id: 1,
+      name: 'John',
+      email: 'test@example.com'
+    )
+
+    @compare_dto = TestDTO.new(
+      id: 1,
+      name: 'John',
+      email: 'test@example.com'
+    )
+
+    @uncompareable_dto = TestDTO.new(
+      id: 3,
+      name: 'Arthur'
+    )
+  end
+
+
+  it { expect(@test_dto.id).to eq(1) }
+  it { expect(@test_dto.name).to eq('John') }
+  it { expect(@test_dto.email).to eq('test@example.com') }
+  it { expect(@test_dto).to eq(@compare_dto) }
+  it { expect(@test_dto).to_not eq(@uncompareable_dto)}
+
+  context "missing args" do
+    it {
+      dto = TestDTO.new(name: 'John')
+      expect(dto.id).to eq(nil)
+      expect(dto.email).to eq(nil)
+    }
+  end
+
+  context "#to_s" do
+    it {
+      expect(@test_dto.to_s).to eq(
+%Q(
+TestDTO
+  email = test@example.com
+  id    = 1
+  name  = John)
+      )
+    }
+  end
+
+  context "#values_for" do
+    it {
+      dto = TestDTO.new(
+        id:    1,
+        name:  'John',
+        email: 'test@example.com'
+      )
+
+      expect(dto.values_for(:id)).to eq([1])
+      expect(dto.values_for(:id, :name)).to eq([1, 'John'])
+      expect(dto.values_for(:email, :name)).to eq(['test@example.com', 'John'])
+    }
+  end
+
+  context "#from" do
+    it {
+      StructDTO = Struct.new(:id, :name, :email, :phone)
+
+      obj = StructDTO.new(1, 'John', 'test@example.com', '123123')
+
+      dto = TestDTO.import_from(obj)
+
+      expect(dto).to be_a(TestDTO)
+      expect(dto.id).to eq(1)
+      expect(dto.name).to eq('John')
+      expect(dto.email).to eq('test@example.com')
+    }
+  end
+
+  context "#to_h" do
+    it {
+      dto = TestDTO.new(
+        id: 1,
+        name: 'John',
+        email: 'test@example.com',
+      )
+
+      expect(dto.to_h).to eq({
+        id: 1,
+        name: 'John',
+        email: 'test@example.com'
+      })
+    }
+  end
+end

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

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

data/lib/ree_lib/packages/ree_enum/.rspec

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

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

@@ -0,0 +1,23 @@
+{
+  "schema_type": "package",
+  "ree_version": "1.0.1",
+  "name": "ree_enum",
+  "entry_path": "packages/ree_enum/package/ree_enum.rb",
+  "tags": [
+    "ree_enum"
+  ],
+  "depends_on": [
+    {
+      "name": "ree_mapper"
+    },
+    {
+      "name": "ree_validator"
+    }
+  ],
+  "env_vars": [
+
+  ],
+  "objects": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_enum/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_enum/package/ree_enum/contractable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ReeEnum::Contractable
+  include Ree::Contracts::Truncatable
+
+  def valid?(value)
+    value.is_a?(ReeEnum::Value) && value.enum_name == self.enum_name && all.include?(value)
+  end
+
+  def message(value, name, lvl = 1)
+    return "expected one of #{self.name}, got #{value.class} => #{truncate(value.inspect)}"
+  end
+end

data/lib/ree_lib/packages/ree_enum/package/ree_enum/dsl.rb

@@ -0,0 +1,103 @@
+module ReeEnum
+  module DSL
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.extended(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def enum(name, &proc)
+        dsl = Ree::ObjectDsl.new(
+          Ree.container.packages_facade, name, self, :object
+        )
+
+        dsl.instance_exec(&proc) if block_given?
+
+        klass = dsl.object.klass
+        klass.send(:include, ReeEnum::Enumerable)
+        klass.setup_enum(dsl.object.name)
+        Ree.container.compile(dsl.package, name)
+      end
+
+      def register_as_mapper_type
+        mapper_factory = ReeMapper.get_mapper_factory(
+          Object.const_get(self.name.split('::').first)
+        )
+
+        klass = Class.new(ReeMapper::AbstractType) do
+          def initialize(enum)
+            @enum = enum
+          end
+
+          contract(
+            ReeEnum::Value,
+            Kwargs[
+              role: Nilor[Symbol, ArrayOf[Symbol]]
+            ] => String
+          )
+          def serialize(value, role: nil)
+            value.to_s
+          end
+
+          contract(
+            Any,
+            Kwargs[
+              role: Nilor[Symbol, ArrayOf[Symbol]]
+            ] => ReeEnum::Value
+          ).throws(ReeMapper::CoercionError)
+          def cast(value, role: nil)
+            if value.is_a?(String)
+              enum_val = @enum.values.all.detect { |v| v.to_s == value }
+
+              if !enum_val
+                raise ReeMapper::CoercionError, "should be one of #{@enum.values.all.map(&:to_s).inspect}"
+              end
+
+              enum_val
+            elsif value.is_a?(Integer)
+              enum_val = @enum.values.all.detect { |v| v.to_i == value }
+
+              if !enum_val
+                raise ReeMapper::CoercionError, "should be one of #{@enum.values.all.map(&:to_s).inspect}"
+              end
+
+              enum_val
+            else
+              raise ReeMapper::CoercionError, "should be one of #{@enum.values.all.map(&:to_s).inspect}"
+            end
+          end
+
+          contract(
+            ReeEnum::Value,
+            Kwargs[
+              role: Nilor[Symbol, ArrayOf[Symbol]]
+            ] => Integer
+          )
+          def db_dump(value, role: nil)
+            value.to_i
+          end
+
+          contract(
+            Integer,
+            Kwargs[
+              role: Nilor[Symbol, ArrayOf[Symbol]]
+            ] => ReeEnum::Value
+          ).throws(ReeMapper::TypeError)
+          def db_load(value, role: nil)
+            cast(value, role: role)
+          end
+        end
+
+        mapper_factory.register(
+          self.enum_name,
+          ReeMapper::Mapper.build(
+            mapper_factory.strategies, klass.new(self)
+          )
+        )
+      end
+    end
+  end
+end

data/lib/ree_lib/packages/ree_enum/package/ree_enum/enumerable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'value'
+require_relative 'values'
+require_relative 'contractable'
+
+module ReeEnum::Enumerable
+  module CommonMethods
+    def by_value(value)
+      values.by_value(value)
+    end
+
+    def by_number(number)
+      values.by_number(number)
+    end
+
+    def all
+      values.all
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    include ReeEnum::Contractable
+
+    def setup_enum(enum_name)
+      @values ||= ReeEnum::Values.new(self, enum_name)
+    end
+
+    def values
+      @values
+    end
+
+    def enum_name
+      return if !@values
+      @values.enum_name
+    end
+
+    include CommonMethods
+
+    def val(value, number, label = nil)
+      if value == :new
+        raise ArgumentError.new(":new is not allowed as enum value")
+      end
+      
+      enum_value = values.add(value, number: number, label: label)
+
+      define_method "#{enum_value.value}" do
+        by_value(enum_value.value)
+      end
+
+      define_singleton_method "#{enum_value.value}" do
+        by_value(enum_value.value)
+      end
+
+      enum_value
+    end
+  end
+
+  def values
+    self.class.values
+  end
+
+  include CommonMethods
+end

data/lib/ree_lib/packages/ree_enum/package/ree_enum/value.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class ReeEnum::Value
+  attr_reader :enum_class, :enum_name, :value, :label, :number
+
+  contract(Class, Symbol, Symbol, Integer, Nilor[String] => Any)
+  def initialize(enum_class, enum_name, value, number, label)
+    @enum_class = enum_class
+    @enum_name = enum_name
+    @value = value
+    @label = label
+    @number = number
+  end
+
+  def to_s
+    @value.to_s
+  end
+
+  def to_sym
+    @value
+  end
+
+  def to_i
+    @number
+  end
+
+  def as_json(*args)
+    to_s
+  end
+
+  def label
+    @label
+  end
+
+  contract(Or[ReeEnum::Value, Symbol, Integer, Any] => Bool)
+  def ==(compare)
+    if compare.is_a?(self.class)
+      @value == compare.value
+    else
+      @value == compare || @number == compare
+    end
+  end
+
+  contract(Or[ReeEnum::Value, String, Integer] => Bool)
+  def <=>(other)
+    if other.is_a?(self.class)
+      @number <=> other.number
+    elsif other.is_a?(Symbol)
+      @value == other
+    elsif other.is_a?(Integer)
+      @number == other
+    else
+      raise ArgumentError.new("unable to compare ReeEnum::Value with other classes")
+    end
+  end
+  
+  def inspect
+    "#{enum_class.name}##{@value.to_s}"
+  end
+end

data/lib/ree_lib/packages/ree_enum/package/ree_enum/values.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class ReeEnum::Values
+  attr_reader :klass, :enum_name
+
+  def initialize(klass, enum_name)
+    @klass = klass
+    @enum_name = enum_name
+    @collection = {}
+  end
+
+  def all
+    @collection.values.sort_by(&:number)
+  end
+
+  contract(Symbol => ReeEnum::Value).throws(ArgumentError)
+  def by_value(value)
+    type = @collection.values.detect {|c| c.value == value}
+    type || (raise ArgumentError.new("constant for value #{value.inspect} is not found in #{self.inspect}"))
+  end
+
+  contract(Integer => ReeEnum::Value).throws(ArgumentError)
+  def by_number(number)
+    type = @collection.values.detect {|c| c.number == number}
+    type || (raise ArgumentError.new("constant for value #{number.inspect} is not found in #{self.inspect}"))
+  end
+
+  def inspect
+    @collection.values.map(&:inspect).inspect
+  end
+
+  contract(Symbol, Kwargs[number: Integer, label: Nilor[String]] => ReeEnum::Value)
+  def add(value, number:, label: nil)
+    if @collection.has_key?(value)
+      raise ArgumentError, "#{@klass}: value #{value.inspect} was already added"
+    end
+
+    if @collection.values.any? {|v| v.number == number}
+      raise ArgumentError, "number for #{value.inspect} was already added"
+    end
+
+    @collection[value] = ReeEnum::Value.new(
+      @klass, @enum_name, value, number, label
+    )
+  end
+end

data/lib/ree_lib/packages/ree_enum/package/ree_enum.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ReeEnum
+  include Ree::PackageDSL
+
+  package do
+    depends_on :ree_mapper
+    depends_on :ree_validator
+  end
+end
+
+require_relative 'ree_enum/dsl'
+require_relative 'ree_enum/enumerable'
+
+# Example of Usage
+# class YourPackageName::YourEnumName
+#   include ReeEnum::DSL
+#
+#   enum :your_enum_name
+#
+#   val :first, 0
+#   val :second, 1
+#
+#   register_as_mapper_type
+# end