import_js 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80847dd047d3098f2375708a53acbe8fe3b788d3
-  data.tar.gz: 63db9742a0a4bdb87b019020cf1f20a2fb8f82dd
+  metadata.gz: 3b23358bb0d61ef8fac8b2e8789f2bfffa092fb9
+  data.tar.gz: 132643d9f5029de7cf5087d496fedb91e53d903b
 SHA512:
-  metadata.gz: 1c6631a83e5bc9498db3d1c39a41c5f56df7e2a032b1624a7aa4b3d64b6215cb9990369bec4bbabe4406001245ab921228b1298cc75c5935383694316a3a8469
-  data.tar.gz: dcaf4142fb7e906c8cdb466c14a421bc8cd570c38bf240b7b93591dfc554deb025d135dedd45726252fa630133101c39da176987efdd9b09e8dd5d613094ecf7
+  metadata.gz: 51cd0b9b042fe549668137d6635a68589d031a72ab40fae39908604101fa632363b701546c194d87b0a3140714c10234434127fe4bd679f40c8d8d56855a26df
+  data.tar.gz: b7ccd7a213c9dbd9cd80db90b70421dd16e1b4a9d88a79b67b63ea210611ea72f66c805d07c698baf4dae78dd854292012e56b89e07db04f21e9aed627813cfc

data/lib/import_js/configuration.rb

@@ -8,8 +8,8 @@ module ImportJS
     'aliases' => {},
     'declaration_keyword' => 'var',
     'excludes' => [],
-    'jshint_cmd' => 'jshint',
     'lookup_paths' => ['.'],
+    'strip_file_extensions' => ['.js', '.jsx']
   }
 
   # Class that initializes configuration from a .importjs.json file
@@ -28,19 +28,27 @@ module ImportJS
       @config[key]
     end
 
-    def resolve_alias(variable_name)
+    # @param variable_name [String]
+    # @param path_to_current_file [String?]
+    # @return [ImportJS::JSModule?]
+    def resolve_alias(variable_name, path_to_current_file)
       path = @config['aliases'][variable_name]
       return resolve_destructured_alias(variable_name) unless path
 
       path = path['path'] if path.is_a? Hash
-      ImportJS::JSModule.new(nil, path, self)
+
+      if path_to_current_file && !path_to_current_file.empty?
+        path = path.sub(/\{filename\}/,
+                        File.basename(path_to_current_file, '.*'))
+      end
+      ImportJS::JSModule.new(nil, path, [])
     end
 
     def resolve_destructured_alias(variable_name)
       @config['aliases'].each do |_, path|
         next if path.is_a? String
         if (path['destructure'] || []).include?(variable_name)
-          js_module = ImportJS::JSModule.new(nil, path['path'], self)
+          js_module = ImportJS::JSModule.new(nil, path['path'], [])
           js_module.is_destructured = true
           return js_module
         end

