string-direction 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ef6e54736486fccff8d5e5c004d73c27a5ca7b4
-  data.tar.gz: d16b4d813ef25aa3cbd032af62a2861cf5fe0fe6
+  metadata.gz: 4012023bbe9a099ec7e4bc0c0c366e79df36b194
+  data.tar.gz: 8ad5696dafb160dff2310054f77e1504ee7a4cfe
 SHA512:
-  metadata.gz: 72c1db5ba8b6d1f3cfffe46315a8956a34d41f957a4ebad2e09daad798dcf590c90a06947115caa696e9c32f2eaaf61114e101d621ed5d8a27b53267ad3f50c0
-  data.tar.gz: 4424cab8cab4d1b9e016169867a1cf0c8b050ce6f498727c234a89414ebbad36b24a704abf6c84c15ef55b251064379918c42f0ffbd436b006dd08fa0f7d1bb9
+  metadata.gz: efc912ae089c7ea5b7002797f935543619c18bc7c8ea12db133ff9cff49e0c8f40af69213710c1df03db4e4ca2b6cd8f15eb0741449070f1dd93162ccdc2c976
+  data.tar.gz: 228e529c260071ea4d8b21e89556a91b7780fab5d803a673807d636cf29e22fb1412e80a42a9b5c7e916a8f81001f70d0c0bd6d261ba1415cc1c837713fffc54

data/README.md

@@ -31,11 +31,19 @@ String.send(:include, StringDirection::StringMethods)
 
 `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.
+Strategies are passed to the detector during its initialization:
+
+```ruby
+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.
 
 ### 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).
+Looks for the presence of Unicode direction 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)
@@ -44,6 +52,8 @@ detector.direction("\u200eالعربية") #=> "ltr"
 detector.direction("\u200fEnglish") #=> "rtl"
 ```
 
+`marks` strategy can not only analyze a string but everything responding to `to_s`.
+
 ### characters
 
 Looks for the presence of right-to-left characters in the scripts used in the string.
@@ -71,8 +81,8 @@ You can change these defaults:
 ```ruby
 detector.direction('ᚪᚫᚬᚭᚮᚯ') #=> 'ltr'
 
-StringDirection.configuration do |config|
-    config.rtl_scripts << 'Runic'
+StringDirection.configure do |config|
+  config.rtl_scripts << 'Runic'
 end
 
 detector.direction('ᚪᚫᚬᚭᚮᚯ') #=> 'rtl'
@@ -90,12 +100,14 @@ 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.
 
+`characters` 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`.
+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`.
 
 ```ruby
-class StringDirection::AlwaysLtrStrategy
+class StringDirection::AlwaysLtrStrategy < StringDirection::Strategy
   def run(string)
     ltr
   end
@@ -110,8 +122,26 @@ detector.direction('العربية') #=> 'ltr'
 `marks` and `characters` are default strategies, but you can change them:
 
 ```ruby
