opal-irb 0.7.0

data/lib/opal-irb.rb

@@ -0,0 +1,44 @@
+require 'opal'
+require 'opal-jquery'
+require 'opal-irb/version.rb'
+Opal.append_path File.expand_path('../../opal', __FILE__)
+Opal.append_path File.expand_path('../../js', __FILE__)
+
+module OpalIrbUtils
+
+  # used to include the requirements in a template file ala
+  # <%= OpalIrbUtils.include_opal_irb_jqconsole_requirements %>
+  # params opts[:include_jquery] include a canned version of jquery, jquery-ui, jquery-migrate that is compatibable w/the jqconsole.  Set this to false if you already include these files
+  # params opts[:include_codemirror] include the code mirror
+  def self.include_opal_irb_jqconsole_requirements(opts = { :include_jquery => true, :include_codemirror => true})
+    jquery_scripts = opts[:include_jquery] ? include_web_jquery : ""
+    code_mirror_scripts = opts[:include_codemirror] ? include_code_mirror : ""
+
+    jquery_scripts + code_mirror_scripts
+ end
+
+  def self.include_web_jquery
+   jquery_requirements = [
+                          "http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js",
+                          "https://ajax.googleapis.com/ajax/libs/jqueryui/1.10.3/jquery-ui.min.js",
+                          "http://code.jquery.com/jquery-migrate-1.2.1.js"
+                         ]
+    # style sheet so editor window has styling
+   '<link rel="stylesheet" href="http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css" />' +
+      require_scripts(jquery_requirements)
+ end
+
+  def self.require_scripts(javascripts)
+   javascripts.map { |js|
+     "<script src='#{js}'></script>"
+   }.join("\n")
+  end
+
+  def self.include_code_mirror
+    '<link rel="stylesheet" href="//codemirror.net/lib/codemirror.css"/>' +
+   require_scripts( [ "//codemirror.net/lib/codemirror.js",
+                     "//codemirror.net/keymap/emacs.js",
+                     "//codemirror.net/mode/ruby/ruby.js"])
+ end
+
+end

data/opal/object_extensions.rb

@@ -0,0 +1,20 @@
+# monkey patch object to get some stuff we want
+class Object
+  def irb_instance_variables
+    filtered = ["@constructor", "@toString"]
+    instance_variables.reject {|var| filtered.include?(var)}.sort
+  end
+
+  def irb_instance_var_values
+    irb_instance_variables.map {|var_name| [var_name, instance_variable_get("#{var_name}")]}
+  end
+
+end
+
+# test class
+class Foo
+  def initialize
+    @a = "a"
+    @b = "b"
+  end
+end

data/opal/opal_irb/completion_engine.rb

@@ -0,0 +1,202 @@
+$CE_DEBUG = false               # override to turn on debugging
+require_relative 'completion_results'
+class OpalIrb
+  # CompletionEngine for tab completes
+  class CompletionEngine
+    VARIABLE_DOT_COMPLETE = /(\s*([$]*\w+)\.)$/
+    METHOD_COMPLETE = /(\s*([$]*\w+)\.(\w+))$/
+    CONSTANT = /(\s*([A-Z]\w*))$/
+    METHOD_OR_VARIABLE = /(\s*([a-z]\w*))$/
+    GLOBAL = /(\s*\$(\w*))$/
+
+    NO_MATCHES_PARAMS = [nil, []]
+    # Shows completions for text in opal-irb
+    # @param text [String] the text to try to find completions for
+    # @returns [CompletionResults]
+
+    def self.complete(text, irb)
+      index, matches = get_matches(text, irb)
+      CompletionResults.new(text, index, matches)
+    end
+    # Editor complete, intended to be called from CodeMirror or other
+    # javascript editor that does not have the ability to see into
+    # Opal objects w/o some work.  To use this, you must first
+    # set_irb() the irb you will be using
+    # @params text [String] the text to try to find completions for
+    # @returns [String[]] the matches
+    def self.editor_complete(text)
+      debug_puts "Getting matches for #{text}"
+      index, matches = get_matches(text, get_irb)
+      debug_puts "\tMatches  = #{matches.inspect}"
+      matches || []
+    end
+
+    # For use with CodeMirror autocompletion, or anything that needs persistent irb
+    # of interacts through javascript
+    # @param irb [OpalIrb] the irb engine to use, typically that of an OpalIrb condole
+    def self.set_irb irb
+      @irb = irb
+    end
+    # Called by self.editor_complete to get the irb that is set
+    def self.get_irb
+      if @irb
+        @irb
+      else
+        raise "You must set irb to use this funtion"
+      end
+    end
+    def self.get_matches(text, irb)
+      index, matches = case text
+                       when GLOBAL
+                         debug_puts 'GLOBAL'
+                         global_complete(text, irb)
+                       when VARIABLE_DOT_COMPLETE
+                         debug_puts 'VARIABLE_DOT_COMPLETE'
+                         variable_dot_complete(text, irb)
+                       when METHOD_COMPLETE
+                         debug_puts 'METHOD_COMPLETE'
+                         method_complete(text, irb)
+                       when CONSTANT
+                         debug_puts 'CONSTANT'
+                         constant_complete(text, irb)
+                       when METHOD_OR_VARIABLE
+                         debug_puts 'METHOD_OR_VARIABLE'
+                         method_or_variable_complete(text, irb)
+                       else
+                         NO_MATCHES_PARAMS
+                       end
+      [index, matches]
+    end
+    def self.variable_dot_complete(text, irb)
+      index = text =~ VARIABLE_DOT_COMPLETE # broken in 0.7, fixed in 0.7
+      whole = $1
+      target_name = $2
+      get_correct_methods_by_type(whole, target_name, index, irb)
+    end
+
+    def self.get_correct_methods_by_type(whole, target_name, index, irb)
+      case target_name
+      when /^[A-Z]/
+        get_class_methods(whole, target_name, index)
+      when /^\$/
+        get_global_methods(whole, target_name, index, irb)
+      else
+        get_var_methods(whole, target_name, index, irb)
+      end
+    end
+
+    def self.get_class_methods(whole, target_name, index)
+      begin
+        klass = Kernel.const_get(target_name)
+        debug_puts "\t#{klass.inspect} #{klass.methods}"
+        [whole.size + index, klass.methods]
+      rescue
+        puts "\t RESCUE"
+        NO_MATCHES_PARAMS
+      end
+    end
+
+    def self.get_global_methods(whole, target_name, index, irb)
+      debug_puts "get_global_methods(#{whole}, #{target_name}, #{index})"
+      target_name = target_name[1..-1] # strip off leading $
+      name_val_pair = irb.irb_gvars.find { |array| array[0] == target_name }
+      if name_val_pair
+        methods = name_val_pair[1].methods
+        return [whole.size + index, methods]
+      end
+      NO_MATCHES_PARAMS
+    end
+
+    def self.get_var_methods(whole, target_name, index, irb)
+      name_val_pair = irb.irb_vars.find { |array| array[0] == target_name }
+      if name_val_pair
+        methods = name_val_pair[1].methods
+        return [whole.size + index, methods]
+      end
+      NO_MATCHES_PARAMS
+    end
+
+    def self.method_complete(text, irb)
+      index = text =~ METHOD_COMPLETE # broken in 0.7, fixed in 0.7
+      whole = $1
+      target_name = $2
+      method_fragment = $3
+      get_matches_for_correct_type(whole, target_name, method_fragment, index, irb)
+    end
+
+    def self.get_matches_for_correct_type(whole, target_name, method_fragment, index, irb)
+      debug_puts("get_matches_for_correct_type(#{whole}, #{target_name}, #{method_fragment}, #{index})")
+      case target_name
+      when /^[A-Z]/
+        get_class_methods_by_fragment(whole, target_name, method_fragment, index)
+      when /^\$/
+        get_global_methods_by_fragment(whole, target_name, method_fragment, index, irb)
+      else
+        get_var_methods_by_fragment(whole, target_name, method_fragment, index, irb)
+      end
+    end
+
+    def self.get_class_methods_by_fragment(whole, target_name, method_fragment, index)
+      debug_puts "get_class_methods_by_fragment whole: #{whole}, target_name: #{target_name}, method_fragment: #{method_fragment}, index"
+      begin
+        klass = Kernel.const_get(target_name)
+        debug_puts "\t#{klass.inspect} #{klass.methods}"
+        [whole.size + index - method_fragment.size, klass.methods.grep(/^#{method_fragment}/)]
+      rescue
+        puts "\t RESCUE"
+        NO_MATCHES_PARAMS
+      end
+    end
+
+    def self.get_global_methods_by_fragment(whole, target_name, method_fragment, index, irb)
+      debug_puts "get_global_methods_by_fragment whole: #{whole}, target_name: #{target_name}, method_fragment: #{method_fragment}, index"
+      target_name = target_name[1..-1] # strip off leading $
+      name_val_pair = irb.irb_gvars.find { |array| array[0] == target_name }
+      if name_val_pair
+        methods = name_val_pair[1].methods.grep /^#{method_fragment}/
+                                                return [whole.size + index - method_fragment.size, methods]
+      end
+      NO_MATCHES_PARAMS
+    end
+
+    def self.get_var_methods_by_fragment(whole, target_name, method_fragment, index, irb)
+      debug_puts "get_var_methods_by_fragment whole: #{whole}, target_name: #{target_name}, method_fragment: #{method_fragment}, index"
+      name_val_pair = irb.irb_vars.find { |array| array[0] == target_name }
+      if name_val_pair
+        methods = name_val_pair[1].methods.grep /^#{method_fragment}/
+                                                return [whole.size + index - method_fragment.size, methods]
+      end
+      NO_MATCHES_PARAMS
+    end
+
+    def self.constant_complete(text, irb)
+      index = text =~ CONSTANT
+      whole = $1
+      fragment = $2
+      [whole.size + index - fragment.size, Object.constants.grep( /^#{fragment}/)]
+    end
+
+    def self.method_or_variable_complete(text, irb)
+      index = text =~ METHOD_OR_VARIABLE
+      whole = $1
+      fragment = $2
+      varnames = irb.irb_varnames.grep /^#{fragment}/
+      matching_methods = methods.grep /^#{fragment}/
+      [whole.size + index - fragment.size, varnames + matching_methods]
+    end
+
+    def self.global_complete(text, irb)
+      index = text =~ GLOBAL
+      whole = $1
+      fragment = $2
+      debug_puts "looking for |#{fragment}| from |#{text}|"
+      varnames = irb.irb_gvarnames.grep /^#{fragment}/
+      [whole.size + index - fragment.size - 1, varnames.map { |name| "$#{name}" }]
+    end
+
+    def self.debug_puts stuff
+      puts(stuff) if $CE_DEBUG  # completion_engine debug
+    end
+  end
+
+end

data/opal/opal_irb/completion_formatter.rb

@@ -0,0 +1,49 @@
+class Array
+  def in_groups_of(number, fill_with = nil)
+    if number.to_i <= 0
+      raise ArgumentError,
+            "Group size must be a positive integer, was #{number.inspect}"
+    end
+
+    if fill_with == false
+      collection = self
+    else
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - size % number) % number
+      collection = dup.concat(Array.new(padding, fill_with))
+    end
+
+    if block_given?
+      collection.each_slice(number) { |slice| yield(slice) }
+    else
+      collection.each_slice(number).to_a
+    end
+  end
+end
+
+class OpalIrb
+  # format completion in columns, like MRI irb
+  class CompletionFormatter
+    def self.format(choices)
+      new.format(choices)
+    end
+
+    def format(choices, width=80)
+      max_length = choices.inject(0) { |length, element| element.size > length ? element.size : length}
+      num_cols = (width/(max_length+1)).floor # coz this is JS
+
+      if max_length * num_cols == width
+        num_cols -= 1
+      end
+
+      column_width = max_length + ((width - (max_length * num_cols))/num_cols).floor
+
+      groups = choices.sort.in_groups_of(num_cols, false)
+      groups.map { |grouping| grouping.map { |choice| sprintf("%-#{column_width}s", choice) }.join }.join("\n") + "\n"
+    end
+  end
+
+
+end

data/opal/opal_irb/completion_results.rb

@@ -0,0 +1,88 @@
+class OpalIrb
+    # Used to store results and perform the correct actions on the console
+    # 3 cases:
+    # * No match
+    #   * no change to prompt
+    #   * insert_tab ==  true
+    # * There is a single match
+    #   * change prompt to the single match
+    #   * insert_tab == false
+    # * There are multiple matches
+    #   * show the matches
+    #   * change prompt to the max common prefix
+    #   * insert_tab == false
+    class CompletionResults
+
+      attr_reader :matches, :old_prompt, :new_prompt_text
+      def initialize(orig_text, match_index, matches)
+        @matches = matches || [] # Native#methods is nil, need to figure out how to handle it
+        # @insert_tab = matches.size > 0 ? false : true
+        @insert_tab = false
+
+        CompletionEngine.debug_puts "orig_text: |#{orig_text}| match_index: #{match_index} matches #{matches.inspect}"
+        if matches.size == 1
+          @new_prompt_text =  match_index == 0 ? matches.first : "#{orig_text[0..match_index-1]}#{matches.first}"
+        elsif matches.size > 1
+          @old_prompt = orig_text
+          @new_prompt_text = common_prefix_if_exists(orig_text, match_index, matches)
+        end
+      end
+
+      def common_prefix_if_exists(orig_text, match_index, results)
+        working_copy = results.clone
+        first_word = working_copy.shift
+        chars = []
+        i = 0
+        # first_word.each_char { |char|
+        letters = [] #- break is broken on 0.8.0 beta for each_char
+        first_word.each_char { |char| letters << char }
+        letters.each { |char|
+          if working_copy.all? { |str| str[i] == char }
+            chars << char
+            i += 1
+          else
+            break
+          end
+        }
+        common = chars.join
+        CompletionEngine.debug_puts "\torig_text: |#{orig_text}| common prefix: #{common} match_index: #{match_index}"
+        match_index == 0 ? common : orig_text[0..match_index-1] + common
+      end
+
+
+      def old_prompt?
+        @old_prompt
+      end
+
+      def matches?
+        @matches.size > 1
+      end
+
+      def new_prompt?
+        @new_prompt_text
+      end
+
+      # Tells the console whether or not to tab or not
+      def insert_tab?
+        @insert_tab
+      end
+      # writes an "old prompt" before showing matchings results, if there are matches
+      # @param jqconsole [Native] jq-console used by opal-irb
+      # @param jqconsole [String] the old class
+      def set_old_prompt(jqconsole, prompt, jqconsole_class)
+        jqconsole.Write("#{prompt}#{old_prompt}\n", jqconsole_class) if old_prompt?
+      end
+      # Displays matches if there are any
+      # @param jqconsole [Native] jq-console used by opal-irb
+      def display_matches(jqconsole)
+        jqconsole.Write(OpalIrb::CompletionFormatter.format(matches)) if matches?
+      end
+
+      # Updates the prompt to include the only match or most common prefix if there are any
+      # @param jqconsole [Native] jq-console used by opal-irb
+      def update_prompt(jqconsole)
+        jqconsole.SetPromptText(new_prompt_text) if new_prompt?
+      end
+
+    end
+end

data/opal/opal_irb.rb

@@ -0,0 +1,88 @@
+require 'opal'
+require 'opal/compiler'
+require 'object_extensions'
+require 'opal-parser'           # so I can have require_remote
+
+# 'require' a javascript filename over the internet, asynchronously,
+# so you'll have to delay before using.  Should be fine if typed by hand
+# but if scripted add delay
+def require_js(url)
+  # used to use this, but don't want to depend on opal-jquery
+  # Element.find("head").append("<script src='#{js_filename}' type='text/javascript'></script>")
+  %x|
+    var script = document.createElement( 'script' );
+    script.type = 'text/javascript';
+    script.src = url;
+    document.body.appendChild(script);
+  |
+end
+
+# 'require' a javascrit filename over the internet, synchronously.
+# Chrome complains that this is deprecated, so it might go away
+def require_js_sync(url)
+  %x|
+     var r = new XMLHttpRequest();
+     r.open("GET", url, false);
+     r.send('');
+     window.eval(r.responseText)
+  |
+  nil
+end
+
+class OpalIrb
+  def irb_vars
+    %x|irbVars = [];
+       for(variable in Opal.irb_vars) {
+         if(Opal.irb_vars.hasOwnProperty(variable)) {
+            irbVars.push([variable, Opal.irb_vars[variable]])
+         }
+       };
+       return irbVars;|
+  end
+
+  def irb_varnames
+    irb_vars.map { |varname, value| varname }
+  end
+
+  def irb_gvars
+    %x|gvars = [];
+       for(variable in Opal.gvars) {
+         if(Opal.gvars.hasOwnProperty(variable)) {
+            gvars.push([variable, Opal.gvars[variable]])
+         }
+       };
+       return gvars;|
+  end
+
+  def irb_gvarnames
+    irb_gvars.map { |varname, value| varname }
+  end
+
+  def opal_classes
+    classes = []
+    $opal_js_object = Native(`Opal`)    # have to make this global right now coz not seen in the each closure w/current opal
+    $opal_js_object.each {|k|
+      attr = $opal_js_object[k]
+      classes << attr if attr.is_a?(Class)
+    }
+    classes.uniq.sort_by { |cls| cls.name } # coz some Opal classes are the same, i.e. module == class, base, Kernel = Object
+  end
+
+  def opal_constants
+    constants = []
+    $opal_js_object = Native(`Opal`)    # have to make this global right now coz not seen in the each closure w/current opal
+    $opal_js_object.each {|k|
+      attr = $opal_js_object[k]
+      constants << attr
+    }
+    constants.uniq
+
+  end
+
+  attr_reader :parser
+
+  def parse(cmd)
+    Opal::Compiler.new(cmd, irb: true).compile
+  end
+
+end