data/lib/import_js/emacs_editor.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+module ImportJS
+end
+
+class ImportJS::EmacsEditor
+  attr_accessor :current_word
+
+  def initialize
+    loop do
+      input = gets.chomp
+      command, value, path = input.split(':')
+
+      begin
+        @path = path
+        @file = File.readlines(path).map(&:chomp)
+        @current_word = value
+
+        case command
+        when 'import'
+          ImportJS::Importer.new(self).import
+          write_file
+          puts 'import:success'
+        when 'goto'
+          ImportJS::Importer.new(self).goto
+        end
+      rescue Exception => e
+        puts e.inspect
+      end
+    end
+  end
+
+  def write_file
+    new_file = File.open(@path, 'w')
+    @file.each {|line| new_file.puts(line) }
+    new_file.close
+  end
+
+  # Open a file specified by a path.
+  #
+  # @param file_path [String]
+  def open_file(file_path)
+    puts "goto:success:#{File.expand_path(file_path)}"
+  end
+
+  # Get the path to the file currently being edited. May return `nil` if an
+  # anonymous file is being edited.
+  #
+  # @return [String?]
+  def path_to_current_file
+    # Not yet implemented for Emacs
+    nil
+  end
+
+  # Display a message to the user.
+  #
+  # @param str [String]
+  def message(str)
+    puts str
+  end
+
+  # Read the entire file into a string.
+  #
+  # @return [String]
+  def current_file_content
+    @file.join('\n')
+  end
+
+  # Reads a line from the file.
+  #
+  # Lines are one-indexed, so 1 means the first line in the file.
+  # @return [String]
+  def read_line(line_number)
+    @file[line_number - 1]
+  end
+
+  # Get the cursor position.
+  #
+  # @return [Array(Number, Number)]
+  def cursor
+    return 0, 0
+  end
+
+  # Place the cursor at a specified position.
+  #
+  # @param position_tuple [Array(Number, Number)] the row and column to place
+  #   the cursor at.
+  def cursor=(position_tuple)
+  end
+
+  # Delete a line.
+  #
+  # @param line_number [Number] One-indexed line number.
+  #   1 is the first line in the file.
+  def delete_line(line_number)
+    @file.delete_at(line_number - 1)
+  end
+
+  # Append a line right after the specified line.
+  #
+  # Lines are one-indexed, but you need to support appending to line 0 (add
+  # content at top of file).
+  # @param line_number [Number]
+  def append_line(line_number, str)
+    @file.insert(line_number, str)
+  end
+
+  # Count the number of lines in the file.
+  #
+  # @return [Number] the number of lines in the file
+  def count_lines
+    @file.size
+  end
+
+  # Ask the user to select something from a list of alternatives.
+  #
+  # @param heading [String] A heading text
+  # @param alternatives [Array<String>] A list of alternatives
+  # @return [Number, nil] the index of the selected alternative, or nil if
+  #   nothing was selected.
+  def ask_for_selection(heading, alternatives)
+    puts "asking for selection"
+    puts heading
+    puts JSON.pretty_generate(alternatives)
+    return
+
+    # need to implement this
+    escaped_list = [heading]
+    escaped_list << alternatives.each_with_index.map do |alternative, i|
+      "\"#{i + 1}: #{alternative}\""
+    end
+    escaped_list_string = '[' + escaped_list.join(',') + ']'
+
+    selected_index = VIM.evaluate("inputlist(#{escaped_list_string})")
+    return if selected_index < 1
+    selected_index - 1
+  end
+
+  # Get the preferred max length of a line
+  # @return [Number?]
+  def max_line_length
+    80
+  end
+
+  # @return [String] shiftwidth number of spaces if expandtab is not set,
+  #   otherwise `\t`
+  def tab
+    return ' ' * shift_width || 2
+  end
+
+  # @return [Number?]
+  def shift_width
+    2
+  end
+end

data/lib/import_js/import_statement.rb

