arql 0.3.31 → 0.4.0

data/auto-set-id-before-save-zh_CN.org

@@ -5,7 +5,7 @@
   创建一个文件 =~/.arql.d/auto_gen_id.rb= ，内容如下：
 
   #+BEGIN_SRC ruby
-    class ::ArqlModel
+    class ::Arql::BaseModel
       before_create do
         if id.blank?
           id_type = self.class.columns_hash['id'].sql_type.scan(/\w+/).first

data/custom-configurations-zh_CN.org

@@ -1,6 +1,6 @@
 * 配置文件中的自定义配置项
 
-  你可以在配置文件 (如默认的 =~/.arql.yaml= / =~/.arql.d/init.yaml= ) 中定义自己的配置项，然后在代码中通过 =Arql::App.config["CONF_KEY"]-= 来获取配置项的值。
+  你可以在配置文件 (如默认的 =~/.arql.yaml= / =~/.arql.d/init.yaml= ) 中定义自己的配置项，然后在代码中通过 =env_config(/my_env/)["CONF_KEY"]-= 来获取配置项的值。
 
   例如，假设系统对 BankAccount 表的 =account_no= 字段进行了加密，你可以在配置文件中定义加密的密钥：
 
@@ -23,7 +23,7 @@
       def self.encrypt_account_no(account_no)
         cipher = OpenSSL::Cipher.new('AES-128-ECB')
         cipher.encrypt
-        cipher.key = Arql::App.config["encrypt_key"]
+        cipher.key = env_config(/my_env/)["encrypt_key"]
         encrypted = cipher.update(account_no) + cipher.final
         encrypted.unpack('H*').first
       end
@@ -31,7 +31,7 @@
       def self.decrypt_account_no(encrypted_account_no)
         cipher = OpenSSL::Cipher.new('AES-128-ECB')
         cipher.decrypt
-        cipher.key = Arql::App.config["encrypt_key"]
+        cipher.key = env_config(/my_env/)["encrypt_key"]
         decrypted = cipher.update([encrypted_account_no].pack('H*')) + cipher.final
         decrypted
       end
@@ -48,3 +48,40 @@
       end
     end
   #+END_SRC
+
+  也可以直接使用 Namespace Module 的 config 方法来获取配置项的值，例如：
+
+  假设 Namespace Module 为 =NS=, 那么上述代码可以改写为：
+
+  #+BEGIN_SRC ruby
+    class BankAccount
+    
+      def self.encrypt_account_no(account_no)
+        cipher = OpenSSL::Cipher.new('AES-128-ECB')
+        cipher.encrypt
+        cipher.key = NS::config["encrypt_key"]
+        encrypted = cipher.update(account_no) + cipher.final
+        encrypted.unpack('H*').first
+      end
+    
+      def self.decrypt_account_no(encrypted_account_no)
+        cipher = OpenSSL::Cipher.new('AES-128-ECB')
+        cipher.decrypt
+        cipher.key = NS::config["encrypt_key"]
+        decrypted = cipher.update([encrypted_account_no].pack('H*')) + cipher.final
+        decrypted
+      end
+    
+    
+      # 从数据库查询出数据之后，自动解密 account_no 字段
+      after_find do
+        self.password = decrypt_account_no(self.password)
+      end
+    
+      # 保存数据之前，自动加密 account_no 字段
+      before_save do
+        self.password = encrypt_account_no(self.password)
+      end
+    end
+  #+END_SRC
+  

data/define-associations-zh_CN.org

@@ -5,26 +5,29 @@
   Initializer 文件是一个 Ruby 文件，因此可以在其中定义关联关系，例如：
 
   #+BEGIN_SRC ruby
-    class Student
-      has_many :courses, foreign_key: :student_id, class_name: 'Course'
-      belongs_to :school, foreign_key: :school_id, class_name: 'School'
-
-      has_and_belongs_to_many :teachers, join_table: 'students_teachers', foreign_key: :student_id, association_foreign_key: :teacher_id, class_name: 'Teacher'
-    end
-
-    class Course
-      belongs_to :student, foreign_key: :student_id, class_name: 'Student'
-    end
-
-    class School
-      has_many :students, foreign_key: :school_id, class_name: 'Student'
-    end
-
-    class Teacher
-      has_and_belongs_to_many :students, join_table: 'students_teachers', foreign_key: :teacher_id, association_foreign_key: :student_id, class_name: 'Student'
+    module Blog
+      class Student
+        has_many :courses, foreign_key: :student_id, class_name: 'Course'
+        belongs_to :school, foreign_key: :school_id, class_name: 'School'
+    
+        has_and_belongs_to_many :teachers, join_table: 'students_teachers', foreign_key: :student_id, association_foreign_key: :teacher_id, class_name: 'Teacher'
+      end
+    
+      class Course
+        belongs_to :student, foreign_key: :student_id, class_name: 'Student'
+      end
+    
+      class School
+        has_many :students, foreign_key: :school_id, class_name: 'Student'
+      end
+    
+      class Teacher
+        has_and_belongs_to_many :students, join_table: 'students_teachers', foreign_key: :teacher_id, association_foreign_key: :student_id, class_name: 'Student'
+      end
     end
   #+END_SRC
 
