txdb 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51610845d38e64996c61cf4079ba3a41125cd848
-  data.tar.gz: 5587fd9b799ed26f04f81358e19ee4eb64cb59a5
+  metadata.gz: 0e59bfc3e60354b89d0a572dc8639ecc1bec5146
+  data.tar.gz: 05599e91b876f536edabd4f05163f769fbf2a2c5
 SHA512:
-  metadata.gz: efae7ded7c1f025b5fb2df089f83e93b4015028f6cf9c9a8653e3cb0c330e1e9a37477fdb0067dba5e3ee46b04cac6aa7cd6186d50df1d3220c3a91e24778820
-  data.tar.gz: 77b6edd9f4d7ec885727216b7a8fe57da44556d3681203862cdcef389b5af080bcf9c97a38f4d32f6b7edc8cf9973db10168e20b0c810ad315e12a362854a79f
+  metadata.gz: 7903d1a0966bc7428dce7de537418ba437e06e48ec95032c4fb21bcc513c8703552c28183be6e23b6271b2f5b921d8ebe5eb4e27500c005c3316590daa84f7a2
+  data.tar.gz: 470a4c9d4d8df0a31f8d8c1275384dab4ba8c487266a6093ad44299ba42e12f61ea0b750e1c814a9b5c2e289204b1b110b83bf8aa5c93c204beb2d74cd3a21e4

data/lib/ext/txgh/tx_resource.rb

@@ -0,0 +1,18 @@
+require 'txgh'
+
+module Txgh
+  class TxResource
+    class << self
+      def from_api_response(project_slug, response)
+        new(
+          project_slug,
+          response['slug'],
+          response['i18n_type'],
+          response['source_language_code'],
+          response['name'],
+          '', nil
+        )
+      end
+    end
+  end
+end

data/lib/txdb.rb

@@ -1,3 +1,5 @@
+require 'ext/txgh/tx_resource'
+
 module Txdb
   autoload :Application,      'txdb/app'
   autoload :Backends,         'txdb/backends'

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

@@ -3,13 +3,19 @@ module Txdb
     module Globalize
 
       class Backend
+        RESOURCE_TYPE = 'YML'
+
         class << self
           def read_content_from(table)
             Reader.new(table).read_content
           end
 
-          def write_content_to(table, content, locale)
-            Writer.new(table).write_content(content, locale)
+          def write_content_to(table, resource, locale)
+            Writer.new(table).write_content(resource, locale)
+          end
+
+          def owns_resource?(table, resource)
+            resource.resource_slug == Helpers.resource_slug_for(table)
           end
         end
       end

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

@@ -10,6 +10,10 @@ module Txdb
             table_name.sub(/_translations\z/, '')
           )
         end
+
+        def resource_slug_for(table)
+          Txgh::Utils.slugify("#{table.database.database}-#{table.name}")
+        end
       end
 
       Helpers.extend(Helpers)

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

@@ -1,3 +1,5 @@
+require 'txgh'
+
 module Txdb
   module Backends
     module Globalize
@@ -12,11 +14,42 @@ module Txdb
         end
 
         def read_content
-          { origin_table_name(table.name) => content_for_records }
+          [Txdb::TxResource.new(resource, serialized_content)]
         end
 
         private
 
+        def resource
+          @resource ||= Txgh::TxResource.new(
+            project_slug, resource_slug, Globalize::Backend::RESOURCE_TYPE,
+            source_lang, source_file, nil, nil
+          )
+        end
+
+        def project_slug
+          table.database.transifex_project.project_slug
+        end
+
+        def resource_slug
+          resource_slug_for(table)
+        end
+
+        def source_lang
+          table.source_lang
+        end
+
+        def source_file
+          table.name
+        end
+
+        def serialized_content
+          YAML.dump(content)
+        end
+
+        def content
+          @content ||= { origin_table_name(table.name) => content_for_records }
+        end
+
         def content_for_records
           each_record.each_with_object({}) do |record, ret|
             ret[record[:id]] = content_for_record(record)

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

@@ -13,22 +13,48 @@ module Txdb
           @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
+        def write_content(resource, locale)
+          content = deserialize_content(resource.content)
+          content = content.fetch(origin_table_name(table.name), {})
+
+          content.each_pair do |id, fields|
+            update_row(id, fields, locale)
           end
         end
 
         private
 