@@ -0,0 +1,111 @@
+module ImportJS
+  # Class that represents an import statement, e.g.
+  # "const foo = require('foo');"
+  class ImportStatement
+    REGEX_CONST_LET_VAR = %r{
+      \A
+      (?:const|let|var)\s+ # declaration keyword
+      (?<assignment>.+?)   # <assignment> variable assignment
+      \s*=\s*
+      require\(
+        (?<quote>'|")      # <quote> opening quote
+        (?<path>[^\2]+)    # <path> module path
+        \k<quote>          # closing quote
+      \);?
+      \s*
+    }xm
+
+    REGEX_IMPORT = %r{
+      \A
+      import\s+
+      (?<assignment>.*?) # <assignment> variable assignment
+      \s+from\s+
+      (?<quote>'|")      # <quote> opening quote
+      (?<path>[^\2]+)    # <path> module path
+      \k<quote>          # closing quote
+      ;?\s*
+    }xm
+
+    attr_accessor :assignment
+    attr_accessor :original_import_string # a cache of the parsed import string
+    attr_accessor :variables
+    attr_accessor :is_destructured # can't use `destructured?` because of 1.9.3
+    attr_accessor :path
+
+    # @param string [String] a possible import statement, e.g.
+    #   `const foo = require('foo');`
+    # @return [ImportJS::ImportStatement?] a parsed statement, or nil if the
+    #   string can't be parsed
+    def self.parse(string)
+      match = REGEX_CONST_LET_VAR.match(string) ||
+              REGEX_IMPORT.match(string)
+      return unless match
+
+      statement = new
+      statement.original_import_string = match.string
+      statement.path = match[:path]
+      statement.assignment = match[:assignment]
+      if dest_match = statement.assignment.match(/\{\s*(.*)\s*\}/)
+        statement.variables = dest_match[1].split(/,\s*/).map(&:strip)
+        statement.is_destructured = true
+      else
+        statement.variables = [statement.assignment]
+      end
+      statement
+    end
+
+    # Injects a new variable into an already existing set of destructured
+    #   variables.
+    # @param variable_name [String]
+    def inject_variable(variable_name)
+      variables << variable_name
+      variables.sort!.uniq!
+
+      @original_import_string = nil # clear import string cache if there was one
+    end
+
+    # Deletes a variable from an already existing set of destructured
+    #   variables.
+    # @param variable_name [String]
+    def delete_variable(variable_name)
+      variables.delete(variable_name)
+
+      @original_import_string = nil # clear import string cache if there was one
+    end
+
+    # @return [Array] an array that can be used in `uniq!` to dedupe equal
+    #   statements, e.g.
+    #   `const foo = require('foo');`
+    #   `import foo from 'foo';`
+    def normalize
+      [variables, path]
+    end
+
+    # @param declaration_keyword [String] const, let, var, or import
+    # @param max_line_length [Number] where to cap lines at
+    # @param tab [String] e.g. '  ' (two spaces)
+    # @return a generated import statement string
+    def to_import_string(declaration_keyword, max_line_length, tab)
+      return original_import_string if original_import_string
+
+      declaration = if is_destructured
+                      "#{declaration_keyword} { #{variables.join(', ')} }"
+                    else
+                      "#{declaration_keyword} #{variables.first}"
+                    end
+
+      equals, value = if declaration_keyword == 'import'
+                        ['from', "'#{path}';"]
+                      else
+                        ['=', "require('#{path}');"]
+                      end
+
+      if max_line_length &&
+         "#{declaration} #{equals} #{value}".length > max_line_length
+        "#{declaration} #{equals}\n#{tab}#{value}"
+      else
+        "#{declaration} #{equals} #{value}"
+      end
+    end
+  end
+end

data/lib/import_js/importer.rb

@@ -23,8 +23,16 @@ module ImportJS
       current_row, current_col = @editor.cursor
 
       old_buffer_lines = @editor.count_lines
-      import_one_variable variable_name
-      return unless lines_changed = @editor.count_lines - old_buffer_lines
+      js_module = find_one_js_module(variable_name)
+      return unless js_module
+
+      old_imports = find_current_imports
+      inject_js_module(variable_name, js_module, old_imports[:imports])
+      replace_imports(old_imports[:newline_count],
+                      old_imports[:imports],
+                      old_imports[:imports_start_at])
+      lines_changed = @editor.count_lines - old_buffer_lines
+      return unless lines_changed
       @editor.cursor = [current_row + lines_changed, current_col]
     end
 
@@ -39,103 +47,148 @@ module ImportJS
       @editor.open_file(js_module.file_path)
     end
 
+    def fix_imports
+      remove_unused_imports
+      import_all
+    end
+
     # Finds all variables that haven't yet been imported.
     def import_all
       @config.refresh
-      unused_variables = find_unused_variables
+      undefined_variables = run_eslint_command.map do |line|
+        /"([^"]+)" is not defined/.match(line) do |match_data|
+          match_data[1]
+        end
+      end.compact.uniq
 
-      if unused_variables.empty?
-        message('No variables to import')
-        return
+      return message('No variables to import') if undefined_variables.empty?
+
+      old_imports = find_current_imports
+      undefined_variables.each do |variable|
+        if js_module = find_one_js_module(variable)
+          inject_js_module(variable, js_module, old_imports[:imports])
+        end
       end
+      replace_imports(old_imports[:newline_count],
+                      old_imports[:imports],
+                      old_imports[:imports_start_at])
+    end
+
+    def remove_unused_imports
+      @config.refresh
+      unused_variables = run_eslint_command.map do |line|
+        /"([^"]+)" is defined but never used/.match(line) do |match_data|
+          match_data[1]
+        end
+      end.compact.uniq
 
