iated 0.0.1

data/lib/iated/browser_token_db.rb

@@ -0,0 +1,76 @@
+require 'yaml'
+require 'pathname'
+require 'digest/md5'
+
+module Iated
+  ## The database for storing authorized browser tokens
+  class BrowserTokenDB
+
+    def initialize fname
+      @fname = Pathname.new fname
+      @tokens = {}
+
+      # Write an empty file.
+      if @fname.exist?
+        read
+      else
+        write
+      end
+    end
+
+    ## Add a token to the database.
+    # This stores it persistently.
+    # @return [String] the new token
+    def add user_agent
+      token = generate_token
+      @tokens[token] = user_agent.to_s
+      write
+      return token
+    end
+
+    ## Does the token exist in the db?
+    # @return [Boolean] Does this token exist in the store?
+    def has_token? token
+      @tokens.key? token
+    end
+
+    ## List of all tokens in DB.
+    # @return [Array] All tokens stored in DB.
+    def tokens
+      @tokens.keys
+    end
+
+    ## What is the user_agent for the token?
+    # @return [String] The user agent
+    def user_agent token
+      @tokens[token]
+    end
+
+    private
+
+    ## Generate a token
+    # @return [String] a hex string, 32 characters long
+    def generate_token
+      # FIXME this could be better.
+      digest = Digest::MD5.new
+      digest << Time.now.to_s
+      digest << rand.to_s
+      return digest.hexdigest
+    end
+
+    ## Write the data to the store
+    # @return [nil]
+    def write
+      @fname.dirname.mkpath unless @fname.dirname.directory?
+      @fname.open('w') do |f|
+        f.puts @tokens.to_yaml
+      end
+    end
+
+    ## Read the data from the store
+    # @return [nil]
+    def read
+      @tokens = YAML::load_file @fname.to_s
+    end
+  end
+end

data/lib/iated/edit_session.rb

