string-direction 0.0.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f39604302e8df7944be6b2e1797f74570597820
-  data.tar.gz: ad31b8233d04f4e6a4cc0950f417c053bf7da18f
+  metadata.gz: 0ef6e54736486fccff8d5e5c004d73c27a5ca7b4
+  data.tar.gz: d16b4d813ef25aa3cbd032af62a2861cf5fe0fe6
 SHA512:
-  metadata.gz: 9bd9e95fda3d57c5c73d6a3a62d9133f3f4bb201de767b0f36a2b5475b41f8f4ce24abc14b2f1325e8d1d42c2905673fdd1432f135142a83e80956886221ac24
-  data.tar.gz: ce4026eadff9db6f4a1d9e9ccd8f131b3f84c18d8e70c4c1eaba88a135132514345bc970cdeefbf2914951c73d63266515076ca34231781ecf7516e1a92001ab
+  metadata.gz: 72c1db5ba8b6d1f3cfffe46315a8956a34d41f957a4ebad2e09daad798dcf590c90a06947115caa696e9c32f2eaaf61114e101d621ed5d8a27b53267ad3f50c0
+  data.tar.gz: 4424cab8cab4d1b9e016169867a1cf0c8b050ce6f498727c234a89414ebbad36b24a704abf6c84c15ef55b251064379918c42f0ffbd436b006dd08fa0f7d1bb9

data/.gitignore

@@ -1,2 +1,3 @@
 .yardoc/
 *gem
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in algorithm.gemspec
+gemspec

data/README.md

@@ -1,32 +1,53 @@
 # string-direction
 
-`string-direction` is a ruby `String` extension for automatic detection of the direction (left-to-right, right-to-left or bi-directional) in which a text should be displayed.
+`string-direction` is a ruby library for automatic detection of the direction (left-to-right, right-to-left or bi-directional) in which a text should be displayed.
 
-Mainly, it exposes four new methods to `String` instances. `direction` can return `ltr`, `rtl` or `bidi` depending on the characters used in the string. There are as well `is_ltr?`, `is_rtl?` and `is_bidi?` convenient predicate methods.
+## Overview
 
 ```ruby
-#encoding: utf-8
 require 'string-direction'
 
-p 'english'.direction #=> "ltr"
-p 'العربية'.direction #=> "rtl"
-p 'english العربية'.direction #=> "bidi"
+detector = StringDirection::Detector.new
 
-p 'english'.is_ltr? #=> "true"
-p 'العربية'.is_ltr? #=> "false"
-p 'العربية'.is_rtl? #=> "true"
-p 'english العربية'.is_bidi? #=> "true"
+detector.direction('english') #=> 'ltr'
+detector.direction('العربية') #=> 'rtl'
+detector.direction("english العربية") #=> 'bidi'
+
+detector.ltr?('english') #=> true
+detector.rtl?('العربية') #=> true
+detector.bidi?('english') #=> false
 ```
 