+        def update_row(id, fields, locale)
+          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)
+              .merge(created_at)
+              .merge(updated_at)
+          else
+            row.update(fields.merge(updated_at))
+          end
+        end
+
+        def created_at
+          return {} unless table.db.columns.include?(:created_at)
+          { created_at: get_utc_time }
+        end
+
+        def updated_at
+          return {} unless table.db.columns.include?(:updated_at)
+          { updated_at: get_utc_time }
+        end
+
+        def get_utc_time
+          Time.now.utc
+        end
+
+        def deserialize_content(content)
+          YAML.load(content)
+        end
+
         def foreign_key
           @foreign_key ||= table.name.sub(/_translations/, '_id')
         end

data/lib/txdb/downloader.rb

@@ -1,3 +1,5 @@
+require 'txgh'
+
 module Txdb
   class Downloader
     class << self
@@ -19,14 +21,38 @@ module Txdb
     end
 
     def download_table(table, locale)
-      content = transifex_api.download(table.resource, locale)
-      table.write_content(content, locale)
+      resources.each do |tx_resource|
+        next unless process_resource?(tx_resource, table)
+        download_resource(tx_resource, table, locale)
+      end
+    end
+
+    def download_resource(tx_resource, table, locale)
+      content = transifex_api.download(tx_resource, locale)
+      resource = Txdb::TxResource.new(tx_resource, content)
+      table.write_content(resource, locale)
     end
 
     private
 
+    def process_resource?(resource, table)
+      database.backend.owns_resource?(table, resource)
+    end
+
+    def project_slug
+      database.transifex_project.project_slug
+    end
+
     def transifex_api
       database.transifex_api
     end
+
+    def resources
+      @resources ||= transifex_api
+        .get_resources(project_slug)
+        .map do |resource_hash|
+          Txgh::TxResource.from_api_response(project_slug, resource_hash)
+        end
+    end
   end
 end

data/lib/txdb/handlers/hook_handler.rb

@@ -19,11 +19,8 @@ module Txdb
       end
 
       def handle
-        tables.each do |table|
-          content = table.database.transifex_api.download(table.resource, locale)
-          table.write_content(content, locale)
-        end
-
+        return respond_with_error(401, 'Unauthorized') unless authentic_request?
+        downloader.download_resource(resource, table, locale)
         respond_with(200, {})
       rescue => e
         respond_with_error(500, "Internal server error: #{e.message}", e)
@@ -31,23 +28,54 @@ module Txdb
 
       private
 
-      def locale
-        payload['language']
+      def downloader
+        @downloader ||= Txdb::Downloader.new(database)
       end
 
-      def tables
-        @tables ||= Txdb::Config.each_table.select do |table|
-          table.resource.resource_slug == payload['resource'] &&
-            authentic_request?(table.database.transifex_project)
+      def database
+        @database ||= Txdb::Config.databases.find do |database|
+          database.transifex_project.project_slug == project_slug
         end
       end
 
-      def authentic_request?(project)
+      def table
+        @table ||= database.tables.find do |table|
+          database.backend.owns_resource?(table, resource)
+        end
+      end
+
+      def resource
+        @resource ||= Txgh::TxResource.from_api_response(
+          project_slug, transifex_api.get_resource(project_slug, resource_slug)
+        )
+      end
+
+      def transifex_project
+        database.transifex_project
+      end
+
+      def authentic_request?
         Txgh::TransifexRequestAuth.authentic_request?(
-          request, project.webhook_secret
+          request, transifex_project.webhook_secret
         )
       end
 
+      def transifex_api
+        database.transifex_api
+      end
+
+      def project_slug
+        payload['project']
+      end
+
+      def resource_slug
+        payload['resource']
+      end
+
+      def locale
+        payload['language']
+      end
+
       def payload
         @payload ||= begin
           request.body.rewind

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

@@ -24,26 +24,17 @@ module Txdb
           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
+        def database
+          @database ||= Txdb::Config.databases.find do |database|
+            database.database == request.params['database']
           end
         end
 
-        def tables
-          @tables ||= each_table_in(databases).select do |table|
+        def table
+          @table ||= database.tables.find 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

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

@@ -5,10 +5,8 @@ module Txdb
       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
+            locales.each do |locale|
+              downloader.download_table(table, locale)
             end
 
             respond_with(200, {})
@@ -17,15 +15,14 @@ module Txdb
 
         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'] }
