redcar-filter-through-command 1.3.0-java

data/README.md

@@ -0,0 +1,119 @@
+#✩‿✩ Filter Through Command
+_A Redcar Editor plugin for manipulating and displaying text using shell commands_
+
+**Filter Through Command** supports running the current line of a document as a shell script, as well as manipulating and displaying text using several options for input and output.
+
+
+##Installation
+
+Version 1.0 supports Redcar 0.8 and above, versions 1.1 and beyond support Redcar 0.12 and above only.
+
+###Redcar v0.12 and above:
+
+    gem install redcar-filter-through-command
+
+
+alternately, you can install from source:
+
+###Redcar v0.8 to v0.11:
+
+Download a build from the Downloads section and copy to `~/.redcar/plugins`, or build from source:
+
+    cd ~/.redcar/plugins
+    git clone git://github.com/kattrali/redcar-filter-through-command.git filter_through_command
+    git fetch origin --tags
+    git checkout 1.0  # or 1.1, etc
+
+
+##Usage
+
+### Running the current line or selection as a shell script
+
+Select `Plugins > Filter Through Command > Evaluate Text` to run the cursor line or selection as a shell script.
+
+![Evaluating a text as shell command](https://github.com/kattrali/redcar-filter-through-command/raw/master/docs/images/run%20command.png)
+
+### Filtering text through a shell script
+
+Select `Plugins > Filter Through Command > Open Speedbar...` to view command filtering options.
+Press the `Execute` button or press `Return` in the Command field to run a shell command with the selected options. To rerun the last used filter options, select `Plugins > Filter Through Command > Re-run Last Filter`, or use the keyboard shortcuts.
+
+**Autocompletion** is available for recently run commands, and the 10 most recent commands are available from the Command menu.
+
+####Input Options
+
+<table style="border:none">
+  <tbody>
+    <tr><td><strong>None</strong></td><td>Run a command without input</td></tr>
+    <tr><td><strong>Cursor Line</strong></td><td>Run a command using the text of the cursor line as input</td></tr>
+    <tr><td><strong>Cursor Word</strong></td><td>Run a command with the word containing the cursor as input</td></tr>
+    <tr><td><strong>Document</strong></td><td>Run a command with all of the text of the current document given as input</td></tr>
+    <tr><td><strong>Selection</strong></td><td>Run a command with the selected text or the cursor line text given as input</td></tr>
+  </tbody>
+</table>
+
+####Output Options
+
+<table style="border:none">
+  <tbody>
+    <tr><td><strong>Create new Document</strong></td><td>Insert output into a new document</td></tr>
+    <tr><td><strong>Discard</strong></td><td>Ignore output</td></tr>
+    <tr><td><strong>Insert as Text</strong></td><td>Insert output into the current document at the cursor</td></tr>
+    <tr><td><strong>Open as URL</strong></td><td>Open the output in a web browser as a URL</td></tr>
+    <tr><td><strong>Replace Document</strong></td><td>Replace the entire document with output</td></tr>
+    <tr><td><strong>Replace Selection</strong></td><td>Replace the selected text with output</td></tr>
+    <tr><td><strong>Show as HTML</strong></td><td>Open the output in a new HtmlTab or in the default browser</td></tr>
+    <tr><td><strong>Show as Popup</strong></td><td>Open the output in a popup dialog under the selected text or cursor line</td></tr>
+    <tr><td><strong>Show as HTML Popup</strong></td><td>Open the output in a popup dialog formatted as HTML</td></tr>
+  </tbody>
+</table>
+
+####Variable Substitution
+
+Filter through Command also provides substitution variables for commonly needed text in commands. Substitutions can be further shortened to # + lower case first letter. (Scope being the exception, instead using `#c`.)
+
+<table style="border:none">
+  <tbody>
+    <tr><td><strong>DOCUMENT (#d)</strong></td><td>All of the text of the current document</td></tr>
+    <tr><td><strong>LINE (#l)</strong></td><td>Text of the cursor line</td></tr>
+    <tr><td><strong>FILE_PATH (#f)</strong></td><td>The file path to the current document</td></tr>
+    <tr><td><strong>SELECTION (#s)</strong></td><td>Text of the current selection</td></tr>
+    <tr><td><strong>TEMP (#t)</strong></td><td>A new empty file, which is afterwards opened by Redcar</td></tr>
+    <tr><td><strong>WORD (#w)</strong></td><td>Text of the word containing the cursor</td></tr>
+    <tr><td><strong>SCOPE (#c)</strong></td><td>The current scope of the cursor</td></tr>
+  </tbody>
+</table>
+
+
+##Extending this Plugin
+
+Additional output types can be added by subclassing `FilterCommand::OutputFormat` and implementing the `supported_types` and `format(text,type)` methods, then including the new class in a Redcar plugin. Examples can be found in `lib/filter_command/formats`.
+
+
+##Screenshots
+
+![HTML Text before conversion to HAML](https://github.com/kattrali/redcar-filter-through-command/raw/redcar-0.12/docs/images/before.png)
+
+![HTML Text after conversion to HAML](https://github.com/kattrali/redcar-filter-through-command/raw/redcar-0.12/docs/images/after.png)
+
+_Converting HTML to Haml_
+
+![Example of HTML output](https://github.com/kattrali/redcar-filter-through-command/raw/master/docs/images/html%20output.png)
+
+_HTML Output_
+
+![Example of Popup output](https://github.com/kattrali/redcar-filter-through-command/raw/master/docs/images/popup%20output.png)
+
+_Popup Output_
+
+![Example of HTML Popup Output](https://github.com/kattrali/redcar-filter-through-command/raw/master/docs/images/html%20popup%20output.png)
+
+_HTML Popup_
+
+![Example of Autocompletion](https://github.com/kattrali/redcar-filter-through-command/raw/redcar-0.12/docs/images/autocomplete.png)
+
+_Autocompletion_
+
+![Example of Substitution](https://github.com/kattrali/redcar-filter-through-command/raw/redcar-0.12/docs/images/substitution.png)
+
+_Using Variable Substitution_

data/changes.md

@@ -0,0 +1,22 @@
+Changelog
+=========
+
+##1.3
+
+* Added cursor line and cursor word as input types
+
+##1.2
+
+* Added variable substitutions, like #d to insert the current document text and #f for the current file path
+* Set command area font to match editable tabs
+* Typed commands autocomplete from recently entered commands
+
+##1.1
+
+* Required Redcar version bumped to 0.12
+* Added command history
+* Saved commands also save input and output parameters
+
+##1.0
+
+Initial Version

data/lib/filter_command/autocompletion.rb

@@ -0,0 +1,42 @@
+
+module Redcar
+  class FilterCommand
+    # Command auto-completion manager
+    class Autocompletion
+
+      # Provides command suggestions for text snippets
+      # based on previously run commands
+      # @param [String] text the start of a command
+      # @return [Hash] a hash containing a command beginning with the given text, an input type, an output type, and which characters of the text to select.
+      def self.suggest text
+        match, completion,selection = nil
+        if text.length > 0
+          FilterCommand::History.recent_commands.each do |map|
+            if map['command'] == text
+              match = map unless match
+            elsif map['command'][0,text.length] == text
+              completion = map unless completion
+            end
+          end
+          if completion and not match
+            if !@typed or @typed != text
+              match  = completion
+              selection = [text.length,match['command'].length]
+            end
+          end
+          @typed = text
+          if match
+            {
+              'command'     => match['command'],
+              'input_type'  => match['input_type'],
+              'output_type' => match['output_type'],
+              'selection'   => selection
+            }
+          end
+        else
+          @typed_length = nil
+        end
+      end
+    end
+  end
+end

data/lib/filter_command/command_parser.rb

@@ -0,0 +1,58 @@
+
+module Redcar
+  class FilterCommand
+    # Finds, evaluates and replaces supported Redcar environment
+    # variables in shell commands
+    class CommandParser
+
+      # A list of supported variables
+      def self.supported_variables
+        ['SELECTION','DOCUMENT','WORD','LINE','SCOPE']
+      end
+
+      # Sets and inserts supported variables into the shell command enviroment
+      # and replaces shortened substitution characters
+      # @param [Redcar::Document] doc a document for use in the current command
+      # @param [String] command the command to be executed
+      def self.substitute_variables doc, command
+        output = {}
+        ENV['REDCAR_SELECTION'] = doc.selected_text if doc.selection?
+        ENV['REDCAR_DOCUMENT'] = doc.get_all_text
+        ENV['REDCAR_WORD'] = doc.current_word
+        ENV['REDCAR_LINE'] = doc.get_line(doc.cursor_line)
+        ENV['REDCAR_SCOPE'] = doc.cursor_scope
+        supported_variables.each do |var|
+          unless ENV['REDCAR_'+var].nil?
+            var_alias = var == 'SCOPE' ? '#c' : /(##{var.downcase.split(//).first})(\W|\z)/
+            var_env = to_env(var,Redcar.platform)
+            command = command.gsub(var,var_env).gsub(var_alias,"#{var_env}\\2")
+          end
+        end
+        if doc.mirror and doc.mirror.respond_to?(:path) and path = doc.mirror.path
+          path = "\\\\\"#{path}\\\\\""
+          command = command.gsub('FILE_PATH',path).gsub(/(#f)(\W|\z)/,"#{path}\\2")
+        end
+        if command.include?('TEMP') or command =~ /(#t)(\W|\z)/
+          temp = java.io.File.create_temp_file("tempfile",".txt")
+          temp.delete_on_exit
+          path = temp.get_absolute_path
+          output['temp'] = path
+          path = "\\\\\"#{path}\\\\\""
+          command = command.gsub('TEMP',path).gsub(/(#t)(\W|\z)/,path)
+        end
+        output['command'] = command
+        output
+      end
+
+      # Proper escaping for environment variables (platform-specific)
+      def self.to_env variable, platform
+        case platform
+        when :windows
+          return "%REDCAR_#{variable}%"
+        when :linux,:osx
+          return "\\\\\"$REDCAR_#{variable}\\\\\""
+        end
+      end
+    end
+  end
+end

data/lib/filter_command/commands.rb

@@ -0,0 +1,36 @@
+
+module Redcar
+  class FilterCommand
+    # Opens a filter speedbar in the current window
+    class OpenFilterSpeedbar < Redcar::Command
+      def execute
+        window = Redcar.app.focussed_window
+        speedbar = Redcar::FilterCommand::FilterSpeedbar.new
+        window.open_speedbar(speedbar)
+      end
+    end
+
+    # Reruns the last filter command, if available
+    class RerunLastFilter < Redcar::Command
+      def execute
+        if command = FilterCommand.command and
+          output = FilterCommand.output_type and
+          input = FilterCommand.input_type
+          FilterCommand::Evaluator.evaluate(command,input,output)
+        end
+      end
+    end
+
+    # Evaluates the currently selected text or cursor line as a shell command
+    class EvaluateText < Redcar::EditTabCommand
+      def execute
+        if doc.selection?
+          command = doc.selected_text
+        else
+          command = doc.get_line_without_end_of_line(doc.cursor_line)
+        end
+        FilterCommand::Evaluator.evaluate(command,"None",FilterCommand.output_type)
+      end
+    end
+  end
+end

data/lib/filter_command/evaluator.rb

@@ -0,0 +1,118 @@
+
+module Redcar
+  class FilterCommand
+    # The command parser and runner for FilterCommand
+    class Evaluator
+
+      # List of supported input types for command execution
+      def self.input_types
+        ['None','Selection','Document','Cursor Line','Cursor Word']
+      end
+
+      # Command processing before execution. If successful,
+      # the given command is run.
+      # @param [String] command the command to run
+      # @param [String] input the selected input format
+      # @param [String] output the selected output format
+      def self.evaluate(command,input,output)
+        win = Redcar.app.focussed_window
+        tab = win.focussed_notebook_tab
+        original_command = command.clone
+        unless input == "None"
+          if tab and tab.is_a?(Redcar::EditTab) and doc = tab.edit_view.document
+            case input
+            when "Selection"
+              if doc.selection?
+                selection = doc.selected_text
+              else
+                selection = doc.get_line_without_end_of_line(doc.cursor_line)
+              end
+              command = pipe_text(selection, command)
+            when "Document"
+              command  = pipe_text(doc.get_all_text, command)
+            when "Cursor Line"
+              command  = pipe_text(doc.get_line_without_end_of_line(doc.cursor_line), command)
+            when "Cursor Word"
+              command  = pipe_text(doc.current_word, command)
+            else
+              raise "Unknown input type found: #{input}"
+            end
+            result  = FilterCommand::CommandParser.substitute_variables(doc,command)
+            command = result['command']
+            temp    = result['temp']
+          else
+            tab_type_error input
+            return
+          end
+        end
+        execute_command win, command, input, output
+        if temp and File.exist?(temp)
+          Redcar::Project::Manager.open_file(temp)
+        end
+        FilterCommand::History.update_commands original_command, input, output
+      end
+
+      # The actual running of a command
+      # @param [Redcar::Window] window a Redcar window, generally the window containing the
+      # filter speedbar. If the current window has a project open, the process working directory
+      # will be the project directory.
+      # @param [String] command the command to be executed
+      # @param [String] input the selected input format
+      def self.execute_command window, command, input, output
+        if project = Project::Manager.in_window(window)
+          command = set_path command, project.path
+        end
+        pid, io_input, io_output, io_error = IO.popen4(command)
+        if error = io_error.read and error.empty?
+          format_text(io_output.read, output)
+        else
+          Redcar::Application::Dialog.message_box(error, :type => :error)
+        end
+      end
+
+      # Command post-processing.
+      # @param [String] text the text output of the the command process
+      # @param [String] output the selected output format
+      def self.format_text text, format
+        if format_class = OutputFormat.formats[format]
+          format_class.new.format(text,format)
+        else
+          raise "Unknown output type found: #{format}"
+        end
+      end
+
+      # Sets the working directory for a given command to a given path,
+      # and adds proper escaping (platform-specific).
+      # @param [String] command the command to be executed
+      # @param [String] path the desired running directory
+      def self.set_path command, path
+        case Redcar.platform
+        when :osx, :linux
+          command = "sh -c \"cd \\\"#{path}\\\" && #{command}\""
+        when :windows
+          command = "cd \"#{path.gsub('/', '\\')}\" & #{command}"
+        end
+        command
+      end
+
+      private
+
+      def self.tab_type_error type
+        Redcar::Application::Dialog.message_box(
+          "This command currently cannot be run with #{type} as the Input type." +
+          " The focussed tab is not an editable tab.")
+      end
+
+      def self.pipe_text text, command
+        ENV['REDCAR_FILTER_TEXT'] = text
+        case Redcar.platform
+        when :osx, :linux
+          command   = "echo \\\"$REDCAR_FILTER_TEXT\\\" | #{command}"
+        when :win
+          command   = "echo %REDCAR_FILTER_TEXT% | #{command}"
+        end
+        command
+      end
+    end
+  end
+end

data/lib/filter_command/filter_speedbar.rb

@@ -0,0 +1,70 @@
+
+module Redcar
+  class FilterCommand
+    class FilterSpeedbar < Redcar::Speedbar
+      include Redcar::Observable
+
+      def initialize
+        win = Redcar.app.focussed_window
+        if win and tab = win.focussed_notebook_tab and tab.is_a?(Redcar::EditTab)
+          command.value = tab.edit_view.document.selected_text
+          input = 'None'
+        end
+        set_commands
+        input_type.items  = FilterCommand::Evaluator.input_types
+        input_type.value  = input || FilterCommand::History.input_type
+        output_type.items = FilterCommand::OutputFormat.formats.keys.sort
+        output_type.value = FilterCommand::History.output_type
+      end
+
+      def set_commands
+        command.items = FilterCommand::History.command_list[0..10]
+        command.value = FilterCommand::History.command
+      end
+
+      def set_font
+        @font = Swt::Graphics::Font.new(
+          ApplicationSWT.display,
+          EditView.font,
+          EditView.font_size,
+          Swt::SWT::NORMAL)
+        win = Redcar.app.focussed_window
+        @command_widget = win.speedbar.controller.focussable_widgets.first
+        @command_widget.font = @font
+      end
+
+      def close
+        @command_widget = nil
+        @font.dispose if @font and not @font.disposed?
+      end
+
+      label :command_label, "Command:"
+      combo :command, [], "", true do
+        set_font unless @font
+        if completion = FilterCommand::Autocompletion.suggest(command.value)
+          input_type.value     = completion['input_type']
+          output_type.value    = completion['output_type']
+          command.value        = completion['command']
+          @command_widget.text = completion['command']
+          if selection = completion['selection']
+            point = Swt::Graphics::Point.new(selection.first,selection.last)
+            @command_widget.selection = point
+          end
+        end
+      end
+
+      label :input_label, "Input:"
+      combo :input_type
+
+      label :output_label, "Output:"
+      combo :output_type
+
+      button :execute, "Execute", "Return" do
+        unless command.value.empty?
+          FilterCommand::Evaluator.evaluate(command.value, input_type.value, output_type.value)
+          set_commands
+        end
+      end
+    end
+  end
+end

data/lib/filter_command/formats/discard.rb

@@ -0,0 +1,12 @@
+
+module Redcar
+  class FilterCommand
+    # An output format for displaying nothing after execution
+    class DiscardOutput < OutputFormat
+      supported_types "Discard"
+
+      def format text, type
+      end
+    end
+  end
+end

data/lib/filter_command/formats/insert.rb

@@ -0,0 +1,40 @@
+
+module Redcar
+  class FilterCommand
+
+    # Output formats for inserting command output into a document.
+    # Currently supported formats are 'Insert as Text' and 'Create new Document'
+    class InsertOutput < OutputFormat
+      supported_types "Insert as Text", "Create new Document"
+
+      def format text, type
+        case type
+        when "Insert as Text"
+          if edit_tab_focussed?
+            if doc = tab.edit_view.document
+              if doc.selection?
+                line = doc.line_at_offset(doc.selection_range.last)
+                offset = doc.offset_at_line_end(line)
+              else
+                offset = doc.cursor_line_end_offset
+              end
+              unless doc.get_line(doc.line_at_offset(offset)).to_java.ends_with newline
+                text = "#{newline}#{text}"
+              end
+              doc.insert(offset,text)
+              doc.cursor_offset = offset + text.length
+            end
+          else
+            missing_edit_tab(type)
+          end
+        when "Create new Document"
+          win = Redcar.app.focussed_window
+          tab = win.new_tab(Redcar::EditTab)
+          tab.edit_view.document.text = text
+          tab.edit_view.reset_undo
+          tab.focus
+        end
+      end
+    end
+  end
+end

data/lib/filter_command/formats/replace.rb

@@ -0,0 +1,29 @@
+
+module Redcar
+  class FilterCommand
+    # Output formats for replacing text in the current document
+    # Currently supported outputs are 'Replace Selection' and 'Replace Document'
+    class ReplaceInput < OutputFormat
+      supported_types "Replace Selection", "Replace Document"
+
+      def format text, type
+        if edit_tab_focussed?
+          case type
+          when "Replace Selection"
+            doc = tab.edit_view.document
+            if doc.selection?
+              doc.replace_selection text
+            else
+              text= text+newline unless text.to_java.ends_with newline
+              doc.replace_line(doc.cursor_line,text)
+            end
+          when "Replace Document"
+            tab.edit_view.document.text = text
+          end
+        else
+          missing_edit_tab(type)
+        end
+      end
+    end
+  end
+end

data/lib/filter_command/formats/show.rb

@@ -0,0 +1,44 @@
+
+module Redcar
+  class FilterCommand
+    # An output format for displaying command output to the user
+    # in a specially-formatted way.
+    # Supported Formats:
+    # - Show as HTML: Displays command output in a new browser tab or window
+    # - Show as Popup: Displays command output in a text popup under the cursor in the current document
+    # - Show as HTML Popup: Displays command output in a popup under the cursor in the current document using HTML markup
+    # - Open as URL: Opens the command output as a URL in a new browser tab or window
+    class ShowText < OutputFormat
+      supported_types "Show as HTML", "Show as Popup", "Show as HTML Popup", "Open as URL" #, "Show as Tooltip"
+
+      def format text, type
+        name = "Command Output"
+        case type
+        when "Show as HTML"
+          output = java.io.File.create_temp_file("output","html")
+          output.delete_on_exit
+          path = output.get_absolute_path
+          File.open(path,'w') {|f| f.puts(text)}
+          url = File.expand_path(path)
+          Redcar::HtmlView::DisplayWebContent.new(name,url,false).run
+        when "Open as URL"
+          Redcar::HtmlView::DisplayWebContent.new(name,text.strip,false).run
+        when "Show as HTML Popup"
+          if edit_tab_focussed?
+            Redcar::Application::Dialog.popup_html(text,:below_cursor)
+          else
+            missing_edit_tab type
+          end
+        when "Show as Popup"
+          if edit_tab_focussed?
+            Redcar::Application::Dialog.popup_text(name,text,:below_cursor)
+          else
+            missing_edit_tab type
+          end
+        when "Show as Tooltip"
+          Redcar::Application::Dialog.tool_tip(text,:cursor)
+        end
+      end
+    end
+  end
+end

data/lib/filter_command/history.rb

@@ -0,0 +1,61 @@
+
+module Redcar
+  class FilterCommand
+    # Plugin storage manager for FilterCommand
+    class History
+
+      # How many recent commands to save
+      STORAGE_SIZE = 30
+
+      # The last or default used output format
+      # @return [String]
+      def self.output_type
+        @output_type ||= "Replace Selection"
+      end
+
+      # The last or default used input format
+      # @return [String]
+      def self.input_type
+        @input_type ||= "Selection"
+      end
+
+      # The most recently run command
+      # @return [String]
+      def self.command
+        @command ||= ""
+      end
+
+      # The commands and formats stored in history
+      # @return [Hash]
+      def self.recent_commands
+        FilterCommand.storage['recent_commands']
+      end
+
+      # The commands stored in history
+      # @return [Array] list of commands
+      def self.command_list
+        items = []
+        recent_commands.each {|map| items << map['command'] }
+        items
+      end
+
+      # Clears all saved commands
+      def self.clear
+        FilterCommand.storage['recent_commands'] = []
+      end
+
+      # Prepends a command and formats into recent history
+      # @param [String] command the command
+      # @param [String] input_type which input format was used
+      # @param [String] output_type which output format was used
+      def self.update_commands command, input_type, output_type
+        @command, @input_type, @output_type = command, input_type, output_type
+        commands = FilterCommand.storage['recent_commands']
+        commands.reject! {|item| item['command'] == @command}
+        commands.unshift({"command" => @command,"input_type" => @input_type, "output_type" => @output_type })
+        commands = commands[0..STORAGE_SIZE]
+        FilterCommand.storage['recent_commands'] = commands
+      end
+    end
+  end
+end

data/lib/filter_command/output_format.rb

@@ -0,0 +1,62 @@
+
+module Redcar
+  class FilterCommand
+    # A means of displaying text. New output formats can be defined by
+    # extending OutputFormat and implementing the `type` and
+    # `format` methods
+    class OutputFormat
+      # A Hash of all known formats
+      def self.formats
+        @types ||= {}
+      end
+
+      # The generator method for `formats`
+      def self.supported_types(*names)
+        if names.any?
+          names.each {|n| OutputFormat.formats[n] = self }
+          @supported_types = supported_types + names
+        else
+          @supported_types ||= []
+        end
+      end
+
+      # A check whether an editable tab is currently focussed in Redcar
+      def edit_tab_focussed?
+        tab and tab.is_a?(Redcar::EditTab)
+      end
+
+      # The currently focussed tab
+      def tab
+        win = Redcar.app.focussed_window
+        win.focussed_notebook_tab
+      end
+
+      # A newline character (platform-specific)
+      def newline
+        if Redcar.platform == :win
+          newline = "\r\n"
+        else
+          newline = "\n"
+        end
+      end
+
+      # The error message indicating that the currently selected output format
+      # requires the current tab to be an editable tab
+      def missing_edit_tab type
+        Redcar::Application::Dialog.message_box("To use the #{type} output format, the current tab must be an edit tab.")
+      end
+
+      # A name or list of names of supported output formats for the current class
+      def type
+        raise "A name has not been defined by #{self.class.name}. This text is displayed in the Filter Command speedbar."
+      end
+
+      # Where the work happens! This method is called when there is text to be processed
+      # @param [String] text the text to be formatted
+      # @param [String] type a name of a defined output type for the current class
+      def format text, type
+        raise "A format method has not been defined by #{self.class.name}"
+      end
+    end
+  end
+end

data/lib/filter_command.rb

@@ -0,0 +1,56 @@
+
+require 'java'
+require 'filter_command/autocompletion'
+require 'filter_command/commands'
+require 'filter_command/command_parser'
+require 'filter_command/evaluator'
+require 'filter_command/filter_speedbar'
+require 'filter_command/history'
+require 'filter_command/output_format'
+require 'filter_command/formats/discard'
+require 'filter_command/formats/insert'
+require 'filter_command/formats/replace'
+require 'filter_command/formats/show'
+
+module Redcar
+  # A Shell Command Runner and Parser with support for many output formats
+  class FilterCommand
+
+    # Defined Menu Items to display in Redcar
+    def self.menus
+      Menu::Builder.build do
+        sub_menu "Plugins" do
+          sub_menu "Filter Through Command" do
+            item "Open Speedbar...", FilterCommand::OpenFilterSpeedbar
+            item "Re-run Last Filter", FilterCommand::RerunLastFilter
+            item "Evaluate Text", FilterCommand::EvaluateText
+          end
+        end
+      end
+    end
+
+    # Registered Default Keybindings
+    def self.keymaps
+      osx = Redcar::Keymap.build("main", :osx) do
+        link "Cmd+Shift+R", OpenFilterSpeedbar
+        link "Ctrl+L", RerunLastFilter
+        link "Ctrl+R", EvaluateText
+      end
+      linwin = Redcar::Keymap.build("main", [:linux, :windows]) do
+        link "Alt+O", OpenFilterSpeedbar
+        link "Alt+U", RerunLastFilter
+        link "Alt+R", EvaluateText
+      end
+      [osx, linwin]
+    end
+
+    # Plugin Storage for recently run commands
+    def self.storage
+      @storage ||= begin
+        storage = Plugin::Storage.new('filter_through_command')
+        storage.set_default('recent_commands', [])
+        storage
+      end
+    end
+  end
+end

data/license

@@ -0,0 +1,9 @@
+LICENSE
+
+Copyright (c) 2011 Delisa Mason
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/plugin.rb

@@ -0,0 +1,8 @@
+Plugin.define do
+  name    "Filter Through Command"
+  version "1.3"
+  file    "lib", "filter_command"
+  object  "Redcar::FilterCommand"
+  dependencies "redcar", ">0",
+               "application",">0"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: redcar-filter-through-command
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.3.0
+platform: java
+authors: 
+  - Delisa Mason
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-01 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: redcar-dev
+    version_requirements: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ~>
+          - !ruby/object:Gem::Version 
+            version: 0.12.16dev
+    requirement: *id001
+    prerelease: false
+    type: :runtime
+  - !ruby/object:Gem::Dependency 
+    name: cucumber
+    version_requirements: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    requirement: *id002
+    prerelease: false
+    type: :development
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    version_requirements: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    requirement: *id003
+    prerelease: false
+    type: :development
+  - !ruby/object:Gem::Dependency 
+    name: rcov
+    version_requirements: &id004 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    requirement: *id004
+    prerelease: false
+    type: :development
+  - !ruby/object:Gem::Dependency 
+    name: yard
+    version_requirements: &id005 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    requirement: *id005
+    prerelease: false
+    type: :development
+description: Filter Through Command - A Redcar Editor plugin which supports running the current line of a document as a shell script, as well as manipulating and displaying text using shell commands with several options for input and output.
+email: iskanamagus@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - lib/filter_command.rb
+  - lib/filter_command/history.rb
+  - lib/filter_command/evaluator.rb
+  - lib/filter_command/autocompletion.rb
+  - lib/filter_command/output_format.rb
+  - lib/filter_command/filter_speedbar.rb
+  - lib/filter_command/commands.rb
+  - lib/filter_command/command_parser.rb
+  - lib/filter_command/formats/show.rb
+  - lib/filter_command/formats/replace.rb
+  - lib/filter_command/formats/discard.rb
+  - lib/filter_command/formats/insert.rb
+  - license
+  - README.md
+  - changes.md
+  - plugin.rb
+homepage: http://github.com/kattrali/redcar-filter-through-command
+licenses: 
+  - MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 2
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 2
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Redcar Editor plugin for manipulating text using shell commands
+test_files: []
+