rails_dictionary 0.2.3 → 0.3.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: a3cc435df2a7cdf214af4e1843755b3c56b56edc2680fe644a8f38a991236567
-  data.tar.gz: 573815dc3115fc14232cbf0cca60c2fd3721f4676ff68a87541abf465a68f1f1
+SHA1:
+  metadata.gz: 309d2e3ca49c9e564523d61307014d44987b7561
+  data.tar.gz: e6ea71c9fc377893c23883a0a0f08d001bc2f328
 SHA512:
-  metadata.gz: cb51afd93704440a426dee3e366ca80912c578be74836466afe7d3d567fd5880fff2fa99de4d9dd0f9fc988566e96b34be0e0ef2498ac173ae85232fa71f835f
-  data.tar.gz: 04c1f6992583f8b9d76675d912a4fb9cc5068b1254d928fc07ad92bb77df616d212d8d4041fc3563b313da1abbe6a9f52a2343e411992e3d595987525d9f560b
+  metadata.gz: 0daca999ef3ad0ff8888e5e2ca7ae85fe81bbc62c5e1a7c696f51f7d904eeb5bb985200a471306efb75f5c4ce3e599b5cd2e57513f07ef7d1a95f26294b0acef
+  data.tar.gz: 987fdd01ad2d98bb9a211eda4aed92cedbe9469f4cfaf7a1d6b6803a52f41315ba9c4239e43826a620fb7d289fcc9c53dd206942db0f6f60ccd25ebe206f9d54

data/CHANGELOG

@@ -1,3 +1,7 @@
+0.3.1
+  Replace rspec with minitest.
+  Replace dict_types with STI.
+
 0.2
   Add Support For Rails4
 

data/Gemfile

@@ -4,8 +4,7 @@ source "http://rubygems.org"
 gemspec
 
 group :development,:test do
-  gem 'rspec'
+  gem 'minitest'
   gem 'byebug'
-  gem "rspec-rails"
   gem 'sqlite3'
 end

data/{README.rdoc → README.v2.0.rdoc}

@@ -1,6 +1,3 @@
-= Plan
-Working on sti branch will target to 0.3 version which will not compatible with 0.1 and 0.2
-
 = Intro
 There are always some static data(not static page) in application.For example product type or student diploma type.
 
@@ -29,7 +26,7 @@ See change log for brief info.
 == Sample
 Run following task will give you a simple start.Maybe you should try it in a new application first.
     rake dicts:generate
-    rake dicts:sample_slave
+    rake dicts:sample_consumer
     rake db:migrate
     rake dicts:sample_data
 These task are just generate table dictionaries,dict_types,students and some sample data.The data should be
@@ -80,7 +77,7 @@ Here is what should be like.Student model can be other models.
       end
 
       class Student < ActiveRecord::Base
-        # use acts_as_dict_slave when your rails_dictionary version < 0.2
+        # use acts_as_dict_consumer when your rails_dictionary version < 0.2
         acts_as_dict_consumer
       end
 

data/Rakefile

@@ -5,6 +5,7 @@ task :default => [:test]
 
 desc "Running Test"
 task :test do
-  # system "ruby -I . test/rails_dictionary_test.rb " # used with version 0.0.8 or before it
-  system "rspec spec/rails_dictionary_spec.rb"
+  system 'ruby test/rails_dictionary_test.rb'
+  system 'ruby test/acts_as_consumer_test.rb'
+  system 'ruby test/lookup_test.rb'
 end

data/Readme.md

@@ -0,0 +1,10 @@
+## Usage
+
+Version 0.3 is not backward compatible!!
+Only for version 0.3.
+
+See [README.rdoc](https://github.com/raykin/rails_dictionary/blob/sti/README.v2.0.rdoc) for version 0.2.
+
+### Changes from 0.2 to 0.3
+
+Locale feature removed. Please use i18n.

data/lib/rails_dictionary/models/active_record_extension.rb

@@ -5,44 +5,34 @@ module RailsDictionary
     end
 
     module ClassMethods
-      # TODO: move macro define in each module file
-      # See Usage in readme.doc.
-      def acts_as_dict_type
-
-        has_many :dictionaries
-        validates_uniqueness_of :name
-        after_save :delete_all_caches
-        after_destroy :delete_all_caches
-
-        include RailsDictionary::ActsAsDictType
-      end
 
       def acts_as_dictionary
-
-        belongs_to :dict_type
-        after_save :delete_dicts_cache
-        after_destroy :delete_dicts_cache
-        scope :dict_type_name_eq, lambda { |name| joins(:dict_type).where("dict_types.name" => name) }
-
-        include RailsDictionary::ActsAsDictionary
+        include ActsAsDictionary
+        validates_uniqueness_of :name, scope: [inheritance_column]
       end
 
-      # Ex: acts_as_dict_slave :add => :category
-      # :except - remove dict mapping column
-      # :add - add dict mapping column
-      # :locale - add and initialize class attribute default_dict_locale
-      def acts_as_dict_slave(ops={})
-        include RailsDictionary::ActsAsDictSlave
-        class_attribute :default_dict_locale, :instance_writer => false
-        cattr_accessor :dict_mapping_columns, :instance_writer => false
-        self.default_dict_locale = ops[:locale] if ops[:locale]
-        self.dict_mapping_columns = dict_columns(ops)
-        unless dict_mapping_columns.nil?
-          add_dynamic_column_method
+      # Ex: acts_as_dict_consumer on: :city
+      #
+      # on:         - add dict mapping columns, can be string or array of string
+      # relation_type: - belongs_to/many_to_many, default is belongs_to. has_many Not supported yet
+      # class_name: - Dictionary class name
+      # locale:     - add and initialize class attribute default_dict_locale
+      def acts_as_dict_consumer(opts={})
+        include ActsAsDictConsumer
+        case opts[:on]
+        when Array
+          opts[:on].each do |on_value|
+            build_dict_relation(opts.merge(on: on_value))
+          end
+        when String, Symbol
+          build_dict_relation(opts)
+        else
+          raise TypeError, 'Wrong value of params on'
         end
       end
 
-      alias_method :acts_as_dict_consumer, :acts_as_dict_slave
     end
   end
 end
+
+::ActiveRecord::Base.send :include, RailsDictionary::ActiveRecordExtension

data/lib/rails_dictionary/models/acts_as_dict_consumer.rb

@@ -0,0 +1,77 @@
+module RailsDictionary
+  module ActsAsDictConsumer
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Generate dynamic instance method named_column to consumer model
+      # def named_city(locale=nil)
+      #   locale = locale.presence || default_dict_locale.presence || :en
+      #   locale = "name_#{locale}"
+      #   self.send(city_dict).try(:send,locale)
+      # end
+      # alias_method :city_name, :named_city
+      # def named_dict_value(method_name)
+      #   belongs_to_name="#{method_name}_dict".to_sym
+      #   origin_method_name = method_name
+      #   method_name="named_#{method_name}"
+      #   define_method(method_name) do | locale=nil |
+      #     locale = locale.presence || default_dict_locale.presence || :en
+      #     locale = "name_#{locale}"
+      #     self.send(belongs_to_name).try(:send,locale)
+      #   end
+      #   alias_method "#{origin_method_name}_name".to_sym, method_name.to_sym
+      # end
+
+      # Build dynamic method column_name= to the consumer model
+      #
+      # ex:
+      #   def city_name=(value, options = {})
+      #     send "city=", dictionary_obj
+      #   end
+      def dict_name_equal
+        relation_name = @dict_relation_name
+        relation_type = @dict_relation_type
+        method_name = "#{relation_name}_name="
+        class_opt = @opt
+        define_method(method_name) do |value, options={}|
+          dicts = RailsDictionary.dclass.where(name: Array(value), type: class_opt[:class_name])
+          if dicts
+            if relation_type == :belongs_to
+              send "#{relation_name}=", dicts.first
+            elsif relation_type == :many_to_many
+              send "#{relation_name}=", dicts.map(&:id)
+            else
+              raise "Wrong relation method name: #{relation_type}"
+            end
+          else
+            # do nothing ?
+          end
+        end
+      end
+
+      # dont think instance var is a good sollution
+      # cause the consumer class will include other lib too
+      def build_dict_relation(opt)
+        @opt = opt
+        @dict_relation_name = @opt.delete :on
+        raise 'params on cant be nil' if @dict_relation_name.nil?
+        @dict_relation_type = @opt.delete(:relation_type) || :belongs_to
+        # @opt[:foreign_key] ||= "#{@dict_relation_name}_id"
+        @opt[:class_name] ||= "#{RailsDictionary.config.dictionary_klass}::#{@dict_relation_name.to_s.singularize.camelize}"
+        ::RailsDictionary.init_dict_sti_class(@opt[:class_name])
+        if @dict_relation_type.to_sym == :belongs_to
+          send @dict_relation_type, @dict_relation_name, @opt
+        elsif @dict_relation_type.to_sym == :many_to_many
+          # no code required?
+          # build_many_to_many_dict_relation
+        end
+        dict_name_equal
+      end
+
+    end # END ClassMethods
+
+  end
+end

data/lib/rails_dictionary/models/acts_as_dictionary.rb

@@ -2,83 +2,24 @@ module RailsDictionary
   module ActsAsDictionary
     def self.included(base)
       base.extend(ClassMethods)
-      base.send :include,InstanceMethods
+      base.send :include, InstanceMethods
     end
 
     module ClassMethods
 
-      # For rails3
-      # I thought it would be better to define a method in method_missing, Not just generate cache.
-      #   Cause cache can not store ActiveRecord
-      # Generate methods like Dictionary.student_city
-      #   Dictionary.student_city - a list of dictionary object which dict type is student_city
-      #   Dictionary.student_city(:locale => :zh) - a select format array which can be used
-      #   in view method select as choice params
-      # Programmer DOC && TODO:
-      #   rethink about the cache.
-      #   cache methods like Dictionary.student_city(:locale => :zh,:sort => :name_fr)
-      #   but not cache Dictionary.student_city, return it as relation
-      #
-      #   Remove nil noise,if listed_attr =[[nil, 201], [nil, 203], [nil, 202], ["Sciences", 200]]
-      #   the sort would be failed of ArgumentError: comparison of Array with Array failed
-      #   split this method ,make it more short and maintainance
-      def method_missing(method_id,options={})
-        if DictType.all_types.include? method_id
-          method_name=method_id.to_s.downcase
-          # TODO: If cache engine is failed, then the code will failed with null cant dup
-          Rails.cache.fetch("Dictionary.#{method_name}") { dict_type_name_eq(method_name).to_a }
-          listed_attr=Rails.cache.read("Dictionary.#{method_name}").dup  # Instance of ActiveRecord::Relation can not be dup?
-          build_scope_method(method_id)
-          if options.keys.include? :locale or options.keys.include? "locale"
-            locale="name_#{ options[:locale] }"
-            sort_block=sort_dicts(options)
-            listed_attr.sort!(&sort_block) if sort_block
-            listed_attr.map! { |a| [a.send(locale),a.id] }.reject! {|ele| ele.first.nil?}
-          end
-          listed_attr
-        else
-          super
-        end
-      end
-
-      # Override this method to get customed sort block
-      def sort_dicts(options)
-        if options.keys.include? :locale or options.keys.include? "locale"
-          locale="name_#{ options[:locale] }"
-          if options[:locale].to_sym == :zh
-            Proc.new { |a,b| a.send(locale).encode('GBK') <=> b.send(locale).encode('GBK') }
-          else
-            Proc.new { |a,b| a.send(locale).downcase <=> b.send(locale).downcase }
-          end
-        else
-          false
-        end
-      end
-
-      def respond_to?(name, include_private=false)
-        DictType.all_types.include?(name) || super
-      end
-
-      private
-
-      def build_scope_method(name)
-        scope_method_name = "scoped_#{name}".to_sym
-        unless respond_to? scope_method_name
-          define_singleton_method scope_method_name do
-            # see http://stackoverflow.com/questions/18198963/with-rails-4-model-scoped-is-deprecated-but-model-all-cant-replace-it
-            # for usage of where(nil)
-            dict_type_name_eq(name).where(nil)
-          end
-        end
+      # override to make sure STI class init first
+      def new(opts)
+        type_opt = opts.with_indifferent_access[inheritance_column]
+        RailsDictionary.init_dict_sti_class(type_opt) if type_opt
+        super
       end
 
     end # End ClassMethods
 
     module InstanceMethods
-      def delete_dicts_cache
-        method_name=DictType.revert(self.dict_type_id)
-        Rails.cache.delete("Dictionary.#{method_name}")
-        return true
+      def type=(name)
+        ::RailsDictionary.init_dict_sti_class(name)
+        super
       end
     end # End InstanceMethods
 

data/lib/rails_dictionary/version.rb

@@ -1,3 +1,3 @@
 module RailsDictionary
-  VERSION = "0.2.3"
+  VERSION = "0.3-rc1"
 end

data/lib/rails_dictionary.rb

@@ -1,10 +1,33 @@
-require File.join(File.dirname(__FILE__), "rails_dictionary/array_core_ext")
 require File.join(File.dirname(__FILE__), "rails_dictionary/models/active_record_extension")
-require File.join(File.dirname(__FILE__), "rails_dictionary/models/acts_as_dict_type")
 require File.join(File.dirname(__FILE__), "rails_dictionary/models/acts_as_dictionary")
-require File.join(File.dirname(__FILE__), "rails_dictionary/models/acts_as_dict_slave")
+require File.join(File.dirname(__FILE__), "rails_dictionary/models/acts_as_dict_consumer")
 
 # rake tasks not autoload in Rails4
-Dir[File.expand_path('../tasks/**/*.rake',__FILE__)].each { |ext| load ext } if defined?(Rake)
+# todo: may add migration(from 0.2 to 0.3) task
+# Dir[File.expand_path('../tasks/**/*.rake',__FILE__)].each { |ext| load ext } if defined?(Rake)
 
-::ActiveRecord::Base.send :include, RailsDictionary::ActiveRecordExtension
+module RailsDictionary
+
+  def self.config
+    Config.instance
+  end
+
+  class Config < Struct.new(:dictionary_klass, :defined_sti_klass)
+    include Singleton
+  end
+
+  config.dictionary_klass = :Dictionary
+  config.defined_sti_klass = []
+
+  def self.dclass
+    @dclass ||= config.dictionary_klass.to_s.constantize
+  end
+
+  def self.init_dict_sti_class(klass)
+    unless config.defined_sti_klass.include?(klass) || Module.const_defined?(klass)
+      subklass = klass.sub "#{config.dictionary_klass}::", ''
+      dclass.const_set subklass, Class.new(dclass)
+      config.defined_sti_klass.push(klass)
+    end
+  end
+end

data/lib/tasks/dicts.rake

@@ -2,20 +2,22 @@
 namespace :dicts do
   desc "Generate dictionary and dict_type model"
   task :generate do
-    system "rails g model dictionary name_en:string name_zh:string name_fr:string dict_type_id:integer"
-    system "rails g model dict_type name:string"
+    system "rails g model dictionary name_en name_zh name_fr type"
   end
+
   desc "Generate student model"
-  task :sample_slave do
+  task :sample_consumer do
     system "rails g model student email:string city:integer school:integer"
   end
+
   desc "Generate sample data for rails_dictionary gem"
   task :sample_data => [:environment] do
-    @dt_stu_city=DictType.create! :name => "student_city"
-    @dt_stu_school=DictType.create! :name => "student_school"
-    @dy_shanghai=Dictionary.create! name_en: "shanghai",name_zh: "上海",name_fr: "shanghai",dict_type_id: @dt_stu_city.id
-    @dy_beijing=Dictionary.create! name_en: "beijing",name_zh: "北京",name_fr: "Pékin",dict_type_id: @dt_stu_city.id
-    @stu_beijing=Student.create! email: "beijing@dict.com",city: @dy_beijing.id
-    @stu_shanghai=Student.create! email: "shanghai@dict.com",city: @dy_shanghai.id
+    # @dt_stu_city=DictType.create! name: "student_city"
+    # @dt_stu_school=DictType.create! name: "student_school"
+    @dy_shanghai=Dictionary.create! name_en: "shanghai", name_zh: "上海", name_fr: "shanghai", dict_type_id: @dt_stu_city.id
+    @dy_beijing=Dictionary.create! name_en: "beijing", name_zh: "北京", name_fr: "Pékin", dict_type_id: @dt_stu_city.id
+    @stu_beijing=Student.create! email: "beijing@dict.com", city: @dy_beijing.id
+    @stu_shanghai=Student.create! email: "shanghai@dict.com", city: @dy_shanghai.id
   end
+
 end

data/rails_dictionary.gemspec

@@ -14,9 +14,10 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "rails_dictionary"
 
   s.add_runtime_dependency 'rails', '> 4.0'
+  s.add_runtime_dependency 'database_cleaner'
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.test_files    = `git ls-files -- {test}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 end

data/test/acts_as_consumer_test.rb

@@ -0,0 +1,44 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+class TestConsumer < TestSupporter
+
+end
+
+class TestConsumeOneColumn < TestConsumer
+  def setup
+    super
+    Student.acts_as_dict_consumer on: :city
+  end
+
+  def test_student_should_has_method_city
+    assert Student.new.respond_to?(:city), 'student should has method city'
+    assert Student.new.respond_to?(:create_city), 'student should has method create_city'
+    assert_includes RailsDictionary.config.defined_sti_klass, 'Dictionary::City'
+  end
+
+  def test_dictionary_city_class_exist
+    assert Dictionary.const_defined?('City'), 'Dictionary::City should be defined'
+    assert_includes RailsDictionary.config.defined_sti_klass, 'Dictionary::City'
+  end
+end
+
+class TestConsumeMultipleColumns < TestConsumer
+
+  def setup
+    super
+    Student.acts_as_dict_consumer on: [:city, :school]
+  end
+
+  def test_student_should_has_method_city
+    assert Student.new.respond_to?(:city), 'student should has method city'
+    assert Student.new.respond_to?(:create_city), 'student should has method create_city'
+    assert Student.new.respond_to?(:school), 'student should has method city'
+    assert Student.new.respond_to?(:create_school), 'student should has method city'
+  end
+
+  def test_dictionary_city_and_schoold_exist
+    assert Dictionary.const_defined?('City'), 'Dictionary::City should be defined'
+    assert Dictionary.const_defined?('School'), 'Dictionary::City should be defined'
+    assert_equal(['Dictionary::City', 'Dictionary::School'], RailsDictionary.config.defined_sti_klass)
+  end
+end

data/test/fake_app.rb

@@ -0,0 +1,40 @@
+# database
+ActiveRecord::Base.configurations = {'test' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection(:test)
+
+# config
+app = Class.new(Rails::Application)
+app.config.active_support.deprecation = :log
+app.config.eager_load = false
+app.initialize!
+
+class Dictionary < ActiveRecord::Base
+  acts_as_dictionary
+end
+
+class Student < ActiveRecord::Base
+end
+
+class Lookup < ActiveRecord::Base
+end
+
+#migrations
+class CreateAllTables < ActiveRecord::Migration
+  def self.up
+    create_table(:dictionaries) {|t| t.string :name; t.string :type}
+    create_table(:students) do |t|
+      t.string :email
+      t.integer :city_id
+      t.integer :school_id
+      t.text :major_array
+      t.text :majors
+    end
+    create_table(:lookups) { |t| t.string :name; t.string :type }
+  end
+
+  def self.down
+    drop_table :dictionaries
+    drop_table :students
+    drop_table :lookups
+  end
+end

data/test/lookup_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+module TestLookup
+
+  class TestAsDictionary < TestSupporter
+
+    def prepare_data
+      @art = Lookup.create!(name: 'art', type: 'Lookup::Major')
+      @math = Lookup.create!(name: 'math', type: 'Lookup::Major')
+    end
+
+    def setup
+      RailsDictionary.config.dictionary_klass = :Lookup
+      Lookup.acts_as_dictionary
+      super
+    end
+
+    def test_lookup
+      prepare_data
+      assert Lookup, Lookup::Major.superclass
+    end
+
+    def test_student_major_array
+      Student.acts_as_dict_consumer on: :major_array, relation_type: :many_to_many, class_name: 'Lookup::Major'
+      prepare_data
+      s = Student.new(major_array_name: ['art', 'math'])
+      s.save!; s.reload
+      assert_equal([@art.id, @math.id], s.major_array)
+    end
+
+    def test_student_with_majors
+      Student.acts_as_dict_consumer on: :majors, relation_type: :many_to_many
+      prepare_data
+      s = Student.new(majors_name: ['art', 'math'])
+      s.save!; s.reload
+      assert_equal([@art.id, @math.id], s.majors)
+    end
+  end
+end

data/test/rails_dictionary_test.rb

@@ -0,0 +1,81 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+
+class TestRailsDictionary < TestSupporter
+
+  class TestActiveRecordExtension < TestRailsDictionary
+    [:acts_as_dictionary, :acts_as_dict_consumer].each do |method_name|
+      define_method "test_#{method_name}_exists_ar" do
+        assert_includes ActiveRecord::Base.methods, method_name
+      end
+    end
+  end
+
+  class PreTestDatabase < TestRailsDictionary
+
+    def test_no_dictionary_data_exist_before
+      assert_equal 0, Dictionary.count, 'dicionaries table should be blank'
+    end
+  end
+
+  class TestInitSubDictClass < TestRailsDictionary
+    def setup
+      super
+      if Dictionary.const_defined? 'City'
+        Dictionary.send :remove_const, 'City'
+        RailsDictionary.config.defined_sti_klass.delete('Dictionary::City')
+      end
+    end
+
+    def test_dictionary_city_class_when_create_dictionary
+      @shanghai = Dictionary.create!(name: "shanghai", type: 'Dictionary::City')
+      assert Dictionary, Dictionary::City.superclass
+    end
+
+    def test_dictionary_city_class_when_assign_type
+      beijing = Dictionary.new(name: 'beijing')
+      beijing.type = 'Dictionary::City'
+      beijing.save!
+      assert Dictionary, Dictionary::City.superclass
+    end
+
+    def test_dictionary_city_class_when_assign_type_in_new
+      beijing = Dictionary.new(name: 'beijing', type: 'Dictionary::City')
+      beijing.save!
+      assert Dictionary, Dictionary::City.superclass
+    end
+
+  end
+end
+
+class TestWithDB < TestRailsDictionary
+  def setup
+    super
+    Dictionary.acts_as_dictionary
+    @beijing, @shanghai = prepare_city_data
+
+    @stu_beijing = Student.create! email: "beijing@dict.com", city_id: @shanghai.id
+    @stu_shanghai = Student.create! email: "shanghai@dict.com", city_id: @shanghai.id
+  end
+end
+
+class TestStudent < TestWithDB
+  def setup
+    super
+    Student.acts_as_dict_consumer on: [:city]
+  end
+
+  def test_city_name_equal_to_exist_dictionary_name
+    assert_equal 1, Dictionary.where(name: "beijing").count
+    @stu_shanghai.update_attributes city_name: "beijing"
+    assert_equal 'beijing', @stu_shanghai.reload.city.name
+    assert_equal 1, Dictionary.where(name: "beijing").count
+  end
+
+  def create_a_student_with_shanghai_city
+    s = Student.create(city_name: "shanghai")
+    s.reload
+    s.city.name.should == "shanghai"
+    assert_equal Dictionary.find_by(name: 'shanghai').id, s.city_id
+    assert_equal 1, Dictionary.where(name: "shanghai").count
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+# copy and modify the test design of kaminari(a paginate gem for Rails3)
+RAILS_ENV = 'test'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'byebug'
+require 'rack/test'
+require 'rails'
+require 'active_record'
+require 'rails_dictionary'
+
+ActiveRecord::Migration.verbose = false
+
+require File.join(File.dirname(__FILE__), 'fake_app')
+
+CreateAllTables.up unless ActiveRecord::Base.connection.table_exists? 'dictionaries'
+
+Student.serialize :major_array, Array
+Student.serialize :majors, Array
+
+require 'minitest/autorun'
+require 'database_cleaner'
+
+DatabaseCleaner.strategy = :truncation
+
+class TestSupporter < Minitest::Test
+  def setup
+    DatabaseCleaner.clean
+  end
+
+  def prepare_city_data
+    [
+     Dictionary.create!(name: 'beijing', type: 'Dictionary::City'),
+     Dictionary.create!(name: 'shanghai', type: 'Dictionary::City')
+    ]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_dictionary
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.pre.rc1
 platform: ruby
 authors:
 - Raykin Lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-24 00:00:00.000000000 Z
+date: 2015-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,20 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Rails plugin for mapping static data of web application to Dictionary
   class
 email:
@@ -35,20 +49,21 @@ files:
 - ".gitignore"
 - CHANGELOG
 - Gemfile
-- README.rdoc
+- README.v2.0.rdoc
 - Rakefile
+- Readme.md
 - lib/rails_dictionary.rb
-- lib/rails_dictionary/array_core_ext.rb
 - lib/rails_dictionary/models/active_record_extension.rb
-- lib/rails_dictionary/models/acts_as_dict_slave.rb
-- lib/rails_dictionary/models/acts_as_dict_type.rb
+- lib/rails_dictionary/models/acts_as_dict_consumer.rb
 - lib/rails_dictionary/models/acts_as_dictionary.rb
 - lib/rails_dictionary/version.rb
 - lib/tasks/dicts.rake
 - rails_dictionary.gemspec
-- spec/fake_app.rb
-- spec/rails_dictionary_spec.rb
-- spec/spec_helper.rb
+- test/acts_as_consumer_test.rb
+- test/fake_app.rb
+- test/lookup_test.rb
+- test/rails_dictionary_test.rb
+- test/test_helper.rb
 homepage: https://github.com/raykin/rails_dictionary
 licenses: []
 metadata: {}
@@ -63,15 +78,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.1
+rubyforge_project: rails_dictionary
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: dictionary data for web application
-test_files:
-- spec/fake_app.rb
-- spec/rails_dictionary_spec.rb
-- spec/spec_helper.rb
+test_files: []
+has_rdoc: 

data/lib/rails_dictionary/array_core_ext.rb

@@ -1,13 +0,0 @@
-class Array
-  # Return a hash by compare two arrays
-  def extract_to_hash(keys_array)
-    ret_hash={}
-    keys_array.each {|ky| ret_hash[ky.to_sym]=[]}
-    self.each do |sf|
-      keys_array.each do |ky|
-        ret_hash[ky.to_sym] << sf.sub("#{ky}_","") if sf =~ Regexp.new("^#{ky}_")
-      end
-    end
-    ret_hash.reject { |k,v| v.blank? }
-  end
-end

data/lib/rails_dictionary/models/acts_as_dict_slave.rb

@@ -1,88 +0,0 @@
-module RailsDictionary
-  module ActsAsDictSlave
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-
-      # return columns that exist in DictType#tab_and_column
-      def columns_in_dict_type
-        if ActiveRecord::VERSION::STRING < '3.1'
-          DictType.tab_and_column[self.name.underscore.to_sym]
-        elsif DictType.table_exists?
-          DictType.tab_and_column[self.name.underscore.to_sym]
-        else
-          []
-        end
-      end
-
-      # columns which map to dictionary
-      def dict_columns(ops={})
-        conf = { except: nil, add: nil}
-        conf.update(ops)
-        cidt = columns_in_dict_type || []
-        cidt.delete(conf[:except])
-        case conf[:add]
-        when String
-          cidt.push(conf[:add])
-        when Array
-          cidt.push(*conf[:add])
-        else nil
-        end
-        cidt.uniq! || cidt
-      end
-
-      # add a belongs_to(Dictionary) association and a named_{column} method
-      def add_dynamic_column_method
-        dict_mapping_columns.each { |e| belongs_to "#{e}_dict".to_sym, class_name: "Dictionary", foreign_key: e.to_sym }
-        dict_mapping_columns.each { |ele| named_dict_value ele.to_sym }
-        dict_mapping_columns.each { |ele| dict_name_equal ele.to_sym }
-      end
-
-      # Generate dynamic instance method named_column to consumer model
-      # def named_city(locale=nil)
-      #   locale = locale.presence || default_dict_locale.presence || :en
-      #   locale = "name_#{locale}"
-      #   self.send(city_dict).try(:send,locale)
-      # end
-      # alias_method :city_name, :named_city
-      def named_dict_value(method_name)
-        belongs_to_name="#{method_name}_dict".to_sym
-        origin_method_name = method_name
-        method_name="named_#{method_name}"
-        define_method(method_name) do | locale=nil |
-          locale = locale.presence || default_dict_locale.presence || :en
-          locale = "name_#{locale}"
-          self.send(belongs_to_name).try(:send,locale)
-        end
-        alias_method "#{origin_method_name}_name".to_sym, method_name.to_sym
-      end
-
-      # Build dynamic method column_name= to the consumer model
-      #
-      # def city_name=(value, options = {})
-      #
-      #
-      # end
-      def dict_name_equal(colname)
-        method_name = "#{colname}_name="
-        belongs_to_name="#{colname}_dict".to_sym
-        define_method(method_name) do |value, options={}|
-          options.merge!(name_en: value)
-          dict_type_id = DictType.revert("#{self.class.table_name.singularize}_#{colname}")
-          options.merge!(dict_type_id: dict_type_id)
-          exist_dictionary = Dictionary.where(options)
-          if exist_dictionary.present?
-            exist_id = exist_dictionary.first.id
-          else
-            exist_id = send("create_#{belongs_to_name}!", options).id
-          end
-          send "#{colname}=", exist_id
-        end
-      end
-
-    end # END ClassMethods
-
-  end
-end

data/lib/rails_dictionary/models/acts_as_dict_type.rb

@@ -1,56 +0,0 @@
-module RailsDictionary
-  module ActsAsDictType
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send :include, InstanceMethods
-      base.mattr_accessor :whole_types
-    end
-
-    module ClassMethods
-
-      def all_types
-        whole_types ||
-          self.whole_types = all.map(&:name).map(&:to_sym)
-      end
-
-      # short method to transfer id to name or name to id
-      # TODO: cache it
-      def revert(arg)
-        if arg.is_a?(String)
-          DictType.where(name: arg).first.try(:id)
-        elsif arg.is_a?(Integer)
-          DictType.where(id: arg).first.try(:name)
-        end
-      end
-
-      #
-      # Parse the name value to get which column and model(or table) are listed in DictType
-      #
-      # Programmer DOC:
-      #   There are two chooses to get subclass,one is subclasses the other is descendants,
-      #   I don't know which is better,but descendants contains subclass of subclass,it contains more.
-      #
-      #   Class like +Ckeditor::Asset+ transfer to "ckeditor/asset",but we can not naming method like that,
-      #   So it still not support, the solution may be simple,just make another convention to escape "/"
-      #
-      #   Seems this method did not need to be cached in production.
-      #   Because everyclass was cached before application was run.So after application was run, it never be run again.
-      # TODO:
-      #   To cache this method output need more skills on how to caculate ActiveRecord::Base.descendants
-      #   Temply remove the cache
-      #   And add test for this situation
-      def tab_and_column
-        all_model_class=ActiveRecord::Base.descendants.map(&:name).map(&:underscore)
-        all_types.map(&:to_s).extract_to_hash(all_model_class)
-      end
-    end
-
-    module InstanceMethods
-      def delete_all_caches
-        self.whole_types = nil
-        return true
-      end
-    end
-
-  end
-end

data/spec/fake_app.rb

@@ -1,41 +0,0 @@
-# database
-ActiveRecord::Base.configurations = {'test' => {:adapter => 'sqlite3', :database => ':memory:'}}
-
-if ActiveRecord::VERSION::MAJOR >= 5
-  ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-else
-  ActiveRecord::Base.establish_connection(:test)
-end
-
-# config
-app = Class.new(Rails::Application)
-app.config.active_support.deprecation = :log
-app.config.eager_load = false
-app.initialize!
-
-# models
-class DictType < ActiveRecord::Base
-  acts_as_dict_type
-end
-
-class Dictionary < ActiveRecord::Base
-  acts_as_dictionary
-end
-
-class Student < ActiveRecord::Base
-end
-
-#migrations
-class CreateAllTables < ActiveRecord::VERSION::MAJOR >= 5 ? ActiveRecord::Migration[5.0] : ActiveRecord::Migration
-  def self.up
-    create_table(:dict_types) {|t| t.string :name}
-    create_table(:dictionaries) {|t| t.string :name_en; t.string :name_zh ; t.string :name_fr ; t.integer :dict_type_id}
-    create_table(:students) {|t| t.string :email; t.integer :city; t.integer :school}
-  end
-
-  def self.down
-    drop_table :dict_types
-    drop_table :dictionaries
-    drop_table :students
-  end
-end

data/spec/rails_dictionary_spec.rb

@@ -1,122 +0,0 @@
-# -*- coding: utf-8 -*-
-require File.expand_path('spec_helper', File.dirname(__FILE__))
-
-describe RailsDictionary::ActiveRecordExtension do
-  %w[acts_as_dict_type acts_as_dictionary acts_as_dict_slave].each do |method_name|
-    it "contains #{method_name}" do
-      expect(ActiveRecord::Base.methods).to include(method_name.to_sym)
-    end
-  end
-end
-
-describe RailsDictionary do
-  let!(:dt_stu_city) { DictType.create! :name => "student_city" }
-  let!(:dt_stu_school) { DictType.create! :name => "student_school" }
-  let!(:dy_shanghai) { Dictionary.create! name_en: "shanghai",name_zh: "上海",name_fr: "shanghai",dict_type_id: dt_stu_city.id }
-  let!(:dy_beijing) { Dictionary.create! name_en: "beijing",name_zh: "北京",name_fr: "Pékin",dict_type_id: dt_stu_city.id }
-  let!(:stu_beijing) { Student.create! email: "beijing@dict.com",city: dy_beijing.id }
-  let!(:stu_shanghai) { Student.create! email: "shanghai@dict.com",city: dy_shanghai.id }
-
-  describe DictType do
-    it "parse model and method" do
-      expected_hash={:student => %w[city school]}
-      DictType.tab_and_column.should == expected_hash
-    end
-
-    it "all types" do
-      DictType.all_types.should == [:student_city, :student_school]
-    end
-
-    it "reverts id to name or name to id" do
-      DictType.revert(dt_stu_school.id).should == "student_school"
-      DictType.revert(100).should be_nil
-    end
-
-    it "after one record removed" do
-      DictType.all_types
-      DictType.whole_types.should == [:student_city, :student_school]
-      dt_stu_school.destroy
-      DictType.all_types.should == [:student_city]
-      DictType.tab_and_column.should == Hash[:student,["city"]]
-    end
-  end
-
-  describe Dictionary do
-    it "should respond to student_city" do
-      Dictionary.should respond_to(:student_city)
-    end
-
-    it "generate student_city method" do
-      Dictionary.student_city.should == [dy_shanghai,dy_beijing]
-    end
-
-    it "generate student_city method with locale" do
-      Dictionary.student_city(:locale => :zh).should == [["北京", 2],["上海",1]]
-    end
-
-    it "build scope method scoped_student_city" do
-      Dictionary.scoped_student_city.class.name.should == "ActiveRecord::Relation"
-      Dictionary.scoped_student_city.where(:id => 1).should == [dy_shanghai]
-    end
-
-    it "after record added or removed" do
-      @dy_wuhan=Dictionary.create! name_en: "wuhan",name_zh: "武汉",name_fr: "wuhan",dict_type_id: dt_stu_city.id
-      Dictionary.student_city(:locale => :en).should == [["beijing", 2],["shanghai",1],["wuhan", 3]]
-      @dy_wuhan.destroy
-      Dictionary.student_city(:locale => :en).should == [["beijing", 2],["shanghai",1]]
-    end
-
-  end
-
-  describe Student do
-    before :each do
-      Student.acts_as_dict_slave
-    end
-    it "method of columns_in_dict_type and dict_columns" do
-      Student.columns_in_dict_type.should == %w[city school]
-      Student.dict_columns == %w[city school]
-    end
-
-    it "named_city with different locale" do
-      stu_shanghai.named_city(:en).should == "shanghai"
-      stu_shanghai.city_name(:en).should == "shanghai"
-      stu_shanghai.city_name.should == "shanghai"
-      stu_shanghai.named_city("").should == "shanghai"
-      stu_beijing.named_city(:fr).should == "Pékin"
-    end
-
-    it "update city by set city_name to a value" do
-      stu_shanghai.update_attributes city_name: "wuhan"
-      stu_shanghai.reload.city_name.should == "wuhan"
-      Dictionary.student_city.map(&:name_en).include?("wuhan").should be_truthy
-    end
-
-    it "update city by set city_name to an exist dictionary name" do
-      Dictionary.where(name_en: "beijing").count.should eq(1)
-      stu_shanghai.update_attributes city_name: "beijing"
-      stu_shanghai.reload.city_name.should eq('beijing')
-      Dictionary.where(name_en: "beijing").count.should eq(1)
-    end
-
-    it "create a student with shanghai city" do
-      s = Student.create(city_name: "shanghai")
-      s.reload
-      s.city_name.should == "shanghai"
-    end
-
-    it "override default locale" do
-      Student.acts_as_dict_slave :locale => :fr
-      stu_beijing.named_city.should == "Pékin"
-    end
-  end
-end
-
-describe Array do
-  let(:an_array) { %w[root student_school student_city admin_role] }
-  let(:expected_hash) { {:student => %w[school city],:admin => %w[role]} }
-  let(:blank_hash) { Hash.new }
-  it "extract to hash" do
-    an_array.extract_to_hash(%w[student admin]).should == expected_hash
-    an_array.extract_to_hash(%w[students]).should == blank_hash
-  end
-end

data/spec/spec_helper.rb

@@ -1,24 +0,0 @@
-# copy and modify the test design of kaminari(a paginate gem for Rails3)
-RAILS_ENV = 'test'
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rails'
-require 'active_record'
-require 'action_controller/railtie'
-require 'action_view/railtie'
-require 'rails_dictionary'
-
-require File.join(File.dirname(__FILE__), 'fake_app')
-
-require 'rspec/rails'
-
-$stdout = StringIO.new  # remove the noise output
-
-RSpec.configure do |config|
-  config.use_transactional_fixtures = true
-  # not work, must syntax error
-  # config.expect_with(:rspec) { |c| c.syntax = :should }
-  CreateAllTables.up unless ActiveRecord::Base.connection.table_exists? 'dict_types'
-end
-
-require 'byebug'