rails_dictionary 0.2.8 → 0.3.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 1509dd96efe66e6ad9a0d4cf6d69f84db021ebcfa3268361dffede4e0665bc97
-  data.tar.gz: f34e202ef03601dda3dcdf2da5e3044076af433de3b9880e73493cbdfdac1307
+SHA1:
+  metadata.gz: 309d2e3ca49c9e564523d61307014d44987b7561
+  data.tar.gz: e6ea71c9fc377893c23883a0a0f08d001bc2f328
 SHA512:
-  metadata.gz: 5c41d702f1073fe6530c84ace0ae1c9e4f3d010e2f45e591cce6a0f9f571b77bbd7404ffdb792812227ca79ded59e39e7d60ce2e3dead073c8f8fb8bebd58247
-  data.tar.gz: f4da47391e06286e144a517111e29c4b4c33a31f022a9c53604b632030562ead283a347a3fd4f8bf4ecc9430c4ef4404a0ebc54e865d6c45a040dad93a99ec60
+  metadata.gz: 0daca999ef3ad0ff8888e5e2ca7ae85fe81bbc62c5e1a7c696f51f7d904eeb5bb985200a471306efb75f5c4ce3e599b5cd2e57513f07ef7d1a95f26294b0acef
+  data.tar.gz: 987fdd01ad2d98bb9a211eda4aed92cedbe9469f4cfaf7a1d6b6803a52f41315ba9c4239e43826a620fb7d289fcc9c53dd206942db0f6f60ccd25ebe206f9d54

data/.gitignore

@@ -1,8 +1,6 @@
 pkg/
 .git/
+.gitignore
+Gemfile.lock
 tmp/*
-.idea/
-.byebug_history
-log/
-.DS_Store
-.ruby-version
+.idea/

data/CHANGELOG

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

data/Gemfile

@@ -1,12 +1,10 @@
-source "https://rubygems.org"
-
-ruby '> 3.3'
+source "http://rubygems.org"
 
 # Specify your gem's dependencies in rails_dictionary.gemspec
 gemspec
 
 group :development,:test do
-  gem 'rails', '< 9.0'
-  gem "rspec-rails", '< 9'
+  gem 'minitest'
+  gem 'byebug'
   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 "bundle exec 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

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

@@ -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

@@ -0,0 +1,27 @@
+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/lib/rails_dictionary/version.rb

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

data/lib/rails_dictionary.rb

@@ -1,13 +1,33 @@
+require File.join(File.dirname(__FILE__), "rails_dictionary/models/active_record_extension")
+require File.join(File.dirname(__FILE__), "rails_dictionary/models/acts_as_dictionary")
+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)
+
+module RailsDictionary
+
+  def self.config
+    Config.instance
+  end
+
+  class Config < Struct.new(:dictionary_klass, :defined_sti_klass)
+    include Singleton
+  end
 
-require File.join(File.dirname(__FILE__), "rails_dictionary/array_core_ext")
+  config.dictionary_klass = :Dictionary
+  config.defined_sti_klass = []
 
-ActiveSupport.on_load :active_record do
-  require File.join(File.dirname(__FILE__), "rails_dictionary/active_record_extension")
-  require File.join(File.dirname(__FILE__), "rails_dictionary/acts_as_dict_type")
-  require File.join(File.dirname(__FILE__), "rails_dictionary/acts_as_dictionary")
-  require File.join(File.dirname(__FILE__), "rails_dictionary/acts_as_dict_slave")
+  def self.dclass
+    @dclass ||= config.dictionary_klass.to_s.constantize
+  end
 
-  ::ActiveRecord::Base.send :include, RailsDictionary::ActiveRecordExtension
+  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

@@ -7,17 +7,17 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Raykin Lee"]
   s.email       = ["raykincoldxiao@campus.com"]
-  s.licenses    = ['MIT']
   s.homepage    = "https://github.com/raykin/rails_dictionary"
   s.summary     = %q{dictionary data for web application}
   s.description = %q{Rails plugin for mapping static data of web application to Dictionary class}
 
+  s.rubyforge_project = "rails_dictionary"
 
-  s.add_runtime_dependency 'rails', '< 9'
+  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"]
-  s.required_ruby_version = '>= 2.7.0'
 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