i18n-tasks 0.4.5 → 0.5.0

data/lib/i18n/tasks/key/key_group.rb

@@ -1,45 +0,0 @@
-# coding: utf-8
-module I18n
-  module Tasks
-    class Key
-      module KeyGroup
-        attr_accessor :key_group
-
-        def self.included(base)
-          base.class_eval do
-            extend ClassMethods
-            delegate_to_attr :[], :key?
-            delegate_to_attr_accessor :type, :locale
-          end
-        end
-
-        def attr
-          key_group.attr.merge @own_attr
-        end
-
-        def clone_orphan
-          clone.tap { |k| k.key_group = nil }
-        end
-
-        module ClassMethods
-          def delegate_to_attr_accessor(*methods)
-            methods.each do |m|
-              define_method(m) do
-                @own_attr[m] || (kg = key_group) && kg.attr[m]
-              end
-            end
-          end
-
-          def delegate_to_attr(*methods)
-            methods.each do |m|
-              define_method(m) do |*args|
-                @own_attr.send(m, *args) ||
-                    (kg = key_group) && kg.attr.send(m, *args)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/i18n/tasks/key/match_pattern.rb

@@ -1,24 +0,0 @@
-# coding: utf-8
-module I18n
-  module Tasks
-    class Key
-      module MatchPattern
-        def key_match_pattern
-          @key_match_pattern ||= begin
-            k = key
-            "#{k.gsub(/\#{.*?}/, '*')}#{'*' if k.end_with?('.')}"
-          end
-        end
-
-        # A key interpolated with expression
-        def expr?
-          if @is_expr.nil?
-            k        = key
-            @is_expr = (k =~ /\#{.*?}/ || k.end_with?('.'))
-          end
-          @is_expr
-        end
-      end
-    end
-  end
-end

data/lib/i18n/tasks/key/usages.rb

@@ -1,12 +0,0 @@
-# coding: utf-8
-module I18n
-  module Tasks
-    class Key
-      module Usages
-        def usages
-          self[:usages]
-        end
-      end
-    end
-  end
-end

data/lib/i18n/tasks/key_group.rb

@@ -1,68 +0,0 @@
-# coding: utf-8
-require 'set'
-module I18n
-  module Tasks
-    # Container for keys with shared attributes
-    class KeyGroup
-      attr_reader :keys, :attr, :key_names
-
-      delegate :size, :length, :each, :[], :blank?, to: :keys
-      include Enumerable
-
-      def initialize(keys, attr = {})
-        @keys = if keys && !keys[0].is_a?(::I18n::Tasks::Key)
-                  keys.map { |key| I18n::Tasks::Key.new(key) }
-                else
-                  keys
-                end
-        @keys.each { |key| key.key_group ||= self } unless attr.delete(:orphan)
-
-        @keys_by_name = @keys.inject({}) { |h, k| h[k.key.to_s] = k; h }
-        @key_names    = @keys.map(&:key)
-        @attr         = attr
-      end
-
-      def find_by_name(key)
-        @keys_by_name[key.to_s]
-      end
-
-      def key_names_set
-        @key_names_set ||= Set.new(@key_names)
-      end
-
-      def include?(key)
-        key_names_set.include?(key.to_s)
-      end
-
-      def sort!(&block)
-        @keys.sort!(&block)
-        @key_names = @keys.map(&:to_s)
-        self
-      end
-
-      # Sort keys by their attributes in order
-      # @param [Hash] order e.g. {locale: :asc, type: :desc, key: :asc}
-      def sort_by_attr!(order)
-        order_keys = order.keys
-        sort! { |a, b|
-          by = order_keys.detect { |by| a[by] != b[by] }
-          order[by] == :desc ? b[by] <=> a[by] : a[by] <=> b[by]
-        }
-        self
-      end
-
-      def to_a
-        @array ||= keys.map(&:attr)
-      end
-
-      alias as_json to_a
-
-      def merge(other)
-        KeyGroup.new(keys + other.keys,
-                     type: [attr[:type], other.attr[:type]].flatten.compact)
-      end
-
-      alias + merge
-    end
-  end
-end

data/spec/key_group_spec.rb

@@ -1,49 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-describe 'KeyGroup' do
-  def key_group(group, attr = {})
-    ::I18n::Tasks::KeyGroup.new(group, attr)
-  end
-
-  let!(:kg_attr) { { a: :b, x: '0' } }
-  let!(:kg) { key_group %w(a b), kg_attr }
-
-  it('#attr') { expect(kg.attr).to eq kg_attr }
-
-  it '#to_a' do
-    expect(kg.to_a).to eq [
-        {key: 'a'}.merge(kg_attr),
-        {key: 'b'}.merge(kg_attr)
-    ]
-  end
-
-  it '#merge' do
-    kg2_attr = {a: :b, x: '1', c: :d}
-    kg2 = key_group %w(c), kg2_attr
-    kg3 = key_group [{key: 'd', prop: true}]
-    expect([kg, kg2, kg3].reduce(:+).to_a).to eq [
-        {key: 'a'}.merge(kg_attr),
-        {key: 'b'}.merge(kg_attr),
-        {key: 'c'}.merge(kg2_attr),
-        {key: 'd', prop: true}
-    ]
-  end
-
-  it '#merge shared attr' do
-    kg2 = key_group %w(c d), kg_attr
-    expect((kg + kg2).keys[0].own_attr).to eq kg.keys[0].own_attr
-  end
-
-  it '#sort!' do
-    kg = key_group [{key: 'a', prop: '0'}, {key: 'b', prop: '1'}]
-    kg.sort! { |a, b| b[:prop] <=> a[:prop] }
-    expect(kg.keys[0][:prop]).to eq '1'
-  end
-
-  it '#sort_by_attr!' do
-    expect(key_group(%w(a b c)).tap { |kg|
-      kg.sort_by_attr!(key: :desc)
-    }.keys.map(&:key)).to eq %w(c b a)
-  end
-end