rubyjs-vite 1.1.3 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 576fb17b237ee647e5d9f84e0ff5cbc365f79e982586ff2e8fa84830e66dbea3
-  data.tar.gz: 260eefacab7d61466718240bd85c3c3363b469e9b75966a2af746f3790e4f552
+  metadata.gz: 0e448860a7ddcb9e6dafe089169a1540b2e02d7b8e579b8ea0c0ff665f9f3970
+  data.tar.gz: 07332aaa9d963717b44db9204817dcc24a9ea59dc8024aa818b5cc5edbfa37ba
 SHA512:
-  metadata.gz: d1885cc6c4d236704619bb3493e47e831a1221c187f0cbf4b5c08ab031ef8c359466a54cf3a0b92ee909cc8c0509cfa01f080239929e26107a44a3fb499a891d
-  data.tar.gz: ba9cbe7ef7845fcaef87f8b2bf2b2a16f79733415b8fdf933715075b5a614acb046359b969a45941d63d0094ad4bb3304f6eaa66d43a83ff314da32a43115de9
+  metadata.gz: aec8b571b7827c6e7414500e61e89ab4ea01a6d9089a26e0bc0fbfb5207e0170c1cf305fa2e690e3d1874d54dd8c0808e0891c5338e88616078a28c49c2dfed3
+  data.tar.gz: 48fefe6f420e47046f03cc2d11c75949840b21b460b613a9a0c4367811f8514e90169e9f78f552f856c785b551188f7dd123214bcedc47365e6a34e21f9adf06

data/bin/rjsv

@@ -1,5 +1,9 @@
 #!/usr/bin/env ruby
-$: << File.expand_path("../lib", __dir__)
 
+APP_NAME = File.basename($0)
 ROOT = File.expand_path("..", __dir__)
-require_relative "../app/main"
+$: << File.join(ROOT, 'lib')
+
+require 'rjsv'
+
+RJSV.main()

data/lib/option_parser.rb

@@ -62,8 +62,12 @@ class OptionParser
                 end
             end
         else
-            flag = @flags[0]
-            flag[:block].call
+            @flags.each do |flag|
+                if flag[:short_flag] == '-h' or flag[:long_flag] == '--help'
+                    flag[:block].call
+                    break
+                end
+            end
         end
     end
 

data/lib/rjsv/cli/arguments.rb

@@ -0,0 +1,77 @@
+module RJSV
+  module CLI
+    ##
+    # Module for all arguments to the CLI application.
+    # The argument initializes the OptionParser,
+    # which defines the arguments in detail.
+    # It is also nested with a function that adds
+    # all arguments from modules.
+
+    module Arguments
+      @options = {
+        translate: false,
+        watch:   false,
+        source:  Dir.pwd,
+        output:  Dir.pwd,
+      }
+
+      OptionParser.parse do |parser|
+        parser.banner(
+          "A transpiler tool that translates code\n" +
+          "from Ruby to JS language and transforms it into\n" +
+          "files that are readable by browsers.\n\n" +
+          "Usage: #{APP_NAME} [options]\n" +
+          "\nOptions:"
+        )
+
+        Plugins.add_arguments(parser)
+
+        parser.on( "-w", "--watch", "Monitors all RB files in real time\n" +
+                                    "to see if they have been modified." ) do
+          @options[:watch] = true
+        end
+        parser.on( "-t", "--translate", "It translates all loaded RB files\n" +
+                                        "into JavaScript code and stores them\n" +
+                                        "in certain type files." ) do
+          @options[:translate] = true
+        end
+        parser.on("-s DIR", "--source DIR", "The path of the source folder where\n" +
+                                            "all RB files are found (example of\n" +
+                                            "ending file type *.js.#{RJSV::Constants::SUFFIX_RB}).\n") do |dir|
+          @options[:source] = dir
+        end
+        parser.on("-o DIR", "--output DIR", "The path of the output folder where\n" +
+                                            "all Ruby codes will be translated into\n" +
+                                            "JavaScript with the prepared file type." ) do |dir|
+          @options[:output] = dir
+        end
+
+        parser.on( "-h", "--help", "Show help" ) do
+          puts parser
+          exit
+        end
+        parser.on( "-v", "--version", "Show version" ) do
+          puts "Version is #{RJSV::VERSION}"
+          exit
+        end
+      end
+
+      ##
+      # Options is a get method and gets
+      # all options from arguments.
+      
+      def self.options
+        @options
+      end
+
+      ##
+      # It finds out if the plugin is written in the argument.
+
+      def self.active_plugin?
+        unless ARGV.empty?
+          return ARGV[0].index(/^-/) == nil
+        end
+      end
+    end#Arguments
+  end
+end

data/lib/rjsv/cli/plugins.rb

@@ -0,0 +1,72 @@
+module RJSV
+  module CLI
+    ##
+    # This is the module that handles plugins so
+    # that they are found, imported and inizialized.
+
+    module Plugins
+      PLUGIN_INFO = "(this is a plugin)"
+
+      module_function
+
+      ##
+      # Finds all init.rb files in the plugins folder.
+      # Otherwise, the absolute path is determined
+      # by the Dir.pwd() method.
+
+      def find_all_init(path = Dir.pwd)
+        l_path = lambda { |p| File.join(p, 'plugins', '**', 'init.rb') }
+        Dir.glob [
+          l_path.call(path),
+          l_path.call(ROOT),
+          l_path.call(File.join(Dir.home, '.rjsv'))
+        ]
+      end
+
+      ##
+      # Imports all found init.rb files into Ruby script.
+      #
+      # Returns the classes that are imported,
+      # otherwise returns an empty array.
+
+      def require_all_init()
+        find_all_init().each do |plugin_index_path|
+          require plugin_index_path
+        end
+
+        if defined?(RJSV::Plugins)
+          return Core::Constants.get_classes(RJSV::Plugins)
+        end
+
+        return []
+      end
+
+      ##
+      # Adds a plugin argument and initializes its nested arguments.
+      #
+      # It chooses the name and description of the argument
+      # to be the one written on behalf of the plugin, 
+      # which is found from the RJSV::Plugin class.
+
+      def add_arguments(parser)
+        @classes.each_with_index do |plugin_class, i|
+          begin
+            if plugin_class
+              plugin = plugin_class.new
+              parser.on(plugin.name, "", "#{plugin.description}\n" +
+                  "#{PLUGIN_INFO}#{"\n" if @classes.length == i+1}" ) do
+                plugin.arguments()
+                plugin.init()
+              end
+            end
+          rescue => exception
+            Core::Event.print('class', "The program found the '#{plugin_class.name}' class, " +
+                                        "but its arguments cannot be created.\n\n")
+          end
+        end
+      end#add_arguments
+
+      @classes = require_all_init()
+    end
+  end
+end

data/lib/rjsv/cli/signals.rb

@@ -0,0 +1,15 @@
+module RJSV
+  module CLI
+    ##
+    # Dedicated to all signals for Unix system.
+    # Here we find the signal for INT.
+
+    module Signals
+      Signal.trap("INT") do
+        puts
+        Core::Event.print("exiting")
+        exit
+      end
+    end
+  end
+end

data/lib/rjsv/cli/states.rb

