twitter_cldr 3.6.0 → 4.0.0

data/lib/twitter_cldr/transforms/transformer.rb

@@ -0,0 +1,220 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Transforms
+
+    class InvalidTransformRuleError < StandardError; end
+
+    class Transformer
+      RULE_CLASSES = [
+        CommentRule,
+        VariableRule,
+        Transforms::TransformRule,
+        Filters::FilterRule,
+        Conversions::ConversionRule,
+      ]
+
+      class << self
+        def exists?(transform_id_or_str)
+          !!get(transform_id_or_str)
+        rescue
+          false
+        end
+
+        def get(transform_id_or_str)
+          id = parse_id(transform_id_or_str)
+
+          if resource_exists?(id)
+            load(id).forward_rule_set
+          else
+            reversed_id = id.reverse
+
+            if resource_exists?(reversed_id)
+              load(reversed_id).backward_rule_set
+            end
+          end
+        end
+
+        def each_transform
+          if block_given?
+            path = TwitterCldr.resources.absolute_resource_path(
+              File.join('shared', 'transforms')
+            )
+
+            Dir.glob(File.join(path, '*.*')).each do |file|
+              file = File.basename(file.chomp(File.extname(file)))
+              source, target, variant = TransformId.split(file)
+              yield TransformId.join(source, target, variant)
+            end
+          else
+            to_enum(__method__)
+          end
+        end
+
+        private
+
+        def parse_id(transform_id)
+          case transform_id
+            when TransformId
+              transform_id
+            else
+              TransformId.parse(transform_id)
+          end
+        end
+
+        def load(transform_id)
+          transformers[transform_id.to_s] ||= begin
+            resource = resource_for(transform_id)
+            direction = direction_from(resource)
+            new(parse_resource(resource), direction, transform_id)
+          end
+        end
+
+        def build(rule_list, direction)
+          rules = parse_rules(rule_list)
+          new(rules, direction)
+        end
+
+        def direction_from(resource)
+          case transform_from(resource)[:direction]
+            when 'both'
+              :bidirectional
+            else
+              :forward
+          end
+        end
+
+        def transformers
+          @transformers ||= {}
+        end
+
+        def parse_resource(resource)
+          parse_rules(rules_from(resource))
+        end
+
+        def parse_rules(rule_list)
+          symbol_table = {}
+          rules = []
+
+          parse_each_rule(rule_list, symbol_table) do |rule|
+            if rule.is_variable?
+              symbol_table[rule.name] = rule
+            elsif !rule.is_comment?
+              rules << rule
+            end
+          end
+
+          rules
+        end
+
+        def parse_each_rule(rule_list, symbol_table)
+          rule_list.each_with_index do |rule_text, idx|
+            if klass = identify_class(rule_text)
+              rule = klass.parse(
+                rule_text, symbol_table, idx
+              )
+
+              yield rule
+            else
+              raise InvalidTransformRuleError,
+                "Invalid rule: '#{rule_text}'"
+            end
+          end
+        end
+
+        def identify_class(rule_text)
+          RULE_CLASSES.find do |klass|
+            klass.accepts?(rule_text)
+          end
+        end
+
+        def rules_from(resource)
+          transform_from(resource)[:rules]
+        end
+
+        def transform_from(resource)
+          resource[:transforms].first
+        end
+
+        def resource_for(transform_id)
+          TwitterCldr.get_resource(
+            'shared', 'transforms', transform_id.file_name
+          )
+        end
+
+        def resource_exists?(transform_id)
+          TwitterCldr.resource_exists?(
+            'shared', 'transforms', transform_id.file_name
+          )
+        end
+      end
+
+      attr_reader :rules, :direction, :transform_id
+
+      def initialize(rules, direction, transform_id)
+        @rules = rules
+        @direction = direction
+        @transform_id = transform_id
+      end
+
+      # all rules are either forward or bidirectional
+      def bidirectional?
+        direction == :bidirectional
+      end
+
+      def forward_rule_set
+        @forward_rule_set ||= begin
+          RuleSet.new(
+            filter_rule, inverse_filter_rule,
+            ct_rules, transform_id
+          )
+        end
+      end
+
+      def backward_rule_set
+        if bidirectional?
+          @backward_rule_set ||= forward_rule_set.invert
+        else
+          raise NotInvertibleError,
+            "cannot invert this #{self.class.name}"
+        end
+      end
+
+      private
+
+      def ct_rules
+        @ct_rules ||= rules.select do |rule|
+          rule.is_transform_rule? || rule.is_conversion_rule?
+        end
+      end
+
+      def filter_rule
+        @filter_rule ||= if is_forward_filter?(rules.first)
+          rules.first
+        else
+          Filters::NullFilter.new
+        end
+      end
+
+      def inverse_filter_rule
+        @inverse_filter_rule ||= if is_backward_filter?(rules.last)
+          rules.last
+        else
+          Filters::NullFilter.new
+        end
+      end
+
+      def is_forward_filter?(rule)
+        rule.is_filter_rule? && !rule.backward?
+      end
+
+      def is_backward_filter?(rule)
+        rule.is_filter_rule? && rule.backward?
+      end
+    end
+
+  end
+end