+
   1. =has_one= 表明此表是一对一关系的属主
   2. =belongs_to= 表明此表是一对多或一对一关系的从属方
   3. =has_and_belongs_to_many= 表明此表是多对多关系的其中一方
@@ -36,3 +39,14 @@
 
   可以参考： https://guides.rubyonrails.org/association_basics.html
 
+  考虑到模型类都是定义在 Namespace module 下面的, 因此这里的 Blog 是必要的。
+
+  当然，不管通过 =-e= 选项选择了哪个环境，Arql 默认都会加载 =~/.arql.rb= 或 =~/.arql.d/init.rb= 文件，
+  因此像上述示例中把固定的 Namespace =Blog= 放在默认的初始化文件中, 不是一个好的选择。
+
+  有两种方案解决这个问题：
+
+  1. 使用 arql 时，对于不同的环境，用 =-i= 选项来指定不同的初始化文件，例如: =arql -e blog -i ~/.arql.d/blog.rb=
+  2. 参考 [[./initializer-structure-zh_CN.org][将不同环境的初始化代码放在不同的文件中]]
+
+  

data/initializer-structure-zh_CN.org

@@ -19,10 +19,11 @@
   然后在 =~/.arql.d/init.eb= 文件中写入以下代码：
 
   #+BEGIN_SRC ruby
-    ["apollo", "space"].each do |project|
-      if Arql::App.env.try { |e| e.include?(project + ".") }
-        load(File.absolute_path(File.dirname(__FILE__) + "/#{project}.rb"))
-        break
+    Dir.glob(File.dirname(__FILE__) + '/*.rb').each do |f|
+      Arql::App.instance.definitions.each do |env, definition|
+        if env.starts_with?(File.basename(f, '.rb'))
+          load(f, definition.namespace_module)
+        end
       end
     end
   #+END_SRC
@@ -30,4 +31,21 @@
   这样，当执行 =arql -e apollo.dev= 或 =arql =e apollo.prod= 时，就会加载 =apollo.rb= 文件中的初始化代码；当执行 =arql
   -e space.dev= 或 =arql -e space.prod= 时，就会加载 =space.rb= 文件中的初始化代码。
 
+   =apollo.rb= 或 =space.rb= 文件中的代码将在对应的 Namespace Module 下执行：
+
+  #+BEGIN_SRC ruby
+    class Astronaut
+      has_many :missions
+    end
+  #+END_SRC
+
+  等价于：
+
+  #+BEGIN_SRC ruby
+    module Apollo
+      class Astronaut
+        has_many :missions
+      end
+    end
+  #+END_SRC
   

data/lib/arql/app.rb

@@ -1,114 +1,141 @@
 module Arql
   class App
+    attr_accessor :log_io, :environments, :definitions, :options, :config
 
     class << self
-      attr_accessor :log_io, :env, :prompt, :instance, :connect_options
+      attr_accessor :instance
 
-      def config
-        @@effective_config
+      def log_io
+        instance.log_io
+      end
+
+      def log_io=(io)
+        instance.log_io = io
+      end
+
+      # environment names
+      def environments
+        instance.environments
       end
 
       def prompt
-        if env
-          env
-        else
-          File.basename(@@effective_config[:database])
-        end
+        instance.prompt
+      end
+
+      def config
+        instance.config
+      end
+    end
+
+    def prompt
+      if environments.present?
+        environments.join('+')
+      else
+        File.basename(@options.database)
       end
     end
 
     def initialize(options)
-      require "arql/connection"
       require "arql/definition"
+
+      App.instance = self
+
+      # command line options
       @options = options