+        def downloader
+          @downloader ||= Downloader.new(database)
         end
 
-        def locale_cache
-          @locale_cache ||= {}
+        def locales
+          database.transifex_api
+            .get_languages(database.transifex_project.project_slug)
+            .map { |locale| locale['language_code'] }
         end
       end
 

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

@@ -5,10 +5,7 @@ module Txdb
       class PushHandler < Handler
         def handle
           handle_safely do
-            tables.each do |table|
-              Uploader.new(table.database).upload_table(table)
-            end
-
+            Uploader.new(database).upload_table(table)
             respond_with(200, {})
           end
         end

data/lib/txdb/table.rb

@@ -1,5 +1,4 @@
 require 'txgh'
-require 'yaml'
 
 module Txdb
   class Table
@@ -17,20 +16,12 @@ module Txdb
       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)
-      )
+      database.backend.read_content_from(self)
     end
 
-    def write_content(content, locale)
-      database.backend.write_content_to(
-        self, YAML.load(content), locale
-      )
+    def write_content(resource, locale)
+      database.backend.write_content_to(self, resource, locale)
     end
   end
 end

data/lib/txdb/tx_resource.rb

@@ -1,52 +1,18 @@
-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
+    attr_reader :original, :content
 
-    def initialize(resource)
-      @resource = resource
+    def initialize(original, content)
+      @original = original
+      @content = content
     end
 
     def respond_to?(method)
-      resource.respond_to?(method)
+      original.respond_to?(method)
     end
 
     def method_missing(method, *args, &block)
-      resource.send(method, *args, &block)
+      original.send(method, *args, &block)
     end
   end
 end

data/lib/txdb/uploader.rb

@@ -19,9 +19,11 @@ module Txdb
     end
 
     def upload_table(table)
-      transifex_api.create_or_update(
-        table.resource, table.read_content
-      )
+      table.read_content.each do |resource|
+        transifex_api.create_or_update(
+          resource.original, resource.content
+        )
+      end
     end
 
     private

data/lib/txdb/version.rb

@@ -1,3 +1,3 @@
 module Txdb
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end

data/spec/backends/globalize/helpers_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
+require 'spec_helpers/test_db'
 
 include Txdb::Backends
 
-describe Globalize::Helpers do
+describe Globalize::Helpers, test_db: true do
   describe '.origin_table_name' do
     it 'pluralizes and removes the translations suffix' do
       origin = Globalize::Helpers.origin_table_name('widget_translations')
@@ -14,4 +15,15 @@ describe Globalize::Helpers do
       expect(origin).to eq('oxen')
     end
   end
+
+  describe '#resource_slug_for' do
+    let(:database) { TestDb.database }
+    let(:table) { database.tables.first }
+
+    it 'constructs a slug from the database and table names' do
+      expect(Globalize::Helpers.resource_slug_for(table)).to eq(
+        'spec_test.sqlite3-my_table'
+      )
+    end
+  end
 end

data/spec/backends/globalize/reader_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'spec_helpers/globalize_db'
+require 'yaml'
 
 include Txdb::Backends
 
@@ -7,19 +8,31 @@ 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
+    it 'reads data from the given table and returns an array of resources' 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' }
-        }
-      })
+      resources = reader.read_content
+      expect(resources.size).to eq(1)
+      resource = resources.first
+
+      expect(resource.source_file).to eq(widget_translations_table.name)
+      expect(resource.project_slug).to eq(database.transifex_project.project_slug)
+      expect(resource.resource_slug).to(
+        eq(Globalize::Helpers.resource_slug_for(widget_translations_table))
+      )
+
+      expect(resource.content).to eq(
+        YAML.dump(
+          'widgets' => {
+            1 => { 'name' => 'sprocket' },
+            2 => { 'name' => 'flange' }
+          }
+        )
+      )
     end
   end
 end

data/spec/backends/globalize/writer_spec.rb

@@ -1,5 +1,8 @@
+require 'active_support/core_ext/numeric/time'
 require 'spec_helper'
 require 'spec_helpers/globalize_db'
+require 'timecop'
+require 'yaml'
 
 include Txdb::Backends
 
@@ -7,25 +10,74 @@ 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)
+    let(:base_resource) do
+      # project_slug, resource_slug, type, source_lang, source_file,
+      # lang_map, translation_file
+      Txgh::TxResource.new(
+        'project_slug', 'resource_slug', Globalize::Backend::RESOURCE_TYPE,
+        'source_lang', 'source_file', nil, nil
+      )
+    end
 
