RubyGems - pwkeep - Versions diffs - 0.0.3 → 0.0.4 - Mend

pwkeep 0.0.3 → 0.0.4

Files changed (32) hide show

data/.gitignore +1 -0
data/Gemfile.lock +3 -13
data/README.md +4 -2
data/Rakefile +5 -0
data/doc/PWKeep.html +323 -0
data/doc/PWKeep/Config.html +192 -0
data/doc/PWKeep/Editor.html +778 -0
data/doc/PWKeep/EditorApplication.html +1221 -0
data/doc/PWKeep/Exception.html +123 -0
data/doc/PWKeep/Main.html +805 -0
data/doc/PWKeep/StatusBar.html +436 -0
data/doc/PWKeep/Storage.html +1128 -0
data/doc/_index.html +191 -0
data/doc/class_list.html +54 -0
data/doc/css/common.css +1 -0
data/doc/css/full_list.css +57 -0
data/doc/css/style.css +338 -0
data/doc/file.README.html +145 -0
data/doc/file_list.html +56 -0
data/doc/frames.html +28 -0
data/doc/index.html +145 -0
data/doc/js/app.js +214 -0
data/doc/js/full_list.js +178 -0
data/doc/js/jquery.js +4 -0
data/doc/method_list.html +371 -0
data/doc/top-level-namespace.html +112 -0
data/lib/pwkeep.rb +0 -1
data/lib/pwkeep/editor.rb +8 -457
data/lib/pwkeep/main.rb +36 -13
data/lib/pwkeep/storage.rb +22 -12
data/pwkeep.gemspec +2 -2
metadata +26 -4

@@ -0,0 +1,112 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>
+  Top Level Namespace
+    &mdash; Documentation by YARD 0.8.6.2
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  hasFrames = window.top.frames.main ? true : false;
+  relpath = '';
+  framesUrl = "frames.html#!" + escape(window.location.href);
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div id="header">
+      <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+  <div class="noframes"><span class="title">(</span><a href="." target="_top">no frames</a><span class="title">)</span></div>
+</div>
+      <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+      Class List
+    </a>
+    <a class="full_list_link" id="method_list_link"
+        href="method_list.html">
+      Method List
+    </a>
+    <a class="full_list_link" id="file_list_link"
+        href="file_list.html">
+      File List
+    </a>
+</div>
+      <div class="clear"></div>
+    </div>
+    <iframe id="search_frame"></iframe>
+    <div id="content"><h1>Top Level Namespace
+</h1>
+<dl class="box">
+</dl>
+<div class="clear"></div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <span class='object_link'><a href="PWKeep.html" title="PWKeep (module)">PWKeep</a></span>
+</p>
+</div>
+    <div id="footer">
+  Generated on Thu Jan  9 16:06:06 2014 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.8.6.2 (ruby-1.9.3).
+</div>
+  </body>
+</html>

data/lib/pwkeep.rb CHANGED

@@ -6,7 +6,6 @@ require 'pathname'
 require 'colorize'
 require 'lockfile'
 require 'openssl'
-require 'ruco'
 module PWKeep
   extend self

data/lib/pwkeep/editor.rb CHANGED

@@ -1,462 +1,13 @@
-require 'clipboard'
+require 'open3'
 module PWKeep