-StringDirection.configuration do |config|
-    config.default_strategies = [:custom, :marks, :always_ltr]
+StringDirection.configure do |config|
+  config.default_strategies = [:custom, :marks, :always_ltr]
+end
+```
+
+## Monkey patching String
+
+If you desire, you can monkey patch `String`:
+
+```ruby
+String.send(:include, StringDirection::StringMethods)
+
+'english'.direction #=> 'ltr'
+```
+
+In that case, strategies configured in `string_method_strategies` are used:
+
+```ruby
+StringDirection.configure do |config|
+  config.string_methods_strategies = [:marks, :characters]
 end
 ```
 

data/lib/string-direction/configuration.rb

@@ -11,10 +11,16 @@ module StringDirection
     # @return [Array]
     attr_accessor :default_strategies
 
+    # Strategies, in order, that {StringMethods} uses. 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 :string_methods_strategies
+
     # Initialize defaults
     def initialize
       self.rtl_scripts = %w(Arabic Hebrew Nko Kharoshthi Phoenician Syriac Thaana Tifinagh)
       self.default_strategies = [:marks, :characters]
+      self.string_methods_strategies = [:marks, :characters]
     end
   end
 end

data/lib/string-direction/detector.rb

@@ -32,7 +32,7 @@ module StringDirection
     # @param string [String] The string to inspect
     # @return [Boolean]
     def ltr?(string)
-      direction(string) == StringDirection::LTR
+      direction(string) == ltr
     end
 
     # Returns whether string is right-to-left or not
@@ -40,7 +40,7 @@ module StringDirection
     # @param string [String] The string to inspect
     # @return [Boolean]
     def rtl?(string)
-      direction(string) == StringDirection::RTL
+      direction(string) == rtl
     end
 
     # Returns whether string is bidirectional or not
@@ -48,7 +48,7 @@ module StringDirection
     # @param string [String] The string to inspect
     # @return [Boolean]
     def bidi?(string)
-      direction(string) == StringDirection::BIDI
+      direction(string) == bidi
     end
 
     private
@@ -68,5 +68,17 @@ module StringDirection
       base_name = strategy.to_s.split('_').map(&:capitalize).join
       "StringDirection::#{base_name}Strategy"
     end
+
+    def ltr
+      StringDirection::LTR
+    end
+
+    def rtl
+      StringDirection::RTL
+    end
+
+    def bidi
+      StringDirection::BIDI
+    end
   end
 end

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

@@ -22,15 +22,15 @@ module StringDirection
     private
 
     def rtl_characters?(string)
-      string.match(/[#{join_scripts_for_regexp(rtl_scripts)}]/) ? true : false
+      string.match(/[#{join_rtl_for_regex}]/)
     end
 
     def ltr_characters?(string)
-      string.gsub(CHAR_IGNORE_REGEX, '').match(/[^#{join_scripts_for_regexp(rtl_scripts)}]/) ? true : false
+      string.gsub(CHAR_IGNORE_REGEX, '').match(/[^#{join_rtl_for_regex}]/)
     end
 
-    def join_scripts_for_regexp(scripts)
-      scripts.map { |script| '\p{' + script + '}' }.join
+    def join_rtl_for_regex
+      rtl_scripts.map { |script| '\p{' + script + '}' }.join
     end
 
     def rtl_scripts

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

@@ -25,11 +25,11 @@ module StringDirection
     private
 
     def ltr_mark?(string)
-      string.include?(LTR_MARK) ? true : false
+      string.include?(LTR_MARK)
     end
 
     def rtl_mark?(string)
-      string.include?(RTL_MARK) ? true : false
+      string.include?(RTL_MARK)
     end
   end
 end

data/lib/string-direction/string_methods.rb

@@ -25,7 +25,11 @@ module StringDirection
     private
 
     def string_direction_detector
-      @string_direction_detector ||= StringDirection::Detector.new
+      @string_direction_detector ||= StringDirection::Detector.new(*string_direction_strategies)
+    end
+
+    def string_direction_strategies
+      StringDirection.configuration.string_methods_strategies
     end
   end
 end

data/lib/string-direction/version.rb

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

data/spec/string-direction/configuration_spec.rb

@@ -12,4 +12,10 @@ describe StringDirection::Configuration do
       expect(subject.default_strategies).to eq([:marks, :characters])
     end
   end
+
+  describe '#string_methods_strategies' do
+    it 'defaults to an array with :marks and :characters' do
+      expect(subject.string_methods_strategies).to eq([:marks, :characters])
+    end
+  end
 end

data/spec/string-direction/string_methods_spec.rb

@@ -3,31 +3,57 @@ require 'spec_helper'
 describe StringDirection::StringMethods do
   subject { 'abc' }
 
-  before :each do
-    String.send(:include, StringDirection::StringMethods)
-  end
+  context 'in any case' do
+    before :each do
+      String.send(:include, StringDirection::StringMethods)
+    end
 
-  describe '#direction' do
-    it 'returns string direction' do
-      expect(subject.direction).to eq(StringDirection::LTR)
+    describe '#direction' do
+      it 'returns string direction' do
+        expect(subject.direction).to eq(StringDirection::LTR)
+      end
     end
-  end
 
-  describe '#ltr?' do
-    it 'returns whether string direction is left-to-right' do
-      expect(subject.ltr?).to eq(true)
+    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
-  end
 
-  describe '#rtl?' do
-    it 'returns whether string direction is right-to-left' do
-      expect(subject.rtl?).to eq(false)
+    describe '#bidi?' do
+      it 'returns whether string direction is bidirectional' do
+        expect(subject.bidi?).to eq(false)
+      end
     end
   end
 
-  describe '#bidi?' do
-    it 'returns whether string direction is bidirectional' do
-      expect(subject.bidi?).to eq(false)
+  context 'when StringDirection.configuration.string_methods_strategies is changed' do
+    before :each do
+      class StringDirection::AlwaysRtlStrategy < StringDirection::Strategy
+        def run(string)
+          rtl
+        end
+      end
+
+      StringDirection.configure do |config|
+        config.string_methods_strategies = [:always_rtl]
+      end
+
+      String.send(:include, StringDirection::StringMethods)
+    end
+
+    it 'uses that configured strategies' do
+      expect('abc'.direction).to eq('rtl')
+    end
+
+    after :each do
+      StringDirection.reset_configuration
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: string-direction
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Marc Busqué
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-11 00:00:00.000000000 Z
+date: 2015-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard