ripl-fresh 0.1.2 → 0.2.0

data/.gemspec

@@ -11,8 +11,10 @@ Gem::Specification.new do |s|
   s.summary     = "Fresh Ruby Enhanced SHell"
   s.description = "Fresh Ruby Enhanced SHell automatically detects, if your current command should be Ruby or a system command."
   s.required_rubygems_version = ">= 1.3.6"
+  s.required_ruby_version = ">= 1.9"
   s.executables = ['ripl-fresh', 'fresh']
-  s.add_dependency 'ripl', '>= 0.2.5'
+  s.add_dependency 'ripl', '>= 0.2.6'
+  s.add_dependency 'ripl-multi_line', '>= 0.2.0'
   s.files = Dir.glob(%w[{lib,test}/**/*.rb bin/* [A-Z]*.{txt,rdoc} ext/**/*.{rb,c} **/deps.rip]) + %w{Rakefile .gemspec}
   s.extra_rdoc_files = ["README.rdoc", "LICENSE"]
   s.license = 'MIT'

data/CHANGELOG.rdoc

@@ -1,2 +1,21 @@
+== 0.2.0
+* Better system command error handling
+* Refactored command mode detection, changed configuration settings
+* Now you can redirect system results to ruby vars using => variable
+* Compatible with ripl-0.2.6 and ripl-multi_line-0.2.0
+* No more Ruby 1.8 support!
+* More little changes and doc updates
+
+== 0.1.2
+* Command mode detection changes
+* Added flexible fresh_prompt configuration
+  * set config[:fresh_prompt] to :PS1 to get your shell prompt, thanks to fallwith
+* Improved auto-completion
+
+== 0.1.1
+* Fixed cd command
+* Changed command_mode detection (using PATH)
+* Better autocompletion
+
 == 0.1.0
 * Initial release

data/README.rdoc

@@ -26,23 +26,20 @@ Note, that it will also load your <tt>.irbrc</tt> file. To avoid this, you can d
 
 == Usage & configuration options
 