-## Unicode marks
-If Unicode marks [left-to-right](http://en.wikipedia.org/wiki/Left-to-right_mark) (\u200e) or [right-to-left](http://en.wikipedia.org/wiki/Right-to-left_mark) (\u200f) are present, then `string-direction` rely on them instead of trying to guess from the characters used.
+But, if you preffer, you can monkey patch `String`:
 
 ```ruby
-p "\u200eالعربية".direction #=> "ltr"
-p "\u200fEnglish".direction #=> "rtl"
+String.send(:include, StringDirection::StringMethods)
+
+'english'.direction #=> 'ltr'
+'العربية'.rtl? #=> true
 ```
 
-## Changing default right-to-left scripts
+## Strategies
+
+`string-direction` uses different strategies in order to try to detect the direction of a string. The detector uses them once at a time and returns the result once one of them succeeds, aborting any further analysis.
+
+Right now, two strategies are natively integrated: `marks` and `characters`. They are used, in that order, as default strategies if no strategies are given.
+
+### marks
+
+Looks for the presence of direction Unicode marks: [left-to-right](http://en.wikipedia.org/wiki/Left-to-right_mark) (\u200e) or [right-to-left](http://en.wikipedia.org/wiki/Right-to-left_mark) (\u200f).
+
+```ruby
+detector = StringDirection::Detector.new(:marks)
+
+detector.direction("\u200eالعربية") #=> "ltr"
+detector.direction("\u200fEnglish") #=> "rtl"
+```
+
+### characters
+
+Looks for the presence of right-to-left characters in the scripts used in the string.
+
 By default, `string-direction` consider following scripts to have a right-to-left writing:
 
 * Arabic
@@ -38,12 +59,23 @@ By default, `string-direction` consider following scripts to have a right-to-lef
 * Thaana
 * Tifinagh
 
-You can change easily these defaults interacting with the array `StringDirection.rtl_scripts`
+```ruby
+detector = StringDirection::Detector.new(:characters)
+
+detector.direction('english') #=> 'ltr'
+detector.direction('العربية') #=> 'rtl'
+```
+
+You can change these defaults:
 
 ```ruby
-p 'ᚪᚫᚬᚭᚮᚯ'.direction #=> "ltr"
-StringDirection.rtl_scripts << 'Runic'
-p 'ᚪᚫᚬᚭᚮᚯ'.direction #=> "rtl"
+detector.direction('ᚪᚫᚬᚭᚮᚯ') #=> 'ltr'
+
+StringDirection.configuration do |config|
+    config.rtl_scripts << 'Runic'
+end
+
+detector.direction('ᚪᚫᚬᚭᚮᚯ') #=> 'rtl'
 ```
 
 This can be useful, mainly, for scripts that have both left-to-right and right-to-left representations:
@@ -58,6 +90,31 @@ This can be useful, mainly, for scripts that have both left-to-right and right-t
 
 Keep in mind than only [scripts recognized by Ruby regular expressions](http://www.ruby-doc.org/core-1.9.3/Regexp.html#label-Character+Properties) are allowed.
 
+### Custom Strategies
+
+You can define your custom strategies. To do so, you just have to define a class inside `StringDirection` module with a name ending with `Strategy`. This class has to respond to an instance method `run` which takes the string as argument. You can inherit from `StringDirection::Strategy` to have convenient methods `ltr`, `rtl` and `bidi`.
+
+```ruby
+class StringDirection::AlwaysLtrStrategy
+  def run(string)
+    ltr
+  end
+end
+
+detector = StringDirection::Detector.new(:always_ltr)
+detector.direction('العربية') #=> 'ltr'
+```
+
+### Changing default strategies
+
+`marks` and `characters` are default strategies, but you can change them:
+
+```ruby
+StringDirection.configuration do |config|
+    config.default_strategies = [:custom, :marks, :always_ltr]
+end
+```
+
 ## Release Policy
 
 `string-direction` follows the principles of [semantic versioning](http://semver.org/).

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'string-direction'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/string-direction.rb

@@ -1,3 +1,39 @@
-require_relative 'string-direction/string-direction'
+require 'string-direction/version'
+require 'string-direction/configuration'
+require 'string-direction/detector'
+require 'string-direction/strategy'
+require 'string-direction/strategies/marks_strategy'
+require 'string-direction/strategies/characters_strategy'
+require 'string-direction/string_methods'
 
-String.send :include, StringDirection
+# Constants & configuration common in the whole library
+module StringDirection
+  # left-to-right identifier
+  LTR  = 'ltr'.freeze
+
+  # right-to-left identifier
+  RTL  = 'rtl'.freeze
+
+  # bidi identifier
+  BIDI = 'bidi'.freeze
+
+  class << self
+    # {Configuration} object
+    attr_accessor :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Yields current {Configuration}
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    # Reset {Configuration}
+    def reset_configuration
+      self.configuration = Configuration.new
+    end
+  end
+end

data/lib/string-direction/configuration.rb

@@ -0,0 +1,20 @@
+module StringDirection
+  # {StringDirection} configuration
+  class Configuration
+    # Scripts for which characters are treated as right-to-left. Defaults to Arabic, Hebrew, Nko, Kharoshthi, Phoenician, Syriac, Thaana and Tifinagh. Notice than only {http://ruby-doc.org/core-2.2.3/Regexp.html#class-Regexp-label-Character+Properties recognized Ruby regular expression scripts} are accepted.
+    #
+    # @return [Array]
+    attr_accessor :rtl_scripts
+
+    # Default strategies, in order, that {Detector} uses if they are not given explicetly. Values are symbols with a matching class expected. For example, `:marks` expects a class `StringDirection::MarksStrategy` to exist. Defaults to `:marks` and `:characters`.
+    #
+    # @return [Array]
+    attr_accessor :default_strategies
+
+    # Initialize defaults
+    def initialize
+      self.rtl_scripts = %w(Arabic Hebrew Nko Kharoshthi Phoenician Syriac Thaana Tifinagh)
+      self.default_strategies = [:marks, :characters]
+    end
+  end
+end

data/lib/string-direction/detector.rb

@@ -0,0 +1,72 @@
+module StringDirection
+  # String direction detector
+  class Detector
+    # Array of initialized strategies used, in order, to try to detect the direction of a string
+    #
+    # @return [Array]
+    attr_accessor :strategies
+
+    # Initialize strategies from given arguments. If no strategies are given, they are taken from the value of {StringDirection::Configuration#default_strategies}
+    #
+    # @raise [ArgumentError] if strategy class is not found. For example, for an strategy `:marks` a class `StringDirection::MarksStrategy` is expected
+    def initialize(*strategies)
+      strategies = StringDirection.configuration.default_strategies if strategies.empty?
+      initialize_strategies(strategies)
+    end
+
+    # Tries to detect and return the direction of a string. It returns `ltr` if the string is left-to-right, `rtl` if it is right-to-left, `bidi` if it is bidirectional or `nil` if it can't detect the direction. It iterates through {#strategies} until one of them successes.
+    #
+    # @param string [String] The string to inspect
+    # @return [String, nil]
+    def direction(string)
+      direction = nil
+      strategies.each do |strategy|
+        direction = strategy.run(string)
+        break if direction
+      end
+      direction
+    end
+
+    # Returns whether string is left-to-right or not
+    #
+    # @param string [String] The string to inspect
+    # @return [Boolean]
+    def ltr?(string)
+      direction(string) == StringDirection::LTR
+    end
+
+    # Returns whether string is right-to-left or not
+    #
+    # @param string [String] The string to inspect
+    # @return [Boolean]
+    def rtl?(string)
+      direction(string) == StringDirection::RTL
+    end
+
+    # Returns whether string is bidirectional or not
+    #
+    # @param string [String] The string to inspect
+    # @return [Boolean]
+    def bidi?(string)
+      direction(string) == StringDirection::BIDI
+    end
+
+    private
+
+    def initialize_strategies(strategies)
+      self.strategies = strategies.map do |strategy|
+        begin
+          name = infer_strategy_class_name(strategy)
+          Kernel.const_get(name).new
+        rescue NameError
+          raise ArgumentError, "Can't find '#{name}' strategy"
+        end
+      end
+    end
+
+    def infer_strategy_class_name(strategy)
+      base_name = strategy.to_s.split('_').map(&:capitalize).join
+      "StringDirection::#{base_name}Strategy"
+    end
+  end
+end

data/lib/string-direction/strategies/characters_strategy.rb

@@ -0,0 +1,40 @@
+module StringDirection
+  # Strategy to detect direction from the scripts to which string characters belong
+  class CharactersStrategy < Strategy
+    # Ignored characters: unicode marks, punctuations, symbols, separator and other general categories
+    CHAR_IGNORE_REGEX = /[\p{M}\p{P}\p{S}\p{Z}\p{C}]/.freeze
+
+    # Inspect to wich scripts characters belongs and  infer from them the string direction. right-to-left scripts are those in {Configuration#rtl_scripts}
+    #
+    # params [String] The string to inspect
+    # @return [String, nil]
+    def run(string)
+      string = string.to_s
+      if ltr_characters?(string) && rtl_characters?(string)
+        bidi
+      elsif ltr_characters?(string)
+        ltr
+      elsif rtl_characters?(string)
+        rtl
+      end
+    end
+
+    private
+
+    def rtl_characters?(string)
+      string.match(/[#{join_scripts_for_regexp(rtl_scripts)}]/) ? true : false
+    end
+
+    def ltr_characters?(string)
+      string.gsub(CHAR_IGNORE_REGEX, '').match(/[^#{join_scripts_for_regexp(rtl_scripts)}]/) ? true : false
+    end
+
+    def join_scripts_for_regexp(scripts)
+      scripts.map { |script| '\p{' + script + '}' }.join
+    end
+
+    def rtl_scripts
+      StringDirection.configuration.rtl_scripts
+    end
+  end
+end

data/lib/string-direction/strategies/marks_strategy.rb

@@ -0,0 +1,35 @@
+module StringDirection
+  # Strategy to detect direction looking for the presence of unicode marks
+  class MarksStrategy < Strategy
+    # left-to-right unicode mark
+    LTR_MARK = "\u200e".freeze
+
+    # right-to-right unicode mark
+    RTL_MARK = "\u200f".freeze
+
+    # Look for the presence of unicode marks in given string and infers from them its direction
+    #
+    # params [String] The string to inspect
+    # @return [String, nil]
+    def run(string)
+      string = string.to_s
+      if ltr_mark?(string) && rtl_mark?(string)
+        bidi
+      elsif ltr_mark?(string)
+        ltr
+      elsif rtl_mark?(string)
+        rtl
+      end
+    end
+
+    private
+
+    def ltr_mark?(string)
+      string.include?(LTR_MARK) ? true : false
+    end
+
+    def rtl_mark?(string)
+      string.include?(RTL_MARK) ? true : false
+    end
+  end
+end

data/lib/string-direction/strategy.rb

@@ -0,0 +1,25 @@
+module StringDirection
+  # @abstract Subclass and override {#run} to implement
+  class Strategy
+    # Each strategy must implement this method, accepting an string as its argument. It must return {StringDirection::LTR}, {StringDirection::RTL}, {StringDirection::BIDI} depending on direction detected, or nil on detection failure
+    # @abstract
+    # @raise [NotImplementedError]
+    def run(string)
+      fail NotImplementedError, "`run` method must be implemented"
+    end
+
+    private
+
+    def ltr
+      StringDirection::LTR
+    end
+
+    def rtl
+      StringDirection::RTL
+    end
+
+    def bidi
+      StringDirection::BIDI
+    end
+  end
+end

data/lib/string-direction/string_methods.rb

@@ -0,0 +1,31 @@
+module StringDirection
+  # Methods intended to be monkey patched to String through `String.include(StringDirection::StringMethods)`. This will allow stuff like `'English'.direction #=> 'ltr'`. All methods are delegated to {Detector} with `self` as string argument.
+  module StringMethods
+    # @see Detector#direction
+    # @return [String]
+    def direction
+      string_direction_detector.direction(self)
+    end
+
+    # @see Detector#ltr?
+    def ltr?
+      string_direction_detector.ltr?(self)
+    end
+
+    # @see Detector#rtl?
+    def rtl?
+      string_direction_detector.rtl?(self)
+    end
+
+    # @see Detector#bidi?
+    def bidi?
+      string_direction_detector.bidi?(self)
+    end
+
+    private
+
+    def string_direction_detector
+      @string_direction_detector ||= StringDirection::Detector.new
+    end
+  end
+end

data/lib/string-direction/version.rb

@@ -0,0 +1,4 @@
+module StringDirection
+  # Current library version
+  VERSION = '1.0.0'
+end

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
-require_relative '../lib/string-direction'
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'string-direction'
+require 'pry'
 
-RSpec.configure do |c|
-  c.treat_symbols_as_metadata_keys_with_true_values = true
+Dir[File.join(__dir__, 'support/**/*.rb')].each { |f| require f }
+RSpec.configure do |config|
+  config.color = true
 end

data/spec/string-direction/configuration_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe StringDirection::Configuration do
+  describe '#rtl_scripts' do
+    it 'defaults to an array with Arabic, Hebrew, Nko, Kharoshthi, Phoenician, Syriac, Thaana and Tifinagh' do
+      expect(subject.rtl_scripts).to match_array(%w(Arabic Hebrew Nko Kharoshthi Phoenician Syriac Thaana Tifinagh))
+    end
+  end
+
+  describe '#default_strategies' do
+    it 'defaults to an array with :marks and :characters' do
+      expect(subject.default_strategies).to eq([:marks, :characters])
+    end
+  end
+end

data/spec/string-direction/detector_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe StringDirection::Detector do
+  module StringDirection
+    class LtrStrategy < Strategy
+      def run(string)
+        ltr
+      end
+    end
+
+    class RtlStrategy < Strategy
+      def run(string)
+        rtl
+      end
+    end
+
+    class BidiStrategy < Strategy
+      def run(string)
+        bidi
+      end
+    end
+
+    class NilStrategy < Strategy
+      def run(string)
+        nil
+      end
+    end
+
+    class CamelizeCamelizeStrategy < Strategy
+      def run(string)
+        nil
+      end
+    end
+  end
+
+  context '#initialize(*strategies)' do
+    it 'initializes the strategies inflected from the arguments and adds them, in the same order, as strategies instance var array' do
+      detector = described_class.new(:ltr, :nil)
+
+      expect(detector.strategies.first).to be_an_instance_of(StringDirection::LtrStrategy)
+      expect(detector.strategies.last).to be_an_instance_of(StringDirection::NilStrategy)
+    end
+
+    it 'infers strategy name camelizing, ending with "Strategy" and looking inside StringDirection module' do
+      detector = described_class.new(:camelize_camelize)
+
+      expect(detector.strategies.first).to be_an_instance_of(StringDirection::CamelizeCamelizeStrategy)
+    end
+
+    context "when it can't infer the strategy class from given symbol" do
+      it 'raises an ArgumentError' do
+        expect { described_class.new(:something) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when stragies are not given' do
+      it 'takes defaults set in default_strategies configuration option' do
+        allow(StringDirection.configuration).to receive(:default_strategies).and_return([:ltr])
+
+        detector = described_class.new
+
+        expect(detector.strategies.first).to be_an_instance_of(StringDirection::LtrStrategy)
+      end
+    end
+  end
+
+  context '#direction(string)' do
+    context 'when first strategy detects direction' do
+      it 'returns it' do
+        detector = described_class.new(:ltr, :rtl)
+
+        expect(detector.direction('abc')).to eq(StringDirection::LTR)
+      end
+    end
+
+    context 'when first strategy does not detect direction' do
+      it 'it tries with the second' do
+        detector = described_class.new(:nil, :rtl)
+
+        expect(detector.direction('abc')).to eq(StringDirection::RTL)
+      end
+    end
+
+    context 'when no strategy detects direction' do
+      it 'returns nil' do
+        detector = described_class.new(:nil)
+
+        expect(detector.direction('abc')).to be_nil
+      end
+    end
+  end
+
+  describe '#ltr?(string)' do
+    context 'when string has left-to-right direction' do
+      it 'returns true' do
+        detector = described_class.new(:ltr)
+
+        expect(detector.ltr?('abc')).to eq(true)
+      end
+    end
+
+    context 'when string has not left-to-right direction' do
+      it 'returns false' do
+        detector = described_class.new(:rtl)
+
+        expect(detector.ltr?('abc')).to eq(false)
+      end
+    end
+  end
+
+  describe '#rtl?(string)' do
+    context 'when string has right-to-left direction' do
+      it 'returns true' do
+        detector = described_class.new(:rtl)
+
+        expect(detector.rtl?('abc')).to eq(true)
+      end
+    end
+
+    context 'when string has not right-to-left direction' do
+      it 'returns false' do
+        detector = described_class.new(:bidi)
+
+        expect(detector.rtl?('abc')).to eq(false)
+      end
+    end
+  end
+
+  describe '#bidi?(string)' do
+    context 'when string has bidirectional direction' do
+      it 'returns true' do
+        detector = described_class.new(:bidi)
+
+        expect(detector.bidi?('abc')).to eq(true)
+      end
+    end
+
+    context 'when string has not bidirectional direction' do
+      it 'returns false' do
+        detector = described_class.new(:ltr)
+
+        expect(detector.bidi?('abc')).to eq(false)
+      end
+    end
+  end
+end

data/spec/string-direction/strategies/characters_strategy_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe StringDirection::CharactersStrategy do
+  describe '#run' do
+    let(:english) { 'English' }
+    let(:arabic) { 'العربية' }
+
+    subject { described_class.new.run(string) }
+
+    context 'when both left-to-right and right-to-left characters are present' do
+      let(:string) { arabic + english }
+
+      it "returns 'bidi'" do
+        expect(subject).to eq 'bidi'
+      end
+    end
+
+    context 'when right-to-left character are present but none of left-to-right' do
+      let(:string) { arabic }
+
+      it "returns 'rtl'" do
+        expect(subject).to eq 'rtl'
+      end
+    end
+
+    context 'when left-to-right character are present but none of right-to-left' do
+      let(:string) { english }
+
+      it "returns 'ltr'" do
+        expect(subject).to eq 'ltr'
+      end
+    end
+
+    context 'when neither left-to-right nor right-to-left characters are present' do
+      let(:string) { ' ' }
+
+      it 'returns nil' do
+        expect(subject).to be_nil
+      end
+    end
+
+    context 'when default right-to-left scripts are changed' do
+      let(:new_rtl_script) { 'Latin' }
+      let(:old_rtl_script) { 'Arabic' }
+
+      context 'when there are characters from an added right-to-left script' do
+        let(:string) { english }
+
+        it 'treats them as right-to-left chracters' do
+          StringDirection.configure do |config|
+            config.rtl_scripts << new_rtl_script
+          end
+
+          expect(subject).to eq 'rtl'
+        end
+      end
+
+      context 'when there are characters from a deleted right-to-left script ' do
+        let(:string) { arabic }
+
+        it 'treats them as left-to-right characters' do
+          StringDirection.configure do |config|
+            config.rtl_scripts.delete(old_rtl_script)
+          end
+
+          expect(subject).to eq 'ltr'
+        end
+      end
+
+      after :each do
+        StringDirection.reset_configuration
+      end
+    end
+
+    context 'when special characters are present' do
+      let(:string) do
+        mark = "\u0903"
+        punctuation = '_'
+        symbol = '€'
+        separator = ' '
+        other = "\u0005"
+
+        arabic + mark + punctuation + symbol + separator + other
+      end
+
+      it 'ignores them' do
+        expect(subject).to eq 'rtl'
+      end
+    end
+
+    context 'when an object responding to #to_s is given' do
+      let(:string) do
+        class StringDirection::TestObject
+          def to_s
+            'English'
+          end
+        end
+
+        StringDirection::TestObject.new
+      end
+
+      it 'takes as string the result of #to_s method' do
+        expect(subject).to eq('ltr')
+      end
+    end
+  end
+end

data/spec/string-direction/strategies/marks_strategy_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe StringDirection::MarksStrategy do
+  describe '#run' do
+    subject { described_class.new.run(string) }
+
+    context 'when string contains the left-to-right mark but not the right-to-left mark' do
+      let(:string) { described_class::LTR_MARK + 'abc' }
+
+      it "returns 'ltr'" do
+        expect(subject).to eql 'ltr'
+      end
+    end
+
+    context 'when string contains the right-to-left mark but not the left-to-right mark' do
+      let(:string) { described_class::RTL_MARK + 'abc' }
+
+      it "returns 'rtl'" do
+        expect(subject).to eql 'rtl'
+      end
+    end
+
+    context 'when string contains both the left-to-right mark and the right-to-left mark' do
+      let(:string) { described_class::LTR_MARK + described_class::RTL_MARK + 'abc' }
+
+      it "returns 'bidi'" do
+        expect(subject).to eql 'bidi'
+      end
+    end
+
+    context 'when string neither contains the left-to-right mark nor the right-to-left mark' do
+      let(:string) { 'abc' }
+
+      it "returns nil" do
+        expect(subject).to be_nil
+      end
+    end
+
+    context 'when an object responding to #to_s is given' do
+      let(:string) do
+        class StringDirection::TestObject
+          def to_s
+            StringDirection::MarksStrategy::LTR_MARK
+          end
+        end
+
+        StringDirection::TestObject.new
+      end
+
+      it 'takes as string the result of #to_s method' do
+        expect(subject).to eq('ltr')
+      end
+    end
+  end
+end

data/spec/string-direction/strategy_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe StringDirection::Strategy do
+  it { expect(subject).to respond_to(:run).with(1).argument }
+end

data/spec/string-direction/string_methods_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe StringDirection::StringMethods do
+  subject { 'abc' }
+
+  before :each do
+    String.send(:include, StringDirection::StringMethods)
+  end
+
+  describe '#direction' do
+    it 'returns string direction' do
+      expect(subject.direction).to eq(StringDirection::LTR)
+    end
+  end
+
+  describe '#ltr?' do
+    it 'returns whether string direction is left-to-right' do
+      expect(subject.ltr?).to eq(true)
+    end
+  end
+
+  describe '#rtl?' do
+    it 'returns whether string direction is right-to-left' do
+      expect(subject.rtl?).to eq(false)
+    end
+  end
+
+  describe '#bidi?' do
+    it 'returns whether string direction is bidirectional' do
+      expect(subject.bidi?).to eq(false)
+    end
+  end
+end

data/spec/string-direction_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe StringDirection do
+  it 'has a version number' do
+    expect(described_class::VERSION).not_to be nil
+  end
+
+  describe '::LTR' do
+    it "is 'ltr'" do
+      expect(described_class::LTR).to eq('ltr')
+    end
+  end
+
+  describe '::RTL' do
+    it "is 'rtl'" do
+      expect(described_class::RTL).to eq('rtl')
+    end
+  end
+
+  describe '::BIDI' do
+    it "is 'bidi'" do
+      expect(described_class::BIDI).to eq('bidi')
+    end
+  end
+
+  describe '::configure' do
+    it 'initializes configuration instance var with an instance of StringDirection::Configuration' do
+      described_class.configure {}
+
+      expect(described_class.configuration).to be_an_instance_of(StringDirection::Configuration)
+    end
+
+    it 'yields the Configuration instance' do
+      expect { |b| described_class.configure(&b) }.to yield_with_args(StringDirection.configuration)
+    end
+  end
+
+  describe '#reset_configuration' do
+    it 'sets its configuration instance var as a new instance of Configuration' do
+      StringDirection.configure {}
+      configuration = StringDirection.configuration
+
+      StringDirection.reset_configuration
+
+      expect(StringDirection.configuration).to be_an_instance_of(StringDirection::Configuration)
+      expect(StringDirection.configuration).not_to eq(configuration)
+    end
+  end
+end

data/string-direction.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'string-direction/version'
+
+Gem::Specification.new do |s|
+  s.name = 'string-direction'
+  s.version = StringDirection::VERSION
+  s.summary = 'Automatic detection of text direction (ltr, rtl or bidi) for strings'
+  s.description = 'https://github.com/waiting-for-dev/string-direction/'
+  s.license = 'GPL3'
+  s.homepage = 'https://github.com/waiting-for-dev/string-direction/'
+  s.authors = ['Marc Busqué']
+  s.email = 'marc@lamarciana.com'
+  s.files = `git ls-files`.split("\n")
+
+  s.add_runtime_dependency 'yard', '~>0.8'
+
+  s.add_development_dependency 'bundler', '~> 1.10'
+  s.add_development_dependency 'rake', '~> 10.4'
+  s.add_development_dependency 'rspec', '~> 3.3'
+  s.add_development_dependency 'pry', '~> 0.10'
+  s.add_development_dependency 'pry-byebug', '~> 3.2'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: string-direction
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Marc Busqué
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-18 00:00:00.000000000 Z
+date: 2015-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -25,33 +25,75 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.8'
 - !ruby/object:Gem::Dependency
-  name: redcarpet
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
-  type: :runtime
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '10.4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '3.2'
 description: https://github.com/waiting-for-dev/string-direction/
 email: marc@lamarciana.com
 executables: []
@@ -61,12 +103,28 @@ files:
 - ".gitignore"
 - ".yardopts"
 - COPYING.txt
+- Gemfile
 - README.md
+- Rakefile
+- bin/console
+- bin/setup
 - lib/string-direction.rb
-- lib/string-direction/string-direction.rb
+- lib/string-direction/configuration.rb
+- lib/string-direction/detector.rb
+- lib/string-direction/strategies/characters_strategy.rb
+- lib/string-direction/strategies/marks_strategy.rb
+- lib/string-direction/strategy.rb
+- lib/string-direction/string_methods.rb
+- lib/string-direction/version.rb
 - spec/spec_helper.rb
-- spec/string/string_spec.rb
-- string-direction.spec
+- spec/string-direction/configuration_spec.rb
+- spec/string-direction/detector_spec.rb
+- spec/string-direction/strategies/characters_strategy_spec.rb
+- spec/string-direction/strategies/marks_strategy_spec.rb
+- spec/string-direction/strategy_spec.rb
+- spec/string-direction/string_methods_spec.rb
+- spec/string-direction_spec.rb
+- string-direction.gemspec
 homepage: https://github.com/waiting-for-dev/string-direction/
 licenses:
 - GPL3
@@ -87,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Automatic detection of text direction (ltr, rtl or bidi) for strings

data/lib/string-direction/string-direction.rb

@@ -1,102 +0,0 @@
-#encoding: UTF-8
-
-# Module with all the logic for automatic detection of text direction. It will be included in String class.
-module StringDirection
-  # left-to-right unicode mark
-  LTR_MARK = "\u200e"
-
-  # right-to-left unicode mark
-  RTL_MARK = "\u200f"
-
-  # returns the direction in which a string is written
-  #
-  # @return ["lft"] if it's a left-to-right string
-  # @return ["rtl"] if it's a right-to-left string
-  # @return ["bidi"] if it's a bi-directinal string
-  def direction
-    if has_ltr_mark? and has_rtl_mark?
-      'bidi'
-    elsif has_ltr_mark?
-      'ltr'
-    elsif has_rtl_mark?
-      'rtl'
-    elsif not has_rtl_characters?
-      'ltr'
-    elsif has_ltr_characters?
-      'bidi'
-    else
-      'rtl'
-    end
-  end
-
-  # whether string is a left-to-right one
-  #
-  # @return [Boolean] true if it is a left-to-right string, false otherwise
-  def is_ltr?
-    (direction == 'ltr') ? true : false
-  end
-
-  # whether string is a right-to-left one
-  #
-  # @return [Boolean] true if it is a right-to-left string, false otherwise
-  def is_rtl?
-    (direction == 'rtl') ? true : false
-  end
-
-  # whether string is a bi-directional one
-  #
-  # @return [Boolean] true if it is a bi-directional string, false otherwise
-  def is_bidi?
-    (direction == 'bidi') ? true : false
-  end
-
-  # returns whether string contains the unicode left-to-right mark
-  #
-  # @return [Boolean] true if it containts ltr mark, false otherwise
-  def has_ltr_mark?
-    match(/^(.*)#{LTR_MARK}(.*)$/) ? true : false
-  end
-
-  # returns whether string contains the unicode right-to-left mark
-  #
-  # @return [Boolean] true if it containts rtl mark, false otherwise
-  def has_rtl_mark?
-    match(/^(.*)#{RTL_MARK}(.*)$/) ? true : false
-  end
-
-  # returns whether string contains some right-to-left character
-  #
-  # @return [Boolean] true if it containts rtl characters, false otherwise
-  def has_rtl_characters?
-    match(/[#{StringDirection::join_scripts_for_regexp(StringDirection.rtl_scripts)}]/) ? true : false
-  end
-
-  # returns whether string contains some left-to-right character
-  #
-  # @return [Boolean] true if it containts ltr characters, false otherwise
-  def has_ltr_characters?
-    # ignore unicode marks, punctuations, symbols, separator and other general categories
-    gsub(/[\p{M}\p{P}\p{S}\p{Z}\p{C}]/, '').match(/[^#{StringDirection::join_scripts_for_regexp(StringDirection.rtl_scripts)}]/) ? true : false
-  end
-
-  class << self
-    attr_accessor :rtl_scripts
-
-    # hook that is called when the module is included and that initializes rtl_scripts
-    #
-    # @param [Module] base The base module from within current module is included
-    def included(base)
-      @rtl_scripts = %w[Arabic Hebrew Nko Kharoshthi Phoenician Syriac Thaana Tifinagh]
-    end
-
-    # given an array of script names, which should be supported by Ruby {http://www.ruby-doc.org/core-1.9.3/Regexp.html#label-Character+Properties regular expression properties}, returns a string where all of them are concatenaded inside a "\\p{}" construction
-    #
-    # @param [Array] scripts the array of script names
-    # @return [String] the script names joined ready to be used in the construction of a regular expression
-    # @example
-    #   StringDirection.join_scripts_for_regexp(%w[Arabic Hebrew]) #=> "\p{Arabic}\p{Hebrew}"
-    def join_scripts_for_regexp(scripts)
-      scripts.map { |script| '\p{'+script+'}' }.join
-    end
-  end
-end

data/spec/string/string_spec.rb

@@ -1,96 +0,0 @@
-#encoding: UTF-8
-require 'spec_helper'
-
-describe String do
-  let(:english) { 'English' }
-  let(:arabic) { 'العربية' }
-  describe "#direction" do
-    context "when marks are present" do
-      it "should return 'ltr' if it contains the left-to-right mark and no right-to-left mark" do
-        string = String::LTR_MARK+english
-        string.direction.should eql 'ltr'
-      end
-      it "should return 'rtl' if it contains the right-to-left mark and no left-to-right mark" do
-        string = String::RTL_MARK+arabic
-        string.direction.should eql 'rtl'
-      end
-      it "should return 'bidi' if it contains both the left-to-right mark and the right-to-left mark" do
-        string = String::LTR_MARK+english+String::RTL_MARK+arabic
-        string.direction.should eql 'bidi'
-      end
-    end
-    context "when marks are not present" do
-      it "should return 'ltr' if no right-to-left character is present" do
-        string = english
-        string.direction.should eql 'ltr'
-      end
-      it "should return 'rtl' if only right-to-left character are present" do
-        string = arabic
-        string.direction.should eql 'rtl'
-      end
-      it "should return 'bidi' if both left-to-right and right-to-left characters are present" do
-        string = arabic+' '+english
-        string.direction.should eql 'bidi'
-      end
-    end
-    context "when default rtl scripts are changed" do
-      let(:new_rtl_script) { 'Latin' }
-      let(:old_rtl_script) { 'Arabic' }
-      it "should return 'rtl' if there are characters for an added right-to-left script and no marks characters are present" do
-        StringDirection.rtl_scripts << new_rtl_script
-        string = english
-        string.direction.should eql 'rtl'
-      end
-      it "should return 'ltr' if there are characters for a deleted right-to-left script (so now ltr) and no mark characters are present" do
-        StringDirection.rtl_scripts.delete old_rtl_script
-        string = arabic
-        string.direction.should eql 'ltr'
-      end
-      after :each do
-        StringDirection.rtl_scripts.delete new_rtl_script if StringDirection.rtl_scripts.include? new_rtl_script
-        StringDirection.rtl_scripts << old_rtl_script unless StringDirection.rtl_scripts.include? old_rtl_script
-      end
-      context "when special characters are present" do
-        it "should ignore special characters for the direction detection" do
-          mark = "\u0903"
-          punctuation = "_"
-          symbol = "€"
-          separator = " "
-          other = "\u0005"
-          string = arabic+mark+punctuation+symbol+separator+other
-          string.direction.should eql 'rtl'
-        end
-      end
-    end
-  end
-  describe "#is_ltr?" do
-    it "should return true if it is a left-to-right string" do
-      string = english
-      string.is_ltr?.should be_true
-    end
-    it "should return false if it is not a left-to-right string" do
-      string = arabic
-      string.is_ltr?.should be_false
-    end
-  end
-  describe "#is_rtl?" do
-    it "should return true if it is a right-to-left string" do
-      string = arabic
-      string.is_rtl?.should be_true
-    end
-    it "should return false if it is not a right-to-left string" do
-      string = english
-      string.is_rtl?.should be_false
-    end
-  end
-  describe "#is_bidi?" do
-    it "should return true if it is a bi-directional string" do
-      string = english+' '+arabic
-      string.is_bidi?.should be_true
-    end
-    it "should return false if it is not a bi-directional string" do
-      string = english
-      string.is_bidi?.should be_false
-    end
-  end
-end

data/string-direction.spec

@@ -1,16 +0,0 @@
-Gem::Specification.new do |s|
-   s.name = 'string-direction'
-   s.version = '0.0.4'
-   s.summary = 'Automatic detection of text direction (ltr, rtl or bidi) for strings'
-   s.description = 'https://github.com/waiting-for-dev/string-direction/'
-   s.license = 'GPL3'
-   s.homepage = 'https://github.com/waiting-for-dev/string-direction/'
-   s.authors = ['Marc Busqué']
-   s.email = 'marc@lamarciana.com'
-   s.files = `git ls-files`.split("\n")
-
-   s.add_runtime_dependency "yard", "~>0.8"
-   s.add_runtime_dependency "redcarpet", "~>2.2"
-
-   s.add_development_dependency "rspec", "~>2.13"
-end