-      App.env = @options.env
-      App.connect_options = connect_options
-      Connection.open(App.connect_options)
+
+      # env names
+      @environments = @options.environments
+      @environments ||= ['default']
+
       print "Defining models..."
-      @definition = Definition.new(effective_config)
+      @definitions = config[:environments].each_with_object({}) do |(env_name, env_conf), h|
+        h[env_name] = Definition.new(env_conf)
+      end.with_indifferent_access
+
       print "\u001b[2K"
       puts "\rModels defined"
       print "Running initializers..."
       load_initializer!
       print "\u001b[2K"
       puts "\rInitializers loaded"
-      App.instance = self
-    end
-
-    def connect_options
-      connect_conf = effective_config.slice(:adapter, :host, :username,
-                             :password, :database, :encoding,
-                             :pool, :port, :socket)
-      if effective_config[:ssh].present?
-        connect_conf.merge!(start_ssh_proxy!)
-      end
-
-      connect_conf
     end
 
     def load_initializer!
-      return unless effective_config[:initializer]
-      initializer_file = File.expand_path(effective_config[:initializer])
+      return unless config[:options][:initializer]
+
+      initializer_file = File.expand_path(config[:options][:initializer])
       unless File.exist?(initializer_file)
-        STDERR.puts "Specified initializer file not found, #{effective_config[:initializer]}"
+        warn "Specified initializer file not found, #{config[:options][:initializer]}"
         exit(1)
       end
       load(initializer_file)
     end
 
-    def start_ssh_proxy!
-      ssh_config = effective_config[:ssh]
-      local_ssh_proxy_port = Arql::SSHProxy.connect(ssh_config.slice(:host, :user, :port, :password).merge(
-                                                                                                           forward_host: effective_config[:host],
-                                                                                                           forward_port: effective_config[:port],
-                                                                                                           local_port: ssh_config[:local_port]))
-      {
-        host: '127.0.0.1',
-        port: local_ssh_proxy_port
-      }
-    end
-
-    def config
-      @config ||= YAML.load(IO.read(File.expand_path(@options.config_file)), aliases: true).with_indifferent_access
+    def config_from_file
+      @config_from_file ||= YAML.safe_load(IO.read(File.expand_path(@options.config_file)), aliases: true).with_indifferent_access
     rescue ArgumentError
-      @config ||= YAML.load(IO.read(File.expand_path(@options.config_file))).with_indifferent_access
+      @config_from_file ||= YAML.safe_load(IO.read(File.expand_path(@options.config_file))).with_indifferent_access
     end
 
-    def selected_config
-      if @options.env.present? && !config[@options.env].present?
-        STDERR.puts "Specified ENV `#{@options.env}' not exists"
+    # Returns the configuration for config file.
+    #  or default configuration (built from CLI options) if no environment specified
+    def environ_config_from_file
+      if @options.enviroments.present? || @options.environments&.any? { |env_names| !config_from_file.key?(env_names) }
+        warn "Specified ENV `#{@options.env}' not exists in config file"
+        exit(1)
       end
-      if env = @options.env
-        config[env]
+      conf = if @options.environments.present?
+        @config_from_file.slice(*@options.environments)
       else
-        {}
+        { default: @options.to_h }.with_indifferent_access
       end
-    end
-
-    def effective_config
-      @@effective_config ||= nil
-      unless @@effective_config
-        @@effective_config = selected_config.deep_merge(@options.to_h)
-        if @@effective_config[:adapter].blank?
-          @@effective_config[:adapter] = 'sqlite3'
+      conf.each do |env_name, env_conf|
+        unless env_conf.key?(:namespace)
+          env_conf[:namespace] = env_name.to_s.gsub(/[^a-zA-Z0-9]/, '_').camelize
         end
-        @@effective_config[:database] = File.expand_path(@@effective_config[:database]) if @@effective_config[:adapter] == 'sqlite3'
       end
-      @@effective_config
+    end
+
+    # Returns the effective configuration for the application.
+    # structure like:
+    # {
+    #   options: {show_sql: true,
+    #             write_sql: 'output.sql',
+    #             },
+    #   environments: {
+    #     development: {adapter: 'mysql2',
+    #                   host: 'localhost',
+    #                   port: 3306},
+    #     test: {adapter: 'mysql2',
+    #            host: 'localhost',
+    #            port: 3306},
+    #    }
+    # }
+    def config
+      @config ||= {
+        options: @options,
+        environments: environ_config_from_file.each_with_object({}) { |(env_name, env_conf), h|
+          conf = env_conf.deep_merge(@options.to_h)
+          conf[:adapter] = 'sqlite3' if conf[:adapter].blank?
+          conf[:database] = File.expand_path(conf[:database]) if conf[:adapter] == 'sqlite3'
+          h[env_name] = conf
+          h
+        }.with_indifferent_access
+      }
     end
 
     def run!
       show_sql if should_show_sql?
       write_sql if should_write_sql?
       append_sql if should_append_sql?
