modulation 0.31 → 1.0.1

data/lib/modulation/modules/bootstrap.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+export :run, :transform_module_info
+
+require 'zlib'
+
+def run(data, dict_offset)
+  setup(data, dict_offset)
+  import(@dictionary[:entry_point]).send(:main)
+end
+
+def setup(data, dict_offset)
+  patch_builder
+  @data = data
+  @data_offset = data.pos
+  @dictionary = read_dictionary(dict_offset)
+end
+
+def patch_builder
+  class << Modulation::Builder
+    alias_method :orig_make, :make
+    def make(info)
+      info = MODULE.transform_module_info(info)
+      orig_make(info)
+    end
+  end
+end
+
+def transform_module_info(info)
+  location = info[:location]
+  info[:source] = read_file(location) if location
+  info
+end
+
+def find(path)
+  @dictionary[path]
+end
+
+def read_dictionary(offset)
+  @data.seek(@data_offset + offset)
+  eval Zlib::Inflate.inflate(@data.read)
+end
+
+def read_file(path)
+  (offset, length) = @dictionary[path]
+  @data.seek(@data_offset + offset)
+  Zlib::Inflate.inflate(@data.read(length))
+end

data/lib/modulation/modules/cli.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+export_default :CLI
+
+# Command line interface functionality
+class CLI
+  def initialize(argv)
+    @argv = argv
+
+    process
+  end
+
+  def process
+    cmd = ARGV.shift
+    if respond_to? cmd.to_sym
+      send cmd
+    else
+      ARGV.unshift cmd
+      run
+    end
+  end
+
+  def run
+    @argv.each { |arg| run_file arg }
+  rescue StandardError => e
+    cleanup_backtrace(e)
+    raise e
+  end
+
+  def run_file(arg)
+    fn, method = filename_and_method_from_arg(arg)
+    mod = import(File.expand_path(fn))
+    mod.send(method) if method
+  end
+
+  FILENAME_AND_METHOD_RE = /^([^\:]+)\:(.+)$/.freeze
+
+  def filename_and_method_from_arg(arg)
+    if arg =~ FILENAME_AND_METHOD_RE
+      match = Regexp.last_match
+      [match[1], match[2].to_sym]
+    else
+      [arg, :main]
+    end
+  end
+
+  BACKTRACE_RE = /^(#{Modulation::DIR})|(bin\/mdl)/.freeze
+
+  def cleanup_backtrace(error)
+    backtrace = error.backtrace.reject { |l| l =~ BACKTRACE_RE }
+    error.set_backtrace(backtrace)
+  end
+
+  def collect_deps(path, array)
+    if File.directory?(path)
+      Dir["#{path}/**/*.rb"].each { |fn| collect_deps(fn, array) }
+    else
+      array << File.expand_path(path)
+      mod = import(File.expand_path(path))
+      if mod.respond_to?(:__traverse_dependencies)
+        mod.__traverse_dependencies { |m| array << m.__module_info[:location] }
+      end
+    end
+  end
+
+  def deps
+    paths = []
+    @argv.each { |arg| collect_deps(arg, paths) }
+    puts(*paths)
+  end
+
+  def pack
+    STDOUT << import('@modulation/packer').pack(@argv, hide_filenames: true)
+  end
+
+  def version
+    puts "Modulation version #{Modulation::VERSION}"
+  end
+end

data/lib/modulation/modules/creator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+export :from_block,
+       :from_hash,
+       :from_string
+
+RE_ATTR = /^@(.+)$/.freeze
+
+def from_block(block)
+  Module.new.tap { |m| m.instance_eval(&block) }
+end
+
+# Creates a module from a prototype hash
+# @param hash [Hash] prototype hash
+# @return [Module] created object
+def from_hash(hash)
+  Module.new.tap do |m|
+    s = m.singleton_class
+    hash.each { |k, v| process_hash_entry(k, v, m, s) }
+  end
+end
+
+def process_hash_entry(key, value, mod, singleton)
+  if key =~ Modulation::RE_CONST
+    mod.const_set(key, value)
+  elsif key =~ RE_ATTR
+    mod.instance_variable_set(key, value)
+  elsif value.respond_to?(:to_proc)
+    singleton.send(:define_method, key) { |*args| instance_exec(*args, &value) }
+  else
+    singleton.send(:define_method, key) { value }
+  end
+end
+
+def from_string(str)
+  Modulation::Builder.make(source: str)
+end

data/lib/modulation/modules/packer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+export :pack
+
+require 'modulation/version'
+require 'zlib'
+
+BOOTSTRAP_CODE = <<~SRC
+  # encoding: ASCII-8BIT
+  require 'bundler/inline'
+
+  gemfile do
+    source 'https://rubygems.org'
+    gem 'modulation', '~> %<modulation_version>s'
+  end
+
+  import('@modulation/bootstrap').run(DATA, %<dict_offset>d)
+  __END__
+  %<data>s
+SRC
+
+def pack(paths, _options = {})
+  paths = [paths] unless paths.is_a?(Array)
+  entry_point_filename = File.expand_path(paths.first)
+
+  deps = collect_dependencies(paths)
+  package_info = generate_packed_data(deps, entry_point_filename)
+  generate_bootstrap(package_info, entry_point_filename)
+end
+
+def collect_dependencies(paths)
+  paths.each_with_object([]) do |fn, deps|
+    mod = import(File.expand_path(fn))
+    deps << File.expand_path(fn)
+    mod.__traverse_dependencies { |m| deps << m.__module_info[:location] }
+  end
+end
+
+def generate_packed_data(deps, entry_point_filename)
+  files = deps.each_with_object({}) do |path, dict|
+    dict[path] = IO.read(path)
+  end
+  pack_files(files, entry_point_filename)
+end
+
+def pack_files(files, entry_point_filename)
+  dictionary = { entry_point: entry_point_filename }
+  data = (+'').encode('ASCII-8BIT')
+  last_offset = 0
+  files.each_with_object(dictionary) do |(path, content), dict|
+    last_offset = add_packed_file(path, content, data, dict, last_offset)
+  end
+  data << Zlib::Deflate.deflate(dictionary.inspect)
+
+  { dict_offset: last_offset, data: data }
+end
+
+def add_packed_file(path, content, data, dict, last_offset)
+  zipped = Zlib::Deflate.deflate(content)
+  size = zipped.bytesize
+
+  data << zipped
+  dict[path] = [last_offset, size]
+  last_offset + size
+end
+
+def generate_bootstrap(package_info, _entry_point)
+  format(
+    bootstrap_template,
+    modulation_version: Modulation::VERSION,
+    dict_offset:        package_info[:dict_offset],
+    data:               package_info[:data]
+  )
+end
+
+def bootstrap_template
+  BOOTSTRAP_CODE.encode('ASCII-8BIT').gsub(/^\s+/, '').chomp
+end

data/lib/modulation/paths.rb

@@ -5,7 +5,8 @@ module Modulation
   module Paths
     class << self
       def process(path, caller_location)
-        tagged_path(path) || absolute_path(path, caller_location) ||
+        path = expand_tag(path)
+        absolute_path(path, caller_location) ||
           lookup_gem_path(path)
       end
 
@@ -13,27 +14,32 @@ module Modulation
       CALLER_FILE_REGEXP = /^([^\:]+)\:?/.freeze
       TAGGED_REGEXP = /^@([^\/]+)(\/.+)?$/.freeze
 
-      def add_tags(tags, caller_location)
+      def tags
+        @tags ||= {
+          'modulation' => modules_path
+        }
+      end
+
+      def modules_path
+        File.join(Modulation::DIR, 'modulation/modules')
+      end
+
+      def add_tags(new_tags, caller_location)
         caller_file = caller_location[CALLER_FILE_REGEXP, 1]
         caller_dir = caller_file ? File.dirname(caller_file) : nil
 
-        @tags ||= {}
-        tags.each do |k, path|
-          @tags[k.to_s] = caller_dir ? File.expand_path(path, caller_dir) : path
+        new_tags.each do |k, path|
+          tags[k.to_s] = caller_dir ? File.expand_path(path, caller_dir) : path
         end
       end
 
-      def tagged_path(path)
-        return nil unless @tags
+      RE_TAG = /^@([^\/]+)/.freeze
 
-        _, tag, path = path.match(TAGGED_REGEXP).to_a
-        return nil unless tag
-
-        base_path = @tags[tag]
-        return nil unless base_path
-
-        path = path ? File.join(base_path, path) : base_path
-        check_path(path)
+      def expand_tag(path)
+        path.sub RE_TAG do
+          tag = Regexp.last_match[1]
+          tags[tag] || (raise "Invalid tag #{tag}")
+        end
       end
 
       # Resolves the absolute path to the provided reference. If the file is not
@@ -54,6 +60,7 @@ module Modulation
       # @param caller_location [String] caller location
       # @return [String] absolute directory path
       def absolute_dir_path(path, caller_location)
+        path = expand_tag(path)
         caller_file = caller_location[CALLER_FILE_REGEXP, 1]
         return nil unless caller_file
 

data/lib/modulation/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Modulation
-  VERSION = '0.31'
+  VERSION = '1.0.1'
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: modulation
 version: !ruby/object:Gem::Version
-  version: '0.31'
+  version: 1.0.1
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-28 00:00:00.000000000 Z
+date: 2021-04-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -56,12 +84,16 @@ files:
 - lib/modulation.rb
 - lib/modulation/builder.rb
 - lib/modulation/core.rb
-- lib/modulation/default_export.rb
+- lib/modulation/export_default.rb
+- lib/modulation/export_from_receiver.rb
 - lib/modulation/exports.rb
 - lib/modulation/ext.rb
 - lib/modulation/gem.rb
 - lib/modulation/module_mixin.rb
-- lib/modulation/packer.rb
+- lib/modulation/modules/bootstrap.rb
+- lib/modulation/modules/cli.rb
+- lib/modulation/modules/creator.rb
+- lib/modulation/modules/packer.rb
 - lib/modulation/paths.rb
 - lib/modulation/version.rb
 homepage: http://github.com/digital-fabric/modulation
@@ -88,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: 'Modulation: explicit dependency management for Ruby'

data/lib/modulation/packer.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../modulation'
-require_relative '../modulation/version'
-require 'zlib'
-
-module Modulation
-  # Implements packing functionality
-  module Packer
-    BOOTSTRAP_CODE = <<~SRC
-      # encoding: ASCII-8BIT
-      require 'bundler/inline'
-
-      gemfile do
-        source 'https://rubygems.org'
-        gem 'modulation', '~> %<modulation_version>s', require: 'modulation/packer'
-      end
-
-      Modulation::Bootstrap.setup(DATA, %<dictionary>s)
-      import(%<entry_point>s).send(:main)
-      __END__
-      %<data>s
-    SRC
-
-    def self.pack(paths, _options = {})
-      paths = [paths] unless paths.is_a?(Array)
-      deps = collect_dependencies(paths)
-      entry_point_filename = File.expand_path(paths.first)
-      dictionary, data = generate_packed_data(deps)
-      generate_bootstrap(dictionary, data, entry_point_filename)
-    end
-
-    def self.collect_dependencies(paths)
-      paths.each_with_object([]) do |fn, deps|
-        mod = import(File.expand_path(fn))
-        deps << File.expand_path(fn)
-        mod.__traverse_dependencies { |m| deps << m.__module_info[:location] }
-      end
-    end
-
-    def self.generate_packed_data(deps)
-      files = deps.each_with_object({}) do |path, dict|
-        dict[path] = IO.read(path)
-      end
-      pack_files(files)
-    end
-
-    def self.pack_files(files)
-      data = (+'').encode('ASCII-8BIT')
-      last_offset = 0
-      dictionary = files.each_with_object({}) do |(path, content), dict|
-        zipped = Zlib::Deflate.deflate(content)
-        size = zipped.bytesize
-
-        data << zipped
-        dict[path] = [last_offset, size]
-        last_offset += size
-      end
-      [dictionary, data]
-    end
-
-    def self.generate_bootstrap(dictionary, data, entry_point)
-      format(bootstrap_template, modulation_version: Modulation::VERSION,
-                                 dictionary: dictionary.inspect,
-                                 entry_point: entry_point.inspect,
-                                 data: data)
-    end
-
-    def self.bootstrap_template
-      BOOTSTRAP_CODE.encode('ASCII-8BIT').gsub(/^\s+/, '').chomp
-    end
-  end
-
-  # Packed app bootstrapping code
-  module Bootstrap
-    def self.setup(data, dictionary)
-      patch_builder
-      @data = data
-      @data_offset = data.pos
-      @dictionary = dictionary
-    end
-
-    def self.patch_builder
-      class << Modulation::Builder
-        alias_method :orig_make, :make
-        def make(info)
-          if Modulation::Bootstrap.find(info[:location])
-            info[:source] = Modulation::Bootstrap.read(info[:location])
-          end
-          orig_make(info)
-        end
-      end
-    end
-
-    def self.find(path)
-      @dictionary[path]
-    end
-
-    def self.read(path)
-      (offset, length) = @dictionary[path]
-      @data.seek(@data_offset + offset)
-      Zlib::Inflate.inflate(@data.read(length))
-    end
-  end
-end