@@ -0,0 +1,68 @@
+module RJSV
+  module CLI
+    ##
+    # Here are the code blocks that are activated when
+    # the main function is triggered.
+    # Functions communicate using arguments passed via
+    # the command line, which are passed as options_cli.
+    # These functions include translate and watch,
+    # which can be reused when creating custom plugins.
+
+    module States
+      module_function
+
+      ##
+      # Block of code that handles the transpilation of script.
+      # This is opening a Ruby script container file,
+      # which is then converted into a JavaScript file.
+      # The file is saved to the output path.
+
+      def translate_state(path, options_cli)
+        if options_cli[:translate]
+          content_ruby = Core::Files.open(path)
+          if content_ruby && path
+            path_output = Core::Files.change_path_to_output(path, options_cli)
+            RJSV::Translate.ruby_to_js_with_write(content_ruby, path_output) do |err|
+              Core::Event.print('error', "#{path.sub(File.join(Dir.pwd, ''), '')} #{err}")
+              return
+            end
+            Core::Event.print('translated', path_output)
+          end
+        end
+      end
+
+      ##
+      # Block of code that tracks files under the input path.
+      # If a file has been logged, several events are performed
+      # such as to add, modify and remove logged files.
+      # These then trigger procedural methods to process the requests.
+
+      def watch_state(options_cli)
+        if options_cli[:watch]
+          Core::Event.print('message', 'There is now a watch for edited files.')
+          RJSV::Watch.modified_files(options_cli[:source]) do |modified, added, removed|
+            unless added.empty?
+              added.each do |path|
+                translate_state(path, options_cli)
+              end
+            end
+        
+            unless modified.empty?
+              modified.each do |path|
+                translate_state(path, options_cli)
+              end
+            end
+        
+            unless removed.empty?
+              removed.each do |path|
+                path_output = Core::Files.change_path_to_output(path, options_cli)
+                Core::Files.remove(path_output)
+                Core::Event.print('deleted', path_output)
+              end
+            end
+          end
+        end
+      end#watch_state
+    end#States
+  end
+end

data/lib/rjsv/constants.rb

@@ -0,0 +1,8 @@
+module RJSV
+  ##
+  # All constant variables.
+
+  module Constants
+    SUFFIX_RB = 'rb'
+  end
+end

data/lib/rjsv/core/constants.rb

@@ -0,0 +1,31 @@
+module RJSV
+  module Core
+    ##
+    # The module is reserved for handling classes and modules.
+    # Thus, it is a manipulation of constant keywords.
+
+    module Constants
+      module_function
+
+      ##
+      # This method tries to find already initialized
+      # classes from the mod (module) using the abstract
+      # class RJSV::Plugin. It returns an array of classes.
+
+      def get_classes(mod)
+        mod.constants.map do |c|
+          const = mod.const_get(c)
+
+          if const.is_a?(Class) &&
+              const.superclass.name == 'RJSV::Plugin'
+            const
+          elsif const.is_a? Module
+            get_classes(const)
+          else
+            next
+          end
+        end.flatten.compact
+      end#get_classes
+    end
+  end
+end

data/lib/rjsv/core/event.rb

@@ -0,0 +1,24 @@
+module RJSV
+  module Core
+    ##
+    # Event module for handling fifo events. This is
+    # so far a module for just the basic event
+    # printing element.
+
+    module Event
+      module_function
+
+      ##
+      # Prints an event type using the puts() method
+      # that shows the time, cli application name,
+      # event and event message.
+
+      def print(event, message = "")
+        supplement = message.empty? ? message : " | #{message}"
+
+        puts "#{Time.now.strftime("%l:%M:%S %p").lstrip} " +
+        "[#{APP_NAME}] #{event.upcase}#{supplement}"
+      end
+    end
+  end
+end

data/lib/rjsv/core/files.rb

@@ -0,0 +1,95 @@
+module RJSV
+  module Core
+    ##
+    # The file module ensures safe handling of files.
+    # It always checks if a file really exists on
+    # the input path or if a certain folder exists
+    # on the output path. It can also change
+    # the absolute path or find all necessary files
+    # for further manipulation.
+
+    module Files
+      require 'fileutils'
+
+      module_function
+
+      ##
+      # Opens the file securely and returns the content
+      # from the file. If the file does not exist,
+      # it returns nil.
+
+      def open(path)
+        if File.exist? path
+          File.open path do |f|
+            return f.read
+          end
+        end
+
+        return nil
+      end
+
+      ##
+      # Stores the file with the assigned container
+      # by safely discovering its folder and, if necessary,
+      # creating it when it does not exist in the path.
+      # It can also be assigned a file write mode.
+
+      def write_with_dir(content, path, mode = 'w+')
+        unless Dir.exist? File.dirname(path)
+          FileUtils.mkdir_p File.dirname(path)
+        end
+
+        File.open path, mode do |f|
+          f.write(content)
+        end
+      end
+
+      ##
+      # Safely removes the file from the path.
+      # If the file is the last one in the folder,
+      # the folder is also deleted with the file.
+
+      def remove(path)
+        File.delete(path) if File.exist?(path)
+        path_dir = File.dirname(path)
+        Dir.delete(path_dir) if Dir.empty?(path_dir)
+      end
+
+      ##
+      # The method is special in that it examines arguments
+      # from the CLI and modifies the definition
+      # path for the output path.
+
+      def change_path_to_output(path, options_cli)
+        path.sub(options_cli[:source], options_cli[:output])
+            .sub(/\.#{RJSV::Constants::SUFFIX_RB}$/, '')
+            .sub(File.join(Dir.pwd(), ''), '')
+      end
+
+      ##
+      # Finds all files with the extension '.*.rb'
+      # from the defined path.
+
+      def find_all(path)
+        path_all = File.join(path, '**', '*')
+        Dir.glob("#{path_all}.*.#{RJSV::Constants::SUFFIX_RB}")
+      end
+
+      ##
+      # Copies all files from the input path to the
+      # output path. This is a method that copies all
+      # files even those that are invisible to the
+      # UNIX system (dot file).
+
+      def copy(path_input, path_output)
+        files = Dir.glob("#{path_input}/**/*", File::FNM_DOTMATCH)
+                .select { |f| File.file?(f) }
+        files.each do |path_file|
+          path_cp = path_file.sub(path_input, path_output)
+          FileUtils.mkdir_p File.dirname(path_cp)
+          FileUtils.cp(path_file, path_cp)
+        end
+      end
+    end
+  end
+end

data/lib/rjsv/plugin.rb

@@ -0,0 +1,55 @@
+module RJSV
+  ##
+  # Abstract 'class' for creating initialization plagins.
+  # They are teachable for defining basic information
+  # and is the starting point for triggering functions
+  # using the init() function. If we are creating
+  # a custom plugin, we need to inherit this 'class'
+  # into its own 'class'.
+
+  class Plugin
+    ##
+    # Description of the plugin that is printed to the CLI during help.
+
+    def description
+      abstract_error('description()')
+    end
+
+    ##
+    # This function is not mandatory and automatically
+    # defines the 'module' name according to
+    # the plugin 'module'.
+
+    def name
+      self.class.name.split('::')[-2].downcase
+    end
+
+    ##
+    # The method should pass an initialization
+    # method for all arguments of this plugin.
+
+    def arguments
+      abstract_error('arguments()')
+    end
+
+    ##
+    # The method that is the main initialization
+    # block for the code that the plugin
+    # should execute.
+
+    def init
+      abstract_error('init()')
+    end
+
+    private
+    ##
+    # A private method that raises an error
+    # message about an abstract class with
+    # a function name.
+
+    def abstract_error(fn_name)
+      raise "The '#{fn_name}' method is abstract, " +
+            "it needs to be implemented in a nested '#{self.class.name}' class."
+    end
+  end
+end

data/lib/rjsv/translate.rb

@@ -0,0 +1,40 @@
+module RJSV
+  ##
+  # Here we can load everything necessary for
+  # the transpilation process of Ruby script into JavaScript.
+  # The transpilation process uses the Ruby2JS library.
+  # The transpilation is safe and catches error messages
+  # if the Ruby script has been written incorrectly.
+
+  module Translate
+    require 'ruby2js'
+
+    module_function
+
+    ##
+    # Converts Ruby script to JavaScript using Ruby2JS library.
+    # If an error occurs during transpilation, the error
+    # message is raised in the next nested code block.
+
+    def ruby_to_js(content_ruby, &block)
+      begin
+        return Ruby2JS.convert(content_ruby)
+      rescue => exception
+        block.call(exception) if block
+        return nil
+      end
+    end
+
+    ##
+    # Converts Ruby script to JavaScript using Ruby2JS library.
+    # The final transpilation is followed by saving it to
+    # a file with a predefined path.
+
+    def ruby_to_js_with_write(content_ruby, path, &block)
+      content_js = ruby_to_js(content_ruby) do |err|
+        block.call(err) if block
+      end
+      Core::Files.write_with_dir(content_js, path) if content_js
+    end
+  end
+end

data/lib/rjsv/version.rb

@@ -0,0 +1,3 @@
+module RJSV
+  VERSION = '2.0.1'
+end

data/lib/rjsv/watch.rb

@@ -0,0 +1,35 @@
+module RJSV
+  ##
+  # Module for real-time monitoring of files on
+  # the local disk. It uses the 'listen' library
+  # for this function. There is only one method
+  # that can be loaded here which triggers everything.
+
+  module Watch
+    require "listen"
+
+    module_function
+
+    ##
+    # Tracks modified files in the path that is
+    # defined as the source directory. When this
+    # function is called, the event listener is triggered
+    # for events such as modified, added, and deleted
+    # file events. Therefore, the method can put
+    # the application to sleep and silently monitor
+    # the event process. It watches all files with
+    # extension '.*.rb', which asterisk means
+    # any sub extension such as '.js'.
+
+    def modified_files(path, &block)
+      listener = Listen.to(path,
+        only: /\..*\.#{Constants::SUFFIX_RB}$/
+      ) do |m, a, r|
+        
+        block.call(m, a, r) if block
+      end
+      listener.start
+      sleep
+    end
+  end
+end

data/lib/rjsv.rb

@@ -0,0 +1,53 @@
+require 'option_parser'
+require 'json_parser'
+
+require 'rjsv/version'
+require 'rjsv/constants'
+require 'rjsv/plugin'
+
+require 'rjsv/core/event'
+require 'rjsv/core/files'
+require 'rjsv/core/constants'
+
+require 'rjsv/translate'
+require 'rjsv/watch'
+
+require 'rjsv/cli/states'
+require 'rjsv/cli/signals'
+require 'rjsv/cli/plugins'
+require 'rjsv/cli/arguments'
+
+##
+# This is the main initialization module of
+# all modules that are needed for the functionality
+# of this RubyJS-Vite transpiler. The methods that
+# shape the direction of the application are
+# also written here.
+
+module RJSV
+  @options_cli = CLI::Arguments.options
+  
+  module_function
+
+  ##
+  # This is the main function to run the desired
+  # block function scenarios. In order to arm itself
+  # regarding plugins and directly Arguments,
+  # this method checks the accessibility of the plugin
+  # by checking if it is active or attached in
+  # the argument given by the confirmed command
+  # from the terminal.
+
+  def main()
+    unless CLI::Arguments.active_plugin?
+      if @options_cli[:translate]
+        files_rb = Core::Files.find_all(@options_cli[:source])
+        files_rb.each do |path|
+          CLI::States.translate_state(path, @options_cli)
+        end
+      end
+
+      CLI::States.watch_state(@options_cli)
+    end
+  end#main
+end

data/plugins/scaffold/lib/init.rb

@@ -0,0 +1,31 @@
+module RJSV
+  module Plugins
+    module Scaffold
+      require_relative './scaffold/cli/arguments'
+
+      require_relative './scaffold/vite'
+      require_relative './scaffold/states'
+      require_relative './scaffold/create'
+
+      class Init < RJSV::Plugin
+        def initialize
+          @arguments_cli = RJSV::Plugins::Scaffold::CLI::Arguments
+        end
+
+        def description
+          "Scaffolding can create new\n" +
+          "projects or create new elements."
+        end
+
+        def arguments
+          @arguments_cli.init(self)
+        end
+
+        def init()
+          Scaffold::States.create_web_state(@arguments_cli.options)
+          Scaffold::States.create_element_state(@arguments_cli.options)
+        end
+      end
+    end
+  end
+end