-      unused_variables.each do |variable|
-        import_one_variable(variable)
+      old_imports = find_current_imports
+      new_imports = old_imports[:imports].reject do |import_statement|
+        unused_variables.each do |unused_variable|
+          import_statement.delete_variable(unused_variable)
+        end
+        import_statement.variables.empty?
       end
+      replace_imports(old_imports[:newline_count],
+                      new_imports,
+                      old_imports[:imports_start_at])
     end
 
     private
 
     def message(str)
-      @editor.message("[import-js] #{str}")
+      @editor.message("ImportJS: #{str}")
     end
 
-    # @return [Array]
-    def find_unused_variables
-      content = "/* jshint undef: true, strict: true */\n" +
-                "/* eslint no-unused-vars: [2, { \"vars\": \"all\", \"args\": \"none\" }] */\n" +
-                @editor.current_file_content
-
-      out, _ = Open3.capture3("#{@config.get('jshint_cmd')} -", stdin_data: content)
-      result = []
-      out.split("\n").each do |line|
-        /.*['"]([^'"]+)['"] is not defined/.match(line) do |match_data|
-          result << match_data[1]
-        end
+    # @return [Array<String>] the output from eslint, line by line
+    def run_eslint_command
+      command = %w[
+        eslint
+        --stdin
+        --format compact
+        --rule 'no-undef: 2'
+        --rule 'no-unused-vars: [2, { "vars": "all", "args": "none" }]'
+      ].join(' ')
+      out, err = Open3.capture3(command,
+                                stdin_data: @editor.current_file_content)
+
+      if out =~ /Error - Parsing error: / ||
+         out =~ /Unrecoverable syntax error/
+        fail ImportJS::ParseError.new, out
+      end
+
+      if err =~ /SyntaxError: / ||
+         err =~ /eslint: command not found/
+        fail ImportJS::ParseError.new, err
       end
-      result.uniq
+
+      out.split("\n")
     end
 
     # @param variable_name [String]
-    def import_one_variable(variable_name)
+    # @return [ImportJS::JSModule?]
+    def find_one_js_module(variable_name)
       @timing = { start: Time.now }
       js_modules = find_js_modules(variable_name)
       @timing[:end] = Time.now
       if js_modules.empty?
-        message(<<-EOS.split.join(' '))
-          No js module to import for variable `#{variable_name}` #{timing}
-        EOS
+        message(
+          "No JS module to import for variable `#{variable_name}` #{timing}")
         return
       end
 
-      resolved_js_module = resolve_one_js_module(js_modules, variable_name)
-      return unless resolved_js_module
-
-      write_imports(variable_name, resolved_js_module)
+      resolve_one_js_module(js_modules, variable_name)
     end
 
     # @param variable_name [String]
     # @param js_module [ImportJS::JSModule]
-    def write_imports(variable_name, js_module)
-      old_imports = find_current_imports
-
-      # Ensure that there is a blank line after the block of all imports
-      unless @editor.read_line(old_imports[:newline_count] + 1).strip.empty?
-        @editor.append_line(old_imports[:newline_count], '')
-      end
-
-      modified_imports = old_imports[:imports] # Array
-
+    # @param imports [Array<ImportJS::ImportStatement>]
+    def inject_js_module(variable_name, js_module, imports)
       # Add new import to the block of imports, wrapping at the max line length
       unless js_module.is_destructured && inject_destructured_variable(
-        variable_name, js_module, modified_imports)
-        modified_imports << generate_import(variable_name, js_module)
+        variable_name, js_module, imports)
+        imports.unshift(js_module.to_import_statement(variable_name))
       end
 
-      # Sort the block of imports
-      modified_imports.sort!.uniq! do |import|
-        # Determine uniqueness by discarding the declaration keyword (`const`,
-        # `let`, or `var`) and normalizing multiple whitespace chars to single
-        # spaces.
-        import.sub(/\A(const|let|var)\s+/, '').sub(/\s\s+/s, ' ')
+      # Remove duplicate import statements
+      imports.uniq!(&:normalize)
+    end
+
+    # @param old_imports_lines [Number]
+    # @param new_imports [Array<ImportJS::ImportStatement>]
+    # @param imports_start_at [Number]
+    def replace_imports(old_imports_lines, new_imports, imports_start_at)
+      # Ensure that there is a blank line after the block of all imports
+      if old_imports_lines + new_imports.length > 0 &&
+         !@editor.read_line(old_imports_lines + imports_start_at + 1).strip.empty?
+        @editor.append_line(old_imports_lines + imports_start_at, '')
       end
 
