linguara 0.0.3 → 0.0.4

data/.gitignore

@@ -20,3 +20,4 @@ pkg
 
 ## PROJECT::SPECIFIC
 stats
+doc

data/LICENSE

@@ -1,3 +1,5 @@
+The MIT License
+
 Copyright (c) 2009 Aleksander Dabrowski
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.rdoc

@@ -1,6 +1,30 @@
 = linguara
 
-This gem allows integratation with Linguara WebAPI. 
+This gem allows integration with Linguara WebAPI. 
+
+== Installation
+
+You need to somehow store your translation. We assume you use globalize2
+
+  gem install globalize2
+  gem install linguara
+
+Create configuration file in config/initializers/linguara.rb:
+
+  Linguara.configure do |config|
+    config.api_key = 'api_key'
+    config.server_path = 'http://www.example.com/'
+    config.return_url = 'http://maverick.kumulator.com:82/linguara'
+  end
+
+In your model add these two lines:
+
+  BlogPost < ActiveRecord::Base  
+    translates :name, :description
+    translates_with_linguara :name, :description
+  end
+
+And that's all, evrything else is magic. Now every time you create your model (by default), a request is being send to linguara. When translation will be accepted, request will be sent back to your application and model will be updated. 
 
 == Note on Patches/Pull Requests
  

data/Rakefile

@@ -9,7 +9,7 @@ begin
     gem.description = %Q{Gem to integrate with linguara api}
     gem.email = "aleks@kumulator.pl"
     gem.homepage = "http://github.com/tjeden/linguara"