-      if effective_config[:code].present?
-        eval(effective_config[:code])
-      elsif effective_config[:args].present?
-        effective_config[:args].first.tap { |file| load(file) }
-      elsif STDIN.isatty
+      if @options.code&.present?
+        eval(@options.code)
+      elsif @options.args.present?
+        @options.args.first.tap { |file| load(file) }
+      elsif $stdin.isatty
         run_repl!
       else
-        eval(STDIN.read)
+        eval($stdin.read)
       end
     end
 
@@ -117,32 +144,32 @@ module Arql
     end
 
     def should_show_sql?
-      effective_config[:show_sql]
+      @options.show_sql
     end
 
     def should_write_sql?
-      effective_config[:write_sql]
+      @options.write_sql
     end
 
     def should_append_sql?
-      effective_config[:append_sql]
+      @options.append_sql
     end
 
     def show_sql
       App.log_io ||= MultiIO.new
       ActiveRecord::Base.logger = Logger.new(App.log_io)
-      App.log_io << STDOUT
+      App.log_io << $stdout
     end
 
     def write_sql
-      write_sql_file = effective_config[:write_sql]
+      write_sql_file = @options.write_sql
       App.log_io ||= MultiIO.new
       ActiveRecord::Base.logger = Logger.new(App.log_io)
       App.log_io << File.new(write_sql_file, 'w')
     end
 
     def append_sql
-      write_sql_file = effective_config[:append_sql]
+      write_sql_file = @options.append_sql
       App.log_io ||= MultiIO.new
       ActiveRecord::Base.logger = Logger.new(App.log_io)
       App.log_io << File.new(write_sql_file, 'a')

data/lib/arql/cli.rb

@@ -19,7 +19,7 @@ module Arql
           opts.banner = <<~EOF
           Usage: arql [options] [ruby file]
 
-            If neither [ruby file] nor -e option specified, and STDIN is not a tty, a Pry REPL will be launched,
+            If neither [ruby file] nor -e option specified, and STDIN is a tty, a Pry REPL will be launched,
             otherwise the specified ruby file or -e option value or ruby code read from STDIN will be run, and no REPL launched
 
           EOF
@@ -32,8 +32,12 @@ module Arql
             @options.initializer = initializer
           end
 
-          opts.on('-eENVIRON', '--env=ENVIRON', 'Specify config environment.') do |env|
-            @options.env = env
+          opts.on('-eENVIRON', '--env=ENVIRON', 'Specify config environment, multiple environments allowed, separated by comma') do |env_names|
+            @options.environments = env_names.split(/[,\+:]/)
+            if @options.environments.any? { |e| e =~ /^default|arql$/i }
+              warn '[default, arql] are reserved environment names, please use another name'
+              exit(1)
+            end
           end
 
           opts.on('-aDB_ADAPTER', '--db-adapter=DB_ADAPTER', 'Specify database Adapter, default is sqlite3') do |db_adapter|
@@ -117,24 +121,36 @@ module Arql
         end.parse!
 
         @options.args = ARGV
+
+        if @options.environments&.size&.positive? && any_database_options?
+          $stderr.puts "Following options are not allowed when using multiple environments specified: #{database_options.join(', ')}"
+          $stderr.puts "    #{database_options.join(', ')}"
+          exit(1)
+        end
+      end
+
+      def any_database_options?
+        %i[adapter host port database username
+           password encoding pool ssh].reduce(false) do |acc, opt|
+          acc || @options.send(opt).present?
+        end
+      end
+
+      def database_options
+        ['--db-adapter', '--db-host', '--db-port', '--db-name', '--db-user', '--db-password',
+         '--db-encoding', '--db-pool', '--ssh-host', '--ssh-port', '--ssh-user', '--ssh-password', '--ssh-local-port']
       end
 
       def default_config_file
