british 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0237633aac781d2eb9414af40b9ca1975ac4f99c
-  data.tar.gz: 5db567584c645c78ba84c2c9a13e4259bf0a04ca
+  metadata.gz: 7115edabb03d3d4647a323d60496b44acf8d90c3
+  data.tar.gz: 186e32e55afdc4baf90854b20f9c4185e686f351
 SHA512:
-  metadata.gz: 10a7474b9c6dce19165ef13fda273f4d75dc1b05feae0db8305ac0e9e5b813d691e63ecae60ffad82d2b983e8cd3b8cb2f4a486793d904cfe28eea10db6a3f13
-  data.tar.gz: 04d4af10b3b0adaaa187bf5d4df8d4b4cb9c68406f260fa68227591c3b99aa0d33d35208582e22d248f5c4b273de75059a33f955e05eae4e9b6c8157ee20fbdf
+  metadata.gz: 6bb4952776e2e9f52f73dcf6757a1d9bc3827128f5a79c98ab86e8aaa71f6ff8d95b9f33bec79c553033e92f35f8988405d56aa7ffcc9feffe4cad8564b882ed
+  data.tar.gz: 90576b1bb474d3d5df85475071e8a380891f1be5b3e51f52bd4fe19483cfcce603ce3fb94a248f6ba968c5dc887b407493c18c48202d901939e6e681c9478016

data/lib/british.rb

@@ -79,11 +79,26 @@ module British
     'ogue'    => 'og'
   }.freeze
 
+  # Public: Hash of American ↔ British words endings
+  INVERTED_ENDINGS = {
+    # Latin-derived spellings
+    'or'    => 'our',
+    'er'    => 're',
+    'se'    => 'ce',
+    'ction' => 'xion',
+
+    # Greek-derived spellings
+    'ize'     => 'ise',
+    'ization' => 'isation',
+    'yze'     => 'yse',
+    'og'      => 'ogue'
+  }.freeze
+
   # Public: Regexp pattern to search/replace British words endings
-  BRITISH_ENDING_PATTERN  = /#{Regexp.union(ENDINGS.keys)}(?=_|-|\?|\!|=|$)/
+  BRITISH_ENDING_PATTERN  = /#{Regexp.union(ENDINGS.keys)}(?=_|\?|\!|=|$)/
 
   # Public: Regexp pattern to search/replace American words endings
-  AMERICAN_ENDING_PATTERN = /#{Regexp.union(ENDINGS.values)}(?=_|-|\?|\!|=|$)/
+  AMERICAN_ENDING_PATTERN = /#{Regexp.union(ENDINGS.values)}(?=_|\?|\!|=|$)/
 
   # Public: Submodule to be included in your own classes to use `initialise`
   # and allow American methods to be called from outside
@@ -163,19 +178,19 @@ module British
     host_class.extend ClassMethods
     host_class.class_overwrite_method_missing
 
+    return unless host_class.private_methods(true).include?(:method_added)
+
     # Inject our own method_added hook to catch it when
     # `method_missing` is added
-    if host_class.private_methods(true).include?(:method_added)
-      host_class.instance_eval do
-        def british_method_added(name)
-          original_method_added(name)
-          class_overwrite_method_missing if name == :method_missing
-        end
-
-        # do not mess with others :method_added
-        alias original_method_added method_added
-        alias method_added british_method_added
+    host_class.instance_eval do
+      def british_method_added(name)
+        original_method_added(name)
+        class_overwrite_method_missing if name == :method_missing
       end
+
+      # do not mess with others :method_added
+      alias original_method_added method_added
+      alias method_added british_method_added
     end
   end
 
@@ -199,19 +214,19 @@ module British
     host_object.extend ClassMethods
     host_object.object_overwrite_method_missing
 
+    return unless host_object.private_methods(true).include?(:singleton_method_added)
+
     # Inject our own singleton_method_added hook to catch it when
     # `method_missing` is added
