copycopter_client 1.0.0.beta1

data/features/support/rails_server.rb

@@ -0,0 +1,118 @@
+require 'net/http'
+
+# Starts a Rails application server in a fork and waits for it to be responsive
+class RailsServer
+  HOST = 'localhost'.freeze
+
+  class << self
+    attr_accessor :instance
+  end
+
+  def self.start(port = nil, debug = nil)
+    self.instance = new(port, debug)
+    self.instance.start
+    self.instance
+  end
+
+  def self.stop
+    self.instance.stop if instance
+    self.instance = nil
+  end
+
+  def self.get(path)
+    self.instance.get(path)
+  end
+
+  def self.post(path, data)
+    self.instance.post(path, data)
+  end
+
+  def self.run(port, silent)
+    require 'config/environment'
+    require 'thin'
+
+    if Rails::VERSION::MAJOR == 3
+      rails = Rails.application
+    else
+      rails = ActionController::Dispatcher.new
+    end
+    app = Identify.new(rails)
+
+    Thin::Logging.silent = silent
+    Rack::Handler::Thin.run(app, :Port => port, :AccessLog => [])
+  end
+
+  def self.app_host
+    self.instance.app_host
+  end
+
+  def initialize(port, debug)
+    @port = (port || 3001).to_i
+    @debug = debug
+  end
+
+  def start
+    @pid = fork do
+      command = "ruby -r#{__FILE__} -e 'RailsServer.run(#{@port}, #{(!@debug).inspect})'"
+      puts command if @debug
+      exec(command)
+    end
+    wait_until_responsive
+  end
+
+  def stop
+    if @pid
+      Process.kill('INT', @pid)
+      Process.wait(@pid)
+      @pid = nil
+    end
+  end
+
+  def get(path)
+    puts "GET #{path}" if @debug
+    Net::HTTP.start(HOST, @port) { |http| http.get(path) }
+  end
+
+  def post(path, data)
+    puts "POST #{path}\n#{data}" if @debug
+    Net::HTTP.start(HOST, @port) { |http| http.post(path, data) }
+  end
+
+  def wait_until_responsive
+    20.times do
+      if responsive?
+        return true
+      else
+        sleep(0.5)
+      end
+    end
+    raise "Couldn't connect to Rails application server at #{HOST}:#{@port}"
+  end
+
+  def responsive?
+    response = Net::HTTP.start(HOST, @port) { |http| http.get('/__identify__') }
+    response.is_a?(Net::HTTPSuccess)
+  rescue Errno::ECONNREFUSED, Errno::EBADF
+    return false
+  end
+
+  def app_host
+    "http://#{HOST}:#{@port}"
+  end
+
+  # From Capybara::Server
+
+  class Identify
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["PATH_INFO"] == "/__identify__"
+        [200, {}, 'OK']
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/init.rb

@@ -0,0 +1,2 @@
+require 'copycopter_client'
+

data/lib/copycopter_client/client.rb

@@ -0,0 +1,117 @@
+require 'net/http'
+require 'net/https'
+require 'copycopter_client/errors'
+
+module CopycopterClient
+  # Communicates with the Copycopter server. This class is used to actually
+  # download and upload blurbs, as well as issuing deploys.
+  #
+  # A client is usually instantiated when {Configuration#apply} is called, and
+  # the application will not need to interact with it directly.
+  class Client
+    # These errors will be rescued when connecting Copycopter.
+    HTTP_ERRORS = [Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+                   Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+                   Net::ProtocolError]
+
+    # Usually instantiated from {Configuration#apply}. Copies options.
+    # @param options [Hash]
+    # @option options [String] :api_key API key of the project to connect to
+    # @option options [Fixnum] :port the port to connect to
+    # @option options [Boolean] :public whether to download draft or published content
+    # @option options [Fixnum] :http_read_timeout how long to wait before timing out when reading data from the socket
+    # @option options [Fixnum] :http_open_timeout how long to wait before timing out when opening the socket
+    # @option options [Boolean] :secure whether to use SSL
+    # @option options [Logger] :logger where to log transactions
+    def initialize(options)
+      [:api_key, :host, :port, :public, :http_read_timeout,
+        :http_open_timeout, :secure, :logger].each do |option|
+        instance_variable_set("@#{option}", options[option])
+      end
+    end
+
+    # Downloads all blurbs for the given api_key.
+    #
+    # If the +public+ option was set to +true+, this will use published blurbs.
+    # Otherwise, draft content is fetched.
+    #
+    # @return [Hash] blurbs
+    # @raise [ConnectionError] if the connection fails
+    def download
+      connect do |http|
+        response = http.get(uri(download_resource))
+        check(response)
+        log("Downloaded translations")
+        JSON.parse(response.body)
+      end
+    end
+
+    # Uploads the given hash of blurbs as draft content.
+    # @param data [Hash] the blurbs to upload
+    # @raise [ConnectionError] if the connection fails
+    def upload(data)
+      connect do |http|
+        response = http.post(uri("draft_blurbs"), data.to_json)
+        check(response)
+        log("Uploaded missing translations")
+      end
+    end
+
+    # Issues a deploy, marking all draft content as published for this project.
+    # @raise [ConnectionError] if the connection fails
+    def deploy
+      connect do |http|
+        response = http.post(uri("deploys"), "")
+        check(response)
+        log("Deployed")
+      end
+    end
+
+    private
+
+    attr_reader :host, :port, :api_key, :http_read_timeout,
+      :http_open_timeout, :secure, :logger
+
+    def public?
+      @public
+    end
+
+    def uri(resource)
+      "/api/v2/projects/#{api_key}/#{resource}"
+    end
+
+    def download_resource
+      if public?
+        "published_blurbs"
+      else
+        "draft_blurbs"
+      end
+    end
+
+    def connect
+      http = Net::HTTP.new(host, port)
+      http.open_timeout = http_open_timeout
+      http.read_timeout = http_read_timeout
+      http.use_ssl      = secure
+      begin
+        yield(http)
+      rescue *HTTP_ERRORS => exception
+        raise ConnectionError, "#{exception.class.name}: #{exception.message}"
+      end
+    end
+
+    def check(response)
+      if Net::HTTPNotFound === response
+        raise InvalidApiKey, "Invalid API key: #{api_key}"
+      end
+
+      unless Net::HTTPSuccess === response
+        raise ConnectionError, "#{response.code}: #{response.body}"
+      end
+    end
+
+    def log(message)
+      logger.info(message)
+    end
+  end
+end

data/lib/copycopter_client/configuration.rb