-      content = {
-        'widgets' => {
-          sprocket_id => { name: 'sproqueta' }
-        }
-      }
+    context 'with some content' do
+      before(:each) do
+        @sprocket_id = widgets.insert(name: 'sprocket')
+        @writer = Globalize::Writer.new(widget_translations_table)
 
-      expect { writer.write_content(content, 'es') }.to(
-        change { widget_translations.count }.from(0).to(1)
-      )
+        @content = YAML.dump(
+          'widgets' => {
+            @sprocket_id => { name: 'sproqueta' }
+          }
+        )
 
-      translation = widget_translations.first
+        @resource = Txdb::TxResource.new(base_resource, @content)
+      end
 
-      expect(translation).to include(
-        widget_id: sprocket_id, name: 'sproqueta', locale: 'es'
-      )
+      it 'inserts the translations into the database' do
+        expect { @writer.write_content(@resource, '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
+
+      context 'with created_at and updated_at columns' do
+        before(:each) do
+          GlobalizeDb.db.alter_table(:widget_translations) do
+            add_column :created_at, Time
+            add_column :updated_at, Time
+          end
+        end
+
+        it 'fills in the created_at and updated_at columns' do
+          Timecop.freeze(Time.now) do
+            @writer.write_content(@resource, 'es')
+            translation = widget_translations.first
+            expect(translation[:created_at].to_i).to eq(Time.now.utc.to_i)
+            expect(translation[:updated_at].to_i).to eq(Time.now.utc.to_i)
+          end
+        end
+
+        it 'updates the updated_at column if the record already exists' do
+          @writer.write_content(@resource, 'es')
+
+          today = Time.now + 1.day  # groundhog day
+
+          Timecop.freeze(today) do
+            translation = widget_translations.first
+            expect(translation[:updated_at].to_i).to_not eq(today.utc.to_i)
+
+            # record already exists, so should get updated with new timestamp
+            @writer.write_content(@resource, 'es')
+            translation = widget_translations.first
+            expect(translation[:updated_at].to_i).to eq(today.utc.to_i)
+          end
+        end
+      end
     end
 
     it 'updates the record if it already exists' do
@@ -36,13 +88,15 @@ describe Globalize::Writer, globalize_db: true do
 
       writer = Globalize::Writer.new(widget_translations_table)
 
-      content = {
+      content = YAML.dump(
         'widgets' => {
           sprocket_id => { name: 'sproqueta2' }
         }
-      }
+      )
+
+      resource = Txdb::TxResource.new(base_resource, content)
 
-      expect { writer.write_content(content, 'es') }.to_not(
+      expect { writer.write_content(resource, 'es') }.to_not(
         change { widget_translations.count }
       )
 

data/spec/downloader_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helpers/test_backend'
 include Txdb
 
 describe Downloader, test_db: true do
-  let(:database) { Txdb::Config.databases.first }
+  let(:database) { TestDb.database }
   let(:downloader) { Downloader.new(database) }
   let(:transifex_api) { double(:transifex_api) }
 
@@ -17,20 +17,38 @@ describe Downloader, test_db: true do
 
   describe '#download' do
     it 'downloads translations from Transifex and writes them to the db' do
+      expect(transifex_api).to(
+        receive(:get_resources)
+          .with(database.transifex_project.project_slug)
+          .and_return([{
+            'slug' => 'fake_resource_slug',
+            'i18n_type' => 'fake_i18n_type',
+            'source_language_code' => 'en',
+            'name' => 'fake_name',
+          }])
+      )
+
+      content = YAML.dump({ foo: 'bar' })
+
       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(resource.resource_slug).to eq('fake_resource_slug')
         expect(locale).to eq('es')
-        YAML.dump('widgets')
+        content
       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'
-      )
+      write = TestBackend.writes.first
+      expect(write[:table]).to eq(database.tables.first.name)
+      expect(write[:locale]).to eq('es')
+
+      expect(write[:resource]).to be_a(Txdb::TxResource)
+      expect(write[:resource].project_slug).to eq('myproject')
+      expect(write[:resource].resource_slug).to eq('fake_resource_slug')
+      expect(write[:resource].content).to eq(content)
     end
   end
 end

data/spec/handlers/hook_handler_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helpers/test_db'
 require 'uri'
 require 'yaml'
 
+include Txdb
 include Txdb::Handlers
 
 describe HookHandler do
@@ -12,6 +13,16 @@ describe HookHandler do
   let(:database) { TestDb.database }
   let(:table) { database.tables.first }
   let(:project) { database.transifex_project }
+  let(:resource) { TestBackend.resource }
+
+  let(:body) { URI.encode_www_form(params.to_a) }
+  let(:params) do
+    {
+      'project' => resource.project_slug,
+      'resource' => resource.resource_slug,
+      'language' => 'es'
+    }
+  end
 
   def app
     Txdb::Hooks
@@ -21,48 +32,49 @@ describe HookHandler 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(last_response.status).to eq(401)
+    expect(JSON.parse(last_response.body)).to eq([{ 'error' => 'Unauthorized' }])
 
     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) } }