-    gem.authors = ["Aleksander Dabrowski"]
+    gem.authors = ["Aleksander Dabrowski", "Piotr Barczuk"]
     gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.files += FileList['lib/**/*.rb']
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
@@ -44,3 +44,15 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+task :metric do
+  FLAY_MAX = 100
+  correct = true
+  metric_output = %x[flay -s lib/*]
+  if metric_output.first.gsub("Total score (lower is better) = ","").to_i > FLAY_MAX
+    correct = false 
+    puts "Too much flay. It should be less than: #{FLAY_MAX}"
+    puts metric_output
+  end
+  exit(1) unless correct
+end

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/init.rb

@@ -0,0 +1 @@
+require 'linguara'

data/lib/linguara/active_record.rb

@@ -7,12 +7,15 @@ module Linguara
     module LinguaraMethods
       def translates_with_linguara(*attr_names)
         include InstanceMethods
+
+        options = attr_names.extract_options!
         
         class_inheritable_accessor :linguara_translation_attribute_names
               
         self.linguara_translation_attribute_names = attr_names.map(&:to_sym)
 
-        after_create :send_to_linguara 
+        after_create :send_to_linguara if options[:send_on] == :create
+        after_save :send_to_linguara if options[:send_on] == :save
       end
     end
     
@@ -22,20 +25,40 @@ module Linguara
         prepared_fields =  {}
         linguara_translation_attribute_names.each_with_index do |name, index|
           key_name = linguara_key_name(name, index)
-          prepared_fields[key_name] = { :id => key_name, :content => self.send(name) }
+          prepared_fields[key_name] = self.send(name)
         end 
         prepared_fields
       end
+
+      def send_to_linguara(options = {})
+        options = before_send_to_linguara(options)
+        res = Linguara.send_translation_request(self, options )
+        after_send_to_linguara(res)
+        res
+      end
+
+      def send_status_query(translation_request_id)
+        Linguara.send_status_query(translation_request_id)
+      end
       
      protected
       
       def linguara_key_name(field, index)
         "#{self.class.class_name}_#{self.id}_#{index}_#{field}"
-      end      
+      end
 
-      def send_to_linguara
-        Linguara.send_request(self)
-      end 
+      #override this if you want to have a customised method for determining which language to use.
+      def linguara_default_translation_language
+        'en'
+      end
+
+      #override for some callbacks
+      def before_send_to_linguara(options)
+        options
+      end
+
+      def after_send_to_linguara(response)
+      end
      
     end
   end

data/lib/linguara/configuration.rb

@@ -1,8 +1,10 @@
 module Linguara
   class Configuration
-    attr_accessor :api_key, :server_path, :return_url, :user, :password
+    attr_accessor :api_key, :server_path, :return_url, :user, :password, :request_valid_for, :site_url, :log, :return_request
     
     def initialize
+      self.log = true
+      self.request_valid_for = 30
     end
   end
 end

data/lib/linguara/translation.rb

@@ -0,0 +1,22 @@
+class Translation
+  
+  attr_accessor :translation_hash
+  
+  def initialize(element,options = {})
+    unless options[:translation] && options[:translation][:due_date]
+      options[:translation] = Hash.new
+      options[:translation][:due_date] ||= Date.today + Linguara.configuration.request_valid_for.to_i.days unless Linguara.configuration.request_valid_for.blank?
+      options[:translation][:due_date] ||= Date.today + 1.month
+    end
+    options[:return_url] ||= Linguara.configuration.return_url
+    options[:source_language] ||= I18n.locale.to_s
+    options[:content] = Hash.new
+    options[:content][:plain] = Hash.new
+    options[:content][:plain][:paragraphs] = element.fields_to_send
+    self.translation_hash = options
+  end
+  
+  def to_hash
+    self.translation_hash
+  end
+end

data/lib/linguara/utils.rb

@@ -1,18 +1,21 @@
 module Linguara
   module Utils
-    #TODO describe it, spec and move somewhere else
+     #TODO describe it, spec and move somewhere else
      # http://www.keyongtech.com/5211204-nested-http-params-on-ruby
      def serialize_form_data(data, path = "",serialized_params = [])
         if data.kind_of? Hash
-          data.each_pair{|k,v| token = (path == "" ? url_encode(k) :  "[#{url_encode(k)}]"); serialize_form_data(v, "#{path}#{token}",serialized_params)}
-        elsif data.kind_of? Array
-          data.each{|v| serialize_form_data(v, "#{path}[]", serialized_params) }
+          data.each_pair{|k,v| token = (path == "" ? CGI::escape(k.to_s) :  "[#{CGI::escape(k.to_s)}]"); serialize_form_data(v, "#{path}#{token}",serialized_params)}
         else
           #end of recursion
-          serialized_params << "#{path}=#{url_encode(data)}"
+          serialized_params << "#{path}=#{CGI::escape(data.to_s)}"
         end
 
         return serialized_params.join("&") if (path == "")
       end
+      
+      def  strip_blank_attributes(data)
+        data = data.each_pair { |k,v| v.is_a?(Hash) ? (strip_blank_attributes(v)) : (v) }
+        data.delete_if { |k,v| v.blank?}
+      end
   end
 end

data/lib/linguara.rb

@@ -2,6 +2,7 @@ require 'net/http'
 require 'uri'
 require 'linguara/configuration'
 require 'linguara/utils'
+require 'linguara/translation'
 
 module Linguara
   extend Linguara::Utils
@@ -15,47 +16,112 @@ module Linguara
       yield(configuration)
     end
     
+    # Use this method in your controller to accepr and save incoming translations
     def accept_translation(translation)
       target_language = translation[:target_language]
-      translation[:paragraph].each do |key,value|
-        class_name,id,order,field_name = value[:id].split('_')
-        content = value[:content]
+      translation[:paragraphs].each do |key,value|
+        class_name,id,order,field_name = key.split('_')
         original_locale = I18n.locale
         element = class_name.constantize.find(id)
         
         I18n.locale = target_language
-        element.send("#{field_name}=", content)
+        element.send("#{field_name}=", value.gsub(/<p>(.*?)<\/p>/, "\\1\n") )
         element.save(false)
         I18n.locale = original_locale
       end
     end
     
-    def send_request(element)
-      url= URI.parse(Linguara.configuration.server_path)
-      req = Net::HTTP::Post.new(url.path)
-      req.body = serialize_form_data({
-        :translation => {
-          :return_url => Linguara.configuration.return_url,
-          :due_date => '27-06-2010',
-          :source_language =>"pl", 
-          :target_language =>"en",
-          :paragraph  => element.fields_to_send,
-          :account_token => Linguara.configuration.api_key}})
+    def send_translation_request(element, options = {})
+      translation = Translation.new(element, options) 
+      url= URI.parse("#{Linguara.configuration.server_path}api/translations.xml")
+      req = prepare_request(url, translation.to_hash.merge( :authorization => true))
+      send_linguara_request(req, url)
+    end
+
+    def send_status_query(translation_request_id)
+      url= URI.parse("#{Linguara.configuration.server_path}api/translations/#{translation_request_id}/status.xml")
+      req = prepare_request(url, :authorization => true)
+      send_linguara_request(req, url)
+    end
+    
+    def send_languages_request(options={})
+      url= URI.parse("#{Linguara.configuration.server_path}api/languages.xml")
+      req = prepare_request(url, options.merge(:method => :get))
+      send_linguara_request(req, url)
+    end
+    
+    def send_specializations_request(options)
+      url= URI.parse("#{Linguara.configuration.server_path}api/specializations.xml")
+      req = prepare_request(url, options.merge(:method => :get))
+      send_linguara_request(req, url)
+    end
+    
+    def send_translators_request(options)
+      url= URI.parse("#{Linguara.configuration.server_path}api/translators.xml")
+      req = prepare_request(url, options.merge(:method => :get))
+      send_linguara_request(req, url)
+    end
+    
+    # Override this method if you want to perform some action when connection
+    # with linguara cannot be established e.g. log request or redo the send
+    def handle_request_error
+      log("ERROR WHILE SENDING REQUEST TO LINGUARA: #{$!}")
+    end
+    
+    # Log a linguara-specific line. Uses Rails.logger
+    # by default. Set Lingurara.config.log = false to turn off.
+    def log message
+      logger.info("[linguara] #{message}") if logging?
+    end
+
+    def logger #:nodoc:      
+      Rails.logger
+    end
+
+    def logging? #:nodoc:
+      Linguara.configuration.log
+    end
+    
+    private
+    
+    def prepare_request(url, data = {} )
+      data = strip_blank_attributes(data)
+      if data[:method] == :get
+        req = Net::HTTP::Get.new(url.path)
+        data.delete(:method)
+      else
+        req = Net::HTTP::Post.new(url.path)
+      end
+      if data[:authorization]   
+        data.delete(:authorization)
+        req.body = serialize_form_data({
+          :site_url => Linguara.configuration.site_url,
+          :account_token => Linguara.configuration.api_key
+         }.merge(data))
+      else
+        req.body = serialize_form_data(data)
+      end
       req.content_type = 'application/x-www-form-urlencoded'
-      req.basic_auth Linguara.configuration.user, Linguara.configuration.password
+      req.basic_auth(Linguara.configuration.user, Linguara.configuration.password)
+      req
+    end
+    
+    def send_linguara_request(req, url)
       #TODO handle timeout
       begin
-        res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }   
+        log("SENDING LINGUARA REQUEST TO #{url.path}: \n#{req.body}")
+        res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+        log("LINGUARA RESPONSE: #{res.message} -- #{res.body}")
+        #TODO there should be object returned, whih contains request and respnse
+        if Linguara.configuration.return_request
+          return req
+        else
+          return res
+        end
       rescue Errno::ETIMEDOUT 
         handle_request_error
       end
     end
-    
-    # ovverride this method if you want to perform some action when connection
-    # with linguara cannot be established e.g. log request or redo the send
-    def handle_request_error
-    end
-    
   end
 end
 

data/linguara.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{linguara}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Aleksander Dabrowski"]
-  s.date = %q{2010-06-05}
+  s.authors = ["Aleksander Dabrowski", "Piotr Barczuk"]
+  s.date = %q{2010-07-23}
   s.description = %q{Gem to integrate with linguara api}
   s.email = %q{aleks@kumulator.pl}
   s.extra_rdoc_files = [
@@ -23,9 +23,11 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION",
+     "init.rb",
      "lib/linguara.rb",
      "lib/linguara/active_record.rb",
      "lib/linguara/configuration.rb",
+     "lib/linguara/translation.rb",
      "lib/linguara/utils.rb",
      "linguara.gemspec",
      "spec/data/schema.rb",
@@ -33,7 +35,8 @@ Gem::Specification.new do |s|
      "spec/helper_model/database_mock.rb",
      "spec/linguara_spec.rb",
      "spec/spec.opts",
-     "spec/spec_helper.rb"
+     "spec/spec_helper.rb",
+     "spec/translation_spec.rb"
   ]
   s.homepage = %q{http://github.com/tjeden/linguara}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -45,7 +48,8 @@ Gem::Specification.new do |s|
      "spec/helper_model/blog_post.rb",
      "spec/helper_model/database_mock.rb",
      "spec/linguara_spec.rb",
-     "spec/spec_helper.rb"
+     "spec/spec_helper.rb",
+     "spec/translation_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/spec/helper_model/blog_post.rb

@@ -1,3 +1,3 @@
 class BlogPost < ActiveRecord::Base  
-  translates_with_linguara :title, :body
+  translates_with_linguara :title, :body, :send_on => :save
 end

data/spec/linguara_spec.rb

@@ -2,24 +2,26 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Linguara" do
   
-  it "should sent message to linguara for translatable classes" do
-    FakeWeb.register_uri(:post, 'http://www.example.com/', :exception => Net::HTTPError)  
+  it "sent message to linguara for translatable classes" do
+    FakeWeb.register_uri(:post, 'http://www.example.com/api/translations.xml', :exception => Net::HTTPError)  
     blog_post = BlogPost.new( :title => "Title text", :body => "Body text")
     lambda { 
       blog_post.save
     }.should raise_error(Net::HTTPError)
+     FakeWeb.clean_registry
   end
   
-  it 'should accept correct translation' do
-     FakeWeb.register_uri(:post, 'http://www.example.com/', :body => 'response_for_linguara', :status => 200)  
+  it 'accepts correct translation' do
+     FakeWeb.register_uri(:post, 'http://www.example.com/', :body => 'response_for_linguara', :status => 200)
+     FakeWeb.register_uri(:post, 'http://www.example.com/api/translations.xml', :status => 200) 
      blog_post = BlogPost.new( :title => "Old title", :body => "Old body")
      blog_post.save
      id = blog_post.id
      lambda {
        Linguara.accept_translation(            
-            :paragraph => {
-             "BlogPost_#{id}_0_title"=> { :id =>"BlogPost_#{id}_0_title", :content =>"Hello World!"},
-             "BlogPost_#{id}_1_body"=> { :id =>"BlogPost_#{id}_1_body", :content =>"Today is great weather, and I am going to EuRuKo."}
+            :paragraphs => {
+             "BlogPost_#{id}_0_title" => "Hello World!",
+             "BlogPost_#{id}_1_body" => "Today is great weather, and I am going to EuRuKo."
             },
            :source_language =>"pl", 
            :target_language =>"en"
@@ -29,6 +31,83 @@ describe "Linguara" do
      translation.title.should eql("Hello World!")
      translation.body.should eql("Today is great weather, and I am going to EuRuKo.")
   end
+  
+  describe '#send_translation_request' do
+    it 'sends request' do
+      blog_post = BlogPost.new( :title => "Old title", :body => "Old body")
+      FakeWeb.register_uri(:post, "http://www.example.com/api/translations.xml", :body => 'response_from_linguara', :status => 200) 
+      response = Linguara.send_translation_request(blog_post)
+      response.body.should eql('response_from_linguara')
+    end     
+  end
+  
+  describe '#send_status_query' do
+    it 'sends request' do
+      FakeWeb.register_uri(:post, "http://www.example.com/api/translations/5/status.xml", :body => 'response_from_linguara', :status => 200) 
+      response = Linguara.send_status_query(5)
+      response.body.should eql('response_from_linguara')
+    end     
+  end
+  
+  describe '#send_languages_request' do
+    it 'sends request' do
+      FakeWeb.register_uri(:get, "http://www.example.com/api/languages.xml", :body => 'response_from_linguara', :status => 200) 
+      response = Linguara.send_languages_request("city"=>"321", "specialization"=>"technical", "country"=>"pl", "native_speaker"=>"1", "max_price"=>"12")
+      response.body.should eql('response_from_linguara')
+    end
+  end
+  
+  describe '#send_specializations_request' do
+    it 'sends request' do
+      FakeWeb.register_uri(:get, "http://www.example.com/api/specializations.xml", :body => 'response_from_linguara', :status => 200) 
+      response = Linguara.send_specializations_request("language"=>"suomi", "sworn" => "1", "native_speaker"=>"1", "max_price"=>"12")
+      response.body.should eql('response_from_linguara')
+    end
+  end
+  
+  describe '#send_translators_request' do
+    it 'sends request' do
+      FakeWeb.register_uri(:get, "http://www.example.com/api/translators.xml", :body => 'response_from_linguara', :status => 200) 
+      response = Linguara.send_translators_request("city"=>"warsaw", "country"=>"pl", "max_price"=>"12", "query"=>"wojcisz", "target_language"=>"en", "source_language" => "pl")
+      response.body.should eql('response_from_linguara')
+    end
+  end
+  
+  describe '#prepare_request' do
+    before :each do
+      @url = URI.parse("http://www.example.com/api/translations")
+      @options = { :translation => { :translator => { :city => "Prague"}}}
+    end
+    
+    it 'sets :POST by deafault' do
+      request = Linguara.send(:prepare_request, @url, @options)
+      request.is_a?(Net::HTTP::Post).should be_true
+      request.body.include?("post").should be_false
+    end
+    
+    it 'sets :GET when option given' do
+      request = Linguara.send(:prepare_request, @url, @options.merge(:method => :get))
+      request.is_a?(Net::HTTP::Get).should be_true
+      request.body.include?("get").should be_false
+    end
+    
+    it 'skips blank parameters' do
+      request = Linguara.send(:prepare_request, @url, @options.merge(:blank_attribute => ""))
+      request.body.include?("blank_attribute").should be_false
+    end
+    
+    it 'skips blank parameters deep' do
+      request = Linguara.send(:prepare_request, @url, @options.merge(:blank_parent => { :blank_attribute => ""}))
+      request.body.include?("blank_attribute").should be_false
+      request.body.include?("blank_parent").should be_false
+    end
+    
+    it 'sets content type to application/x-www-form-urlencoded' do
+      request = Linguara.send(:prepare_request, @url, @options)
+      request.content_type.should be_eql("application/x-www-form-urlencoded")    
+    end
+  
+  end
 
 end
 
@@ -37,9 +116,8 @@ describe 'Linguara::ActiveRecord' do
     blog_post = BlogPost.new( :title => "Title text", :body => "Body text")
     fields_to_send = blog_post.fields_to_send.to_a.sort { |a,b| a[0] <=> b[0] }
     fields_to_send.size.should eql(2)
-    # It's complicated becouse linguara API is complicated. It will be much simplier in future
-    fields_to_send.first[1][:content].should eql("Title text")
-    fields_to_send.last[1][:content].should eql("Body text")
+    fields_to_send.first[1].should eql("Title text")
+    fields_to_send.last[1].should eql("Body text")
   end
 end
 

data/spec/spec_helper.rb

@@ -1,14 +1,12 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-require 'rubygems'
+require 'cgi'
 require 'active_record'
 require 'active_support'
 require 'helper_model/database_mock'
 require 'linguara'
 require 'helper_model/blog_post'
-require "erb"
-include ERB::Util
 require 'spec'
 require 'spec/autorun'
 require 'fakeweb'
@@ -16,9 +14,10 @@ require 'fakeweb'
 prepare_database
 
 Linguara.configure do |config|
-  config.api_key = 'api_keu'
+  config.api_key = 'api_key'
   config.server_path = 'http://www.example.com/'
   config.return_url = 'http://maverick.kumulator.com:82/linguara'
+  config.log = false
 end
 
 Spec::Runner.configure do |config|

data/spec/translation_spec.rb

@@ -0,0 +1,24 @@
+require 'spec/spec_helper'
+
+describe Translation do
+  subject do
+    @blog_post = BlogPost.new( :title => "Title text", :body => "Body text")
+    Translation.new(@blog_post)
+  end
+  
+  it 'creates default due_date on default' do
+    subject.to_hash[:translation][:due_date].should eql(Date.today + Linguara.configuration.request_valid_for.to_i.days)
+  end
+  
+  it 'creates return_url on default' do
+    subject.to_hash[:return_url].should eql(Linguara.configuration.return_url)
+  end
+  
+  it 'sets source language on default' do
+    subject.to_hash[:source_language].should eql(I18n.locale.to_s)
+  end
+
+  it 'creates paragraphs for model' do
+    subject.to_hash[:content][:plain][:paragraphs].should eql(@blog_post.fields_to_send)
+  end
+end

metadata

@@ -1,21 +1,22 @@
 --- !ruby/object:Gem::Specification 
 name: linguara
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Aleksander Dabrowski
+- Piotr Barczuk
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-06-05 00:00:00 +02:00
+date: 2010-07-23 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,9 +51,11 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- init.rb
 - lib/linguara.rb
 - lib/linguara/active_record.rb
 - lib/linguara/configuration.rb
+- lib/linguara/translation.rb
 - lib/linguara/utils.rb
 - linguara.gemspec
 - spec/data/schema.rb
@@ -61,6 +64,7 @@ files:
 - spec/linguara_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/translation_spec.rb
 has_rdoc: true
 homepage: http://github.com/tjeden/linguara
 licenses: []
@@ -101,3 +105,4 @@ test_files:
 - spec/helper_model/database_mock.rb
 - spec/linguara_spec.rb
 - spec/spec_helper.rb
+- spec/translation_spec.rb