@@ -0,0 +1,197 @@
+require 'logger'
+require 'copycopter_client/i18n_backend'
+require 'copycopter_client/client'
+require 'copycopter_client/sync'
+require 'copycopter_client/prefixed_logger'
+
+module CopycopterClient
+  # Used to set up and modify settings for the client.
+  class Configuration
+
+    # These options will be present in the Hash returned by {#to_hash}.
+    OPTIONS = [:api_key, :development_environments, :environment_name, :host,
+        :http_open_timeout, :http_read_timeout, :client_name, :client_url,
+        :client_version, :port, :protocol, :proxy_host, :proxy_pass,
+        :proxy_port, :proxy_user, :secure, :polling_delay, :logger,
+        :framework, :fallback_backend].freeze
+
+    # @return [String] The API key for your project, found on the project edit form.
+    attr_accessor :api_key
+
+    # @return [String] The host to connect to (defaults to +copycopter.com+).
+    attr_accessor :host
+
+    # @return [Fixnum] The port on which your Copycopter server runs (defaults to +443+ for secure connections, +80+ for insecure connections).
+    attr_accessor :port
+
+    # @return [Boolean] +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+
+    # @return [Fixnum] The HTTP open timeout in seconds (defaults to +2+).
+    attr_accessor :http_open_timeout
+
+    # @return [Fixnum] The HTTP read timeout in seconds (defaults to +5+).
+    attr_accessor :http_read_timeout
+
+    # @return [String, NilClass] The hostname of your proxy server (if using a proxy)
+    attr_accessor :proxy_host
+
+    # @return [String, Fixnum] The port of your proxy server (if using a proxy)
+    attr_accessor :proxy_port
+
+    # @return [String, NilClass] The username to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_user
+
+    # @return [String, NilClass] The password to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_pass
+
+    # @return [Array<String>] A list of environments in which content should be editable
+    attr_accessor :development_environments
+
+    # @return [Array<String>] A list of environments in which the server should not be contacted
+    attr_accessor :test_environments
+
+    # @return [String] The name of the environment the application is running in
+    attr_accessor :environment_name
+
+    # @return [String] The name of the client library being used to send notifications (defaults to +Copycopter Client+)
+    attr_accessor :client_name
+
+    # @return [String, NilClass] The framework notifications are being sent from, if any (such as +Rails 2.3.9+)
+    attr_accessor :framework
+
+    # @return [String] The version of the client library being used to send notifications (such as +1.0.2+)
+    attr_accessor :client_version
+
+    # @return [String] The url of the client library being used
+    attr_accessor :client_url
+
+    # @return [Integer] The time, in seconds, in between each sync to the server. Defaults to +300+.
+    attr_accessor :polling_delay
+
+    # @return [Logger] Where to log messages. Must respond to same interface as Logger.
+    attr_reader :logger
+
+    # @return [I18n::Backend::Base] where to look for translations missing on the Copycopter server
+    attr_accessor :fallback_backend
+
+    alias_method :secure?, :secure
+
+    # Instantiated from {CopycopterClient.configure}. Sets defaults.
+    def initialize
+      self.secure                   = false
+      self.host                     = 'copycopter.com'
+      self.http_open_timeout        = 2
+      self.http_read_timeout        = 5
+      self.development_environments = %w(development staging)
+      self.test_environments        = %w(test cucumber)
+      self.client_name              = 'Copycopter Client'
+      self.client_version           = VERSION
+      self.client_url               = 'http://copycopter.com'
+      self.polling_delay            = 300
+      self.logger                   = Logger.new($stdout)
+
+      @applied = false
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    # @return [Object] the given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    # @return [Hash] configuration attributes
+    def to_hash
+      base_options = { :public => public? }
+      OPTIONS.inject(base_options) do |hash, option|
+        hash.merge(option.to_sym => send(option))
+      end
+    end
+
+    # Returns a hash of all configurable options merged with +hash+
+    #
+    # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+    # @return [Hash] the merged configuration hash
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+    # Determines if the content will be editable
+    # @return [Boolean] Returns +false+ if in a development environment, +true+ otherwise.
+    def public?
+      !(development_environments + test_environments).include?(environment_name)
+    end
+
+    # Determines if the content will fetched from the server
+    # @return [Boolean] Returns +true+ if in a test environment, +false+ otherwise.
+    def test?
+      test_environments.include?(environment_name)
+    end
+
+    # Determines if the configuration has been applied (internal)
+    # @return [Boolean] Returns +true+ if applied, +false+ otherwise.
+    def applied?
+      @applied
+    end
+
+      # Applies the configuration (internal).
+    #
+    # Called automatically when {CopycopterClient.configure} is called in the application.
+    #
+    # This creates the {Client}, {Sync}, and {I18nBackend} and puts them together.
+    #
+    # When {#test?} returns +false+, the sync will be started.
+    def apply
+      client = Client.new(to_hash)
+      sync = Sync.new(client, to_hash)
+      I18n.backend = I18nBackend.new(sync, to_hash)
+      CopycopterClient.client = client
+      CopycopterClient.sync = sync
+      @applied = true
+      logger.info("Client #{VERSION} ready")
+      logger.info("Environment Info: #{environment_info}")
+      sync.start unless test?
+    end
+
+    def port
+      @port || default_port
+    end
+
+    # The protocol that should be used when generating URLs to Copycopter.
+    # @return [String] +https+ if {#secure?} returns +true+, +http+ otherwise.
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    # For logging/debugging (internal).
+    # @return [String] a description of the environment in which this configuration was built.
+    def environment_info
+      parts = ["Ruby: #{RUBY_VERSION}", framework, "Env: #{environment_name}"]
+      parts.compact.map { |part| "[#{part}]" }.join(" ")
+    end
+
+    # Wraps the given logger in a PrefixedLogger. This way, CopycopterClient
+    # log messages are recognizable.
+    # @param original_logger [Logger] the upstream logger to use, which must respond to the standard +Logger+ severity methods.
+    def logger=(original_logger)
+      @logger = PrefixedLogger.new("** [Copycopter]", original_logger)
+    end
+
+    private
+
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+  end
+end