-    if host_object.private_methods(true).include?(:singleton_method_added)
-      host_object.instance_eval do
-        def british_singleton_method_added(name)
-          original_singleton_method_added(name)
-          object_overwrite_method_missing if name == :method_missing
-        end
-
-        # do not mess with others :singleton_method_added
-        alias original_singleton_method_added singleton_method_added
-        alias singleton_method_added british_singleton_method_added
+    host_object.instance_eval do
+      def british_singleton_method_added(name)
+        original_singleton_method_added(name)
+        object_overwrite_method_missing if name == :method_missing
       end
+
+      # do not mess with others :singleton_method_added
+      alias original_singleton_method_added singleton_method_added
+      alias singleton_method_added british_singleton_method_added
     end
   end
 
@@ -251,14 +266,30 @@ module British
       class_eval do
         unless method_defined?(:british_method_missing)
           define_method(:british_method_missing) do |name, *args|
+            binded_class = self.class
+
             # When in our own British class
-            if self.class.include?(British::Initialisable)
+            if binded_class.include?(British::Initialisable)
+              name_str = name.to_s
+
               # do American magic
-              britanised_name = name.to_s.gsub(AMERICAN_ENDING_PATTERN, ENDINGS.invert)
+              britanised_name = if name_str =~ /_/
+                                  name_str.gsub(AMERICAN_ENDING_PATTERN, INVERTED_ENDINGS)
+                                else
+                                  name_str.sub(AMERICAN_ENDING_PATTERN, INVERTED_ENDINGS)
+                                end
+
               return send(britanised_name, *args) if respond_to?(britanised_name)
             else
+              name_str = name.to_s
+
               # do British magic
-              americanised_name = name.to_s.gsub(BRITISH_ENDING_PATTERN, ENDINGS)
+              americanised_name = if name_str =~ /_/
+                                    name_str.gsub(BRITISH_ENDING_PATTERN, ENDINGS)
+                                  else
+                                    name_str.sub(BRITISH_ENDING_PATTERN, ENDINGS)
+                                  end
+
               return send(americanised_name, *args) if respond_to?(americanised_name)
             end
 
@@ -266,7 +297,7 @@ module British
             return original_method_missing(name, *args) if caller[0] !~ /method_missing/ && defined?(:original_method_missing)
 
             # call original parent's method_missing
-            method = self.class.superclass.instance_method(:original_method_missing)
+            method = binded_class.superclass.instance_method(:original_method_missing)
             return method.bind(self).call(name, *args) if method
           end
         end
@@ -312,7 +343,12 @@ module British
         unless respond_to?(:british_method_missing)
           def british_method_missing(name, *args)
             # do British magic
-            americanised_name = name.to_s.gsub(BRITISH_ENDING_PATTERN, ENDINGS)
+            americanised_name = if name.to_s =~ /_/
+                                  name.to_s.gsub(BRITISH_ENDING_PATTERN, ENDINGS)
+                                else
+                                  name.to_s.sub(BRITISH_ENDING_PATTERN, ENDINGS)
+                                end
+
             return send(americanised_name, *args) if respond_to?(americanised_name)
 
             # call original method_missing (avoid double original method calls)

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: british
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Serge Bedzhyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-29 00:00:00.000000000 Z
+date: 2016-12-07 00:00:00.000000000 Z
 dependencies: []
 description: 'Allows to use alternative words endings: -ise instead of -ize etc. Defines
-  `is_an?` as an alias of the is_a? method. Provides module to use `initialise` in
-  your classes.'
+  `is_an?` as an alias of the is_a? method. Provides a module to use `initialise`
+  in your classes.'
 email: smileart21@gmail.com
 executables: []
 extensions: []
@@ -42,6 +42,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: A tiny module that is supposed to help Brits to use Ruby with more comfort
+summary: A tiny module which is supposed to help Brits to use Ruby with more comfort
 test_files: []
-has_rdoc: