jets 0.2.0 → 0.5.0

data/lib/jets/commands/call/anonymous_guesser.rb

@@ -0,0 +1,96 @@
+class Jets::Commands::Call
+  class AnonymousGuesser < BaseGuesser
+    def detect_class_name
+      found_path = function_paths.find do |path|
+        File.exist?("#{Jets.root}#{path}")
+      end
+
+      klass = Jets::Klass.from_path(found_path) if found_path
+      klass.to_s
+    end
+
+    def method_name
+      return @method_name if defined?(@method_name)
+
+      full_function_name = @provided_function_name.underscore
+      underscored_class_name = class_name.underscore
+      meth = full_function_name.sub("#{underscored_class_name}_","")
+
+      if meth == class_name.constantize.handler.to_s
+        @method_name = meth
+      else
+        @method_name_error = "#{class_name} class found but #{meth} method not found"
+        @method_name = nil
+      end
+    end
+
+    # Useful to printing out what was attempted to look up
+    def error_message
+      guess_paths = function_paths
+      puts "Unable to find the function to call."
+      if class_name and !method_name
+        puts @method_name_error
+      else
+        puts "Tried: #{guess_paths.join(', ')}"
+      end
+    end
+
+    def function_filenames(meth=nil, primary_namespace=nil)
+      guesses = []
+      parts = meth.split('_')
+
+      if primary_namespace.nil?
+        guesses << meth
+
+        if parts.size == 1 # already on final_primary_namespace
+          return guesses # end of recursion
+        else
+          next_primary_namespace =  parts.first
+          guesses += function_filenames(meth, next_primary_namespace) # start of recursion
+          return guesses # return early
+        end
+      end
+
+      next_meth = meth.sub("#{primary_namespace}_", '')
+      next_parts = next_meth.split('_')
+
+      # Takes the next_parts and creates guesses with the parts joined by '/'
+      # with the primary_namespace prepended.  So if next_parts is
+      # ["long", "name", "function"] and primary_namespace is "complex"
+      #
+      # guesses that get added:
+      #
+      #   [
+      #     "complex/long_name_function",
+      #     "complex/long/name_function",
+      #     "complex/long/name/function",
+      #   ]
+      n = next_parts.size + 1
+      next_parts.size.times do |i|
+        namespace = i == 0 ? nil : next_parts[0..i-1].join('/')
+        class_path = next_parts[i..-1].join('_')
+        guesses << [primary_namespace, namespace, class_path].compact.join('/')
+      end
+
+      final_primary_namespace = parts[0..-2].join('_')
+      if primary_namespace == final_primary_namespace
+        return guesses # end of recursion
+      else
+        namespace_size = parts.size - next_parts.size
+        next_primary_namespace = parts[0..namespace_size].join('_')
+        guesses += function_filenames(meth, next_primary_namespace)
+        return guesses
+      end
+    end
+
+    def function_paths
+      # drop the last word for starting filename
+      starting_filename = @provided_function_name.underscore.split('_')[0..-2].join('_')
+      filenames = function_filenames(starting_filename)
+      filenames.map do |name|
+        "app/functions/#{name}.rb"
+      end
+    end
+
+  end
+end

data/lib/jets/commands/call/autoload_guesser.rb

