rails_dictionary 0.3.pre.rc1 → 0.4.0

data/spec/load_order/empty_boot_recovers.rb

@@ -0,0 +1,19 @@
+# Scenario: the app boots while the dict_types table does NOT exist yet
+# (e.g. before the first migration). This used to leave the gem permanently
+# broken. It must boot without raising, and recover once data appears.
+
+require_relative "support"
+
+define_models
+build_and_initialize_app # to_prepare runs against an empty DB -> must not raise
+
+assert !Dictionary.respond_to?(:country),
+       "no lookup methods exist when the table is missing at boot"
+
+create_dict_tables
+DictType.create!(name: "country") # runtime write -> after_save hook regenerates
+
+assert Dictionary.respond_to?(:country),
+       "lookup method appears after a DictType is created at runtime"
+
+puts "OK empty_boot_recovers"

data/spec/load_order/lazy_slave_model_boot.rb

@@ -0,0 +1,25 @@
+# Scenario: DictType is loaded and seeded BEFORE the Dictionary model is ever
+# referenced (mirrors a host app whose seed/fixture file writes dict_types
+# first, with eager_load off so the slave model autoloads lazily). The
+# after_save hook fires reload_dict_methods while the Dictionary model is not
+# yet registered, so it must still work once Dictionary is finally loaded.
+
+require_relative "support"
+
+# Only DictType exists at boot; Dictionary is NOT defined/registered yet.
+Object.const_set(:DictType, Class.new(ActiveRecord::Base))
+DictType.class_eval { acts_as_dict_type }
+
+create_dict_tables
+build_and_initialize_app # to_prepare runs; Dictionary not registered yet
+
+DictType.create!(name: "country") # after_save -> reload_dict_methods, empty registry
+
+# Host app references the slave model for the first time here.
+Object.const_set(:Dictionary, Class.new(ActiveRecord::Base))
+Dictionary.class_eval { acts_as_dictionary }
+
+assert Dictionary.respond_to?(:country),
+       "lookup method exists when the slave model is loaded after seeding"
+
+puts "OK lazy_slave_model_boot"

data/spec/load_order/preseeded_boot.rb

@@ -0,0 +1,22 @@
+# Scenario: the dict_types are already seeded BEFORE the app boots (the normal
+# production case). Seeding here uses insert, which skips callbacks, so the
+# after_save hook never fires. The lookup methods must therefore be generated
+# by the Railtie's boot-time hook, with zero runtime writes.
+
+require_relative "support"
+
+define_models
+create_dict_tables
+DictType.insert({ name: "country" }) # seeded without firing callbacks
+
+build_and_initialize_app # to_prepare -> RailsDictionary.load_dict_methods
+
+assert Dictionary.respond_to?(:country),
+       "lookup method is generated at boot from pre-seeded data"
+
+Dictionary.create!(name_en: "France", dict_type_id: DictType.first.id)
+
+assert Dictionary.country.map(&:name_en) == ["France"],
+       "lookup returns seeded rows without any DictType runtime write"
+
+puts "OK preseeded_boot"

data/spec/load_order/support.rb

@@ -0,0 +1,41 @@
+# Shared setup for the isolated load-order scripts. Each scenario runs in its
+# OWN process so it can control what exists in the database at boot time —
+# something the shared rspec suite (single process, tables already created)
+# cannot exercise.
+
+$LOAD_PATH.unshift(File.expand_path("../../../lib", __FILE__))
+
+require "rails"
+require "active_record"
+require "action_controller/railtie"
+require "rails_dictionary"
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+
+def define_models
+  # Assign the constant BEFORE running the macro so the class already has a
+  # name when it registers itself (mirrors `class Dictionary < AR::Base`).
+  Object.const_set(:DictType, Class.new(ActiveRecord::Base))
+  DictType.class_eval { acts_as_dict_type }
+  Object.const_set(:Dictionary, Class.new(ActiveRecord::Base))
+  Dictionary.class_eval { acts_as_dictionary }
+end
+
+def create_dict_tables
+  ActiveRecord::Schema.verbose = false
+  ActiveRecord::Schema.define do
+    create_table(:dict_types) { |t| t.string :name }
+    create_table(:dictionaries) { |t| t.string :name_en; t.integer :dict_type_id }
+  end
+end
+
+def build_and_initialize_app
+  app = Class.new(Rails::Application)
+  app.config.active_support.deprecation = :log
+  app.config.eager_load = false
+  app.initialize!
+end
+
+def assert(condition, message)
+  raise "FAIL: #{message}" unless condition
+end

