string-direction 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4012023bbe9a099ec7e4bc0c0c366e79df36b194
-  data.tar.gz: 8ad5696dafb160dff2310054f77e1504ee7a4cfe
+  metadata.gz: c2d34e48984500c5942983fea9d97942cb09ab49
+  data.tar.gz: 751f2b9960885a5ec1e3905c171cf3716f5e0813
 SHA512:
-  metadata.gz: efc912ae089c7ea5b7002797f935543619c18bc7c8ea12db133ff9cff49e0c8f40af69213710c1df03db4e4ca2b6cd8f15eb0741449070f1dd93162ccdc2c976
-  data.tar.gz: 228e529c260071ea4d8b21e89556a91b7780fab5d803a673807d636cf29e22fb1412e80a42a9b5c7e916a8f81001f70d0c0bd6d261ba1415cc1c837713fffc54
+  metadata.gz: f6e7699515186abbd69f7ee9f99d8c3456b54edf8e7667fa26afda7f7e87d8fb7a5513fc9be95325f28d449fc1c99c06bc3bc0853d2cce368669a66e3b7c6f99
+  data.tar.gz: eebfacf8dc846064bd23e18dcd9ae49306bff5d8e3ca340697b05ff3288d691598109313e883b4062c59ed8dee7bce09882e3a4b155ade834e1a8c1b9982275d

data/README.md

@@ -39,7 +39,7 @@ detector = StringDirection::Detector.new(:foo, :bar)
 
 In the above example, classes `StringDirection::FooStrategy` and `StringDirection::BarStrategy` have to be in the load path.
 
-Two strategies are natively integrated: `marks` and `characters`. They are used, in that order, as default strategies if no arguments are given to the detector.
+Three strategies are natively integrated: `marks`, `characters` & `dominant`. `marks` && `characters` are used as default strategies if no arguments are given to the detector.
 
 ### marks
 
@@ -102,6 +102,21 @@ Keep in mind than only [scripts recognized by Ruby regular expressions](http://w
 
 `characters` strategy can not only analyze a string but everything responding to `to_s`.
 
+### dominant
+
+With `dominant` strategy, a string can be left-to-right or right-to-left, but never bidi. It returns one or the other in function of which one has more characters.
+
+```ruby
+detector = StringDirection::Detector.new(:dominant)
+
+detector.direction('e العربية') #=> 'rtl'
+detector.direction('english ة') #=> 'ltr'
+```
+
+As with `characters` strategy, you can change which scripts are considered right-to-left.
+
+`dominant` strategy can not only analyze a string but everything responding to `to_s`.
+
 ### 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` which return expected result. If the strategy doesn't know the direction, it must return `nil`.

data/lib/string-direction.rb

@@ -4,6 +4,7 @@ require 'string-direction/detector'
 require 'string-direction/strategy'
 require 'string-direction/strategies/marks_strategy'
 require 'string-direction/strategies/characters_strategy'
+require 'string-direction/strategies/dominant_strategy'
 require 'string-direction/string_methods'
 
 # Constants & configuration common in the whole library

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

@@ -2,7 +2,7 @@ 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
+    IGNORED_CHARS = '\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}
     #
@@ -21,16 +21,24 @@ module StringDirection
 
     private
 
+    def rtl_regex
+      @rtl_regex ||= /[#{rtl_script_character_classes}]/
+    end
+
+    def ltr_regex
+      @ltr_regex ||= /[^#{rtl_script_character_classes}#{IGNORED_CHARS}]/
+    end
+
     def rtl_characters?(string)
-      string.match(/[#{join_rtl_for_regex}]/)
+      string.match(rtl_regex)
     end
 
     def ltr_characters?(string)
-      string.gsub(CHAR_IGNORE_REGEX, '').match(/[^#{join_rtl_for_regex}]/)
+      string.match(ltr_regex)
     end
 
-    def join_rtl_for_regex
-      rtl_scripts.map { |script| '\p{' + script + '}' }.join
+    def rtl_script_character_classes
+      @rtl_script_character_classes ||= rtl_scripts.map { |script| "\\p{#{script}}" }.join
     end
 
     def rtl_scripts

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

@@ -0,0 +1,28 @@
+module StringDirection
+  # Strategy to decide direction between ltr or rtl in function of which is the main type
+  class DominantStrategy < CharactersStrategy
+    # Get the number of ltr and rtl characters in the supplied string and infer
+    # direction from the most common type. For this strategy the direction can
+    # be ltr or rtl, but never bidi. In case of draw it returns nil.
+    #
+    # params [String] The string to inspect
+    # @return [String, nil]
+    def run(string)
+      string = string.to_s
+      ltr_count = chars_count(string, ltr_regex)
+      rtl_count = chars_count(string, rtl_regex)
+      diff = ltr_count - rtl_count
+      return ltr if diff > 0
+      return rtl if diff < 0
+      nil
+    end
+
+    private
+
+    def chars_count(string, regex)
+      count = 0
+      string.scan(regex) { count += 1 }
+      count
+    end
+  end
+end

data/lib/string-direction/version.rb

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

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

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe StringDirection::DominantStrategy 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 in equal numbers' do
+      let(:string) { arabic + english }
+
+      it "returns nil" do
+        expect(subject).to eq nil
+      end
+    end
+
+    context 'when both left-to-right and right-to-left characters are present, with more ltr' do
+      let(:string) { english + arabic + english }
+
+      it "returns 'ltr'" do
+        expect(subject).to eq 'ltr'
+      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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: string-direction
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Marc Busqué
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-14 00:00:00.000000000 Z
+date: 2016-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -112,6 +112,7 @@ files:
 - lib/string-direction/configuration.rb
 - lib/string-direction/detector.rb
 - lib/string-direction/strategies/characters_strategy.rb
+- lib/string-direction/strategies/dominant_strategy.rb
 - lib/string-direction/strategies/marks_strategy.rb
 - lib/string-direction/strategy.rb
 - lib/string-direction/string_methods.rb
@@ -120,6 +121,7 @@ files:
 - spec/string-direction/configuration_spec.rb
 - spec/string-direction/detector_spec.rb
 - spec/string-direction/strategies/characters_strategy_spec.rb
+- spec/string-direction/strategies/dominant_strategy_spec.rb
 - spec/string-direction/strategies/marks_strategy_spec.rb
 - spec/string-direction/strategy_spec.rb
 - spec/string-direction/string_methods_spec.rb
@@ -145,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.3
 signing_key: 
 specification_version: 4
 summary: Automatic detection of text direction (ltr, rtl or bidi) for strings