@@ -0,0 +1,221 @@
+require 'digest/md5'
+require 'set'
+require 'addressable/uri'
+require 'fileutils'
+require 'pathname'
+require 'digest/md5'
+
+module Iated
+  ## An Edit Session
+  #
+  # A single session for editing a textarea. It tracks the editor, etc.
+  class EditSession
+    # @return [String,nil] The URL the textarea came from
+    attr_reader :url
+    # @return [String,nil] The textarea id
+    attr_reader :tid
+    # @return [String,nil] The extension the text file should use
+    attr_reader :extension
+    # @return [String] The session id
+    attr_reader :sid
+
+    ##
+    # @param [Hash] options Various optional arguments (:url, :tid, :extension)
+    def initialize options=nil
+      normalized_options = normalize_keys options
+      @url               = normalized_options[:url]
+      @tid               = normalized_options[:tid]
+      @extension         = normalized_options[:extension]
+      @change_id         = 0
+      @sid               = self.class.calculate_sid normalized_options
+      @last_checksum     = :nochecksum
+
+      # Save session.
+      Iated::sessions[@sid] = self
+
+      # Save the text, if passed in the original options
+      self.text = options[:text] if options.key?(:text)
+    end
+
+    ## Finds an existing session
+    # @return [EditSession]
+    def self.find search=nil
+      # TODO Once the sid is random, then find needs to work via a data store.
+      if search.is_a? String
+        tok = search
+      else
+        tok = calculate_sid search
+      end
+      Iated::sessions[tok]
+    end
+
+    ## Finds an existing session or creates a new one
+    # @return [EditSession]
+    def self.find_or_create search=nil
+      sess = find search
+      sess.nil? ? self.new(search) : sess
+    end
+
+    ## Calculate a sid based on url, id, ext
+    # @return [String] A session id
+    def self.calculate_sid options
+      options = normalize_keys options
+
+      # TODO Should retrieve sid from datastore if it exists.
+      # TODO The sid calculation needs a random number
+      # TODO The sid calculation needs the current time or date
+      digest = Digest::MD5.new
+      digest << "url: #{options[:url]}"
+      digest << "tid: #{options[:tid]}"
+      digest << "extension: #{options[:extension]}"
+      return digest.hexdigest
+    end
+
+    ## Increment the change_id
+    # @return [Integer] The new number of changes
+    def increment_change_id
+      @change_id = @change_id + 1
+    end
+
+    ## Return the change_id
+    # @returns [Integer] The new number of changes
+    def change_id
+      if filename.exist?
+        new_checksum = filename.open('r') do |f|
+          Digest::MD5.hexdigest(f.read)
+        end
+
+        if @last_checksum != new_checksum
+          increment_change_id
+          @last_checksum = new_checksum
+        end
+      end
+      @change_id
+    end
+
+    ## Returns true if the editor is running.
+    # @return [Boolean] True if the editor is running
+    def running?
+      # TODO This should check to see if a process is running or not.
+      return true
+    end
+
+    ## Opens the user's configured editor.
+    def edit
+      editor = Iated.mcp.prefs.editor.to_s
+      if Iated::environment == :test
+        # We don't want to fire up real editors in testing mode.
+        #$stderr.puts "I would have edited #{filename.to_s.inspect} with #{editor.inspect}"
+        return
+      else
+        if RUBY_ENGINE == "jruby"
+          edit_jruby
+        else
+          edit_ruby
+        end
+      end
+    end
+
+    ## The Ruby version of edit
+    def edit_ruby
+      editor = Iated.mcp.prefs.editor.to_s
+      cmd = []
+      if RUBY_PLATFORM =~ /darwin/ && editor =~ /\.app$/
+        cmd << "/usr/bin/open"
+        cmd << "-a"
+      end
+      cmd << editor
+      cmd << filename.to_s
+      # TODO This doesn't get the exit code...
+      system *cmd
+    end
+
+    ## The JRuby version of edit
+    def edit_jruby
+      editor = Iated.mcp.prefs.editor.to_s
+
+      cmd = nil # We will store the CommandLine object here.
+      java_import org.apache.commons.exec.OS
+      java_import org.apache.commons.exec.CommandLine
+      java_import org.apache.commons.exec.DefaultExecutor
+
+      if OS.is_family_mac && editor =~ /\.app$/
+        # It's a Mac .app
+        cmd = CommandLine.new "/usr/bin/open"
+        cmd.add_argument("-a").add_argument(editor)
+      else
+        cmd = CommandLine.new editor
+      end
+      cmd.add_argument(filename.to_s)
+
+      executor = DefaultExecutor.new
+      executor.execute(cmd)
+    end
+
+    ## Returns the file where the session is saved.
+    # @return [Pathname] The filename and path the text was saved to.
+    def filename
+      if @filename.nil?
+        bad_chars = /[^a-zA-Z0-9._-]+/
+        url = Addressable::URI.parse(@url)
+        config_dir = Iated::mcp.prefs.config_dir
+        if url.host
+          # TODO Handle case where url is the root and filename is empty.
+          @filename = config_dir + url.host.gsub(bad_chars, '') +
+            "#{url.basename.gsub(bad_chars, '')}#{@extension}"
+        else
+          @filename = config_dir + "#{@url.gsub(bad_chars, '')}#{@extension}"
+        end
+      end
+      return @filename
+    end
+
+    ## Returns the text of the filename
+    def text
+      if filename.exist?
+        filename.read
+      else
+        nil
+      end
+    end
+
+    def text= value
+      increment_change_id if filename.exist?
+      filename.dirname.mkpath
+      # TODO: locking
+      filename.open('w') do |f|
+        f.write value
+      end
+      @last_checksum = Digest::MD5.hexdigest(value)
+    end
+
+    ## Normalizes the search options (`:url`, `:tid`, `:extension`)
+    #
+    # Used by other functions
+    # @return [Hash]
+    def self.normalize_keys hash=nil
+      norm_hash = {}
+      hash = {} if hash.nil?
+
+      [:url, :tid, :extension].each do |key|
+        norm_hash[key] = hash[key] || hash[key.to_s] || (:extension == key ? '.txt' : nil)
+      end
+
+      # Verify the keys are sane. We ignore :text.
+      accepted_keys = Set.new((hash.keys + [:text]).map {|x| [x, x.to_s]}.flatten)
+      unexpected_keys = Set.new(hash.keys) - accepted_keys
+      raise "Invalid keys: #{unexpected_keys.inspect}" if unexpected_keys.count > 0
+      return norm_hash
+    end
+
+    ## Alias for the class-method `normalize_keys`
+    # @see Iated::EditSession.normalize_keys
+    # @return [Hash]
+    def normalize_keys hash
+      self.class.normalize_keys hash
+    end
+
+    private
+
+  end
+end

data/lib/iated/helpers.rb

@@ -0,0 +1,9 @@
+
+require 'sinatra'
+
+helpers do
+  def require_authtoken params
+    cache_control :no_cache, :private
+    halt 403 if params[:auth].nil? or params[:auth] == 'magictoken'
+  end
+end

data/lib/iated/mcp.rb

@@ -0,0 +1,144 @@
+## Iated Master Controller Package
+# This is the coordination point for
+# all the data stored, and the UI.
+
+require 'sinatra'
+require 'pathname'
+require 'iated/sys_pref'
+require 'iated/browser_token_db'
+
+module Iated
+  ## The Master Control Progrom
+  #
+  # Yes, I've been watching Tron lately, why do ask?
+  class MCP
+
+    attr_accessor :debug
+
+    attr_reader :browser_token_db
+
+    # @return [SysPref] The current System Preferencs object
+    attr_reader :prefs
+
+    def initialize
+      @debug = false
+      @prefs = SysPref.new
+      @browser_token_db = Iated::BrowserTokenDB.new(@prefs.config_dir + 'browser_tokens.yml')
+    end
+
+    ## Called by the main program to get everything started.
+    def begin!
+      start_server
+    end
+
+    # @return [String,Symbol] The currently showing secret or the symbol `:notset`
+    def secret
+      showing_secret? ? @secret : :notset
+    end
+
+    ## Confirm the secret
+    #
+    # @param [String] guess The string to check against the secret
+    # @return [Boolean] Was the guess right?
+    def confirm_secret guess
+      success = (guess == secret)
+      hide_secret
+      return success
+    end
+
+    # @return [Boolean] Is the secret being shown to the user?
+    def showing_secret?
+      @is_showing_secret
+    end
+
+    ## Show the secret to the user
+    # @return [nil]
+    def show_secret
+      generate_secret
+      # TODO This should do something different for text, vs. gui.
+      puts " ** A browser requested authorization: #{@secret}" unless :test == ui
+##      require 'java'
+##      Thread.new do
+##        puts " ** A browser requested authorization: #{@secret}"
+### TODO This needs to be abstracted. There is no reason a purely command line version can't be done. Also, loading swing will break CI.
+###        import javax.swing.JOptionPane
+###        JOptionPane.showMessageDialog(nil,
+###                                      "A browser has requested authorization: #{@secret}\nDo not press 'OK' until after you enter the number",
+###                                      "Authorize Browser",
+###                                      JOptionPane::INFORMATION_MESSAGE)
+##        @is_showing_secret = false
+##      end
+    end
+
+    ## Hide the secret again
+    # @return [nil]
+    def hide_secret
+      @is_showing_secret = false
+      # TODO secret should be using a JPanel or something, not a dialog.
+    end
+
+    ## The magic value shown to user to confirm a connection
+    # @return [String] The string
+    def generate_secret
+      @secret = (1..4).map{ rand(10).to_s }.join ""
+      @is_showing_secret = true
+      return @secret
+    end
+
+    ## The magic value registering a browser.
+    # @return [String] The token
+    def generate_token user_agent
+      @browser_token_db.add user_agent
+    end
+
+    ## Is the auth token a valid one?
+    # @return [Boolean] True if the token is valid and exist
+    def is_token_valid? token
+      @browser_token_db.has_token? token
+    end
+
+    def ui= ui_type
+      if [:text, :test, :gui].include? ui_type
+        @ui = ui_type
+      else
+        raise "Invalid UI type: #{ui_type.inspect}"
+      end
+    end
+
+    def ui
+      # Default UI
+      @ui ||= (:test == Iated.environment ? :test : :text)
+    end
+
+    def start_server
+      # TODO this needs to be in a separate thread.
+      set :server, %w[webrick]
+      set :bind, 'localhost'
+      set :port, prefs.port
+      if @debug
+        set :show_exceptions, true
+        set :environment, :development
+      else
+        set :show_exceptions, false
+        set :environment, :production
+      end
+
+      @is_running = true
+      Sinatra::Application.run!
+    end
+
+    def stop_server
+      @is_running = false
+      Sinatra::Application.quit!
+    end
+
+    def cucumber_coverage_check
+      @cucumber_check = true
+    end
+
+    def rspec_coverage_check
+      @rspec_check = true
+    end
+
+  end
+end