-For an example session, see {this blog entry}[http://rbjl.net/43-use-fresh-ruby-as-your-shell].
+Just start the shell and play around, to get a fresh feeling. For an example session, see {this blog entry}[http://rbjl.net/43-use-fresh-ruby-as-your-shell].
 
-The main regexp to determine if the command should be interpreted as system command is similar to this one: <tt>/^[a-z_-]+\s+.*/i</tt> (match a single word followed by at least one space). It can be adjusted in <tt>Ripl.config[:fresh_match_regexp]</tt>.
+The main regexp to determine if the command should be interpreted as system command is similar to this one: <tt>/^\\w+\\s+.*/</tt> (match a single word followed by at least one space). See below for details.
 
-If this regexp matches or the input is a single word <tt>([a-z_-]+)</tt>, _fresh_ searches through the <tt>Ripl.config[:fresh_ruby_words]</tt> array for exceptions that still should get interpreted as Ruby (e.g. <tt>def </tt>).
+You can use the output of system commands and redirect it to a Ruby variable (or similar Ruby expression) like this:
 
-Then, the <tt>Ripl.config[:fresh_system_words]</tt> arrays is checked, if it contains the command. This array defaults to your <tt>ENV['PATH']</tt>. You can add your own system commands there.
+  ls => variable
 
-There is also a third kind of command mode (besides <tt>:ruby</tt> and <tt>:system</tt>): <tt>:mixed</tt>. They look and feel like system commands, but redirect to the Ruby method described by the first word. You can register them in <tt> Ripl.config[:fresh_mixed_words]</tt> (e.g. +cd+).
+Please note: The "=> variable" part has to be at the line ending.
+The output of the <tt>ls</tt> command is now stored as array in <tt>variable</tt> and can be used in the next line. There are three variations of this command: 
+* <tt>=>></tt> append result to the array specified (or create it)
+* <tt>~></tt>  use command as string instead of an array
+* <tt>~>></tt> use command as string instead of an array and append (or create it)
 
-As a fallback, _fresh_ checks <tt>Kernel.respond_to?</tt>, if there is a ruby method with that name.
-
-If the regexp does match, but the command could not be found in any of the three word arrays, the command mode will be set to <tt>Ripl.config[:fresh_match_default]</tt> (<tt>:ruby</tt>). If the regexp does not match, <tt>Ripl.config[:fresh_default]</tt> is used (also defaults to <tt>:ruby</tt>).
-
-Of course, there is a way to explicitly set your command mode: You can prefix your input with a space to force Ruby mode as well as you can prefix it with <tt>^</tt> to force system mode. The strings used for this can be customized in <tt>Ripl.config[:fresh_system_prefix]</tt> and <tt>Ripl.config[:fresh_ruby_prefix]</tt>.
-
-You need to take a look at <tt>get_input</tt> method in the source file to 100% understand the command mode detection way.
 
 === Prompt
 There is <tt>Riplc.config[:fresh_prompt]</tt> option, which takes a wide range of possible values. You can pass in a proc or a direct string. Furthermore, you can pass a symbol to get one of the following:
@@ -52,26 +49,34 @@ There is <tt>Riplc.config[:fresh_prompt]</tt> option, which takes a wide range o
 * <tt>:irb</tt> - use irbs :PROMPT_I (if set)
 * <tt>:simple</tt> - ">> "
 
+=== Command mode determination
+
+There are three different command modes: <tt>:ruby</tt>, <tt>:system</tt> and <tt>:mixed</tt>.
+
+<tt>:ruby</tt> is usual Ruby, <tt>:system</tt> means system command and <tt>:mixed</tt> looks like system command, but is just redirected to the Ruby method with that name.
+
+The input is matched against the regexps in <tt>Ripl.config[:fresh_patterns]</tt>. These regexps also contain named groups, to determine the command or if the command should be stored in a variable.
+
+When a regexp has matched, the command is searched for in <tt>Ripl.config[:fresh_ruby_commands]</tt>, <tt>Ripl.config[:fresh_system_commands]</tt> and <tt>Ripl.config[:fresh_mixed_commands]</tt> (in this order).
+
+The ruby command array contains some common Ruby words, e.g. <tt>def </tt>. The system command array is set to your <tt>ENV['PATH']</tt>. The mixed array currently contains only +cd+. You can adjust the arrays as you want to.
+
+As a fallback, _fresh_ checks <tt>Kernel.respond_to?</tt>, if there is a ruby method with that name.
+
+If the regexp did match, but the command could not be found in any of the three word arrays and <tt>respond_to?</tt> has not been successful, the command mode will be set to <tt>Ripl.config[:fresh_unknown_command_mode]</tt> (default <tt>:ruby</tt>). If the regexp did not match, <tt>Ripl.config[:fresh_default_mope]</tt> is used (default <tt>:ruby</tt>).
+
+You need to take a look at <tt>get_input</tt> method in the source file to 100% understand the command mode detection way.
+
+=== Patterns
+
+The <tt>Ripl.config[:fresh_patterns]</tt> contains three Regexps, which do the following:
+* match <tt>^</tt> to force system mode
+* match a single word
+* match a word followed by a space
+
 === Defaults
 
-  # prefixes
-  Ripl.config[:fresh_system_prefix]  = %w[^]
-  Ripl.config[:fresh_ruby_prefix]    = [' ']
-  # word arrays
-  Ripl.config[:fresh_ruby_words]     = %w[begin case class def for if module undef unless until while puts warn print p pp ap raise fail loop require load lambda proc system]
-  Ripl.config[:fresh_system_words]   =
-    ENV['PATH'].split(File::PATH_SEPARATOR).uniq.map {|e|
-      File.directory?(e) ? Dir.entries(e) : []
-    }.flatten.uniq - ['.', '..'] 
-  Ripl.config[:fresh_mixed_words]    = %w[cd] 
-  # main regexp
-  Ripl.config[:fresh_match_regexp]    = /^([a-z\/_-]+)\s+(?!(?:[=%*]|!=|\+=|-=|\/=))/i
-  # regex matched but word not in one of the three arrays, possible values: :ruby, :system, :mixed
-  Ripl.config[:fresh_match_default]   = :ruby
-  # regex did not match
-  Ripl.config[:fresh_default]         = :ruby
-  # configure prompt
-  Ripl.config[:fresh_prompt] = :default
+See <tt>lib/ripl/fresh/config.rb</tt> for all configuration options and its defaults.
 
 == Customization
 
@@ -87,20 +92,20 @@ There are lots of things which can get better:
 
 * Improve auto-completion
 * More cool (and colorful?) <tt>:mixed</tt> Ruby commands
-* Improve interaction between system and Ruby commands
-  * <tt>ripl-multi_line</tt> for system commands
-  * Result of system commands should be available for ruby, not only printed to stdout
-* Respect "..." (single argument) for :mixed commands
-* Improve default configuration
+  * Respect "..." (single argument) for :mixed commands
 * Add tests
+* Be compatible (and installable) with JRuby/Rubinius
 * Fresh ideas
 
 Feel free to fork in your improvements ;)
 
 == Other gems you might find interesting
 
-* {rush}[https://github.com/adamwiggins/rush] - Another Ruby shell, different concept
-* {ripl}[https://github.com/cldwalker/ripl] - An irb alternative, +fresh+ is based on it
+* {rush}[https://github.com/adamwiggins/rush]  - Another Ruby shell, different concept
+* {ripl}[https://github.com/cldwalker/ripl]    - An irb alternative, _fresh_ is based on it
+* {rubsh}[https://github.com/danielb2/rubsh]   - Some similar ideas
+* {urchin}[https://github.com/Spakman/urchin]  - More unix like approach
+* {rubish}[https://github.com/hayeah/rubish]   - And another approach
 
 == Copyright
 

data/Rakefile

@@ -26,3 +26,10 @@ desc "Validate the gemspec"
 task :gemspec do
   gemspec.validate
 end
+
+desc 'build dummy "fresh" gem'
+task :dummy_gem do
+  sh "gem build fresh.gemspec"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv "fresh-#{gemspec.version}.gem", 'pkg'
+end

data/lib/bond/completions/ripl-fresh.rb

@@ -1,5 +1,5 @@
 # no advanced auto completion, yet
-# todo: not only default options
+# TODO meaningful, fine-tuned, good autocompletion
 
 require 'readline'
 
@@ -18,16 +18,15 @@ everything_completion = proc{ # TODO: improve
 }
 
 
-complete :on => Ripl.config[:fresh_match_regexp],
-         :search => false,
-          &file_completion
+complete on: Regexp.union( *Ripl.config[:fresh_patterns].compact ),
+         search: false,
+         &file_completion
 
 # TODO fires only when space after ^
-complete :on => Ripl::Fresh.option_array_to_regexp( Ripl.config[:fresh_system_prefix] ),
-#         :search => false,
-          &system_command_completion
+complete on: Ripl.config[:fresh_patterns][0],
+         &system_command_completion
 
-complete :on => /^[a-z\/_-]*/i,
-          &everything_completion
+complete on: /^[a-z\/_-]*/i,
+         &everything_completion
 
 # J-_-L

data/lib/ripl/fresh/commands.rb

@@ -4,16 +4,11 @@ require 'fileutils'
 module Ripl
   module Fresh
     module Commands
-=begin
-      def ls(path='.')
-        Dir[ File.join( path, '*' )].map{|res| res =~ /^#{path}\/?/; $' }
-      end
-      alias dir ls
-=end
-
       def cd( path = File.expand_path('~') )
         new_last_path = FileUtils.pwd
-        if path == '-'
+        if path =~ /^\.{3,}$/
+          path = File.join( %w[..] * ($&.size-1) )
+        elsif path == '-'
           if @last_path
             path = @last_path
           else
@@ -29,4 +24,6 @@ module Ripl
   end
 end
 
-Ripl::Commands.send :include, Ripl::Fresh::Commands if defined? Ripl::Commands
+Ripl::Commands.send :include, Ripl::Fresh::Commands
+
+# J-_-L

data/lib/ripl/fresh/config.rb

@@ -0,0 +1,41 @@
+# configure prompt
+Ripl.config[:fresh_prompt] = :default
+
+# word arrays
+Ripl.config[:fresh_ruby_commands]     = %w[begin case class def for if module undef unless until while puts warn print p pp ap raise fail loop require load lambda proc]
+Ripl.config[:fresh_system_commands]   =
+  ENV['PATH'].split(File::PATH_SEPARATOR).uniq.map {|e|
+    File.directory?(e) ? Dir.entries(e) : []
+  }.flatten.uniq - ['.', '..'] 
+Ripl.config[:fresh_mixed_commands]    = %w[cd] 
+
+# a regex matched but command is not in one of the three arrays
+#  or regex did not match
+#  possible values: :ruby, :system, :mixed
+Ripl.config[:fresh_unknown_command_mode] = :ruby
+Ripl.config[:fresh_default_mode]         = :ruby
+
+# main regexes
+# $<command>: whole command_line
+# $<command_line>: only the system command (if possible)
+# $<result_operator>: (optional) result operator
+# $<result_storage>: (optional) variable to store command result
+# $<force>: force system command prefix
+# please note: although the main regexp looks pretty complicated, it's just an detailed version of
+#  /\w+\s+(=> \w)?/
+force           = '(?<force>[\^])'
+command         = '(?<command>[a-zA-Z\/_-]+)'
+result_operator = '(?<result_operator>[=|~]>{1,2})'
+result_storage  = '(?<result_storage>[a-zA-Z@\$_][a-zA-Z0-9@_\[\]:"\']*)'
+_store          = "(?:#{ result_operator }\s*#{ result_storage })?"  # matches for example: "=> here"
+_anything_but_these = '(?!(?:[=%*]|!=|\+=|-=|\/=)).*?'
+
+Ripl.config[:fresh_patterns] = [
+  /^#{ force }(?<command_line>.*?)#{ _store }$/,                             # [0] force system
+  nil, nil, nil, nil,
+  /^(?<command_line>#{ command })\s*#{ _store }$/,                           # [5] single word
+  nil, nil, nil, nil,
+  /^(?<command_line>#{ command }\s+#{ _anything_but_these })#{ _store }$/,   # [10] command + space
+]
+
+# J-_-L

data/lib/ripl/fresh/prompt.rb

@@ -1,17 +1,17 @@
-require 'socket'
-require 'etc'
-
 # save current prompt
-ripl_prompt = Ripl.config[:prompt] # TODO currently not working
+ripl_prompt = Ripl.config[:prompt] # FIXME currently not working
 
 # setup default prompt
-default_prompt = proc{ |path|
+default_prompt = proc{ |path = FileUtils.pwd|
   path.gsub! /#{ File.expand_path('~') }/, '~'
   path + '> '
 }
 
 # PS environment variable prompt
 ps_prompt = proc{ |prompt_number|
+  require 'socket'
+  require 'etc'
+
   prompt = ENV['PS' + prompt_number.to_s].dup
   prompt.gsub!('\a', '')                              # unsupported
   prompt.gsub!('\d', Time.now.strftime("%a %b %d"))
@@ -69,7 +69,7 @@ Ripl.config[:prompt] = proc{
 
   # call if proc or return directly
   if fp.respond_to? :call
-    fp.arity == 1 ? fp[ FileUtils.pwd ] : fp.call
+    fp[ FileUtils.pwd ]
   else
     case fp
     when nil, false
@@ -78,7 +78,7 @@ Ripl.config[:prompt] = proc{
       fp
     else
       Ripl.config[:fresh_prompt] = :default
-      default_proc.call[ FileUtils.pwd ]
+      default_proc.call
     end
   end
 }

data/lib/ripl/fresh.rb

@@ -3,151 +3,132 @@ require 'fileutils'
 
 module Ripl
   module Fresh
-    VERSION = '0.1.2'
-
-    class << self
-      # helper to parse options
-      def option_array_to_regexp(option)
-        case option
-        when Regexp # note: some options still _have_ to be arrays
-          option
-        when Array, Set
-          /^(#{
-            option.map{ |char|
-              Regexp.escape char.to_s
-            }*'|'
-          })/
-        else
-          option.to_s
-        end
-      end
+    VERSION = '0.2.0'
+
+    def before_loop
+      @command_mode = :ruby
+      @real_buffer  = nil
+      super
+      # register bond completion
+      Ripl.config[:completion][:gems] ||= []
+      Ripl.config[:completion][:gems] << 'ripl-fresh'
     end
 
-    module Shell
-      # setup Fresh
-      def before_loop
-        @command_mode = :ruby
-        super
-        # register bond completion
-        Ripl.config[:completion][:gems] ||= []
-        Ripl.config[:completion][:gems] << 'ripl-fresh'
-      end
-
-      # determine @command_mode
-      def get_input
-        input = super
-
-        return input  if @buffer # ripl-multi_line
-
-        @command_mode = case input
-        # force system with a single ^
-        when Ripl::Fresh.option_array_to_regexp( Ripl.config[:fresh_system_prefix] )
-          input = input[$1.size..-1] # TODO refactor, too hacky?
+    # determine @command_mode
+    def get_input
+      command_line = super
+
+      # This case statement decides the command mode,
+      #  and which part of the input should be used for what...
+      #  Note: Regexp match groups are used!
+      @result_storage = @result_operator = nil
+
+      @command_mode = case command_line
+      # force ruby with a space
+      when /^ /
+        :ruby
+      # regexp match shell commands
+      when *Array( Ripl.config[:fresh_patterns] ).compact
+        command_line     = $~[:command_line]     if $~.names.include? 'command_line'
+        command          = $~[:command]          if $~.names.include? 'command'
+        @result_operator = $~[:result_operator]  if $~.names.include? 'result_operator'
+        @result_storage  = $~[:result_storage]   if $~.names.include? 'result_storage'
+        forced           = !! $~[:force]         if $~.names.include? 'force'
+
+        if forced
           :system
-        # force ruby with a space
-        when Ripl::Fresh.option_array_to_regexp( Ripl.config[:fresh_ruby_prefix] )
-          input = input[$1.size..-1]
+        elsif Ripl.config[:fresh_ruby_commands].include?( command )
+          :ruby
+        elsif Ripl.config[:fresh_mixed_commands].include?( command )
+          :mixed
+        elsif Ripl.config[:fresh_system_commands].include?( command )
+          :system
+        elsif Kernel.respond_to? command.to_sym
           :ruby
-        # single words, and main regex to match shell commands
-        when /^([a-z_-]+)$/i, Ripl.config[:fresh_match_regexp]
-          if Ripl.config[:fresh_ruby_words].include?($1)
-            :ruby
-          elsif Ripl.config[:fresh_mixed_words].include?($1)
-            :mixed
-          elsif Ripl.config[:fresh_system_words].include?($1)
-            :system
-          elsif Kernel.respond_to? $1.to_sym
-            :ruby
-          else
-            Ripl.config[:fresh_match_default]
-          end
-        # default is still ruby ;)
         else
-          Ripl.config[:fresh_default]
+          Ripl.config[:fresh_unknown_command_mode]
         end
-
-        input
+      else
+        Ripl.config[:fresh_default_mode]
       end
 
-      # get result (depending on @command_mode)
-      def loop_eval(input)
-        if input == ''
-          @command_mode = :system and return
-        end
-
-        case @command_mode
-        when :system # execute command
-          ret = system input
-          case ret
-          when false
-            warn '[non-nil exit status]' # too verbose?
-          when nil
-            warn "[command error #{$?.exitstatus}]" # add message?
-          end
-          ret
-
-        when :mixed # call the ruby method, but with shell style arguments
-          m, *args = *input.split
-          super "#{m}(*#{args.to_s})"
+      command_line
+    end
 
-        else # good old :ruby
-          super
-        end
+    # get result (depending on @command_mode)
+    def loop_eval(input)
+      if input == ''
+        @command_mode = :system and return
       end
 
-
-      # system commands don't have output values and Ruby is displayed normally
-      def print_result(result)
-        if @error_raised ||
-             @command_mode == :system ||
-             @command_mode == :mixed && (!result || result == '')
-          # don't display anything
+      case @command_mode
+      when :system # generate ruby code to execute the command
+        if !@result_storage
+          ruby_command_code = "_ = system '#{ input }'\n"
         else
-          super # puts(format_result(result))
+          temp_file = "/tmp/ripl-fresh_#{ rand 12345678901234567890 }"
+          ruby_command_code = "_ = system '#{ input } 2>&1', :out => '#{ temp_file }'\n"
+          
+          # assign result to result storage variable
+          case @result_operator
+          when '=>', '=>>'
+            result_literal   = "[]"
+            formatted_result = "File.read('#{ temp_file }').split($/)"
+            operator = @result_operator == '=>>' ? '+=' : '='
+          when '~>', '~>>'
+            result_literal = "''"
+            formatted_result = "File.read('#{ temp_file }')"
+            operator = @result_operator == '~>>' ? '<<' : '='
+          end
+          ruby_command_code << %Q%
+            #{ @result_storage } ||= #{ result_literal }
+            #{ @result_storage } #{ operator } #{ formatted_result }
+            FileUtils.rm '#{ temp_file }'
+          %
         end
-      end
 
-      # catch ctrl+c
-      def loop_once(*args)
+        # ruby_command_code << "raise( SystemCallError.new $?.exitstatus ) if !_\n" # easy auto indent
+        ruby_command_code << "if !_
+                                raise( SystemCallError.new $?.exitstatus )
+                              end;"
+        
+        super @input = "(#{ ruby_command_code })"
+
+      when :mixed # call the ruby method, but with shell style arguments TODO more shell like (e.g. "")
+        method_name, *args = *input.split
+        super @input = "#{ method_name }(*#{ args })"
+
+      else # good old :ruby
         super
-      rescue Interrupt
-        @buffer = @error_raised = nil
-        puts '[C]'
-        retry
+      end
+    end
+
+    # system commands don't have output values and Ruby is displayed normally
+    def print_result(result)
+      if @error_raised ||
+           @command_mode == :system ||
+           @command_mode == :mixed && (!result || result == '')
+        # don't display anything
+      else
+        super # puts(format_result(result))
       end
     end
   end
 end
 
-# hook in (and work around readline loading behaviour)
+# load plugins and hook in (and work around readline loading behaviour)
 Ripl.config[:readline] = false
 require 'ripl/readline'
-Ripl::Shell.send :include, Ripl::Fresh::Shell
+require 'ripl/multi_line'
+Ripl::Shell.send :include, Ripl::Fresh
 
 # load :mixed commands
 require File.dirname(__FILE__) + '/fresh/commands'
 
-## fresh config ###
-
-# prefixes
-Ripl.config[:fresh_system_prefix]  = %w[^]
-Ripl.config[:fresh_ruby_prefix]    = [' ']
-# word arrays
-Ripl.config[:fresh_ruby_words]     = %w[begin case class def for if module undef unless until while puts warn print p pp ap raise fail loop require load lambda proc system]
-Ripl.config[:fresh_system_words]   =
-  ENV['PATH'].split(File::PATH_SEPARATOR).uniq.map {|e|
-    File.directory?(e) ? Dir.entries(e) : []
-  }.flatten.uniq - ['.', '..'] 
-Ripl.config[:fresh_mixed_words]    = %w[cd] 
-# main regexp
-Ripl.config[:fresh_match_regexp]    = /^([a-z\/_-]+)\s+(?!(?:[=%*]|!=|\+=|-=|\/=))/i
-# regex matched but word not in one of the three arrays, possible values: :ruby, :system, :mixed
-Ripl.config[:fresh_match_default]   = :ruby
-# regex did not match
-Ripl.config[:fresh_default]         = :ruby
-# configure prompt
-Ripl.config[:fresh_prompt] = :default
+# fresh config
+require File.dirname(__FILE__) + '/fresh/config'
 
+# fresh_prompt management
 require File.dirname(__FILE__) + '/fresh/prompt'
 
 # J-_-L

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Jan Lelis
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-25 00:00:00 +01:00
+date: 2010-12-03 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,10 +28,25 @@ dependencies:
         segments: 
         - 0
         - 2
-        - 5
-        version: 0.2.5
+        - 6
+        version: 0.2.6
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ripl-multi_line
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id002
 description: Fresh Ruby Enhanced SHell automatically detects, if your current command should be Ruby or a system command.
 email: mail@janlelis.de
 executables: 
@@ -45,6 +60,7 @@ extra_rdoc_files:
 files: 
 - lib/ripl/fresh/commands.rb
 - lib/ripl/fresh/prompt.rb
+- lib/ripl/fresh/config.rb
 - lib/ripl/fresh.rb
 - lib/ripl-fresh/bond_workaround.rb
 - lib/bond/completions/ripl-fresh.rb
@@ -71,8 +87,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version 
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 9
+      version: "1.9"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: