txdb 1.0.0

data/lib/txdb/transifex_project.rb

@@ -0,0 +1,17 @@
+require 'txgh'
+
+module Txdb
+  class TransifexProject
+    attr_reader :organization, :project_slug, :username, :password
+    attr_reader :webhook_secret, :api
+
+    def initialize(options = {})
+      @organization = options.fetch(:organization)
+      @project_slug = options.fetch(:project_slug)
+      @username = options.fetch(:username)
+      @password = options.fetch(:password)
+      @webhook_secret = options.fetch(:webhook_secret)
+      @api = Txgh::TransifexApi.create_from_credentials(username, password)
+    end
+  end
+end

data/lib/txdb/tx_resource.rb

@@ -0,0 +1,52 @@
+require 'txgh'
+
+module Txdb
+  class TxResource
+    RESOURCE_TYPE = 'YML'
+
+    class << self
+      def from_table(table)
+        # project_slug, resource_slug, type, source_lang, source_file,
+        # lang_map, translation_file
+        new(
+          Txgh::TxResource.new(
+            project_slug(table), resource_slug(table), RESOURCE_TYPE,
+            source_lang(table), source_file(table), nil, nil
+          )
+        )
+      end
+
+      private
+
+      def project_slug(table)
+        table.database.transifex_project.project_slug
+      end
+
+      def resource_slug(table)
+        Txgh::Utils.slugify("#{table.database.database}-#{table.name}")
+      end
+
+      def source_lang(table)
+        table.source_lang
+      end
+
+      def source_file(table)
+        table.name
+      end
+    end
+
+    attr_reader :resource
+
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def respond_to?(method)
+      resource.respond_to?(method)
+    end
+
+    def method_missing(method, *args, &block)
+      resource.send(method, *args, &block)
+    end
+  end
+end

data/lib/txdb/uploader.rb

@@ -0,0 +1,33 @@
+module Txdb
+  class Uploader
+    class << self
+      def upload(database)
+        new(database).upload
+      end
+    end
+
+    attr_reader :database
+
+    def initialize(database)
+      @database = database
+    end
+
+    def upload
+      database.tables.each do |table|
+        upload_table(table)
+      end
+    end
+
+    def upload_table(table)
+      transifex_api.create_or_update(
+        table.resource, table.read_content
+      )
+    end
+
+    private
+
+    def transifex_api
+      database.transifex_api
+    end
+  end
+end

data/lib/txdb/version.rb

@@ -0,0 +1,3 @@
+module Txdb
+  VERSION = '1.0.0'
+end

data/spec/backends/globalize/helpers_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+include Txdb::Backends
+
+describe Globalize::Helpers do
+  describe '.origin_table_name' do
+    it 'pluralizes and removes the translations suffix' do
+      origin = Globalize::Helpers.origin_table_name('widget_translations')
+      expect(origin).to eq('widgets')
+    end
+
+    it 'handles unusual pluralizations (via ActiveSupport::Inflector)' do
+      origin = Globalize::Helpers.origin_table_name('ox_translations')
+      expect(origin).to eq('oxen')
+    end
+  end
+end

data/spec/backends/globalize/reader_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'spec_helpers/globalize_db'
+
+include Txdb::Backends
+
+describe Globalize::Reader, globalize_db: true do
+  include_context :globalize
+
+  describe '#read_content' do
+    it 'reads data from the given table and puts it into a hash' do
+      sprocket_id = widgets.insert(name: 'sprocket')
+      flange_id = widgets.insert(name: 'flange')
+      widget_translations.insert(widget_id: sprocket_id, locale: 'es', name: 'sproqueta')
+      widget_translations.insert(widget_id: flange_id, locale: 'es', name: 'flango')
+
+      reader = Globalize::Reader.new(widget_translations_table)
+      expect(reader.read_content).to eq({
+        'widgets' => {
+          1 => { 'name' => 'sprocket' },
+          2 => { 'name' => 'flange' }
+        }
+      })
+    end
+  end
+end

data/spec/backends/globalize/writer_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'spec_helpers/globalize_db'
+
+include Txdb::Backends
+
+describe Globalize::Writer, globalize_db: true do
+  include_context :globalize
+
+  describe '#write_content' do
+    it 'inserts the translations into the database' do
+      sprocket_id = widgets.insert(name: 'sprocket')
+      writer = Globalize::Writer.new(widget_translations_table)
+
+      content = {
+        'widgets' => {
+          sprocket_id => { name: 'sproqueta' }
+        }
+      }
+
+      expect { writer.write_content(content, 'es') }.to(
+        change { widget_translations.count }.from(0).to(1)
+      )
+
+      translation = widget_translations.first
+
+      expect(translation).to include(
+        widget_id: sprocket_id, name: 'sproqueta', locale: 'es'
+      )
+    end
+
+    it 'updates the record if it already exists' do
+      sprocket_id = widgets.insert(name: 'sprocket')
+      sprocket_trans_id = widget_translations.insert(
+        widget_id: sprocket_id, locale: 'es', name: 'sproqueta'
+      )
+
+      writer = Globalize::Writer.new(widget_translations_table)
+
+      content = {
+        'widgets' => {
+          sprocket_id => { name: 'sproqueta2' }
+        }
+      }
+
+      expect { writer.write_content(content, 'es') }.to_not(
+        change { widget_translations.count }
+      )
+
+      translation = widget_translations.where(id: sprocket_trans_id).first
+      expect(translation).to include(name: 'sproqueta2')
+    end
+  end
+end

data/spec/backends_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+include Txdb
+
+describe Backends do
+  around(:each) do |example|
+    old_backends = Backends.all.dup
+    Backends.all.clear
+    example.run
+    Backends.all.replace(old_backends)
+  end
+
+  describe '.register' do
+    it 'adds a backend' do
+      Backends.register(:foo, :bar)
+      expect(Backends.all).to include(foo: :bar)
+    end
+  end
+
+  describe '.get' do
+    it "looks up a backend by it's name" do
+      Backends.register(:foo, :bar)
+      expect(Backends.get(:foo)).to eq(:bar)
+    end
+
+    it 'returns nil if no backend can be found' do
+      expect(Backends.get(:foo)).to be_nil
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'spec_helpers/test_db'
+require 'tempfile'
+require 'yaml'
+
+describe Txdb::Config do
+  before(:each) do
+    # clear out config before each test
+    Txdb::Config.instance_variable_set(:@databases, nil)
+    Txdb::Config.instance_variable_set(:@raw_config, nil)
+  end
+
+  describe '.databases' do
+    it 'loads config from a string' do
+      with_env('TXDB_CONFIG' => "raw://#{YAML.dump(TestDb.raw_config)}") do
+        expect(Txdb::Config.databases.size).to eq(1)
+        database = Txdb::Config.databases.first
+
+        expect(database.adapter).to eq('sqlite')
+        expect(database.transifex_project.organization).to eq('myorg')
+        expect(database.tables.size).to eq(1)
+        expect(database.tables.first.name).to eq('my_table')
+      end
+    end
+
+    it 'loads config from a file' do
+      file = Tempfile.new('translations')
+      file.write(YAML.dump(TestDb.raw_config))
+      file.flush
+
+      with_env('TXDB_CONFIG' => "file://#{file.path}") do
+        expect(Txdb::Config.databases.size).to eq(1)
+        database = Txdb::Config.databases.first
+
+        expect(database.adapter).to eq('sqlite')
+        expect(database.transifex_project.organization).to eq('myorg')
+        expect(database.tables.size).to eq(1)
+        expect(database.tables.first.name).to eq('my_table')
+      end
+
+      file.close
+      file.unlink
+    end
+  end
+
+  describe '.each_table' do
+    it 'returns an enumerator' do
+      expect(Txdb::Config.each_table).to be_a(Enumerator)
+    end
+
+    it 'yields each table in each database' do
+      # set up another database with another table so we can make sure the
+      # method loops over more than one db, yielding tables from each
+      config = TestDb.raw_config.dup
+      config[:databases] = config[:databases].dup
+      config[:databases] << config[:databases].first.merge(
+        database: 'spec/test2.sqlite3',
+        tables: [
+          name: 'another_table',
+          source_lang: 'en',
+          columns: %w(col1 col2)
+        ]
+      )
+
+      with_env('TXDB_CONFIG' => "raw://#{YAML.dump(config)}") do
+        result = Txdb::Config.each_table.to_a
+        expect(result.map(&:name)).to eq(%w(my_table another_table))
+      end
+    end
+  end
+end

data/spec/connection_string_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+include Txdb
+
+describe ConnectionString do
+  describe '#string' do
+    let(:options) do
+      {
+        username: 'janeway', password: 'borgsuck',
+        host: 'voyager', port: 3306, database: 'stellar_cartography'
+      }
+    end
+
+    it 'assembles the correct string for mysql2' do
+      string = ConnectionString.new(options.merge(adapter: 'mysql2')).string
+      expect(string).to eq('mysql2://janeway:borgsuck@voyager:3306/stellar_cartography')
+    end
+
+    it 'assembles the correct string for sqlite' do
+      string = ConnectionString.new(options.merge(adapter: 'sqlite')).string
+      expect(string).to eq('sqlite://stellar_cartography')
+    end
+  end
+end

