Php Google Translate For Free Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require dejurin/php-google-translate-for-free
   

   Ensure your composer.json includes "minimum-stability": "dev" if using pre-release versions (though this package is outdated).

2. Basic Usage

   use Dejurin\GoogleTranslate\GoogleTranslate;
   
   $translator = new GoogleTranslate('en', 'es'); // Source and target languages
   $translation = $translator->translate('Hello, world!');
   echo $translation; // Outputs: "¡Hola, mundo!"
   

3. First Use Case

   • Translate user-generated content in a Laravel app (e.g., comments, support tickets).
   • Example:

     $userInput = request()->input('comment');
     $translated = (new GoogleTranslate('en', 'fr'))->translate($userInput);
     

Implementation Patterns

Common Workflows

1. Batch Translations

   $translator = new GoogleTranslate('en', 'de');
   $texts = ['Hello', 'Goodbye', 'Thank you'];
   $translations = $translator->translateArray($texts);
   // Returns: ['Hallo', 'Auf Wiedersehen', 'Danke']
   

2. Language Detection

   $detector = new GoogleTranslate();
   $language = $detector->detect('Bonjour'); // Returns 'fr'
   

3. Laravel Service Provider Integration

   // config/services.php
   'google_translate' => [
       'default' => 'en-es',
       'connections' => [
           'en-es' => ['source' => 'en', 'target' => 'es'],
       ],
   ];
   
   // app/Providers/AppServiceProvider.php
   public function register()
   {
       $this->app->singleton(GoogleTranslate::class, function ($app) {
           $config = config('services.google_translate.default');
           return new GoogleTranslate(
               config("services.google_translate.connections.{$config}.source"),
               config("services.google_translate.connections.{$config}.target")
           );
       });
   }
   

4. Middleware for Auto-Translation

   // app/Http/Middleware/TranslateContent.php
   public function handle($request, Closure $next)
   {
       $translated = app(GoogleTranslate::class)->translate($request->input('content'));
       $request->merge(['translated_content' => $translated]);
       return $next($request);
   }
   

5. Queueing Long Translations

   // Dispatch a job for async translation
   TranslateJob::dispatch($text, 'en', 'es');
   

Gotchas and Tips

Pitfalls

1. Rate Limiting

   • Google’s free tier has undocumented limits. Expect failures after ~100 requests/hour.
   • Workaround: Implement retry logic with exponential backoff.

     $translator->setMaxRetries(3);
     $translator->setRetryDelay(2); // seconds
     

2. Deprecated API

   • This package uses Google’s deprecated free API (no longer officially supported).
   • Risk: May stop working without notice. Monitor for failures.

3. Language Codes

   • Use ISO 639-1 codes (e.g., en, es). Unsupported codes (e.g., zh-cn) will fail silently.
   • Fix: Validate input languages:

     $supported = ['en', 'es', 'fr', 'de', 'it'];
     if (!in_array($sourceLang, $supported)) {
         throw new \InvalidArgumentException("Unsupported source language");
     }
     

4. Character Limits

   • Google’s free API has a 5,000-character limit per request. Long texts will fail.
   • Solution: Split text into chunks:

     function chunkTranslate($text, $chunkSize = 4000) {
         $chunks = array_chunk(str_split($text, $chunkSize), 1);
         $results = [];
         foreach ($chunks as $chunk) {
             $results[] = $translator->translate(implode('', $chunk));
         }
         return implode('', $results);
     }
     

5. Caching

   • Translations are not cached by default. Repeated calls for the same text hit rate limits.
   • Optimization: Cache results in Laravel’s cache:

     $cacheKey = "translate_{$source}_{$target}_{$text}";
     return cache()->remember($cacheKey, now()->addHours(1), function () use ($translator, $text, $source, $target) {
         return $translator->translate($text);
     });
     

Debugging Tips

1. Enable Logging Add a logger to track failures:

   $translator->setLogger(app(\Psy\Logger::class));
   

2. Mock for Testing Use a mock for unit tests:

   $mock = Mockery::mock(GoogleTranslate::class);
   $mock->shouldReceive('translate')->andReturn('Mocked translation');
   $this->app->instance(GoogleTranslate::class, $mock);
   

3. Fallback Mechanism Combine with a fallback translator (e.g., Symfony’s TranslatorComponent) if Google fails:

   try {
       return $translator->translate($text);
   } catch (\Exception $e) {
       return app(\Symfony\Component\Translation\Translator::class)->trans($text);
   }
   

Extension Points

1. Custom HTTP Client Override the default Guzzle client for proxies/headers:

   $client = new \GuzzleHttp\Client([
       'timeout' => 10,
       'headers' => ['User-Agent' => 'MyApp/1.0'],
   ]);
   $translator = new GoogleTranslate('en', 'es', $client);
   

2. Event Dispatching Trigger events on success/failure:

   $translator->onSuccess(function ($translation) {
       event(new TranslationSucceeded($translation));
   });
   $translator->onFailure(function ($exception) {
       event(new TranslationFailed($exception));
   });
   

3. Language Fallback Extend to auto-fallback to a default language on detection failure:

   public function detect($text, $fallback = 'en') {
       try {
           return parent::detect($text);
       } catch (\Exception $e) {
           return $fallback;
       }
   }