-        conf = File.expand_path('~/.arql.yml')
-        return conf if File.file?(conf)
-        conf = File.expand_path('~/.arql.yaml')
-        return conf if File.file?(conf)
-        conf = File.expand_path('~/.arql.d/init.yml')
-        return conf if File.file?(conf)
-        conf = File.expand_path('~/.arql.d/init.yaml')
-        return conf if File.file?(conf)
+        ['~/.arql.yml', '~/.arql.yaml', '~/.arql.d/init.yml', '~/.arql.d/init.yaml'].find { |f|
+          File.file?(File.expand_path(f))
+        }.try { |f| File.expand_path(f) }
       end
 
       def default_initializer
-        conf = File.expand_path('~/.arql.rb')
-        return conf if File.file?(conf)
-        conf = File.expand_path('~/.arql.d/init.rb')
-        return conf if File.file?(conf)
+        ['~/.arql.rb', '~/.arql.d/init.rb',].find { |f|
+          File.file?(File.expand_path(f))
+        }.try { |f| File.expand_path(f) }
       end
     end
   end

data/lib/arql/commands/info.rb

@@ -3,38 +3,49 @@ require 'rainbow'
 module Arql::Commands
   module Info
     class << self
-      def db_info
-        <<~EOF
-
-        Database Connection Information:
-
-            Active:    #{color_boolean(ActiveRecord::Base.connection.active?)}
-            Host:      #{Arql::App.config[:host]}
-            Port:      #{Arql::App.config[:port]}
-            Username:  #{Arql::App.config[:username]}
-            Password:  #{(Arql::App.config[:password] || '').gsub(/./, '*')}
-            Database:  #{Arql::App.config[:database]}
-            Adapter:   #{Arql::App.config[:adapter]}
-            Encoding:  #{Arql::App.config[:encoding]}
-            Pool Size: #{Arql::App.config[:pool]}
-        EOF
+      def db_info(env_name_regexp)
+
+        Arql::App.instance.definitions.map do |env_name, definition|
+          next unless env_name =~ env_name_regexp
+          config = Arql::App.config[:environments][env_name]
+          <<~DB_INFO
+
+          #{env_name} Database Connection Information:
+
+              Active:    #{color_boolean(definition.connection.active?)}
+              Host:      #{config[:host]}
+              Port:      #{config[:port]}
+              Username:  #{config[:username]}
+              Password:  #{(config[:password] || '').gsub(/./, '*')}
+              Database:  #{config[:database]}
+              Adapter:   #{config[:adapter]}
+              Encoding:  #{config[:encoding]}
+              Pool Size: #{config[:pool]}
+          DB_INFO
+        end
       end
 
-      def ssh_info
-        <<~EOF
+      def ssh_info(env_name_regexp)
+        Arql::App.instance.definitions.map do |env_name, definition|
+          next unless env_name =~ env_name_regexp
+          config = Arql::App.config[:environments][env_name]
+          next unless config[:ssh].present?
+          <<~SSH_INFO
 
-        SSH Connection Information:
+          #{env_name} SSH Connection Information:
 
-            Active:     #{color_boolean(Arql::SSHProxy.active?)}
-            Host:       #{Arql::App.config[:ssh][:host]}
-            Port:       #{Arql::App.config[:ssh][:port]}
-            Username:   #{Arql::App.config[:ssh][:user]}
-            Password:   #{(Arql::App.config[:ssh][:password] || '').gsub(/./, '*')}
-            Local Port: #{Arql::SSHProxy.local_ssh_proxy_port}
-        EOF
+              Active:     #{color_boolean(definition.ssh_proxy.active?)}
+              Host:       #{config[:ssh][:host]}
+              Port:       #{config[:ssh][:port]}
+              Username:   #{config[:ssh][:user]}
+              Password:   #{(config[:ssh][:password] || '').gsub(/./, '*')}
+              Local Port: #{definition.ssh_proxy.local_ssh_proxy_port}
+          SSH_INFO
+        end
       end
 
       private
+
       def color_boolean(bool)
         if bool
           Rainbow('TRUE').green
@@ -44,9 +55,11 @@ module Arql::Commands
       end
     end
 
-    Pry.commands.block_command 'info' do
-      puts Info::db_info
-      puts Info::ssh_info if Arql::App.config[:ssh].present?
+    Pry.commands.block_command 'info' do |env_name_regexp|
+      env_name_regexp ||= '.*'
+      env_name_regexp = Regexp.new(env_name_regexp, Regexp::IGNORECASE)
+      output.puts Info::db_info(env_name_regexp)
+      output.puts Info::ssh_info(env_name_regexp)
     end
   end
 end