data/lib/copycopter_client/errors.rb

@@ -0,0 +1,13 @@
+module CopycopterClient
+  # Raised when an error occurs while contacting the Copycopter server. This is
+  # raised by {Client} and generally rescued by {Sync}. The application will
+  # not encounter this error. Polling will continue even if this error is raised.
+  class ConnectionError < StandardError
+  end
+
+  # Raised when the client is configured with an api key that the Copycopter
+  # server does not recognize. Polling is aborted when this error is raised.
+  class InvalidApiKey < StandardError
+  end
+end
+

data/lib/copycopter_client/helper.rb

@@ -0,0 +1,40 @@
+module CopycopterClient
+  # Helper methods for Copycopter
+  # @deprecated use +I81n#translate+ instead.
+  module Helper
+    # Returns copy for the given key in the current locale.
+    # @param key [String] the key you want copy for
+    # @param default [String, Hash] an optional default value, used if this key is missing
+    # @option default [String] :default the default text
+    def copy_for(key, default=nil)
+      default = if default.respond_to?(:to_hash)
+                  default[:default]
+                else
+                  default
+                end
+
+      key = scope_copycopter_key_by_partial(key)
+      warn("WARNING: #s is deprecated; use t(#{key.inspect}, :default => #{default.inspect}) instead.")
+      I18n.translate(key, { :default => default })
+    end
+    alias_method :s, :copy_for
+
+    private
+
+    def scope_copycopter_key_by_partial(key)
+      if respond_to?(:scope_key_by_partial, true)
+        scope_key_by_partial(key)
+      elsif key.to_s[0].chr == "."
+        if respond_to?(:template)
+          "#{template.path_without_format_and_extension.gsub(%r{/_?}, '.')}#{key}"
+        else
+          "#{controller_name}.#{action_name}#{key}"
+        end
+      else
+        key
+      end
+    end
+  end
+
+  extend Helper
+end

data/lib/copycopter_client/i18n_backend.rb

@@ -0,0 +1,100 @@
+require 'i18n'
+
+module CopycopterClient
+  # I81n implementation designed to synchronize with Copycopter.
+  #
+  # Expects an object that acts like a Hash, responding to +[]+, +[]=+, and +keys+.
+  #
+  # This backend will be used as the default I81n backend when the client is
+  # configured, so you will not need to instantiate this class from the
+  # application. Instead, just use methods on the I81n class.
+  #
+  # If a fallback backend is provided, keys available in the fallback backend
+  # will be used as defaults when those keys aren't available on the Copycopter
+  # server.
+  class I18nBackend
+    include I18n::Backend::Base
+
+    # These keys aren't used in interpolation
+    RESERVED_KEYS = [:scope, :default, :separator, :resolve, :object,
+      :fallback, :format, :cascade, :raise, :rescue_format].freeze
+
+    # Usually instantiated when {Configuration#apply} is invoked.
+    # @param sync [Sync] must act like a hash, returning and accept blurbs by key.
+    # @param options [Hash]
+    # @option options [I18n::Backend::Base] :fallback_backend I18n backend where missing translations can be found
+    def initialize(sync, options)
+      @sync     = sync
+      @base_url = URI.parse("#{options[:protocol]}://#{options[:host]}:#{options[:port]}")
+      @fallback = options[:fallback_backend]
+    end
+
+    # This is invoked by frameworks when locales should be loaded. The
+    # Copycopter client loads content in the background, so this method waits
+    # until the first download is complete.
+    def reload!
+      sync.wait_for_download
+    end
+
+    # Translates the given local and key. See the I81n API documentation for details.
+    #
+    # Because the Copycopter API only supports copy text and doesn't support
+    # nested structures or arrays, the fallback value will be returned without
+    # using the Copycopter API if that value doesn't respond to to_str.
+    #
+    # @return [Object] the translated key (usually a String)
+    def translate(locale, key, options = {})
+      fallback_value = fallback(locale, key, options)
+      return fallback_value if fallback_value && !fallback_value.respond_to?(:to_str)
+
+      default = fallback_value || options.delete(:default)
+      content = super(locale, key, options.update(:default => default))
+      if content.respond_to?(:html_safe)
+        content.html_safe
+      else
+        content
+      end
+    end
+
+    # Returns locales availabile for this Copycopter project.
+    # @return [Array<String>] available locales
+    def available_locales
+      sync.keys.map { |key| key.split('.').first }.uniq
+    end
+
+    private
+
+    def lookup(locale, key, scope = [], options = {})
+      parts = I18n.normalize_keys(locale, key, scope, options[:separator])
+      key = parts.join('.')
+      content = sync[key]
+      sync[key] = "" if content.nil?
+      content
+    end
+
+    attr_reader :sync
+
+    def fallback(locale, key, options)
+      if @fallback
+        fallback_options = options.dup
+        (fallback_options.keys - RESERVED_KEYS).each do |interpolated_key|
+          fallback_options[interpolated_key] = "%{#{interpolated_key}}"
+        end
+
+        @fallback.translate(locale, key, fallback_options)
+      end
+    rescue I18n::MissingTranslationData
+      nil
+    end
+
+    def default(locale, object, subject, options = {})
+      content = super(locale, object, subject, options)
+      if content.respond_to?(:to_str)
+        parts = I18n.normalize_keys(locale, object, options[:scope], options[:separator])
+        key = parts.join('.')
+        sync[key] = content.to_str
+      end
+      content
+    end
+  end
+end