+      # Generate import strings
+      import_strings = new_imports.map do |import|
+        import.to_import_string(
+          @config.get('declaration_keyword'),
+          @editor.max_line_length,
+          @editor.tab)
+      end.sort
+
       # Delete old imports, then add the modified list back in.
-      old_imports[:newline_count].times { @editor.delete_line(1) }
-      modified_imports.reverse_each do |import|
+      old_imports_lines.times { @editor.delete_line(1 + imports_start_at) }
+      import_strings.reverse_each do |import_string|
         # We need to add each line individually because the Vim buffer will
         # convert newline characters to `~@`.
-        import.split("\n").reverse_each { |line| @editor.append_line(0, line) }
+        import_string.split("\n").reverse_each do |line|
+          @editor.append_line(0 + imports_start_at, line)
+        end
       end
     end
 
     def inject_destructured_variable(variable_name, js_module, imports)
       imports.each do |import|
-        match = import.match(%r{((const|let|var) \{ )(.*)( \} = require\('#{js_module.import_path}'\);)})
-        next unless match
+        next unless import.path == js_module.import_path
+        next unless import.is_destructured
 
-        variables = match[3].split(/,\s*/).concat([variable_name]).uniq.sort
-        import.sub!(/.*/, "#{match[1]}#{variables.join(', ')}#{match[4]}")
+        import.inject_variable(variable_name)
         return true
       end
       false
@@ -150,52 +203,38 @@ module ImportJS
         potential_import_lines << line
       end
 
