TextTractor 0.1.0

data/lib/text_tractor/base.rb

@@ -0,0 +1,25 @@
+require 'sinatra'
+require 'json'
+require 'redis'
+require 'redis-namespace'
+require 'digest/md5'
+require 'rack/etag'
+
+module TextTractor
+  class Base < Sinatra::Application
+    use Rack::ETag
+    use Rack::ConditionalGet
+    
+    def initialize(app=nil)
+      super
+    end
+
+    def redis
+      TextTractor.redis
+    end
+
+    def not_authorised
+      [ 403, "Not Authorised" ]
+    end
+  end
+end

data/lib/text_tractor/config.rb

@@ -0,0 +1,48 @@
+require 'uri'
+
+module TextTractor
+  def self.configuration
+    @configuration ||= TextTractor::Config.new
+  end
+
+  def self.config
+    yield self.configuration if block_given?
+    self.configuration
+  end
+
+  class Config
+    attr_accessor :redis, :environment, :default_username, :default_password, :salt, :hostname, :port, :ssl
+    
+    def redis
+      @redis ||= {}
+    end
+    
+    def redis=(value)
+      if value.is_a? String
+        uri = URI.parse(value)
+        @redis = {
+          host: uri.host,
+          port: uri.port,
+          username: uri.user,
+          password: uri.password,
+          ns: uri.path.gsub(/^\//, '')
+        }
+      else
+        @redis = value
+      end
+    end
+
+    def port
+      @port ||= 80
+    end
+    
+    def ssl=(value)
+      @ssl = value
+    end
+    
+    def ssl
+      @ssl = true if @ssl.nil?
+      @ssl
+    end
+  end
+end

data/lib/text_tractor/phrase.rb

@@ -0,0 +1,67 @@
+module TextTractor
+  class Phrase
+    attr_reader :translations, :project
+    
+    def initialize(project, phrase = {})
+      @project = project
+      @translations = {}
+      
+      phrase.each do |locale, value|
+        @translations[locale.to_s] = Translation.new(self, locale.to_s, value["text"], value["translated_at"] && Time.parse(value["translated_at"]))
+      end
+    end
+    
+    def default_locale
+      project.default_locale
+    end
+    
+    def [](locale)
+      @translations[locale.to_s] ||= Translation.new(self, locale.to_s)
+      @translations[locale.to_s]
+    end
+
+    def []=(locale, value)
+      self[locale.to_s].text = value
+    end
+    
+    def to_hash
+      hash = {}
+
+      @translations.each do |locale, value|
+        hash[locale.to_s] = { "text" => value.text, "translated_at" => value.translated_at ? value.translated_at.to_s : nil }
+      end
+      
+      hash
+    end
+
+    class Translation
+      attr_accessor :phrase, :locale, :text, :translated_at
+      
+      def initialize(phrase, locale, text = nil, translated_at = nil, phrase_created_at = nil)
+        @phrase = phrase
+        @locale = locale
+        @text = text
+        @translated_at = translated_at
+        @created_at = phrase_created_at
+      end
+      
+      def text=(value)
+        @text = value
+        @translated_at = Time.now
+      end
+
+      def to_s
+        text || ""
+      end
+      
+      def default_locale
+        phrase.default_locale
+      end
+
+      def state
+        return :untranslated if translated_at.nil?
+        translated_at >= phrase[default_locale].translated_at ? :translated : :stale
+      end
+    end
+  end
+end

data/lib/text_tractor/projects.rb

@@ -0,0 +1,202 @@
+module TextTractor
+  class Project
+    attr_accessor :name, :api_key, :default_locale, :users
+
+    def initialize(attributes = {})
+      attributes.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+    
+    def redis
+      TextTractor.redis
+    end
+    
+    def api_key
+      @api_key ||= Projects.random_key
+    end
+    
+    def users
+      @users || []
+    end
+
+    def default_locale
+      @default_locale || "en"
+    end
+    
+    def to_json(state = nil)
+      # I don't know what the generator state is used for, but it gets passed sometimes. Just accepting it as an argument seems to be
+      # enough to work in this situation.
+
+      { "name" => name, "api_key" => api_key, "default_locale" => default_locale, "users" => users }.reject { |k,v| v.nil? }.to_json
+    end
+
+    def [](key)
+      send(key)
+    end
+    
+    # Set the overwrite option to true to force overwriting existing translations.
+    def update_blurb(state, locale, key, value, overwrite = false)
+      id = key
+      key = "projects:#{api_key}:#{state}_blurbs:#{key}"
+      
+      current_value = redis.sismember("projects:#{api_key}:#{state}_blurb_keys", id) ? JSON.parse(redis.get(key)) : {}
+      phrase = Phrase.new(self, current_value)
+      
+      # A new value is only written if no previous translation was present, or overwriting is enabled.
+      if overwrite || phrase[locale].text.nil?
+        phrase[locale] = value
+        
+        redis.sadd "projects:#{api_key}:#{state}_blurb_keys", id
+        redis.sadd "projects:#{api_key}:locales", locale
+        redis.set key, phrase.to_hash.to_json
+        redis.set "projects:#{api_key}:#{state}_blurbs_etag", Projects.random_key
+      end
+    end
+
+    def update_blurbs(state, blurbs = {}, options = {})
+      options[:overwrite] = false if options[:overwrite].nil?
+      
+      changed = false
+      blurbs.each do |key, value|
+        locale, phrase = key.split(".", 2)
+        update_blurb(state, locale, phrase, value, options[:overwrite])
+      end
+      
+      true
+    end
+
+    def update_draft_blurbs(blurbs = {}, options = {})
+      update_blurbs "draft", blurbs, options
+    end
+    
+    def update_published_blurbs(blurbs = {}, options = {})
+      update_blurbs "published", blurbs, options
+    end
+    
+    def blurbs(state)
+      blurbs = {}
+      redis.smembers("projects:#{api_key}:#{state}_blurb_keys").each do |key|
+        translations = JSON.parse(redis.get("projects:#{api_key}:#{state}_blurbs:#{key}"))
+        translations.each do |locale, value|
+          blurbs["#{locale}.#{key}"] = value["text"]
+        end
+      end
+
+      blurbs
+    end
+
+    def draft_blurbs
+      blurbs("draft")
+    end
+
+    def published_blurbs
+      blurbs("published")
+    end
+    
+    def phrases(state)
+      phrases = {}
+      redis.smembers("projects:#{api_key}:#{state}_blurb_keys").each do |key|
+        phrases[key] = Phrase.new(self, JSON.parse(redis.get("projects:#{api_key}:#{state}_blurbs:#{key}")))
+      end
+
+      phrases
+    end
+    
+    def draft_phrases
+      phrases("draft")
+    end
+
+    def published_phrases
+      phrases("published")
+    end
+    
+    def locales
+      locales = redis.smembers("projects:#{api_key}:locales")
+      locales ? locales.sort : []
+    end
+    
+    def configuration_block
+      <<EOF
+      Copycopter::Client.configure do |config|
+  config.api_key = "#{api_key}"
+  config.host    = "#{TextTractor.configuration.hostname}"
+  config.port    = #{TextTractor.configuration.port}
+  config.secure  = #{TextTractor.configuration.ssl ? "true" : "false"}
+end
+EOF
+    end
+  end
+  
+  module Projects
+    class DuplicateProjectName < Exception; end
+    
+    def self.redis
+      TextTractor.redis
+    end
+    
+    def self.random_key
+      Digest::MD5.hexdigest("#{Kernel.rand(9999999999999)}.#{Time.now.to_i}")
+    end
+    
+    def self.exists?(api_key)
+      redis.sismember "projects", api_key
+    end
+    
+    def self.create(attributes = {})
+      attributes = TextTractor.stringify_keys(attributes)
+      
+      if redis.sismember "project_names", attributes["name"]
+        raise DuplicateProjectName.new
+      else
+        project = Project.new(attributes)
+        
+        redis.set "projects:#{project.api_key}", project.to_json
+        redis.sadd "projects", project.api_key
+        redis.sadd "project_names", project.name
+        project.users.each { |user| assign_user(user, project.api_key) }
+        
+        project
+      end
+    end
+    
+    def self.assign_user(user, api_key)
+      if redis.sismember "projects", api_key
+        redis.sadd "project_users:#{api_key}", user
+      end
+    end
+
+    def self.get(api_key)
+      json = redis.get("projects:#{api_key}")
+      return Project.new(JSON.parse(json)) if json
+    end
+    
+    def self.for_user(user)
+      projects = []
+      redis.smembers("projects").each do |p|
+        projects << get(p) if authorised? user, p
+      end
+
+      projects.reject { |p| p.nil? }.sort { |a, b| a.name <=> b.name }
+    end
+
+    def self.authorised?(user, api_key)
+      user["superuser"] || redis.sismember("project_users:#{api_key}", user["username"])
+    end
+
+    def self.update_datastore
+      redis.smembers("projects").each do |api_key|
+        project = get(api_key)
+
+        redis.smembers("projects:#{api_key}:draft_blurb_keys").each do |blurb|
+          value = redis.get("projects:#{api_key}:draft_blurbs:#{blurb}")
+          locale, phrase = blurb.split(".", 2)
+          
+          project.update_blurb("draft", locale, phrase, value, true)
+          redis.del("projects:#{api_key}:draft_blurbs:#{blurb}")
+          redis.srem("projects:#{api_key}:draft_blurb_keys", blurb)
+        end
+      end
+    end
+  end
+end

data/lib/text_tractor/ui_server.rb

@@ -0,0 +1,152 @@
+require 'haml'
+require 'sass'
+require 'digest/md5'
+
+module TextTractor
+  class UiServer < TextTractor::Base
+    helpers do 
+      def current_user
+        Users.get(env["REMOTE_USER"])
+      end
+
+      def pjax?
+        env.key? "HTTP_X_PJAX" || params["layout"] == "false"
+      end
+
+      def projects
+        Projects.for_user(current_user).sort { |a, b| b.name <=> a.name }
+      end
+    end
+    
+    use Rack::Auth::Basic do |username, password|
+      unless Users.exists?(TextTractor.configuration.default_username)
+        Users.create(username: TextTractor.configuration.default_username, password: TextTractor.configuration.default_password, name: "Default User", superuser: true) 
+      end
+
+      Users.authenticate(username, password)
+    end
+    
+    set :environment, TextTractor.configuration.environment
+    
+    set :public, File.expand_path("../../../assets", __FILE__)
+    set :views, File.expand_path("../../../views", __FILE__)
+    
+    def initialize(app=nil)
+      super
+    end
+    
+    def render_haml(template)
+      haml template, :layout => !pjax? 
+    end
+
+    get '/' do
+      @projects = Projects.for_user(current_user)
+      render_haml :index
+    end
+
+    get '/styles.css' do
+      scss :styles
+    end
+
+    get '/users' do
+      return not_authorised unless current_user["superuser"]
+      
+      @users = Users.all
+      render_haml :users
+    end
+
+    post '/users' do
+      return not_authorised unless current_user["superuser"]
+      
+      Users.create(params[:user])  
+      redirect "/users"
+    end
+
+    get '/projects/new' do
+      return not_authorised unless current_user["superuser"]
+      
+      @users = Users.all
+      render_haml :"projects/new"
+    end
+    
+    get '/projects/:api_key/:locale/*' do |api_key, locale, path|
+      @api_key = api_key
+      @locale = locale
+      @path = path
+      @key = path.gsub("/", ".")
+      @project = Projects.get(api_key)
+      @phrase = Phrase.new(@project, JSON.parse(redis.get("projects:#{@api_key}:draft_blurbs:#{@key}")))
+
+      render_haml :"blurbs/edit"
+    end
+    
+    post '/projects/:api_key/:locale/*' do |api_key, locale, path|
+      @api_key = api_key
+      @locale = locale
+      @project = Projects.get(api_key)
+      @phrase_key = path.gsub("/", ".")
+      @key = "#{locale}.#{@phrase_key}"
+      @value = params[:blurb]
+      
+      @project.update_draft_blurbs({ @key => @value }, { :overwrite => true })
+      @phrase = Phrase.new(@project, JSON.parse(redis.get("projects:#{@api_key}:draft_blurbs:#{@phrase_key}")))
+      
+      if pjax?
+        @value = haml :"blurbs/value", :layout => false, :locals => { 
+          phrase: @phrase[@locale], 
+          key: @key.split(".", 2).last, 
+          locale: @locale, 
+          original: @phrase[@project.default_locale].to_s, 
+          show_original: @project.default_locale != @locale 
+        }
+        
+        haml :"blurbs/_blurb", :layout => false
+      else
+        redirect "/projects/#{api_key}"
+      end
+    end
+    
+    def phrase_list(api_key, locale = nil, state = "all")
+      return not_authorised unless Projects.authorised?(current_user, api_key)
+      
+      @project = Projects.get(api_key)
+      @locale = locale || @project.default_locale
+      @phrases = @project.draft_phrases
+      unless state.nil? || state == "all"
+        @phrases = @phrases.select { |key, value|
+          valid_states = case state
+                         when "translated"
+                           [ :translated ]
+                         when "untranslated"
+                           [ :untranslated ]
+                         when "stale"
+                           [ :stale ]
+                         when "needs_work"
+                           [ :stale, :untranslated ]
+                         end
+
+          valid_states.include? value[locale].state
+        }
+      end
+      
+      if @phrases.size > 0 || params.key?("state")
+        render_haml :"projects/show"
+      else
+        render_haml :"projects/getting_started"
+      end
+    end
+    
+    get '/projects/:api_key' do |api_key|
+      return phrase_list(api_key, nil, params["state"])
+    end
+    
+    get '/projects/:api_key/:locale' do |api_key, locale|
+      return phrase_list(api_key, locale, params["state"])
+    end
+    
+    post '/projects' do
+      project = Projects.create(params[:project])
+      redirect "/projects/#{project["api_key"]}"
+    end
+  end
+end