utusemi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3d9dc71891093baf91f418243e79cda7c2fde5e
+  data.tar.gz: 3c298928855391ac65f36f93b93c44226ba2b54a
+SHA512:
+  metadata.gz: f327281cc8a51c3f0c779bde5f78a0ad4f6f039102024df4dfc07d630a33161e7bba35a2cef9a0c444b78e46af2348a8d545d0df038ba08f4d6d2b641ff86e51
+  data.tar.gz: 721fb167c66338488ba3e136f981e8dddf4d699628a8fb0ad7d38117e41a2fce1562ae01209ffe848f843b44ee42bef328ffbde8ecbce6429a42dc605b277e0d

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# Utusemi
+
+[![Build Status](https://secure.travis-ci.org/hyoshida/utusemi.png)](http://travis-ci.org/hyoshida/utusemi)
+[![Code Climate](https://codeclimate.com/github/hyoshida/utusemi.png)](https://codeclimate.com/github/hyoshida/utusemi)
+[![Coverage Status](https://coveralls.io/repos/hyoshida/utusemi/badge.png)](https://coveralls.io/r/hyoshida/utusemi)
+[![Dependency Status](https://gemnasium.com/hyoshida/utusemi.svg)](https://gemnasium.com/hyoshida/utusemi)
+
+Providing a flexible alias for column names in ActiveRecord.
+
+
+## Installation
+
+1. Add utusemi in the `Gemfile`:
+
+  ```ruby
+  gem 'utusemi'
+  ```
+
+2. Download and install by running:
+
+  ```bash
+  bundle install
+  ```
+
+
+## Usage
+
+1. Create a file named `utusemi.rb` in `config/initializers` and add column names in this file.
+
+  ```ruby
+  Utusemi.configure do
+    map :sample do
+      name :first_name
+    end
+  end
+  ```
+
+2. Use `utusemi` method.
+
+  ```ruby
+  irb> User.utusemi(:sample).where(name: 'John')
+  SELECT "users".* FROM "users" WHERE "users"."first_name" = 'John'
+  ```
+
+
+## Requirements
+
+* Ruby on Rails 3.2, 4.1
+* Ruby 2.1
+
+
+## Development
+
+To set up a development environment, simply do:
+
+```bash
+bundle install
+bundle exec rake db:create
+bundle exec rake db:migrate
+bundle exec rake  # run the test suite
+```

data/Rakefile

@@ -0,0 +1,25 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Utusemi'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+task :rubocop do
+  exec 'rubocop'
+end
+
+task default: ['app:spec', 'rubocop']

data/lib/tasks/utusemi_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :utusemi do
+#   # Task goes here
+# end

data/lib/utusemi.rb

@@ -0,0 +1,62 @@
+require 'rails'
+
+require 'utusemi/definition'
+require 'utusemi/configuration'
+require 'utusemi/railtie'
+
+module Utusemi
+  class << self
+    def enable
+      this = self
+      ActiveSupport.on_load(:active_record) do
+        require 'utusemi/core'
+        # for instance
+        this.include_to_activerecord_base
+        # for model and relation
+        this.prepend_to_activerecord_base
+        this.prepend_to_activerecord_relation
+        this.prepend_to_activerecord_eigenclass
+        this.prepend_to_activerecord_associations_hasmanyassociation
+      end
+    end
+
+    def config
+      @configuration ||= Configuration.new
+    end
+
+    def configure(&block)
+      config.instance_eval(&block)
+    end
+
+    def include_to_activerecord_base
+      ActiveRecord::Base.send(:include, Core::InstanceMethods)
+    end
+
+    def prepend_to_activerecord_base
+      ActiveRecord::Base.send(:prepend, Core::ActiveRecord::Base)
+    end
+
+    def prepend_to_activerecord_relation
+      ActiveRecord::Relation.send(:prepend, Core::ActiveRecord::QueryMethods)
+      ActiveRecord::Relation.send(:prepend, Core::ActiveRecord::Relation)
+    end
+
+    def prepend_to_activerecord_eigenclass
+      activerecord_eigenclass.send(:prepend, Core::ActiveRecord::Querying)
+      # for rails 3.x
+      activerecord_eigenclass.send(:prepend, Core::ActiveRecord::RelationMethod) if Rails::VERSION::MAJOR == 3
+      # for association
+      activerecord_eigenclass.send(:prepend, Core::ActiveRecord::AssociationMethods)
+    end
+
+    def prepend_to_activerecord_associations_hasmanyassociation
+      ActiveRecord::Associations::HasManyAssociation.send(:prepend, Core::ActiveRecord::Associations)
+    end
+
+    private
+
+    def activerecord_eigenclass
+      ActiveRecord::Base.class_eval { class << self; self; end }
+    end
+  end
+end

data/lib/utusemi/configuration.rb

@@ -0,0 +1,26 @@
+module Utusemi
+  class Configuration
+    def initialize
+      @maps ||= {}
+    end
+
+    def map(name, *args, &block)
+      return map_get(name, *args) unless block_given?
+      options = args.shift if args.first.is_a? Hash
+      map_set(name, options, &block)
+    end
+
+    private
+
+    def map_set(name, options, &block)
+      @maps[name.to_sym] = (options || {}).merge(block: block)
+    end
+
+    def map_get(name, *args)
+      map = @maps[name.to_sym].try(:dup) if name
+      block = map.delete(:block) if map
+      definition = Definition.new(map)
+      definition.exec(*args, &block)
+    end
+  end
+end

data/lib/utusemi/core.rb

@@ -0,0 +1,343 @@
+module Utusemi
+  module Core
+    # 用途
+    #   モデル向けカラムマッパとインスタンス向けカラムマッパの共通処理
+    #
+    # 役割
+    #   モデル向けカラムマッパ => Utusemi::Core::ActiveRecord
+    #   インスタンス向けカラムマッパ => Utusemi::Core::InstanceMethods
+    #
+    # 備考
+    #   utusemiメソッドの第２引数は、任意のオプションをHashで指定する。
+    #   ただしoptions[:times]は予約済みで、指定した回数分だけmapメソッドを
+    #   繰り返し、options[:index]にイテレート中のカウントを返す。
+    #   また、その結果から複数のwhere条件を構築する。
+    #
+    module Base
+      def utusemi_values
+        @utusemi_values ||= {}
+      end
+
+      def utusemi(obj = nil, options = {})
+        clone.utusemi!(obj, options)
+      end
+
+      def utusemi!(obj = nil, options = {})
+        obj = true if obj.nil?
+        utusemi_values[:flag] = obj ? true : false
+        utusemi_values[:type] = obj.to_sym if obj.class.in? [Symbol, String]
+        utusemi_values[:options] = options
+        self
+      end
+
+      private
+
+      def utusemi_column_names(index = nil)
+        return {} unless utusemi_values[:flag]
+        options = utusemi_values[:options] || {}
+        options.update(index: index)
+        Utusemi.config.map(utusemi_values[:type], options).attributes
+      end
+
+      def mapped_utusemi_column_name(column_name, index = nil)
+        utusemi_column_names(index)[column_name.to_sym] || column_name
+      end
+
+      def unmapped_utusemi_column_name(column_name, index = nil)
+        utusemi_column_names(index).invert[column_name.to_sym] || column_name
+      end
+
+      def eigenclass
+        class << self; self; end
+      end
+    end
+
+    # 用途
+    #   Utusemi.config.mapに設定したマッピングを意識せずに実装できるよう、
+    #   デフォルト名による各カラムへのアクセスを可能にする
+    #
+    # 使用例
+    #   Utusemi.config do
+    #     map :product do
+    #       name :title
+    #     end
+    #   end
+    #
+    #   product = Product.first
+    #   product.name
+    #   #=> NoMethodError: undefined method `name' for #<Product:...>
+    #
+    #   product.utusemi(:product).name
+    #   #=> 'test product'
+    #
+    module InstanceMethods
+      include Base
+
+      def utusemi!(obj = nil, options = {})
+        super.tap { utusemi_columns_mapper if obj.class.in? [Symbol, String] }
+      end
+
+      def utusemi_columns_mapper
+        utusemi_column_names.keys.each do |column_name|
+          # alias_attributeと同じことを、対象カラム名を動的に変更して行う
+          define_getter_method(column_name)
+          define_setter_method(column_name)
+          define_predicate_method(column_name)
+          define_was_method(column_name)
+        end
+      end
+
+      def changed
+        return super unless utusemi_values[:flag]
+        super + super.map { |column_name| unmapped_utusemi_column_name(column_name).to_s }
+      end
+
+      private
+
+      def define_getter_method(column_name)
+        target_column_name = mapped_utusemi_column_name(column_name)
+        define_singleton_method(column_name) { send target_column_name }
+      end
+
+      def define_setter_method(column_name)
+        target_column_name = mapped_utusemi_column_name(column_name)
+        define_singleton_method("#{column_name}=") { |value| send "#{target_column_name}=", value }
+      end
+
+      def define_predicate_method(column_name)
+        target_column_name = mapped_utusemi_column_name(column_name)
+        define_singleton_method("#{column_name}?") { send "#{target_column_name}?" }
+      end
+
+      def define_was_method(column_name)
+        target_column_name = mapped_utusemi_column_name(column_name)
+        define_singleton_method("#{column_name}_was") { send "#{target_column_name}_was" }
+      end
+
+      def utusemi_for_association(name, association, options = {})
+        utusemi_values = self.utusemi_values
+        utusemi_values = self.class.utusemi_values unless utusemi_values[:flag]
+        utusemi_flag = utusemi_values[:flag] || options[:force]
+        return association unless utusemi_flag
+        association.utusemi!(name.to_s.singularize, utusemi_values[:options])
+      end
+    end
+
+    # 用途
+    #   whereなどのArelチェインにおいて、Utusemi.config.mapに設定したマッピングを
+    #   意識せずに実装できるよう、デフォルト名による各カラムへのアクセスを可能にする
+    #
+    # 使用例
+    #   Product.utusemi(:product).where(name: "test")
+    #   #=> [<products.titleが"test"であるレコード>]
+    #
+    module ActiveRecord
+      module Querying
+        include Base
+
+        case Rails::VERSION::MAJOR
+        when 4
+          delegate :utusemi, to: :all
+        when 3
+          delegate :utusemi, to: :scoped
+        end
+      end
+
+      module QueryMethods
+        include Base
+
+        def utusemi!(obj = nil, options = {})
+          super.tap { warning_checker unless Rails.env.production? }
+        end
+
+        def build_where(opts = :chain, *rest)
+          return super unless utusemi_values[:flag]
+          if utusemi_values[:options][:times]
+            opts_with_times(opts, utusemi_values[:options][:times]) { |opts_with_mapped| super(opts_with_mapped, *rest) }
+          else
+            super(opts_with_mapped_column_name(opts), *rest)
+          end
+        end
+
+        def order(opts = nil, *rest)
+          opts = opts_with_mapped_column_name(opts) if utusemi_values[:flag]
+          super
+        end
+
+        private
+
+        def opts_with_times(opts, times)
+          1.upto(times).map do |index|
+            yield opts_with_mapped_column_name(opts, index)
+          end
+        end
+
+        def opts_with_mapped_column_name(opts, index = nil)
+          case opts
+          when Hash
+            key_values = opts.map { |key, value| [mapped_utusemi_column_name(key.to_s, index), value] }.flatten(1)
+            Hash[*key_values]
+          when String, Symbol
+            mapped_column_names_for_string(opts.to_s, index)
+          else
+            opts
+          end
+        end
+
+        def mapped_column_names_for_string(string, index = nil)
+          utusemi_column_names(index).each do |old_column_name, new_column_name|
+            string.gsub!(/\b#{old_column_name}\b/, new_column_name.to_s)
+          end
+          string
+        end
+
+        def warning_checker
+          utusemi_column_names.each do |old_column_name, new_column_name|
+            return if old_column_name != new_column_name
+            Rails.logger.warn "[Utusemi:WARNING] #{old_column_name} is duplicated in Utusemi::Engine.config.#{utusemi_values[:type]}_columns."
+          end
+        end
+      end
+
+      # Rails 3.x で scope に対してのカラムマッピングが正常に動作するようにするためのもの
+      #
+      # 原因
+      #   scope 内の条件が unscoped { ... } 内で実行されるため、カラムマッピングを実施する為のフラグが
+      #   引き継がれず、カラムマッピングが作動しない
+      #
+      # 対策
+      #   scope メソッドでは unscoped { ... } の結果を Relation.new として再生成しているので
+      #   relation メソッドを利用した際にカラムマッピング実施フラグがあればこれを継承するようにした
+      #
+      module RelationMethod
+        def relation(*args, &block)
+          return super unless current_scope
+          return super unless current_scope.utusemi_values
+          return super unless current_scope.utusemi_values[:flag]
+          super.utusemi(current_scope.utusemi_values[:type], utusemi_values[:options])
+        end
+      end
+
+      module Relation
+        # 用途
+        #   utusemiメソッドを利用してレコードを検索した場合は
+        #   Utusemi::Core#utusemiを個別呼び出さなくても済むようになる
+        #
+        # 使用例
+        #   product = Product.utusemi(:product).where(name: 'test').first
+        #   product.utusemi(:product).name
+        #   #=> 'test' (= products.title)
+        #
+        #   こうなっていたコードが以下のようになる
+        #
+        #   product = Product.utusemi(:product).where(name: 'test').first
+        #   product.name
+        #   #=> true (= products.title)
+        #
+        def to_a
+          utusemi_values = self.utusemi_values
+          utusemi_values = @klass.utusemi_values unless utusemi_values[:flag]
+          return super unless utusemi_values[:flag]
+          super.each { |record| record.utusemi!(utusemi_values[:type], utusemi_values[:options]) }
+        end
+      end
+
+      module Base
+        # 用途
+        #   utusemiメソッドを利用後にレコードを作成した場合は
+        #   Utusemi::Core#utusemiを個別呼び出さなくても済むようになる
+        #
+        # 使用例
+        #   product = Product.utusemi(:product).new(name: 'test')
+        #   product.name
+        #   #=> 'test' (= products.title)
+        #
+        def initialize(*args, &block)
+          case Rails::VERSION::MAJOR
+          when 4
+            current_scope = self.class.current_scope
+          when 3
+            current_scope = self.class.scoped
+          end
+          utusemi_values = current_scope.try(:utusemi_values) || {}
+          utusemi_values = self.class.utusemi_values unless utusemi_values[:flag]
+          utusemi!(utusemi_values[:type], utusemi_values[:options]) if utusemi_values[:flag]
+          super
+        end
+      end
+
+      # 用途
+      #   関連モデルにカラムマッパを継承する
+      #
+      # 使用例
+      #   class Product
+      #     has_many :stocks, utusemi: true
+      #     ...
+      #   end
+      #   stock = Product.utusemi(:product).stocks.first
+      #   stock.quantity
+      #   #=> 10 (= stocks.units)
+      #
+      module Associations
+        def scope(*args)
+          utusemi_values = owner.utusemi_values
+          return super unless utusemi_values[:flag]
+          super.utusemi!(@reflection.name.to_s.singularize, utusemi_values[:options])
+        end
+      end
+
+      module AssociationMethods
+        def belongs_to(name, scope = nil, options = {})
+          check_deplicated_association_warning(:belongs_to, name, scope)
+          utusemi_flag = scope.try(:delete, :utusemi)
+          scope = utusemi_association_scope(:belongs_to, name, scope) if utusemi_flag
+          super if !utusemi_flag || !method_defined?(name)
+          define_utusemi_association_reader(name, utusemi_flag => true)
+        end
+
+        def has_one(name, scope = nil, options = {})
+          check_deplicated_association_warning(:has_one, name, scope)
+          utusemi_flag = scope.try(:delete, :utusemi)
+          scope = utusemi_association_scope(:has_one, name, scope) if utusemi_flag
+          super if !utusemi_flag || !method_defined?(name)
+          define_utusemi_association_reader(name, utusemi_flag => true)
+        end
+
+        def has_many(name, scope = nil, options = {}, &extension)
+          check_deplicated_association_warning(:has_many, name, scope)
+          utusemi_flag = scope.try(:delete, :utusemi)
+          scope = utusemi_association_scope(:has_many, name, scope) if utusemi_flag
+          super if !utusemi_flag || !method_defined?(name)
+          define_utusemi_association_reader(name, utusemi_flag => true)
+        end
+
+        private
+
+        def check_deplicated_association_warning(association_type, name, scope)
+          return unless method_defined?(name)
+          return unless method_defined?("#{name}_with_utusemi")
+          return if scope.try(:[], :utusemi)
+          Rails.logger.warn "[Utusemi:WARNING] \"#{association_type} :#{name}\" is duplicated in #{self.name}."
+        end
+
+        def utusemi_association_scope(method_name, name, scope = {})
+          utusemi_map = Utusemi.config.map(name.to_s.singularize)
+          default_scope = { class_name: utusemi_map.class_name }
+          default_scope[:foreign_key] = utusemi_map.foreign_key if method_name == :belongs_to
+          default_scope.merge(scope)
+        end
+
+        def define_utusemi_association_reader(name, options = {})
+          return if method_defined?("#{name}_with_utusemi")
+          define_method "#{name}_with_utusemi" do |*args|
+            association = send("#{name}_without_utusemi", *args)
+            return unless association
+            return association unless association.is_a? ActiveRecord::Base
+            utusemi_for_association(name, association, options)
+          end
+          alias_method_chain name, :utusemi
+        end
+      end
+    end
+  end
+end

data/lib/utusemi/definition.rb

@@ -0,0 +1,39 @@
+module Utusemi
+  class Definition
+    UNPROXIED_METHODS = %w(__send__ __id__ nil? send object_id extend instance_eval initialize block_given? raise caller method instance_exec)
+    OPTION_METHODS = %w(class_name foreign_key)
+
+    (instance_methods + private_instance_methods).each do |method|
+      undef_method(method) unless UNPROXIED_METHODS.include?(method.to_s)
+    end
+
+    OPTION_METHODS.each do |method|
+      define_method(method) { @options[method.to_sym] }
+    end
+
+    attr_reader :attributes
+
+    def initialize(options = {})
+      @attributes = {}
+      @options = options
+    end
+
+    def exec(*args, &block)
+      instance_exec(*args, &block) if block_given?
+      self
+    end
+
+    def method_missing(name, *args)
+      add_attribute(name, *args)
+    end
+
+    private
+
+    def add_attribute(name, value = nil)
+      fail AttributeDefinitionError, 'Block given' if block_given?
+      @attributes[name.to_sym] = value.to_sym
+    end
+  end
+
+  class AttributeDefinitionError; end
+end

data/lib/utusemi/railtie.rb

@@ -0,0 +1,7 @@
+module Utusemi
+  class Railtie < ::Rails::Railtie
+    initializer 'utusemi.initializer' do
+      Utusemi.enable
+    end
+  end
+end

data/lib/utusemi/version.rb

@@ -0,0 +1,3 @@
+module Utusemi
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: utusemi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- YOSHIDA Hiroki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Providing a flexible alias for column names in ActiveRecord.
+email:
+- hyoshida@appirits.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/tasks/utusemi_tasks.rake
+- lib/utusemi.rb
+- lib/utusemi/configuration.rb
+- lib/utusemi/core.rb
+- lib/utusemi/definition.rb
+- lib/utusemi/railtie.rb
+- lib/utusemi/version.rb
+homepage: https://github.com/hyoshida/utusemi#utusemi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Providing a flexible alias for column names in ActiveRecord.
+test_files: []