+      result = {
+        imports: [],
+        newline_count: 0,
+        imports_start_at: 0
+      }
+
+      if potential_import_lines[0] =~ /(['"])use strict\1;?/
+        result[:imports_start_at] = 1
+        potential_import_lines.shift
+      end
+
       # We need to put the potential imports back into a blob in order to scan
       # for multiline imports
       potential_imports_blob = potential_import_lines.join("\n")
 
-      imports = []
-
       # Scan potential imports for everything ending in a semicolon, then
       # iterate through those and stop at anything that's not an import.
       potential_imports_blob.scan(/^.*?;/m).each do |potential_import|
-        break unless potential_import.match(
-          /(?:const|let|var)\s+.+=\s+require\(.*\).*;/)
-        imports << potential_import
-      end
-
-      newline_count = imports.length + imports.reduce(0) do |sum, import|
-        sum + import.scan(/\n/).length
-      end
-      {
-        imports: imports,
-        newline_count: newline_count
-      }
-    end
-
-    # @param variable_name [String]
-    # @param js_module [ImportJS::JSModule]
-    # @return [String] the import string to be added to the imports block
-    def generate_import(variable_name, js_module)
-      declaration_keyword = @config.get('declaration_keyword')
-      if js_module.is_destructured
-        declaration = "#{declaration_keyword} { #{variable_name} } ="
-      else
-        declaration = "#{declaration_keyword} #{variable_name} ="
-      end
-      value = "require('#{js_module.import_path}');"
+        import_statement = ImportJS::ImportStatement.parse(potential_import)
+        break unless import_statement
 
-      if @editor.max_line_length && "#{declaration} #{value}".length > @editor.max_line_length
-        "#{declaration}\n#{@editor.tab}#{value}"
-      else
-        "#{declaration} #{value}"
+        result[:imports] << import_statement
+        result[:newline_count] += potential_import.scan(/\n/).length + 1
       end
+      result
     end
 
     # @param variable_name [String]
     # @return [Array]
     def find_js_modules(variable_name)
-      if alias_module = @config.resolve_alias(variable_name)
+      if alias_module = @config.resolve_alias(variable_name,
+                                              @editor.path_to_current_file)
         return [alias_module]
       end
 
@@ -210,7 +249,8 @@ module ImportJS
             next if @config.get('excludes').any? do |glob_pattern|
               File.fnmatch(glob_pattern, f)
             end
-            js_module = ImportJS::JSModule.new(lookup_path, f, @config)
+            js_module = ImportJS::JSModule.new(
+              lookup_path, f, @config.get('strip_file_extensions'))
             next if js_module.skip
             js_module
           end.compact
@@ -221,7 +261,7 @@ module ImportJS
       @config.package_dependencies.each do |dep|
         next unless dep =~ /^#{formatted_to_regex(variable_name)}$/
         js_module = ImportJS::JSModule.new(
-          'node_modules', "node_modules/#{dep}/package.json", @config)
+          'node_modules', "node_modules/#{dep}/package.json", [])
         next if js_module.skip
         matched_modules << js_module
       end
@@ -248,8 +288,8 @@ module ImportJS
       end
 
       selected_index = @editor.ask_for_selection(
-        "\"[import-js] Pick js module to import for '#{variable_name}': #{timing}\"",
-        js_modules.map {|m| m.display_name}
+        "\"ImportJS: Pick JS module to import for '#{variable_name}': #{timing}\"",
+        js_modules.map(&:display_name)
       )
       return unless selected_index
       js_modules[selected_index]

data/lib/import_js/js_module.rb

@@ -11,8 +11,9 @@ module ImportJS
     # @param lookup_path [String] the lookup path in which this module was found
     # @param relative_file_path [String] a full path to the file, relative to
     #   the project root.
-    # @param configuration [ImportJS::Configuration]
-    def initialize(lookup_path, relative_file_path, configuration)
+    # @param strip_file_extensions [Array] a list of file extensions to strip,
+    #   e.g. ['.js', '.jsx']
+    def initialize(lookup_path, relative_file_path, strip_file_extensions)
       @lookup_path = lookup_path
       @file_path = relative_file_path
       if relative_file_path.end_with? '/package.json'
@@ -26,8 +27,11 @@ module ImportJS
         @import_path = match[1]
       else
         @import_path = relative_file_path
-        unless configuration.get('keep_file_extensions')
-          @import_path = @import_path.sub(/\.js.*$/, '')
+        strip_file_extensions.each do |ext|
+          if @import_path.end_with?(ext)
+            @import_path = @import_path[0...-ext.length]
+            break
+          end
         end
       end
 
@@ -42,5 +46,15 @@ module ImportJS
       parts << " (main: #{@main_file})" if @main_file
       parts.join('')
     end
+
+    # @param variable_name [String]
+    # @return [ImportJS::ImportStatement]
+    def to_import_statement(variable_name)
+      ImportJS::ImportStatement.new.tap do |statement|
+        statement.is_destructured = is_destructured
+        statement.variables = [variable_name]
+        statement.path = import_path
+      end
+    end
   end
 end

data/lib/import_js/vim_editor.rb

@@ -10,6 +10,14 @@ module ImportJS
       VIM.evaluate("expand('<cword>')")
     end
 
+    # Get the path to the file currently being edited. May return `nil` if an
+    # anonymous file is being edited.
+    #
+    # @return [String?]
+    def path_to_current_file
+      VIM.evaluate("expand('%')")
+    end
+
     # Open a file specified by a path.
     #
     # @param file_path [String]

data/lib/import_js.rb

@@ -1,11 +1,17 @@
 # Namespace declaration
 module ImportJS
-  # We initialize an empty "ImportJS" namespace here so that we can define
-  # classes under that namespace, e.g. `ImportJS::Importer`.
+  # We initialize the "ImportJS" namespace here so that we can define classes
+  # under that namespace, e.g. `ImportJS::Importer`.
+
+  class ParseError < StandardError
+    # Error thrown when a JS file can't be parsed
+  end
 end
 
 require_relative 'import_js/js_module'
+require_relative 'import_js/import_statement'
 require_relative 'import_js/importer'
 require_relative 'import_js/vim_editor'
+require_relative 'import_js/emacs_editor'
 require_relative 'import_js/command_line_editor'
 require_relative 'import_js/configuration'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: import_js
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Henric Trotzig
@@ -21,6 +21,8 @@ files:
 - lib/import_js.rb
 - lib/import_js/command_line_editor.rb
 - lib/import_js/configuration.rb
+- lib/import_js/emacs_editor.rb
+- lib/import_js/import_statement.rb
 - lib/import_js/importer.rb
 - lib/import_js/js_module.rb
 - lib/import_js/vim_editor.rb