-  def self.run_editor(data, options)
-    ret = [false, data]
-    Dispel::Screen.open do |screen|
-      $ruco_screen = screen
-      app = PWKeep::EditorApplication.new(data.to_s,
-        :lines => screen.lines, :columns => screen.columns
-      )
-      screen.draw *app.display_info
-      Dispel::Keyboard.output do |key|
-        if key == :resize
-          app.resize(screen.lines, screen.columns)
-        else
-          result = app.key key
-          if result == :quit
-            ret = [app.editor.saved_content != data, app.editor.saved_content]
-            break
-          end
-        end
-        screen.draw *app.display_info
-      end
-    end
-    return ret
-  end
-  class EditorApplication
-    attr_reader :editor, :status, :command, :options
-    def initialize(data, options)
-      @options = Ruco::OptionAccessor.new(options)
-      @data = data
-      setup_actions
-      setup_keys
-      create_components
-    end
-    def display_info
-      [view, style_map, cursor]
-    end
-    def view
-      [status.view, editor.view, command.view].join("\n")
-    end
-    def style_map
-      status.style_map + editor.style_map + command.style_map
-    end
-    def cursor
-      Ruco::Position.new(@focused.cursor.line + @status_lines, @focused.cursor.column)
-    end
-    # user typed a key
-    def key(key)
-      # deactivate select_mode if its not re-enabled in this action
-      @select_mode_was_on = @select_mode
-      @select_mode = false
-      if bound = @bindings[key]
-        return execute_action(bound)
-      end
-      case key
-      # move
-      when :down then move_with_select_mode :relative, 1,0
-      when :right then move_with_select_mode :relative, 0,1
-      when :up then move_with_select_mode :relative, -1,0
-      when :left then move_with_select_mode :relative, 0,-1
-      when :page_up then move_with_select_mode :page_up
-      when :page_down then move_with_select_mode :page_down
-      when :"Ctrl+right", :"Alt+f" then move_with_select_mode :jump, :right
-      when :"Ctrl+left", :"Alt+b" then move_with_select_mode :jump, :left
-      # select
-      when :"Shift+down" then @focused.selecting { move(:relative, 1, 0) }
-      when :"Shift+right" then @focused.selecting { move(:relative, 0, 1) }
-      when :"Shift+up" then @focused.selecting { move(:relative, -1, 0) }
-      when :"Shift+left" then @focused.selecting { move(:relative, 0, -1) }
-      when :"Ctrl+Shift+left", :"Alt+Shift+left" then @focused.selecting{ move(:jump, :left) }
-      when :"Ctrl+Shift+right", :"Alt+Shift+right" then @focused.selecting{ move(:jump, :right) }
-      when :"Shift+end" then @focused.selecting{ move(:to_eol) }
-      when :"Shift+home" then @focused.selecting{ move(:to_bol) }
-      # modify
-      when :tab then
-        if @editor.selection
-          @editor.indent
-        else
-          @focused.insert("\t")
-        end
-      when :"Shift+tab" then @editor.unindent
-      when :enter then @focused.insert("\n")
-      when :backspace then @focused.delete(-1)
-      when :delete then @focused.delete(1)
-      when :escape then # escape from focused
-        @focused.reset
-        @focused = editor
-      else
-        @focused.insert(key) if key.is_a?(String)
-      end
-    end
-    def bind(key, action=nil, &block)
-      raise "Ctrl+m cannot be bound" if key == :"Ctrl+m" # would shadow enter -> bad
-      raise "Cannot bind an action and a block" if action and block
-      @bindings[key] = action || block
-    end
-    def action(name, &block)
-      @actions[name] = block
-    end
-    def ask(question, options={}, &block)
-      @focused = command
-      command.ask(question, options) do |response|
-        @focused = editor
-        block.call(response)
-      end
-    end
-    def loop_ask(question, options={}, &block)
-      ask(question, options) do |result|
-        finished = (block.call(result) == :finished)
-        loop_ask(question, options, &block) unless finished
-      end
-    end
-    def configure(&block)
-      instance_exec(&block)
-    end
-    def resize(lines, columns)
-      @options[:lines] = lines
-      @options[:columns] = columns
-      create_components
-      @editor.resize(editor_lines, columns)
-    end
-    private
-    def setup_actions
-      @actions = {}
-      action :paste do
-        @focused.insert(Clipboard.paste)
-      end
-      action :copy do
-        Clipboard.copy(@focused.text_in_selection)
-      end
-      action :cut do
-        Clipboard.copy(@focused.text_in_selection)
-        @focused.delete(0)
-      end
-      action :save do
-        result = editor.save
-        if result != true
-          ask("#{result.slice(0,100)} -- Enter=Retry Esc=Cancel "){ @actions[:save].call }
-        end
-      end
-      action :quit do
-        if editor.modified?
-          ask("Lose changes? Enter=Yes Esc=Cancel") do
-            editor.store_session
-            :quit
-          end
-        else
-          editor.store_session
-          :quit
-        end
-      end
-      action :go_to_line do
-        ask('Go to Line: ') do |result|
-          editor.move(:to_line, result.to_i - 1)
-        end
-      end
-      action :delete_line do
-        editor.delete_line
-      end
-      action :select_mode do
-        @select_mode = !@select_mode_was_on
-      end
-      action :select_all do
-        @focused.move(:to, 0, 0)
-        @focused.selecting do
-          move(:to, 9999, 9999)
-        end
-      end
-      action :find do
-        ask("Find: ", :cache => true) do |result|
-          next if editor.find(result)
-          if editor.content.include?(result)
-            ask("No matches found -- Enter=First match ESC=Stop") do
-              editor.move(:to, 0,0)
-              editor.find(result)
-            end
-          else
-            ask("No matches found in entire file", :auto_enter => true){}
-          end
-        end
-      end
-      action :find_and_replace do
-        ask("Find: ", :cache => true) do |term|
-          if editor.find(term)
-            ask("Replace with: ", :cache => true) do |replace|
-              loop_ask("Replace=Enter Skip=s All=a Cancel=Esc", :auto_enter => true) do |ok|
-                case ok
-                when '' # enter
-                  editor.insert(replace)
-                when 'a'
-                  stop = true
-                  editor.insert(replace)
-                  editor.insert(replace) while editor.find(term)
-                when 's' # do nothing
-                else
-                  stop = true
-                end
-                :finished if stop or not editor.find(term)
-              end
-            end
-          end
-        end
-      end
-      action(:undo){ @editor.undo if @focused == @editor }
-      action(:redo){ @editor.redo if @focused == @editor }
-      action(:move_line_up){ @editor.move_line(-1) if @focused == @editor }
-      action(:move_line_down){ @editor.move_line(1) if @focused == @editor }
-      action(:move_to_eol){ move_with_select_mode :to_eol }
-      action(:move_to_bol){ move_with_select_mode :to_bol }
-      action(:insert_hash_rocket){ @editor.insert(' => ') }
-    end
-    def setup_keys
-      @bindings = {}
-      bind :"Ctrl+s", :save
-      bind :"Ctrl+w", :quit
-      bind :"Ctrl+q", :quit
-      bind :"Ctrl+g", :go_to_line
-      bind :"Ctrl+f", :find
-      bind :"Ctrl+r", :find_and_replace
-      bind :"Ctrl+b", :select_mode
-      bind :"Ctrl+a", :select_all
-      bind :"Ctrl+d", :delete_line
-      bind :"Ctrl+l", :insert_hash_rocket
-      bind :"Ctrl+x", :cut
-      bind :"Ctrl+c", :copy
-      bind :"Ctrl+v", :paste
-      bind :"Ctrl+z", :undo
-      bind :"Ctrl+y", :redo
-      bind :"Alt+Ctrl+down", :move_line_down
-      bind :"Alt+Ctrl+up", :move_line_up
-      bind :end, :move_to_eol
-      bind :"Ctrl+e", :move_to_eol # for OsX
-      bind :home, :move_to_bol
-    end
-    def load_user_config
-      Ruco.application = self
-      config = File.expand_path(@options[:rc] || "~/.ruco.rb")
-      load config if File.exist?(config)
-    end
-    def create_components
-      @status_lines = 1
-      editor_options = @options.slice(
-        :columns, :convert_tabs, :convert_newlines, :undo_stack_size, :color_theme
-      ).merge(
-        :window => @options.nested(:window),
-        :history => @options.nested(:history),
-        :lines => editor_lines
-      ).merge(@options.nested(:editor))
-      @editor ||= PWKeep::Editor.new(@data, editor_options)
-      @status = PWKeep::StatusBar.new(@editor, @options.nested(:status_bar).merge(:columns => options[:columns]))
-      @command = Ruco::CommandBar.new(@options.nested(:command_bar).merge(:columns => options[:columns]))
-      command.cursor_line = editor_lines
-      @focused = @editor
-    end
-    def editor_lines
-      command_lines = 1
-      @options[:lines] - @status_lines - command_lines
-    end
-    def parse_file_and_line(file)
-      if file.to_s.include?(':') and not File.exist?(file)
-        short_file, go_to_line = file.split(':',2)
-        if File.exist?(short_file)
-          file = short_file
-        else
-          go_to_line = nil
-        end
-      end
-      [file, go_to_line]
-    end
-    def move_with_select_mode(*args)
-      @select_mode = true if @select_mode_was_on
-      if @select_mode
-        @focused.selecting do
-          move(*args)
-        end
-      else
-        @focused.send(:move, *args)
-      end
-    end
-    def execute_action(action)
-      if action.is_a?(Symbol)
-        @actions[action].call
-      else
-        action.call
-      end
-    end
-  end
-  class Editor
-    attr_reader :file
-    attr_reader :text_area
-    attr_reader :history
-    attr_reader :saved_content
-    private :text_area
-    delegate :view, :style_map, :cursor, :position,
-      :insert, :indent, :unindent, :delete, :delete_line,
-      :redo, :undo, :save_state,
-      :selecting, :selection, :text_in_selection, :reset,
-      :move, :resize, :move_line,
-      :to => :text_area
-    def initialize(data, options)
-      @options = options
-      content = data
-      @options[:language] ||= LanguageSniffer.detect(@file, :content => content).language
-      content.tabs_to_spaces! if @options[:convert_tabs]
-      # cleanup newline formats
-      @newline = content.match("\r\n|\r|\n")
-      @newline = (@newline ? @newline[0] : "\n")
-      content.gsub!(/\r\n?/,"\n")
-      @saved_content = content
-      @text_area = Ruco::EditorArea.new(content, @options)
-      @history = @text_area.history
-      restore_session
-    end
-    def find(text)
-      move(:relative, 0,0) # reset selection
-      start = text_area.content.index(text, text_area.index_for_position+1)
-      return unless start
-      # select the found word
-      finish = start + text.size
-      move(:to_index, finish)
-      selecting{ move(:to_index, start) }
-      true
-    end
-    def modified?
-      @saved_content != text_area.content
-    end
-    def save
-      lines = text_area.send(:lines)
-      lines.each(&:rstrip!) if @options[:remove_trailing_whitespace_on_save]
-      lines << '' if @options[:blank_line_before_eof_on_save] and lines.last.to_s !~ /^\s*$/
-      content = lines * @newline
-      @saved_content = content.gsub(/\r?\n/, "\n")
-      true
-    rescue Object => e
-      e.message
-    end
-    def store_session
-    end
-    def content
-      text_area.content.freeze # no modifications allowed
-    end
-    private
-    def restore_session
-    end
-    def session_store
-    end
-  end
-  class StatusBar
-    def initialize(editor, options)
-      @editor = editor
-      @options = options
-    end
-    def view
-      columns = @options[:columns]
-      version = "Ruco #{Ruco::VERSION} -- "
-      position = " #{@editor.position.line + 1}:#{@editor.position.column + 1}"
-      indicators = "#{change_indicator}#{writable_indicator}"
-      essential = version + position + indicators
-      space_left = [columns - essential.size, 0].max
-      # fit file name into remaining space
-      "#{version}#{indicators}#{' ' * space_left}#{position}"[0, columns]
-    end
-    def style_map
-      Dispel::StyleMap.single_line_reversed(@options[:columns])
-    end
-    def change_indicator
-      @editor.modified? ? '*' : ' '
-    end
-    def writable_indicator
-      true
-    end
-    private
-    # fill the line with left column and then overwrite the right section
-    def spread(left, right)
-      empty = [@options[:columns] - left.size, 0].max
-      line = left + (" " * empty)
-      line[(@options[:columns] - right.size - 1)..-1] = ' ' + right
-      line
+  def self.run_editor(data, options)
+    ret = [false, data]
+    Open3.pipeline_rw("vipe") do |din,dout,ts|
+      din.write data
+      din.close
+      data2 = dout.read
+      ret = [data != data2, data2]
     end
   end
 end