ree 1.2.3 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b2a4983f915c5d0761d563998b0c5a6fa9bd344d39e61046e47c088b5f53b4d
-  data.tar.gz: 2ec723f70527921b5784989d5f4294a211c5cb5015fe2e16b181990829979dde
+  metadata.gz: c4b0c989272201bf193600af16a5d4010842b6d169c4cd97afc9af4bea38d4cd
+  data.tar.gz: 0723ffdd0c7fdfb7220348d7bad7d0af8691f66330c24d64ff9e4d52300802dc
 SHA512:
-  metadata.gz: f86a204bf1134fbc800898d98e4d379bd9b7e9275db0e4ae6aa278142b6e3af3ef7b5f276eb4a301f711b024737c70dcb0d3e251985854747b0042899fea69f0
-  data.tar.gz: 4e20a1cc184a8b94472c707c07512827e5359626ddf5deb1f9e507fd46f37caac565330d526cee852de120585d3d9b949b809820c3492bc25463cafcd2eea919
+  metadata.gz: ca5e021ac6507f3679d44fd7fd48068f8918a5990fbd2b993f19e55db06cc1e80c42a23796a9962cdb29b1e20a2e979d7d7765030ca58997979fc7a8bf5cac1d
+  data.tar.gz: d12e9983fea63b43385e686072922b3f8f7bc5dc0e5864a276c3d80d7fcd31e9021ed6c8337814ada8c75cd76add04eab81a903df747833b0bcc69ea30a22e78

data/Gemfile.lock

@@ -1,13 +1,15 @@
 PATH
   remote: .
   specs:
-    ree (1.2.3)
+    ree (1.2.6)
+      base64
       commander (~> 5.0.0)
       logger (~> 1.6.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    base64 (0.3.0)
     commander (5.0.0)
       highline (~> 3.0.0)
     debug (1.9.1)

data/exe/ree

@@ -223,6 +223,87 @@ class ReeCliRunner
       end
     end
 
+    command :"licensing.register_client" do |c|
+      c.syntax      = 'ree licensing.register_client --name=NAME --contact=CONTACT'
+      c.description = 'register a new licensing client'
+      c.summary     = '> ' + c.description
+      c.example     'register a client', 'ree licensing.register_client --name="Glabix" --contact="hello@glabix.com" --metadata="type=enterprise,country=RU"'
+      c.option      '--name NAME', String, 'Client name'
+      c.option      '--contact CONTACT', String, 'Client contact email'
+      c.option      '--metadata METADATA', String, 'Client metadata (key=value pairs separated by commas)'
+      c.option      '--clients_dir DIR', String, 'Directory for clients.json (default: current dir)'
+      c.action do |args, options|
+        options_hash = options.__hash__
+        options_hash.delete(:trace)
+
+        raise Ree::Error.new("--name is required") unless options_hash[:name]
+        raise Ree::Error.new("--contact is required") unless options_hash[:contact]
+
+        Ree::CLI::Licensing::RegisterClient.run(
+          name: options_hash[:name],
+          contact: options_hash[:contact],
+          metadata_str: options_hash[:metadata],
+          clients_dir: options_hash[:clients_dir] || Dir.pwd
+        )
+      end
+    end
+
+    command :"licensing.obfuscate" do |c|
+      c.syntax      = 'ree licensing.obfuscate --source_path=PATH --target_path=PATH --client_id=ID --expires_at=DATE'
+      c.description = 'obfuscate a Ree project for distribution'
+      c.summary     = '> ' + c.description
+      c.example     'obfuscate project', 'ree licensing.obfuscate --source_path=./project --target_path=./dist --client_id=client_abc123 --expires_at="2026-12-31"'
+      c.option      '--source_path PATH', String, 'Source project path'
+      c.option      '--target_path PATH', String, 'Target distribution path'
+      c.option      '--client_id ID', String, 'Client ID from clients.json'
+      c.option      '--expires_at DATE', String, 'License expiration date (YYYY-MM-DD)'
+      c.option      '--exclude_files FILES', String, 'Comma-separated list of files to exclude'
+      c.option      '--clients_dir DIR', String, 'Directory for clients.json (default: current dir)'
+      c.action do |args, options|
+        options_hash = options.__hash__
+        options_hash.delete(:trace)
+
+        raise Ree::Error.new("--source_path is required") unless options_hash[:source_path]
+        raise Ree::Error.new("--target_path is required") unless options_hash[:target_path]
+        raise Ree::Error.new("--client_id is required") unless options_hash[:client_id]
+        raise Ree::Error.new("--expires_at is required") unless options_hash[:expires_at]
+
+        Ree::CLI::Licensing::Obfuscate.run(
+          source_path: options_hash[:source_path],
+          target_path: options_hash[:target_path],
+          client_id: options_hash[:client_id],
+          expires_at: options_hash[:expires_at],
+          exclude_files: options_hash[:exclude_files] || "",
+          clients_dir: options_hash[:clients_dir] || Dir.pwd
+        )
+      end
+    end
+
+    command :"licensing.renew_license" do |c|
+      c.syntax      = 'ree licensing.renew_license --client_id=ID --expires_at=DATE'
+      c.description = 'renew a license for an existing client'
+      c.summary     = '> ' + c.description
+      c.example     'renew license', 'ree licensing.renew_license --client_id=client_abc123 --expires_at="2028-01-01"'
+      c.option      '--client_id ID', String, 'Client ID from clients.json'
+      c.option      '--expires_at DATE', String, 'New license expiration date (YYYY-MM-DD)'
+      c.option      '--output_path PATH', String, 'Output path for license.json'
+      c.option      '--clients_dir DIR', String, 'Directory for clients.json (default: current dir)'
+      c.action do |args, options|
+        options_hash = options.__hash__
+        options_hash.delete(:trace)
+
+        raise Ree::Error.new("--client_id is required") unless options_hash[:client_id]
+        raise Ree::Error.new("--expires_at is required") unless options_hash[:expires_at]
+
+        Ree::CLI::Licensing::RenewLicense.run(
+          client_id: options_hash[:client_id],
+          expires_at: options_hash[:expires_at],
+          output_path: options_hash[:output_path],
+          clients_dir: options_hash[:clients_dir] || Dir.pwd
+        )
+      end
+    end
+
     command :"gen.index_project" do |c|
       c.syntax      = 'ree gen.index_project'
       c.description = 'generate index schema of methods'

data/lib/ree/benchmark_method_plugin.rb

@@ -12,14 +12,14 @@ class Ree::BenchmarkMethodPlugin
   end
 
   def call
-    config = @target.instance_variable_get(:@__ree_benchmark_config)
+    return unless @method_name == :call && ree_fn?
 
-    if @method_name == :call
-      if config
-        wrap_as_entry_point(config)
-      else
-        wrap_as_collector
-      end
+    config = @target.instance_variable_get(:@__ree_benchmark_config)
+    
+    if config
+      wrap_as_entry_point(config)
+    else
+      wrap_as_collector
     end
   end
 
@@ -41,7 +41,11 @@ class Ree::BenchmarkMethodPlugin
     benchmark_done = false
 
     alias_target.define_method(method_name) do |*args, **kwargs, &block|
-      if once && benchmark_done
+      if Ree::BenchmarkTracer.active?
+        Ree::BenchmarkTracer.collect(benchmark_name) do
+          send(method_alias, *args, **kwargs, &block)
+        end
+      elsif once && benchmark_done
         Ree::BenchmarkTracer.collect(benchmark_name) do
           send(method_alias, *args, **kwargs, &block)
         end
@@ -85,6 +89,17 @@ class Ree::BenchmarkMethodPlugin
     @method_name == :call ? base : "#{base}##{@method_name}"
   end
 
+  def ree_fn?
+    pkg = @target.instance_variable_get(:@__ree_package_name)
+    obj = @target.instance_variable_get(:@__ree_object_name)
+    return false unless pkg && obj
+
+    facade = Ree.container.packages_facade
+    return false unless facade.has_object?(pkg, obj)
+
+    facade.get_object(pkg, obj).fn?
+  end
+
   def eigenclass
     class << @target; self; end
   end

data/lib/ree/benchmark_tracer.rb

@@ -34,6 +34,11 @@ class Ree::BenchmarkTracer
       result
     end
 
+    def active?
+      stack = Thread.current[THREAD_KEY]
+      stack && !stack.empty?
+    end
+
     # Collector trace — only participates if a trace is already active
     def collect(name)
       stack = Thread.current[THREAD_KEY]

data/lib/ree/cli/licensing/obfuscate.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ree
+  module CLI
+    module Licensing
+      class Obfuscate
+        class << self
+          def run(source_path:, target_path:, client_id:, expires_at:, exclude_files: "", clients_dir: Dir.pwd, stdout: $stdout)
+            exclude_list = exclude_files.to_s.split(',').map(&:strip).reject(&:empty?)
+
+            Ree::Licensing::Obfuscator.run(
+              source_path: source_path,
+              target_path: target_path,
+              client_id: client_id,
+              expires_at: expires_at,
+              clients_dir: clients_dir,
+              exclude_files: exclude_list,
+              stdout: stdout
+            )
+          rescue Ree::Error => e
+            stdout.puts "Error: #{e.message}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ree/cli/licensing/register_client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ree
+  module CLI
+    module Licensing
+      class RegisterClient
+        class << self
+          def run(name:, contact:, metadata_str: nil, clients_dir: Dir.pwd, stdout: $stdout)
+            metadata = parse_metadata(metadata_str)
+
+            store = Ree::Licensing::ClientStore.new(clients_dir)
+            client = store.register_client(
+              name: name,
+              contact: contact,
+              metadata: metadata
+            )
+
+            stdout.puts "Client registered successfully:"
+            stdout.puts "  Client ID: #{client['client_id']}"
+            stdout.puts "  Name: #{client['name']}"
+            stdout.puts "  Contact: #{client['contact']}"
+            stdout.puts "  Saved to: #{File.join(clients_dir, 'clients.json')}"
+
+            client
+          rescue Ree::Error => e
+            stdout.puts "Error: #{e.message}"
+          end
+
+          private
+
+          def parse_metadata(metadata_str)
+            return {} if metadata_str.nil? || metadata_str.empty?
+
+            metadata_str.split(',').each_with_object({}) do |pair, hash|
+              key, value = pair.split('=', 2)
+              hash[key.strip] = value&.strip
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ree/cli/licensing/renew_license.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Ree
+  module CLI
+    module Licensing
+      class RenewLicense
+        class << self
+          def run(client_id:, expires_at:, output_path: nil, clients_dir: Dir.pwd, stdout: $stdout)
+            store = Ree::Licensing::ClientStore.new(clients_dir)
+            client = store.find_client(client_id)
+            raise Ree::Error.new("Client #{client_id} not found") unless client
+
+            last_license = store.last_license(client_id)
+            raise Ree::Error.new("No existing license found for #{client_id}") unless last_license
+
+            result = Ree::Licensing::LicenseGenerator.generate(
+              client_id: client_id,
+              private_key_pem: client['private_key_pem'],
+              public_key_pem: client['public_key_pem'],
+              aes_key_hex: last_license['aes_key_hex'],
+              iv_hex: last_license['iv_hex'],
+              expires_at: expires_at
+            )
+
+            store.add_license(client_id, result[:license_record])
+
+            output = output_path || File.join(clients_dir, "license_#{client_id}.json")
+            File.write(output, JSON.pretty_generate(result[:license_file]))
+
+            stdout.puts "License renewed successfully:"
+            stdout.puts "  Client ID: #{client_id}"
+            stdout.puts "  Expires at: #{expires_at}"
+            stdout.puts "  License file: #{output}"
+
+            result
+          rescue Ree::Error => e
+            stdout.puts "Error: #{e.message}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ree/cli.rb

@@ -8,5 +8,11 @@ module Ree
     autoload :GenerateTemplate, 'ree/cli/generate_template'
     autoload :Indexing, 'ree/cli/indexing'
     autoload :SpecRunner, 'ree/cli/spec_runner'
+
+    module Licensing
+      autoload :RegisterClient, 'ree/cli/licensing/register_client'
+      autoload :Obfuscate, 'ree/cli/licensing/obfuscate'
+      autoload :RenewLicense, 'ree/cli/licensing/renew_license'
+    end
   end
 end

data/lib/ree/core/package_loader.rb

@@ -95,7 +95,22 @@ class Ree::PackageLoader
 
     Ree.logger.debug("load_file(:#{package_name}, '#{path}')")
 
-    Kernel.require(path)
+    if Ree.obfuscated?
+      load_encrypted_file(path)
+    else
+      Kernel.require(path)
+    end
+  end
+
+  private
+
+  def load_encrypted_file(path)
+    license = Ree.license
+    full_path = path.end_with?('.rb') ? path : "#{path}.rb"
+    encrypted_data = File.binread(full_path)
+    bytecode = license.decrypt_file(encrypted_data)
+    iseq = RubyVM::InstructionSequence.load_from_binary(bytecode)
+    iseq.eval
   end
 end
 

data/lib/ree/dsl/object_dsl.rb

@@ -333,6 +333,11 @@ class Ree::ObjectDsl
       .set_package(package.name)
       .set_rpath(object_rpath)
 
+    if mount_as == :fn
+      klass.instance_variable_set(:@__ree_package_name, package.name)
+      klass.instance_variable_set(:@__ree_object_name, object_name)
+    end
+
     package.set_object(object)
     object.set_loaded
 

data/lib/ree/fn_dsl.rb

@@ -21,9 +21,6 @@ module Ree::FnDSL
       dsl.tags(["fn"])
       dsl.object.set_as_compiled(false)
 
-      self.instance_variable_set(:@__ree_package_name, dsl.package.name)
-      self.instance_variable_set(:@__ree_object_name, name)
-
       Ree.container.compile(dsl.package, name)
     end
   end

data/lib/ree/licensing/bytecode_compiler.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ree
+  module Licensing
+    class BytecodeCompiler
+      def self.compile_file(path)
+        iseq = RubyVM::InstructionSequence.compile_file(path)
+        iseq.to_binary
+      end
+
+      def self.compile_string(source, path = "(eval)")
+        iseq = RubyVM::InstructionSequence.compile(source, path)
+        iseq.to_binary
+      end
+
+      def self.load_from_binary(binary)
+        RubyVM::InstructionSequence.load_from_binary(binary)
+      end
+    end
+  end
+end

data/lib/ree/licensing/client_store.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'securerandom'
+require 'openssl'
+
+module Ree
+  module Licensing
+    class ClientStore
+      CLIENTS_FILE = 'clients.json'
+
+      def initialize(dir)
+        @dir = dir
+        @file_path = File.join(dir, CLIENTS_FILE)
+      end
+
+      def register_client(name:, contact:, metadata: {})
+        data = load_data
+        client_id = "client_#{SecureRandom.hex(8)}"
+        rsa_key = OpenSSL::PKey::RSA.new(4096)
+
+        client = {
+          'client_id' => client_id,
+          'name' => name,
+          'contact' => contact,
+          'metadata' => metadata,
+          'created_at' => Date.today.to_s,
+          'private_key_pem' => rsa_key.to_pem,
+          'public_key_pem' => rsa_key.public_key.to_pem,
+          'licenses' => []
+        }
+
+        data['clients'] << client
+        save_data(data)
+
+        client
+      end
+
+      def find_client(client_id)
+        data = load_data
+        data['clients'].detect { |c| c['client_id'] == client_id }
+      end
+
+      def add_license(client_id, license)
+        data = load_data
+        client = data['clients'].detect { |c| c['client_id'] == client_id }
+        raise Ree::Error.new("Client #{client_id} not found") unless client
+
+        client['licenses'] << license
+        save_data(data)
+      end
+
+      def last_license(client_id)
+        client = find_client(client_id)
+        raise Ree::Error.new("Client #{client_id} not found") unless client
+
+        client['licenses'].last
+      end
+
+      def load_data
+        if File.exist?(@file_path)
+          JSON.parse(File.read(@file_path))
+        else
+          { 'clients' => [] }
+        end
+      end
+
+      private
+
+      def save_data(data)
+        File.write(@file_path, JSON.pretty_generate(data))
+      end
+    end
+  end
+end

data/lib/ree/licensing/decryptor.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'base64'
+require 'openssl'
+require 'date'
+
+module Ree
+  module Licensing
+    class Decryptor
+      attr_reader :aes_key, :iv, :expires_at, :client_id
+
+      def initialize(aes_key:, iv:, expires_at:, client_id:)
+        @aes_key = aes_key
+        @iv = iv
+        @expires_at = expires_at
+        @client_id = client_id
+      end
+
+      def self.load_license(license_path)
+        unless File.exist?(license_path)
+          raise Ree::Error.new("License file not found: #{license_path}")
+        end
+
+        license_data = JSON.parse(File.read(license_path))
+        public_key_pem = license_data['public_key_pem']
+        encrypted_payload = Base64.strict_decode64(license_data['encrypted_payload'])
+
+        payload_json = Encryptor.rsa_public_decrypt(encrypted_payload, public_key_pem)
+        payload = JSON.parse(payload_json)
+
+        expires_at = Date.parse(payload['expires_at'])
+
+        if expires_at < Date.today
+          raise Ree::Error.new("License expired on #{payload['expires_at']}")
+        end
+
+        aes_key = [payload['aes_key_hex']].pack('H*')
+        iv = [payload['iv_hex']].pack('H*')
+
+        new(
+          aes_key: aes_key,
+          iv: iv,
+          expires_at: expires_at,
+          client_id: payload['client_id']
+        )
+      end
+
+      def decrypt_file(encrypted_data)
+        Encryptor.aes_decrypt(encrypted_data, @aes_key, @iv)
+      end
+    end
+  end
+end

data/lib/ree/licensing/encryptor.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'securerandom'
+require 'json'
+require 'base64'
+
+module Ree
+  module Licensing
+    class Encryptor
+      def self.generate_aes_key
+        cipher = OpenSSL::Cipher::AES256.new(:CBC)
+        cipher.encrypt
+        {
+          key: cipher.random_key,
+          iv: cipher.random_iv
+        }
+      end
+
+      def self.aes_encrypt(data, key, iv)
+        cipher = OpenSSL::Cipher::AES256.new(:CBC)
+        cipher.encrypt
+        cipher.key = key
+        cipher.iv = iv
+        cipher.update(data) + cipher.final
+      end
+
+      def self.aes_decrypt(encrypted_data, key, iv)
+        cipher = OpenSSL::Cipher::AES256.new(:CBC)
+        cipher.decrypt
+        cipher.key = key
+        cipher.iv = iv
+        cipher.update(encrypted_data) + cipher.final
+      end
+
+      def self.rsa_private_encrypt(payload_json, private_key_pem)
+        rsa = OpenSSL::PKey::RSA.new(private_key_pem)
+        rsa.private_encrypt(payload_json)
+      end
+
+      def self.rsa_public_decrypt(encrypted_payload, public_key_pem)
+        rsa = OpenSSL::PKey::RSA.new(public_key_pem)
+        rsa.public_decrypt(encrypted_payload)
+      end
+    end
+  end
+end

data/lib/ree/licensing/license_generator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'base64'
+require 'securerandom'
+
+module Ree
+  module Licensing
+    class LicenseGenerator
+      def self.generate(client_id:, private_key_pem:, public_key_pem:, aes_key_hex:, iv_hex:, expires_at:)
+        payload = {
+          'aes_key_hex' => aes_key_hex,
+          'iv_hex' => iv_hex,
+          'expires_at' => expires_at,
+          'client_id' => client_id
+        }
+
+        payload_json = JSON.generate(payload)
+        encrypted_payload = Encryptor.rsa_private_encrypt(payload_json, private_key_pem)
+
+        license_file = {
+          'version' => 1,
+          'client_id' => client_id,
+          'public_key_pem' => public_key_pem,
+          'encrypted_payload' => Base64.strict_encode64(encrypted_payload)
+        }
+
+        license_record = {
+          'license_id' => "lic_#{SecureRandom.hex(6)}",
+          'expires_at' => expires_at,
+          'aes_key_hex' => aes_key_hex,
+          'iv_hex' => iv_hex,
+          'created_at' => Date.today.to_s
+        }
+
+        { license_file: license_file, license_record: license_record }
+      end
+    end
+  end
+end

data/lib/ree/licensing/obfuscator.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'date'
+
+module Ree
+  module Licensing
+    class Obfuscator
+      def self.run(source_path:, target_path:, client_id:, expires_at:, clients_dir:, exclude_files: [], stdout: $stdout)
+        new(
+          source_path: source_path,
+          target_path: target_path,
+          client_id: client_id,
+          expires_at: expires_at,
+          clients_dir: clients_dir,
+          exclude_files: exclude_files,
+          stdout: stdout
+        ).run
+      end
+
+      def initialize(source_path:, target_path:, client_id:, expires_at:, clients_dir:, exclude_files: [], stdout: $stdout)
+        @source_path = File.expand_path(source_path)
+        @target_path = File.expand_path(target_path)
+        @client_id = client_id
+        @expires_at = expires_at
+        @clients_dir = clients_dir
+        @exclude_files = exclude_files
+        @stdout = stdout
+      end
+
+      def run
+        start_time = Time.now
+
+        store = ClientStore.new(@clients_dir)
+        client = store.find_client(@client_id)
+        raise Ree::Error.new("Client #{@client_id} not found in clients.json") unless client
+
+        copy_project
+        remove_spec_dirs
+
+        aes_data = Encryptor.generate_aes_key
+        aes_key = aes_data[:key]
+        iv = aes_data[:iv]
+        aes_key_hex = aes_key.unpack1('H*')
+        iv_hex = iv.unpack1('H*')
+
+        encrypted_count = encrypt_ruby_files(aes_key, iv)
+
+        result = LicenseGenerator.generate(
+          client_id: @client_id,
+          private_key_pem: client['private_key_pem'],
+          public_key_pem: client['public_key_pem'],
+          aes_key_hex: aes_key_hex,
+          iv_hex: iv_hex,
+          expires_at: @expires_at
+        )
+
+        license_path = File.join(@target_path, 'license.json')
+        File.write(license_path, JSON.pretty_generate(result[:license_file]))
+
+        store.add_license(@client_id, result[:license_record])
+
+        elapsed = (Time.now - start_time).round(2)
+        @stdout.puts "Obfuscation complete:"
+        @stdout.puts "  Files encrypted: #{encrypted_count}"
+        @stdout.puts "  License file: #{license_path}"
+        @stdout.puts "  Time: #{elapsed}s"
+
+        { encrypted_count: encrypted_count, license_path: license_path }
+      end
+
+      private
+
+      def copy_project
+        FileUtils.rm_rf(@target_path) if Dir.exist?(@target_path)
+        FileUtils.cp_r(@source_path, @target_path)
+      end
+
+      def remove_spec_dirs
+        Dir.glob(File.join(@target_path, '**/spec')).each do |spec_dir|
+          FileUtils.rm_rf(spec_dir) if File.directory?(spec_dir)
+        end
+      end
+
+      def encrypt_ruby_files(aes_key, iv)
+        count = 0
+        pattern = File.join(@target_path, '**/package/**/*.rb')
+
+        Dir.glob(pattern).each do |file_path|
+          basename = File.basename(file_path)
+          next if @exclude_files.include?(basename)
+
+          source = File.read(file_path)
+          if source.include?('require_relative')
+            raise Ree::Error.new("File contains require_relative: #{file_path}")
+          end
+
+          bytecode = BytecodeCompiler.compile_file(file_path)
+          encrypted = Encryptor.aes_encrypt(bytecode, aes_key, iv)
+          File.binwrite(file_path, encrypted)
+          count += 1
+        end
+
+        count
+      end
+    end
+  end
+end

data/lib/ree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ree
-  VERSION = "1.2.3"
+  VERSION = "1.2.6"
 end

data/lib/ree.rb

@@ -53,6 +53,15 @@ module Ree
   autoload :TemplateHandler, 'ree/handlers/template_handler'
   autoload :TemplateRenderer, 'ree/templates/template_renderer'
 
+  module Licensing
+    autoload :ClientStore, 'ree/licensing/client_store'
+    autoload :Encryptor, 'ree/licensing/encryptor'
+    autoload :Decryptor, 'ree/licensing/decryptor'
+    autoload :BytecodeCompiler, 'ree/licensing/bytecode_compiler'
+    autoload :LicenseGenerator, 'ree/licensing/license_generator'
+    autoload :Obfuscator, 'ree/licensing/obfuscator'
+  end
+
   PACKAGE = 'package'
   SCHEMAS = 'schemas'
   SCHEMA = 'schema'
@@ -124,6 +133,20 @@ module Ree
       !!@benchmark_mode
     end
 
+    def obfuscated?
+      ENV.has_key?('REE_LICENSE_KEY')
+    end
+
+    def license
+      @license ||= if obfuscated?
+        Ree::Licensing::Decryptor.load_license(ENV['REE_LICENSE_KEY'])
+      end
+    end
+
+    def reset_license
+      @license = nil
+    end
+
     def method_added_plugins
       @method_added_plugins ||= []
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ree
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.6
 platform: ruby
 authors:
 - Ruslan Gatiyatov
@@ -37,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.6.5
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -86,6 +100,9 @@ files:
 - lib/ree/cli/indexing/index_package.rb
 - lib/ree/cli/indexing/index_project.rb
 - lib/ree/cli/init.rb
+- lib/ree/cli/licensing/obfuscate.rb
+- lib/ree/cli/licensing/register_client.rb
+- lib/ree/cli/licensing/renew_license.rb
 - lib/ree/cli/spec_runner.rb
 - lib/ree/container.rb
 - lib/ree/contracts.rb
@@ -166,6 +183,12 @@ files:
 - lib/ree/gen/package.rb
 - lib/ree/handlers/template_handler.rb
 - lib/ree/inspectable.rb
+- lib/ree/licensing/bytecode_compiler.rb
+- lib/ree/licensing/client_store.rb
+- lib/ree/licensing/decryptor.rb
+- lib/ree/licensing/encryptor.rb
+- lib/ree/licensing/license_generator.rb
+- lib/ree/licensing/obfuscator.rb
 - lib/ree/link_dsl.rb
 - lib/ree/method_added_hook.rb
 - lib/ree/object_compiler.rb