data/lib/copycopter_client/prefixed_logger.rb

@@ -0,0 +1,41 @@
+module CopycopterClient
+  class PrefixedLogger
+    attr_reader :prefix, :original_logger
+
+    def initialize(prefix, logger)
+      @prefix          = prefix
+      @original_logger = logger
+    end
+
+    def info(message = nil, &block)
+      log(:info, message, &block)
+    end
+
+    def debug(message = nil, &block)
+      log(:debug, message, &block)
+    end
+
+    def warn(message = nil, &block)
+      log(:warn, message, &block)
+    end
+
+    def error(message = nil, &block)
+      log(:error, message, &block)
+    end
+
+    def fatal(message = nil, &block)
+      log(:fatal, message, &block)
+    end
+
+    private
+
+    def log(severity, message, &block)
+      prefixed_message = "#{prefix} #{thread_info} #{message}"
+      original_logger.send(severity, prefixed_message, &block)
+    end
+
+    def thread_info
+      "[P:#{Process.pid}] [T:#{Thread.current.object_id}]"
+    end
+  end
+end

data/lib/copycopter_client/rails.rb

@@ -0,0 +1,31 @@
+require 'copycopter_client/helper'
+
+if defined?(ActionController::Base)
+  ActionController::Base.send :include, CopycopterClient::Helper
+end
+if defined?(ActionView::Base)
+  ActionView::Base.send :include, CopycopterClient::Helper
+end
+
+module CopycopterClient
+  # Responsible for Rails initialization
+  module Rails
+    # Sets up the logger, environment, name, project root, and framework name
+    # for Rails applications. Must be called after framework initialization.
+    def self.initialize
+      CopycopterClient.configure(false) do |config|
+        config.environment_name = ::Rails.env
+        config.logger           = ::Rails.logger
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
+        config.fallback_backend = I18n.backend
+      end
+    end
+  end
+end
+
+if defined?(Rails::Railtie)
+  require 'copycopter_client/railtie'
+else
+  CopycopterClient::Rails.initialize
+end
+

data/lib/copycopter_client/railtie.rb

@@ -0,0 +1,13 @@
+module CopycopterClient
+  # Connects to integration points for Rails 3 applications
+  class Railtie < ::Rails::Railtie
+    initializer :initialize_copycopter_rails, :after => :before_initialize do
+      CopycopterClient::Rails.initialize
+    end
+
+    rake_tasks do
+      load "tasks/copycopter_client_tasks.rake"
+    end
+  end
+end
+