@@ -0,0 +1,112 @@
+class Jets::Commands::Call
+  class AutoloadGuesser < BaseGuesser
+    def detect_class_name
+      guess_classes.each do |class_name_guess|
+        begin
+          class_name_guess.constantize
+          return class_name_guess # if there's no error then the class is found
+        rescue NameError
+          if out_of_guesses(class_name_guess)
+            # puts "Unable to find the class to call. Tried guessing: #{guess_classes[0..-2].join(', ')}."
+            # raise # re-raise NameError for now but maybe better to provide
+              # a custom error class, so we can rescue it and provide a
+              # friendly message to the user
+          else
+            next
+          end
+        end
+      end
+
+      nil
+    end
+
+    def method_name
+      return @method_name if defined?(@method_name)
+      return nil unless class_name
+
+      underscored_class_name = class_name.underscore.gsub('/','_')
+      underscored_function_name = @provided_function_name.underscore.gsub('/','_')
+      meth = underscored_function_name.sub(underscored_class_name, '')
+      meth = meth.sub(/^[-_]/,'') # remove leading _ or -
+
+      if class_name.constantize.tasks.map(&:meth).include?(meth.to_sym)
+        @method_name = meth
+      else
+        @method_name_error ="#{class_name} class found but #{meth} method not found"
+        @method_name = nil
+      end
+    end
+
+    # Useful to printing out what was attempted to look up
+    def error_message
+      guesses = guess_classes
+      puts "Unable to find the function to call."
+      if class_name and !method_name
+        puts @method_name_error
+      else
+        puts "Tried: #{guesses.join(', ')}"
+      end
+    end
+
+    def process_type
+      if @provided_function_name =~ /[-_]controller/
+        "controller"
+      elsif @provided_function_name =~ /[-_]job/
+        "job"
+      elsif @provided_function_name =~ /[-_]rule/
+        "rule"
+      else
+        "function"
+      end
+    end
+
+    def process_type_pattern
+      Regexp.new("[-_]#{process_type}[-_](.*)")
+    end
+
+    # Strips the action because we dont want it to guess the class name
+    # So:
+    #   admin-related-pages => admin_related_pages_controller
+    def underscored_name
+      # strip action and concidentally the _controller_ string
+      name = @provided_function_name.sub(process_type_pattern,'')
+      # Ensure _controller or _job at the end except for simple functions
+      unless process_type == "function"
+        name = name.gsub('-','_') + "_#{process_type}"
+      end
+      name
+    end
+
+    # Guesses autoload paths.
+    #
+    # underscored_name: admin_related_pages_controller
+    # Returns:
+    #   [
+    #     "admin_related_pages_controller",
+    #     "admin/related_pages_controller",
+    #     "admin_related/pages_controller",
+    #     "admin_related_pages/controller",
+    #   ]
+    def autoload_paths
+      guesses = []
+
+      parts = underscored_name.split('_')
+      parts.size.times do |i|
+        namespace = i == 0 ? nil : parts[0..i-1].join('/')
+        class_path = parts[i..-1].join('_')
+        guesses << [namespace, class_path].compact.join('/')
+      end
+
+      guesses
+    end
+
+    def guess_classes
+      autoload_paths.map(&:classify)
+    end
+
+    def out_of_guesses(guess)
+      guess.include?("::Controller")
+    end
+
+  end
+end

data/lib/jets/commands/call/base_guesser.rb

@@ -0,0 +1,33 @@
+# Subclasses of BaseGuessor must implement interface:
+#   detect_class_name
+#   method_name
+#   error_message
+#
+class Jets::Commands::Call
+  class BaseGuesser
+    # provided_function_name:
+    #   admin/related_pages_controller-list_all
+    #   admin-related-pages-controller-list-all
+    def initialize(provided_function_name)
+      @provided_function_name = provided_function_name
+    end
+
+    def class_name
+      return @class_name if @detection_ran
+
+      @class_name = detect_class_name
+      @detection_ran = true
+      @class_name
+    end
+
+    def function_name
+      # Strip the project namespace if the user has accidentally added it
+      # Since we're going to automatically add it no matter what at the end
+      # and dont want the namespace to be included twice
+      @provided_function_name = @provided_function_name.sub("#{Jets.config.project_namespace}-", "")
+
+      code_path = class_name.underscore.gsub('/','-')
+      function_name = [Jets.config.project_namespace, code_path, method_name].join('-')
+    end
+  end
+end

data/lib/jets/commands/call/guesser.rb

