txdb 1.0.0

data/lib/txdb/backends/globalize/writer.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+
+module Txdb
+  module Backends
+    module Globalize
+
+      class Writer
+        include Helpers
+
+        attr_reader :table
+
+        def initialize(table)
+          @table = table
+        end
+
+        def write_content(content, locale)
+          content[origin_table_name(table.name)].each_pair do |id, fields|
+            row = table.db.where(foreign_key.to_sym => id, locale: locale)
+
+            if row.empty?
+              table.db << fields.merge(
+                foreign_key.to_sym => id, locale: locale
+              )
+            else
+              row.update(fields)
+            end
+          end
+        end
+
+        private
+
+        def foreign_key
+          @foreign_key ||= table.name.sub(/_translations/, '_id')
+        end
+      end
+
+    end
+  end
+end

data/lib/txdb/config.rb

@@ -0,0 +1,52 @@
+require 'yaml'
+
+module Txdb
+  class Config
+    class << self
+      def databases
+        @databases ||= raw_config[:databases].map do |database_config|
+          Database.new(database_config)
+        end
+      end
+
+      def each_table(&block)
+        return to_enum(__method__) unless block_given?
+        databases.each { |database| database.tables.each(&block) }
+      end
+
+      private
+
+      def raw_config
+        @raw_config ||= begin
+          scheme, payload = ENV['TXDB_CONFIG'].split('://')
+          send(:"load_#{scheme}", payload)
+        end
+      end
+
+      def load_file(payload)
+        deep_symbolize_keys(YAML.load_file(payload))
+      end
+
+      def load_raw(payload)
+        deep_symbolize_keys(YAML.load(payload))
+      end
+
+      def deep_symbolize_keys(obj)
+        case obj
+          when Hash
+            obj.each_with_object({}) do |(k, v), ret|
+              ret[k.to_sym] = deep_symbolize_keys(v)
+            end
+
+          when Array
+            obj.map do |elem|
+              deep_symbolize_keys(elem)
+            end
+
+          else
+            obj
+        end
+      end
+    end
+  end
+end

data/lib/txdb/connection_string.rb

@@ -0,0 +1,18 @@
+module Txdb
+  class ConnectionString
+    TEMPLATES = {
+      mysql2: "%{adapter}://%{username}:%{password}@%{host}:%{port}/%{database}",
+      sqlite: "%{adapter}://%{database}"
+    }
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def string
+      TEMPLATES[options[:adapter].to_sym] % options
+    end
+  end
+end

data/lib/txdb/database.rb

@@ -0,0 +1,40 @@
+require 'sequel'
+
+module Txdb
+  class Database
+    DEFAULT_HOST = '127.0.0.1'
+    DEFAULT_PORT = '3306'
+    DEFAULT_POOL = 10
+
+    attr_reader :adapter, :backend, :username, :password, :host, :port, :database
+    attr_reader :pool, :transifex_project, :tables, :connection_string
+
+    def initialize(options = {})
+      @adapter = options.fetch(:adapter)
+      @backend = Txdb::Backends.get(options.fetch(:backend))
+      @username = options.fetch(:username)
+      @password = options.fetch(:password)
+      @host = options.fetch(:host, DEFAULT_HOST)
+      @port = options.fetch(:port, DEFAULT_PORT)
+      @database = options.fetch(:database)
+      @pool = options.fetch(:pool, DEFAULT_POOL)
+      @transifex_project = TransifexProject.new(options.fetch(:transifex))
+      @connection_string = ConnectionString.new(options).string
+      @tables = options.fetch(:tables).map do |table_config|
+        Table.new(self, table_config)
+      end
+    end
+
+    def db
+      @db ||= Sequel.connect(connection_string, max_connections: pool)
+    end
+
+    def from(*args, &block)
+      db.from(*args, &block)
+    end
+
+    def transifex_api
+      transifex_project.api
+    end
+  end
+end

data/lib/txdb/downloader.rb

@@ -0,0 +1,32 @@
+module Txdb
+  class Downloader
+    class << self
+      def download(database)
+        new(database).download
+      end
+    end
+
+    attr_reader :database
+
+    def initialize(database)
+      @database = database
+    end
+
+    def download(locale)
+      database.tables.each do |table|
+        download_table(table, locale)
+      end
+    end
+
+    def download_table(table, locale)
+      content = transifex_api.download(table.resource, locale)
+      table.write_content(content, locale)
+    end
+
+    private
+
+    def transifex_api
+      database.transifex_api
+    end
+  end
+end

data/lib/txdb/handlers.rb

@@ -0,0 +1,6 @@
+module Txdb
+  module Handlers
+    autoload :HookHandler, 'txdb/handlers/hook_handler'
+    autoload :Triggers,    'txdb/handlers/triggers'
+  end
+end

data/lib/txdb/handlers/hook_handler.rb

@@ -0,0 +1,59 @@
+require 'txgh'
+require 'uri'
+
+module Txdb
+  module Handlers
+    class HookHandler
+      class << self
+        def handle_request(request)
+          new(request).handle
+        end
+      end
+
+      include ResponseHelpers
+
+      attr_reader :request
+
+      def initialize(request)
+        @request = request
+      end
+
+      def handle
+        tables.each do |table|
+          content = table.database.transifex_api.download(table.resource, locale)
+          table.write_content(content, locale)
+        end
+
+        respond_with(200, {})
+      rescue => e
+        respond_with_error(500, "Internal server error: #{e.message}", e)
+      end
+
+      private
+
+      def locale
+        payload['language']
+      end
+
+      def tables
+        @tables ||= Txdb::Config.each_table.select do |table|
+          table.resource.resource_slug == payload['resource'] &&
+            authentic_request?(table.database.transifex_project)
+        end
+      end
+
+      def authentic_request?(project)
+        Txgh::TransifexRequestAuth.authentic_request?(
+          request, project.webhook_secret
+        )
+      end
+
+      def payload
+        @payload ||= begin
+          request.body.rewind
+          Hash[URI.decode_www_form(request.body.read)]
+        end
+      end
+    end
+  end
+end

data/lib/txdb/handlers/triggers.rb

@@ -0,0 +1,9 @@
+module Txdb
+  module Handlers
+    module Triggers
+      autoload :Handler,     'txdb/handlers/triggers/handler'
+      autoload :PullHandler, 'txdb/handlers/triggers/pull_handler'
+      autoload :PushHandler, 'txdb/handlers/triggers/push_handler'
+    end
+  end
+end

data/lib/txdb/handlers/triggers/handler.rb

@@ -0,0 +1,50 @@
+module Txdb
+  module Handlers
+    module Triggers
+      class Handler
+        include ResponseHelpers
+
+        class << self
+          def handle_request(request)
+            new(request).handle
+          end
+        end
+
+        attr_reader :request
+
+        def initialize(request)
+          @request = request
+        end
+
+        private
+
+        def handle_safely
+          yield
+        rescue => e
+          respond_with_error(500, "Internal server error: #{e.message}", e)
+        end
+
+        def databases
+          @databases ||= if database_name = request.params['database']
+            Txdb::Config.databases.select do |database|
+              database.database == database_name
+            end
+          else
+            Txdb::Config.databases
+          end
+        end
+
+        def tables
+          @tables ||= each_table_in(databases).select do |table|
+            table.name == request.params['table']
+          end
+        end
+
+        def each_table_in(databases, &block)
+          return to_enum(__method__, databases) unless block_given?
+          databases.each { |database| database.tables.each(&block) }
+        end
+      end
+    end
+  end
+end

data/lib/txdb/handlers/triggers/pull_handler.rb

@@ -0,0 +1,34 @@
+module Txdb
+  module Handlers
+    module Triggers
+
+      class PullHandler < Handler
+        def handle
+          handle_safely do
+            tables.each do |table|
+              locales_for(table).each do |locale|
+                Downloader.new(table.database).download_table(table, locale)
+              end
+            end
+
+            respond_with(200, {})
+          end
+        end
+
+        private
+
+        def locales_for(table)
+          locale_cache[table.resource.project_slug] ||=
+            table.database.transifex_api
+              .get_languages(table.resource.project_slug)
+              .map { |locale| locale['language_code'] }
+        end
+
+        def locale_cache
+          @locale_cache ||= {}
+        end
+      end
+
+    end
+  end
+end

data/lib/txdb/handlers/triggers/push_handler.rb

@@ -0,0 +1,19 @@
+module Txdb
+  module Handlers
+    module Triggers
+
+      class PushHandler < Handler
+        def handle
+          handle_safely do
+            tables.each do |table|
+              Uploader.new(table.database).upload_table(table)
+            end
+
+            respond_with(200, {})
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/txdb/response.rb

@@ -0,0 +1,11 @@
+module Txdb
+  class Response
+    attr_reader :status, :body, :error
+
+    def initialize(status, body, error = nil)
+      @status = status
+      @body = body
+      @error = error
+    end
+  end
+end

data/lib/txdb/response_helpers.rb

@@ -0,0 +1,26 @@
+module Txdb
+  module ResponseHelpers
+    private
+
+    def respond_with(status, body, e = nil)
+      Txdb::Response.new(status, body, e)
+    end
+
+    def respond_with_error(status, message, e = nil)
+      respond_with(status, error(message), e)
+    end
+
+    def error(message)
+      [{ error: message }]
+    end
+
+    def data(body)
+      { data: body }
+    end
+
+    # includes these methods in the singleton class as well
+    def self.included(base)
+      base.extend(self)
+    end
+  end
+end

data/lib/txdb/table.rb

@@ -0,0 +1,36 @@
+require 'txgh'
+require 'yaml'
+
+module Txdb
+  class Table
+    attr_reader :database, :name, :columns
+    attr_reader :source_lang
+
+    def initialize(database, options = {})
+      @database = database
+      @name = options.fetch(:name)
+      @columns = options.fetch(:columns)
+      @source_lang = options.fetch(:source_lang)
+    end
+
+    def db
+      database.db.from(name)
+    end
+
+    def resource
+      @resource ||= Txdb::TxResource.from_table(self)
+    end
+
+    def read_content
+      YAML.dump(
+        database.backend.read_content_from(self)
+      )
+    end
+
+    def write_content(content, locale)
+      database.backend.write_content_to(
+        self, YAML.load(content), locale
+      )
+    end
+  end
+end