data/lib/twitter_cldr/transforms/transforms.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Transforms
+
+    module Transforms
+      autoload :BreakInternalTransform, 'twitter_cldr/transforms/transforms/break_internal_transform'
+      autoload :CasingTransform,        'twitter_cldr/transforms/transforms/casing_transform'
+      autoload :NamedTransform,         'twitter_cldr/transforms/transforms/named_transform'
+      autoload :NormalizationTransform, 'twitter_cldr/transforms/transforms/normalization_transform'
+      autoload :NullTransform,          'twitter_cldr/transforms/transforms/null_transform'
+      autoload :Parser,                 'twitter_cldr/transforms/transforms/parser'
+      autoload :TransformPair,          'twitter_cldr/transforms/transforms/transform_pair'
+      autoload :TransformRule,          'twitter_cldr/transforms/transforms/transform_rule'
+    end
+
+  end
+end

data/lib/twitter_cldr/transforms/transforms/break_internal_transform.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Transforms
+    module Transforms
+
+      class BreakInternalTransform < NullTransform
+        class << self
+          def accepts?(forward_form, backward_form)
+            forward_form.transform.downcase == 'any-breakinternal'
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/twitter_cldr/transforms/transforms/casing_transform.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Transforms
+    module Transforms
+
+      class CasingTransform < TransformRule
+        VALID_FORMS = %w(lower upper title)
+
+        class << self
+          def accepts?(forward_form, backward_form)
+            valid_form?(forward_form) && valid_form?(backward_form)
+          end
+
+          private
+
+          def valid_form?(form)
+            !form || (
+              form && VALID_FORMS.include?(form.transform.downcase)
+            )
+          end
+        end
+
+        attr_reader :forward_transform, :backward_transform
+
+        def apply_to(cursor)
+          if forward_transform
+            case forward_transform
+              when 'lower'
+                apply_lower(cursor)
+              when 'upper'
+                apply_upper(cursor)
+              when 'title'
+                apply_title(cursor)
+            end
+
+            cursor.reset_position
+          end
+        end
+
+        private
+
+        def after_initialize
+          @forward_transform = normalize_transform(forward_form)
+          @backward_transform = normalize_transform(backward_form)
+        end
+
+        def normalize_transform(form)
+          if form && form.has_transform?
+            form.transform.downcase
+          end
+        end
+
+        def apply_lower(cursor)
+          cursor.set_text(caser.downcase(cursor.text))
+        end
+
+        def apply_upper(cursor)
+          cursor.set_text(caser.upcase(cursor.text))
+        end
+
+        def apply_title(cursor)
+          cursor.set_text(caser.titlecase(cursor.text))
+        end
+
+        def caser
+          TwitterCldr::Shared::Caser
+        end
+      end
+
+    end
+  end
+end

data/lib/twitter_cldr/transforms/transforms/named_transform.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Transforms
+    module Transforms
+
+      class NamedTransform < TransformRule
+        Transformer = TwitterCldr::Transforms::Transformer
+
+        class << self
+          def accepts?(forward_form, backward_form)
+            exists?(forward_form) && exists?(backward_form)
+          end
+
+          private
+
+          def exists?(form)
+            !form || Transformer.exists?(form.transform)
+          end
+        end
+
+        def apply_to(cursor)
+          if forward_form
+            rule_set = forward_form.to_rule_set
+            cursor.set_text(rule_set.transform(cursor.text))
+            cursor.reset_position
+          end
+        end
+
+        private
+
+        def after_initialize
+          if forward_form
+            @backward_form = TransformPair.new(
+              nil, TransformId.parse(forward_form.transform).reverse.to_s
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twitter_cldr/transforms/transforms/normalization_transform.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Transforms
+    module Transforms
+
+      class NormalizationTransform < TransformRule
+        class << self
+          def accepts?(forward_form, backward_form)
+            valid_form?(forward_form) && valid_form?(backward_form)
+          end
+
+          private
+
+          def valid_form?(form)
+            !form || (
+              form && TwitterCldr::Normalization::VALID_NORMALIZERS.include?(
+                form.transform.downcase.to_sym
+              )
+            )
+          end
+        end
+
+        attr_reader :forward_transform, :backward_transform
+
+        def apply_to(cursor)
+          if forward_transform
+            cursor.set_text(
+              TwitterCldr::Normalization.normalize(
+                cursor.text, using: forward_transform
+              )
+            )
+
+            cursor.reset_position
+          end
+        end
+
+        private
+
+        def after_initialize
+          @forward_transform = symbolize_transform(forward_form)
+          @backward_transform = symbolize_transform(backward_form)
+        end
+
+        def symbolize_transform(form)
+          if form && form.has_transform?
+            form.transform.downcase.to_sym
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/twitter_cldr/transforms/transforms/null_transform.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+module TwitterCldr
+  module Transforms
+    module Transforms
+
+      class NullTransform < TransformRule
+        class << self
+          def accepts?(forward_form, backward_form)
+            valid_form?(forward_form) || valid_form?(backward_form)
+          end
+
+          private
+
+          def valid_form?(form)
+            form && form.transform == 'Null'
+          end
+        end
+
+        def apply_to(cursor)
+          cursor.reset_position
+        end
+      end
+
+    end
+  end
+end