@@ -0,0 +1,51 @@
+require "active_support/core_ext/hash"
+require "active_support/core_ext/object"
+
+# Guesser transforms the user provided function name to the actual lambda
+# function name.
+#
+# Allow for variety of different inputs to work:
+# Simple:
+#   admin/pages_controller-index => admin-pages_controller-index
+#   admin-pages_controller-index => admin-pages_controller-index
+#
+# Complex, requires detecting the right class name:
+#   admin/related_pages_controller-list_all
+#   admin-related-pages-controller-list-all
+#
+# All still result in: admin-related_pages_controller-index
+#
+# The detection process follows. Given worse case:
+#   admin-related-pages-controller-list-all
+#
+# Know that the action comes after controller, try:
+#   AdminRelatedPagesController
+#   Admin::RelatedPagesController <= found stop guessing
+#
+# admin/related_pages_controller <= underscored
+# admin/related_pages_controller-list_all <= add action back on
+# admin-related_pages_controller-list_all <= gsub / - DONE
+#
+# Now we're at a point where we can start guessing
+# function_name = detect_function_name(function_name)
+class Jets::Commands::Call
+  class Guesser
+    delegate :class_name, :method_name, :error_message, :function_name,
+      to: :delegate_guesser
+
+    # Example of provided_function_name:
+    #   admin/related_pages_controller-list_all
+    #   admin-related-pages-controller-list-all
+    def initialize(provided_function_name)
+      @provided_function_name = provided_function_name
+    end
+
+    def delegate_guesser
+      @delegate_guesser ||= if @provided_function_name =~ /[-_](controller|job|rule)/
+                              AutoloadGuesser.new(@provided_function_name)
+                            else
+                              AnonymousGuesser.new(@provided_function_name)
+                            end
+    end
+  end
+end

data/lib/jets/commands/console.rb

@@ -0,0 +1,12 @@
+class Jets::Commands::Console
+  def self.run
+    puts Jets::Booter.message
+
+    # Thanks: https://mutelight.org/bin-console
+    require "irb"
+    require "irb/completion"
+
+    ARGV.clear # https://stackoverflow.com/questions/33070092/irb-start-not-starting/33136762
+    IRB.start
+  end
+end

data/lib/jets/commands/db.rb

@@ -0,0 +1,15 @@
+require "rails/generators"
+require "rails/generators/active_record/migration/migration_generator"
+
+module Jets::Commands
+  class Db < Jets::Commands::Base
+    autoload :Tasks, 'jets/commands/db/tasks'
+
+    desc "generate", "Creates a migration to change a db table"
+    long_desc Help.text('db:generate')
+    def generate(*args)
+      generator = ActiveRecord::Generators::MigrationGenerator.new(args)
+      generator.create_migration_file
+    end
+  end
+end

data/lib/jets/commands/db/environment-task.rake

@@ -0,0 +1,3 @@
+task :environment do
+  Jets.boot
+end

data/lib/jets/commands/db/tasks.rb

@@ -0,0 +1,30 @@
+require "rails"
+require "active_record"
+require "recursive-open-struct"
+
+class Jets::Commands::Db::Tasks
+  # Ugly but it loads ActiveRecord database tasks
+  def self.load!
+    # Jets.boot # Jets.boot here screws up jets -h, the db_config doesnt seem to match exactly
+    # but seems to be working anyway.
+    db_configs = Jets.application.config.database
+    ActiveRecord::Tasks::DatabaseTasks.database_configuration = db_configs
+    ActiveRecord::Tasks::DatabaseTasks.migrations_paths = ["db/migrate"]
+
+    # Need to mock out the usage of Rails.application in:
+    # activerecord-5.1.4/lib/active_record/tasks/database_tasks.rb
+    Rails.application = RecursiveOpenStruct.new(
+      config: {
+        paths: {
+          db: ["db"],
+        }
+      },
+      paths: {
+        "db/migrate": ["db/migrate"]
+      }
+    )
+    load "active_record/railties/databases.rake"
+
+    load File.expand_path("../environment-task.rake", __FILE__)
+  end
+end

data/lib/jets/commands/dbconsole.rb

@@ -0,0 +1,131 @@
+# Thanks: Rails dbconsole_command.rb
+module Jets::Commands
+  class Dbconsole
+    def self.start(*args)
+      new(*args).start
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def start
+      ENV["RAILS_ENV"] ||= @options[:environment] || environment
+
+      case config["adapter"]
+      when /^(jdbc)?mysql/
+        args = {
+          "host"      => "--host",
+          "port"      => "--port",
+          "socket"    => "--socket",
+          "username"  => "--user",
+          "encoding"  => "--default-character-set",
+          "sslca"     => "--ssl-ca",
+          "sslcert"   => "--ssl-cert",
+          "sslcapath" => "--ssl-capath",
+          "sslcipher" => "--ssl-cipher",
+          "sslkey"    => "--ssl-key"
+        }.map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }.compact
+
+        if config["password"] && @options["include_password"]
+          args << "--password=#{config['password']}"
+        elsif config["password"] && !config["password"].to_s.empty?
+          args << "-p"
+        end
+
+        args << config["database"]
+
+        find_cmd_and_exec(["mysql", "mysql5"], *args)
+
+      when /^postgres|^postgis/
+        ENV["PGUSER"]     = config["username"] if config["username"]
+        ENV["PGHOST"]     = config["host"] if config["host"]
+        ENV["PGPORT"]     = config["port"].to_s if config["port"]
+        ENV["PGPASSWORD"] = config["password"].to_s if config["password"] && @options["include_password"]
+        find_cmd_and_exec("psql", config["database"])
+
+      when "sqlite3"
+        args = []
+
+        args << "-#{@options['mode']}" if @options["mode"]
+        args << "-header" if @options["header"]
+        args << File.expand_path(config["database"], Jets.root)
+
+        find_cmd_and_exec("sqlite3", *args)
+
+      when "oracle", "oracle_enhanced"
+        logon = ""
+
+        if config["username"]
+          logon = config["username"]
+          logon << "/#{config['password']}" if config["password"] && @options["include_password"]
+          logon << "@#{config['database']}" if config["database"]
+        end
+
+        find_cmd_and_exec("sqlplus", logon)
+
+      when "sqlserver"
+        args = []
+
+        args += ["-D", "#{config['database']}"] if config["database"]
+        args += ["-U", "#{config['username']}"] if config["username"]
+        args += ["-P", "#{config['password']}"] if config["password"]
+
+        if config["host"]
+          host_arg = "#{config['host']}"
+          host_arg << ":#{config['port']}" if config["port"]
+          args += ["-S", host_arg]
+        end
+
+        find_cmd_and_exec("sqsh", *args)
+
+      else
+        abort "Unknown command-line client for #{config['database']}."
+      end
+    end
+
+    def config
+      @config ||= begin
+        if configurations[environment].blank?
+          raise ActiveRecord::AdapterNotSpecified, "'#{environment}' database is not configured. Available configuration: #{configurations.inspect}"
+        else
+          configurations[environment]
+        end
+      end
+    end
+
+    def environment
+      Jets.env.to_s
+    end
+
+    private
+      def configurations # :doc:
+        db_config = Jets.application.config.database
+        ActiveRecord::Base.configurations = db_config
+        ActiveRecord::Base.configurations
+      end
+
+      def find_cmd_and_exec(commands, *args) # :doc:
+        commands = Array(commands)
+
+        dirs_on_path = ENV["PATH"].to_s.split(File::PATH_SEPARATOR)
+        unless (ext = RbConfig::CONFIG["EXEEXT"]).empty?
+          commands = commands.map { |cmd| "#{cmd}#{ext}" }
+        end
+
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            File.file?(full_path_command) && File.executable?(full_path_command)
+          end
+        end
+
+        if found
+          exec full_path_command, *args
+        else
+          abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
+        end
+      end
+  end
+end