data/spec/database_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'spec_helpers/test_db'
+
+include Txdb
+
+describe Database, test_db: true do
+  let(:database) { TestDb.database }
+
+  describe '#db' do
+    it 'provides access to the database connection' do
+      expect(database.db).to be_a(Sequel::SQLite::Database)
+    end
+
+    it 'sets the max number of connections as specified in the config' do
+      expect(database.db.pool.max_size).to eq(database.pool)
+    end
+  end
+
+  describe '#from' do
+    it 'returns a data set to query the given table' do
+      set = database.from(:foo)
+      expect(set).to be_a(Sequel::Dataset)
+      expect(set.sql).to eq("SELECT * FROM `foo`")
+    end
+  end
+
+  describe '#transifex_api' do
+    it 'grabs the api instance from the transifex project' do
+      expect(database.transifex_api).to be_a(Txgh::TransifexApi)
+      expect(database.transifex_api).to eq(database.transifex_project.api)
+    end
+  end
+end

data/spec/downloader_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'spec_helpers/test_db'
+require 'spec_helpers/test_backend'
+
+include Txdb
+
+describe Downloader, test_db: true do
+  let(:database) { Txdb::Config.databases.first }
+  let(:downloader) { Downloader.new(database) }
+  let(:transifex_api) { double(:transifex_api) }
+
+  before(:each) do
+    allow(database.transifex_project).to(
+      receive(:api).and_return(transifex_api)
+    )
+  end
+
+  describe '#download' do
+    it 'downloads translations from Transifex and writes them to the db' do
+      expect(transifex_api).to receive(:download) do |resource, locale|
+        expect(resource.project_slug).to eq('myproject')
+        expect(resource.resource_slug).to eq('spec_test.sqlite3-my_table')
+        expect(locale).to eq('es')
+        YAML.dump('widgets')
+      end
+
+      expect { downloader.download('es') }.to(
+        change { TestBackend.writes.size }.from(0).to(1)
+      )
+
+      expect(TestBackend.writes.first).to eq(
+        table: database.tables.first.name, locale: 'es', content: 'widgets'
+      )
+    end
+  end
+end

data/spec/handlers/hook_handler_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'spec_helpers/test_backend'
+require 'spec_helpers/test_db'
+require 'uri'
+require 'yaml'
+
+include Txdb::Handlers
+
+describe HookHandler do
+  include Rack::Test::Methods
+
+  let(:database) { TestDb.database }
+  let(:table) { database.tables.first }
+  let(:project) { database.transifex_project }
+
+  def app
+    Txdb::Hooks
+  end
+
+  before(:each) do
+    allow(Txdb::Config).to receive(:databases).and_return([database])
+  end
+
+  def sign(body)
+    Txgh::TransifexRequestAuth.header_value(
+      body, project.webhook_secret
+    )
+  end
+
+  it "doesn't write content when unauthorized" do
+    params = { 'resource' => table.resource.resource_slug, 'language' => 'es' }
+    body = URI.encode_www_form(params.to_a)
+    post '/transifex', body
+
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq('{}')
+
+    expect(Txdb::TestBackend.writes).to be_empty
+  end
+
+  context 'with an authorized request' do
+    let(:content) { { 'phrase' => 'trans' } }
+    let(:params) { { 'resource' => table.resource.resource_slug, 'language' => 'es' } }
+    let(:body) { URI.encode_www_form(params.to_a) }
+    let(:headers) { { Txgh::TransifexRequestAuth::RACK_HEADER => sign(body) } }
+
+    it 'downloads and writes new content to the database' do
+      expect(project.api).to receive(:download).and_return(YAML.dump(content))
+
+      expect { post('/transifex', body, headers) }.to(
+        change { Txdb::TestBackend.writes.size }.from(0).to(1)
+      )
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('{}')
+
+      expect(Txdb::TestBackend.writes).to include(
+        locale: 'es', table: table.name, content: content
+      )
+    end
+
+    it 'reports errors' do
+      expect(project.api).to receive(:download).and_raise('jelly beans')
+
+      post '/transifex', body, headers
+
+      expect(last_response.status).to eq(500)
+      expect(JSON.parse(last_response.body)).to eq(
+        [{ 'error' => 'Internal server error: jelly beans' }]
+      )
+    end
+  end
+end