+
+    before(:each) do
+      header(
+        Txgh::TransifexRequestAuth::TRANSIFEX_HEADER,
+        Txgh::TransifexRequestAuth.header_value(body, project.webhook_secret)
+      )
+    end
 
     it 'downloads and writes new content to the database' do
+      expect(project.api).to receive(:get_resource).and_return(resource.to_api_h)
       expect(project.api).to receive(:download).and_return(YAML.dump(content))
 
-      expect { post('/transifex', body, headers) }.to(
+      expect { post('/transifex', body) }.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
-      )
+      write = Txdb::TestBackend.writes.first
+
+      expect(write[:locale]).to eq('es')
+      expect(write[:table]).to eq(table.name)
+      expect(write[:resource]).to be_a(Txdb::TxResource)
+      expect(write[:resource].project_slug).to eq(resource.project_slug)
+      expect(write[:resource].resource_slug).to eq(resource.resource_slug)
     end
 
     it 'reports errors' do
-      expect(project.api).to receive(:download).and_raise('jelly beans')
+      expect(project.api).to receive(:get_resource).and_raise('jelly beans')
 
-      post '/transifex', body, headers
+      post '/transifex', body
 
       expect(last_response.status).to eq(500)
       expect(JSON.parse(last_response.body)).to eq(

data/spec/handlers/triggers/pull_handler_spec.rb

@@ -28,8 +28,12 @@ describe PullHandler do
   it 'downloads the table for each locale' do
     locales = [{ 'language_code' => 'es' }, { 'language_code' => 'ja' }]
     content = { 'phrase' => 'trans' }
+
     expect(database.transifex_api).to receive(:get_languages).and_return(locales)
     allow(database.transifex_api).to receive(:download).and_return(YAML.dump(content))
+    expect(database.transifex_api).to receive(:get_resources).and_return(
+      [Txdb::TestBackend.resource.to_api_h]
+    )
 
     expect { patch('/pull', params) }.to(
       change { Txdb::TestBackend.writes.size }.from(0).to(2)
@@ -38,13 +42,20 @@ describe PullHandler do
     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
-    )
+    expect(Txdb::TestBackend.writes.first[:locale]).to eq('es')
+    expect(Txdb::TestBackend.writes.last[:locale]).to eq('ja')
 
-    expect(Txdb::TestBackend.writes).to include(
-      locale: 'ja', table: table.name, content: content
-    )
+    Txdb::TestBackend.writes.each do |write|
+      expect(write[:table]).to eq(table.name)
+
+      expect(write[:resource].project_slug).to(
+        eq(Txdb::TestBackend.resource.project_slug)
+      )
+
+      expect(write[:resource].resource_slug).to(
+        eq(Txdb::TestBackend.resource.resource_slug)
+      )
+    end
   end
 
   it 'reports errors' do

data/spec/spec_helper.rb

@@ -9,6 +9,8 @@ require 'txdb'
 require 'spec_helpers/env_helpers'
 require 'spec_helpers/test_backend'
 
+Sequel.default_timezone = :utc
+
 RSpec.configure do |config|
   config.before(:each) do
     Txdb::TestBackend.reset

data/spec/spec_helpers/test_backend.rb

@@ -16,13 +16,32 @@ module Txdb
 
       def read_content_from(table)
         reads << { table: table.name }
-        {}
+        [resource]
       end
 
-      def write_content_to(table, content, locale)
-        writes << { table: table.name, content: content, locale: locale }
+      def write_content_to(table, resource, locale)
+        writes << { table: table.name, resource: resource, locale: locale }
         nil
       end
+
+      def owns_resource?(table, resource)
+        true
+      end
+
+      def base_resource
+        @base_resource ||= Txgh::TxResource.new(
+          'myproject', 'resource_slug', 'type',
+          'source_lang', 'source_file', nil, nil
+        )
+      end
+
+      def content
+        @content ||= 'fake content'
+      end
+
+      def resource
+        @resource ||= Txdb::TxResource.new(base_resource, content)
+      end
     end
   end
 end

data/spec/table_spec.rb

@@ -15,44 +15,23 @@ describe Table, test_db: true do
     end
   end
 
-  describe '#resource' do
-    it 'creates a TxResource from the table' do
-      resource = table.resource
-      expect(resource).to be_a(Txdb::TxResource)
-      expect(resource.project_slug).to eq('myproject')
-      expect(resource.resource_slug).to eq(
-        Txgh::Utils.slugify("#{database.database}-#{table.name}")
-      )
-      expect(resource.source_file).to eq(table.name)
-      expect(resource.source_lang).to eq('en')
-    end
-  end
-
   describe '#read_content' do
-    let(:content) { { foo: 'bar' } }
-
-    it 'dumps the content in YAML format' do
-      expect(database.backend).to(
-        receive(:read_content_from).and_return(content)
-      )
-
-      expect(table.read_content).to eq(YAML.dump(content))
+    it 'proxies to the backend' do
+      expect(database.backend).to receive(:read_content_from)
+      table.read_content
     end
   end
 
   describe '#write_content' do
-    let(:content) { { foo: 'bar' } }
-    let(:locale) { 'es' }
-
-    it 'parses and writes the content to the database' do
+    it 'proxies to the backend' do
       expect(database.backend).to(
         receive(:write_content_to) do |_, cont, loc|
-          expect(cont).to eq(content)
-          expect(loc).to eq(locale)
+          expect(cont).to eq(:content)
+          expect(loc).to eq(:locale)
         end
       )
 
-      table.write_content(YAML.dump(content), locale)
+      table.write_content(:content, :locale)
     end
   end
 end

data/spec/uploader_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helpers/test_backend'
 include Txdb
 
 describe Uploader, test_db: true do
-  let(:database) { Txdb::Config.databases.first }
+  let(:database) { TestDb.database }
   let(:uploader) { Uploader.new(database) }
   let(:transifex_api) { double(:transifex_api) }
 
@@ -18,19 +18,13 @@ describe Uploader, test_db: true do
   describe '#upload' do
     it 'reads phrases from the database and uploads them to Transifex' do
       expect(transifex_api).to receive(:create_or_update) do |resource, content|
-        expect(resource.project_slug).to eq('myproject')
-        expect(resource.resource_slug).to(
-          eq(Txgh::Utils.slugify("#{database.database}-#{database.tables.first.name}"))
-        )
+        expect(resource.project_slug).to eq(TestBackend.resource.project_slug)
+        expect(resource.resource_slug).to eq(TestBackend.resource.resource_slug)
       end
 
       expect { uploader.upload }.to(
         change { TestBackend.reads.size }.from(0).to(1)
       )
-
-      expect(TestBackend.reads.first).to eq(
-        table: database.tables.first.name
-      )
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: txdb
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-17 00:00:00.000000000 Z
+date: 2016-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -61,6 +61,7 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/ext/txgh/tx_resource.rb
 - lib/txdb.rb
 - lib/txdb/app.rb
 - lib/txdb/backends.rb
@@ -105,7 +106,6 @@ files:
 - spec/table_spec.rb
 - spec/test.sqlite3
 - spec/transifex_project_spec.rb
-- spec/tx_resource_spec.rb
 - spec/uploader_spec.rb
 - txdb.gemspec
 homepage: https://github.com/lumoslabs/txdb

data/spec/tx_resource_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'spec_helpers/test_db'
-
-include Txdb
-
-describe TxResource, test_db: true do
-  let(:database) { TestDb.database }
-  let(:table) { database.tables.first }
-  let(:resource) { table.resource }
-
-  it 'proxies methods to the underlying Txgh::TxResource' do
-    expect(resource.project_slug).to eq('myproject')
-    expect(resource.resource_slug).to(
-      eq(Txgh::Utils.slugify("#{database.database}-#{table.name}"))
-    )
-  end
-end