data/spec/rails_dictionary_spec.rb

@@ -0,0 +1,172 @@
+# 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
+
+    # Regression: an empty result must not be memoized as a permanent [].
+    # insert bypasses callbacks so whole_types is not reset for us.
+    it "recomputes after being first read while empty (load-order bug)" do
+      DictType.whole_types = []
+      DictType.insert({ name: "country" })
+      DictType.all_types.should include(:country)
+    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
+
+    it "lists categories" do
+      Dictionary.categories.should == [:student_city, :student_school]
+    end
+
+    it "query: true bypasses a stale cache and hits the DB" do
+      Dictionary.student_city.map(&:name_en) # warm the cache
+      Dictionary.insert({ name_en: "wuhan", dict_type_id: dt_stu_city.id }) # no callbacks -> cache stays stale
+      Dictionary.student_city.map(&:name_en).should_not include("wuhan")
+      Dictionary.student_city(query: true).map(&:name_en).should include("wuhan")
+    end
+
+    it "adds and removes a dictionary entry" do
+      Dictionary.add(:student_city, "wuhan")
+      Dictionary.student_city(query: true).map(&:name_en).should include("wuhan")
+      Dictionary.remove(:student_city, "wuhan")
+      Dictionary.student_city(query: true).map(&:name_en).should_not include("wuhan")
+    end
+
+    it "returns form-ready options without the deprecated locale arg" do
+      Dictionary.options_for(:student_city).should == [["shanghai", 1], ["beijing", 2]]
+      Dictionary.options_for(:student_city, locale: :fr).should == [["shanghai", 1], ["Pékin", 2]]
+    end
+
+    it "deprecates the :locale option on the lookup method" do
+      expect(RailsDictionary.deprecator).to receive(:warn)
+      Dictionary.student_city(locale: :en)
+    end
+
+  end
+
+  describe Student do
+    # Run it because dict type value has cached at runtime but data inserted after cache created
+    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 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 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_consumer :locale => :fr
+      stu_beijing.named_city.should == "Pékin"
+    end
+
+    it "create a student with new city(reproduce conflict error with Rails5.2.0)" do
+      s = Student.new
+      s.city_name = 'Sedan'
+      s.save
+      s.reload
+      s.city_name.should == 'Sedan'
+    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
+
+  it "is deprecated in favor of RailsDictionary.extract_to_hash" do
+    expect(RailsDictionary.deprecator).to receive(:warn)
+    an_array.extract_to_hash(%w[student admin])
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# 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 outputo
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.expect_with(:rspec) { |c| c.syntax = [:should, :expect] }
+  CreateAllTables.up unless ActiveRecord::Base.connection.table_exists? 'dict_types'
+  require File.join(File.dirname(__FILE__), 'init_models')
+end

data/v1.0-roadmap.md

@@ -0,0 +1,31 @@
+# rails_dictionary Roadmap
+
+**Core principle: intuitive API. Use naturally, learn nothing.**
+
+## v1.0 (breaking)
+
+<!-- dev note: not suggested, should not add it -->
+### 1. One table, simple schema
+
+Drop `dict_types`/`DictType`. Single `dictionaries` table: `id`, `name`, `category`.
+
+### 2. Clean API
+
+Finish what v0.3 started: **remove** the deprecated `locale:` option and the
+`Array#extract_to_hash` monkey-patch, and add the `uses_dictionary :city, :degree`
+consumer macro.
+
+<!-- how to do it? -->
+### 3. Auto caching
+
+Cache primitive data (ids, names) by default — a derived, rebuildable index rather
+than id-bearing AR records. No manual cache management.
+
+---
+
+## v1.1 (undecided)
+
+<!-- delay it until dict_type table has really decided to remove -->
+### Generator
+
+`rails g dictionary city degree major` to create the migration and seed categories.

metadata

@@ -1,43 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: rails_dictionary
 version: !ruby/object:Gem::Version
-  version: 0.3.pre.rc1
+  version: 0.4.0
 platform: ruby
 authors:
 - Raykin Lee
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">"
-      - !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'
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 description: Rails plugin for mapping static data of web application to Dictionary
   class
 email:
@@ -46,28 +37,39 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - CHANGELOG
 - Gemfile
-- README.v2.0.rdoc
+- Gemfile.lock
+- README.rdoc
 - Rakefile
-- Readme.md
+- docs/load-order.md
 - lib/rails_dictionary.rb
-- lib/rails_dictionary/models/active_record_extension.rb
-- lib/rails_dictionary/models/acts_as_dict_consumer.rb
-- lib/rails_dictionary/models/acts_as_dictionary.rb
+- lib/rails_dictionary/active_record_extension.rb
+- lib/rails_dictionary/acts_as_dict_slave.rb
+- lib/rails_dictionary/acts_as_dict_type.rb
+- lib/rails_dictionary/acts_as_dictionary.rb
+- lib/rails_dictionary/array_core_ext.rb
+- lib/rails_dictionary/railtie.rb
 - lib/rails_dictionary/version.rb
 - lib/tasks/dicts.rake
+- pkg/rails_dictionary-0.2.2.gem
+- pkg/rails_dictionary-0.2.3.gem
 - rails_dictionary.gemspec
-- test/acts_as_consumer_test.rb
-- test/fake_app.rb
-- test/lookup_test.rb
-- test/rails_dictionary_test.rb
-- test/test_helper.rb
+- spec/fake_app.rb
+- spec/init_models.rb
+- spec/load_order/empty_boot_recovers.rb
+- spec/load_order/lazy_slave_model_boot.rb
+- spec/load_order/preseeded_boot.rb
+- spec/load_order/support.rb
+- spec/rails_dictionary_spec.rb
+- spec/spec_helper.rb
+- v1.0-roadmap.md
 homepage: https://github.com/raykin/rails_dictionary
-licenses: []
+licenses:
+- MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -75,17 +77,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubyforge_project: rails_dictionary
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 4.0.10
 specification_version: 4
 summary: dictionary data for web application
 test_files: []
-has_rdoc: 

data/Readme.md

@@ -1,10 +0,0 @@
-## 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

@@ -1,38 +0,0 @@
-module RailsDictionary
-  module ActiveRecordExtension
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-
-      def acts_as_dictionary
-        include ActsAsDictionary
-        validates_uniqueness_of :name, scope: [inheritance_column]
-      end
-
-      # 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
-
-    end
-  end
-end
-
-::ActiveRecord::Base.send :include, RailsDictionary::ActiveRecordExtension

data/lib/rails_dictionary/models/acts_as_dict_consumer.rb

@@ -1,77 +0,0 @@
-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

@@ -1,27 +0,0 @@
-module RailsDictionary
-  module ActsAsDictionary
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send :include, InstanceMethods
-    end
-
-    module ClassMethods
-
-      # 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 type=(name)
-        ::RailsDictionary.init_dict_sti_class(name)
-        super
-      end
-    end # End InstanceMethods
-
-  end
-end

data/test/acts_as_consumer_test.rb

@@ -1,44 +0,0 @@
-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