rails_dictionary 0.0.8 → 0.0.9

data/.gitignore

@@ -1 +1,3 @@
-pkg/
+pkg/
+.git/
+.gitignore

data/CHANGELOG

@@ -0,0 +1,6 @@
+0.0.9
+  add Rails Engine to redesign the gem
+  use Rspec instead of Test::Unit to write test code
+  remove many nonsence code
+0.0.1-0.0.8
+  old mixin coding style

data/Gemfile

@@ -1,4 +1,10 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in dictionary.gemspec
+# Specify your gem's dependencies in rails_dictionary.gemspec
 gemspec
+
+group :development,:test do
+  gem 'rspec', '>= 2.5.0'
+  gem 'rails', '>= 3.0.0'
+  gem 'sqlite3'
+end

data/README.rdoc

@@ -1,6 +1,7 @@
 = Intro
-There are many static data in application.
-For example in a student application,there may be some static data like diploma kind,school and city of school.This gem can map these static data to a Dictionary#method like Dictionary#student_diploma_kind which return data list of diploma kind and generate a list of instance method on Student like @student.named_city which return city name of @student city
+There are always some static data(not static page) in application.For example product type or diploma kind of student.
+
+This gem can map these static data to a Dictionary#method like Dictionary#student_diploma_kind and generate a list of instance method on Student like @student.named_city which return city name (with locale if you need).
 
 = Usage
 == Installation
@@ -43,10 +44,11 @@ These task are just generate table dictionaries,dict_types,students and some sam
          | 2  | shanghai@dict.com | 3    |        |
          +----+-------------------+------+--------+
          2 rows in set
-There is one conventions of DictType.name value.All value of DictType.name is "model_method" : student is model and city is method of student model.
+There is one convention of DictType.name value.All value of DictType.name is "model_method" : student is model and city is method of student model.
 
 === Table Definition
 Make sure you have two tables which named as dict_types and dictionaries.
+
 Table dictionaries has one convention of naming column : name_locale.So the name_fr means this column have a french value,you can see more usage later.
 The students table is not required and variable by your application.
 
@@ -65,13 +67,15 @@ Here is what should be like.Student model can be other models.
         acts_as_dict_slave
       end
 
-== Features : Methods and results (relies on the above data)
+== Features (relies on the above data) :
    DictType.all_cached #=> return cache of DictType.all
    DictType.all_types = %w[student_city student_school] # also cached
    Dictionary.student_city #=> [Dictionary.find(5),Dictionary.find(6)]
-student_city is a dynamic method which returns a list of dictionary object which dict_type is "student_city".Actually Dictionary will have as many dynamic methods as DictType.count and each dynamic method name is DictType.name(This methods returning an array,not ActiveRelation).
+student_city is a dynamic method which returns a list of dictionary object which dict_type is "student_city".
+Actually Dictionary will have as many dynamic methods as DictType.count and each dynamic method name is DictType.name.
+Before version 0.1.0 or 0.2.0 ,all dynamic methods return an array,not ActiveRelation.So
    Dictionary.student_school = []
-   Dictionary.student_city :locale => :en = [["shanghai",1],["beijing",2]]
+   Dictionary.student_city :locale => :en  #=> [["shanghai",1],["beijing",2]]
 You can use it in form select method like
    collection_select :student,:city,Dictionary.student_city,:id,:name_en
    select :student,:city,Dictionary.student_city(params)
@@ -80,6 +84,9 @@ If params contains :locale => :fr,it returns a list of french name of student ci
 Here is an other solution for international translation.
    Student.find(1).named_city(:zh) = "北京"
    Student.find(1).named_city(:fr) = "Pékin"
+   Student.find(1).named_city(:en) = "beijing"
+Make sure your locale is en,not en-US.
+
 Student has two belongs_to assocition which named as city_dict and school_dict,the naming convention is method_dict.
    Student.find(1).city_dict #=> Dictionary.find(6)
 
@@ -97,5 +104,10 @@ The rails cache would not refresh.
 In short,when you confused with the debug data,try running "rails tmp:clear" first.
 
 = TODO & Problems
-There are no convention and implemention to map Class like Ckeditor::Asset to a method.
+There are no convention and implemention to map Class like Ckeditor::Asset to a legal method name.
+
+Rebuild core code.Using Rails engine.
+
+Make cached type of DictType to an array of symbols
+
 Rewrite Testing,make it more maintainable.

data/Rakefile

@@ -3,6 +3,7 @@ Bundler::GemHelper.install_tasks
 
 desc "Running Test"
 task :test do
-  system "ruby -I . test/rails_dictionary_test.rb "
+  # system "ruby -I . test/rails_dictionary_test.rb " # used with version 0.0.8 or before it
+  system "rspec spec/rails_dictionary_spec.rb"
 end
 

data/lib/rails_dictionary/engine.rb

@@ -0,0 +1,4 @@
+module RailsDictionary
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/rails_dictionary/models/active_record_extension.rb

@@ -0,0 +1,45 @@
+module RailsDictionary
+  module ActiveRecordExtension
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # TODO: move macro define in each module file
+      # See Usage in readme.doc.
+      def acts_as_dict_type
+        self.class_eval do
+          has_many :dictionaries
+          validates_uniqueness_of :name
+          after_save :delete_all_caches
+          after_destroy :delete_all_caches
+        end
+        include RailsDictionary::ActsAsDictType
+      end
+
+      def acts_as_dictionary
+        self.class_eval do
+          belongs_to :dict_type
+          after_save :delete_dicts_cache
+          after_destroy :delete_dicts_cache
+        end
+        include RailsDictionary::ActsAsDictionary
+      end
+
+      # :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_writes => 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
+        end
+      end
+
+    end
+  end
+end

data/lib/rails_dictionary/models/acts_as_dict_slave.rb

@@ -0,0 +1,55 @@
+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
+        DictType.tab_and_column[self.name.underscore.to_sym]
+      end
+
+      # columns which map to dictionary
+      def dict_columns(ops={})
+        conf={except: nil,add: nil}
+        conf.update(ops)
+        cidt=self.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.to_s}_dict".to_sym,class_name: "Dictionary",foreign_key: e }
+        dict_mapping_columns.each { |ele| named_dict_value ele.to_sym }
+      end
+
+      # Generate dynamic instance method named_column to slave 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
+      def named_dict_value(method_name)
+        belongs_to_name="#{method_name.to_s}_dict".to_sym
+        method_name="named_#{method_name.to_s}"
+        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
+      end
+
+    end
+
+  end
+end

data/lib/rails_dictionary/models/acts_as_dict_type.rb

@@ -0,0 +1,54 @@
+module RailsDictionary
+  module ActsAsDictType
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send :include,InstanceMethods
+    end
+
+    module ClassMethods
+
+      def all_types
+        Rails.cache.fetch("DictType.all_types") { all.map(&:name).map(&:to_sym) }.dup
+      end
+
+      def cached_all
+        Rails.cache.fetch("DictType.cached_all") { all }.dup
+      end
+
+      # short method to transfer id to name or name to id
+      def revert(arg)
+        if arg.is_a?(String)
+          DictType.where(name: arg).first.try(:id)
+        elsif arg.is_a?(Fixnum)
+          DictType.where(id: arg).first.try(:name)
+        end
+      end
+
+      # TODO: get a more accurate method name
+      #
+      # Parse the name value to get which column and model 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 "/"
+      def tab_and_column
+        Rails.cache.fetch("DictType.tab_and_column") do
+          all_model_class=ActiveRecord::Base.descendants.map(&:name).map(&:underscore)
+          all_types.map(&:to_s).extract_to_hash(all_model_class)
+        end
+      end
+    end
+
+    module InstanceMethods
+      def delete_all_caches
+        Rails.cache.delete("DictType.all_types")
+        Rails.cache.delete("DictType.cached_all")
+        Rails.cache.delete("DictType.tab_and_column")
+        return true
+      end
+    end
+
+  end
+end

data/lib/rails_dictionary/models/acts_as_dictionary.rb

@@ -0,0 +1,56 @@
+module RailsDictionary
+  module ActsAsDictionary
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send :include,InstanceMethods
+    end
+
+    module ClassMethods
+
+      # Return an instance of array
+      # Programmer DOC:
+      #   Following design is failed with sqlite3 in test
+      #   scope :dict_type_name_eq,lambda {|method_name| joins(:dict_type).where("dict_types.name" => method_name)}
+      #   remove the all seems not pass test,return following errors
+      #   TypeError: no marshal_dump is defined for class SQLite3::Database
+      def dict_type_name_eq(method_name)
+        joins(:dict_type).where("dict_types.name" => method_name).all
+      end
+
+      # 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
+      def method_missing(method_id,options={},&block)
+        method_name=method_id.to_s.downcase
+        if DictType.all_types.include? method_id
+          Rails.cache.fetch("Dictionary.#{method_name}") { dict_type_name_eq(method_name) }
+          listed_attr=Rails.cache.read("Dictionary.#{method_name}").dup
+          # Instance of activerelation can not be dup?
+          if options.keys.include? :locale or options.keys.include? "locale"
+            locale="name_#{ options[:locale] }"
+            listed_attr.map! { |a| [a.send(locale),a.id] }
+            listed_attr.sort { |a,b| a.first <=> b.first }
+            # maybe remove the above line,or change some sorting and caching design
+          else
+            listed_attr
+          end
+        else
+          super
+        end
+      end
+    end
+
+    module InstanceMethods
+      def delete_dicts_cache
+        method_name=DictType.revert(self.dict_type_id)
+        Rails.cache.delete("Dictionary.#{method_name}")
+        return true
+      end
+    end
+  end
+end

data/lib/rails_dictionary/railtie.rb

@@ -0,0 +1,17 @@
+require 'rails'
+
+require File.join(File.dirname(__FILE__),"array_core_ext")
+require File.join(File.dirname(__FILE__),"models/acts_as_dict_type")
+require File.join(File.dirname(__FILE__),"models/acts_as_dictionary")
+require File.join(File.dirname(__FILE__),"models/acts_as_dict_slave")
+
+module RailsDictionary
+  class Railtie < ::Rails::Railtie
+    initializer 'rails_dictionary' do |app|
+      ActiveSupport.on_load(:active_record) do
+        require File.join(File.dirname(__FILE__), 'models/active_record_extension')
+        ::ActiveRecord::Base.send :include, RailsDictionary::ActiveRecordExtension
+      end
+    end
+  end
+end

data/lib/rails_dictionary/version.rb

@@ -1,3 +1,3 @@
 module RailsDictionary
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/lib/rails_dictionary.rb

@@ -1,4 +1,2 @@
-require "rails_dictionary/acts_as_dictionary"
-require "rails_dictionary/acts_as_dict_slave"
-require "rails_dictionary/acts_as_dict_type"
-require "rails_dictionary/array_core_ext"
+require File.join(File.dirname(__FILE__), 'rails_dictionary/railtie')
+require File.join(File.dirname(__FILE__), 'rails_dictionary/engine')

data/log/development.log

@@ -0,0 +1,2 @@
+
+***** Debugger requested, but was not available (ensure ruby-debug is listed in Gemfile/installed as gem): Start server with --debugger to enable *****

data/rails_dictionary.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name        = "rails_dictionary"
   s.version     = RailsDictionary::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["raykin"]
+  s.authors     = ["Raykin Lee"]
   s.email       = ["raykincoldxiao@campus.com"]
   s.homepage    = "https://github.com/raykin/rails_dictionary"
   s.summary     = %q{dictionary data for web application}

data/spec/fake_app.rb

@@ -0,0 +1,36 @@
+
+# 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.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::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

@@ -0,0 +1,90 @@
+# -*- 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
+      ActiveRecord::Base.methods.include?(method_name.to_sym).should be_true
+    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
+      dt_stu_school.destroy
+      DictType.all_types.should == [:student_city]
+      DictType.tab_and_column.should == Hash[:student,["city"]]
+    end
+  end
+
+  describe Dictionary do
+    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 == [["上海", 1],["北京", 2]]
+    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.named_city("").should == "shanghai"
+      stu_beijing.named_city(:fr).should == "Pékin"
+    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

@@ -0,0 +1,19 @@
+# copy and modify the test design of kaminari(a paginate gem for Rails3)
+$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
+  CreateAllTables.up unless ActiveRecord::Base.connection.table_exists? 'dict_types'
+end

data/test/rails_dictionary_test.rb

@@ -1,4 +1,7 @@
 # -*- coding: utf-8 -*-
+# Testing for version 0.0.8 or lower.Copy the test design from acts_as_tree
+# Usage: run "ruby -I . test/rails_dictionary_test.rb " in root dir
+#
 require "test/unit"
 require "active_support"
 require "active_record"
@@ -6,7 +9,6 @@ require "ruby-debug" # coupled with debugger to debug code
 Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store
 require "active_support/cache"
 require "rails"
-# $: << "/home/raykin/studio/rails_dictionary/lib" # tmply added for local testing
 require "#{File.dirname(__FILE__)}/../lib/rails_dictionary.rb"
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
@@ -53,7 +55,6 @@ end
 class Student < ActiveRecord::Base
 end
 
-
 class CoreExtTest < Test::Unit::TestCase
   def test_array
     expected_hash={:student => %w[school city],:admin => %w[role]}
@@ -92,6 +93,7 @@ class DictTypeTest < Test::Unit::TestCase
   # test revert method in acts_as_dict_type
   def test_dt_revert
     assert_equal "student_school",DictType.revert(@dt_stu_school.id)
+    assert_equal nil,DictType.revert(100)
   end
 
   # test dynamic instance methods in slave model
@@ -111,18 +113,18 @@ class DictTypeTest < Test::Unit::TestCase
   end
 
   def test_dictionary_method_missing
-    assert_equal [["shanghai",1],["beijing",2]],Dictionary.student_city(:locale => :en)
+    assert_equal [["beijing",2],["shanghai",1]],Dictionary.student_city(:locale => :en)
   end
 
   def test_dictionary_method_missing_with_locale
-    assert_equal [["上海", 1], ["北京", 2]],Dictionary.student_city(:locale => :zh)
+    assert_equal [["上海", 1],["北京", 2]],Dictionary.student_city(:locale => :zh)
   end
 
   def test_delete_dicts_cache
     @dy_wuhan=Dictionary.create! name_en: "wuhan",name_zh: "武汉",name_fr: "wuhan",dict_type_id: @dt_stu_city.id
-    assert_equal [["shanghai", 1], ["beijing", 2], ["wuhan", 3]],Dictionary.student_city(:locale => :en)
+    assert_equal [["beijing", 2],["shanghai",1],["wuhan", 3]],Dictionary.student_city(:locale => :en)
     @dy_wuhan.destroy
-    assert_equal [["shanghai", 1], ["beijing", 2]],Dictionary.student_city(:locale => :en)
+    assert_equal [["beijing", 2],["shanghai",1]],Dictionary.student_city(:locale => :en)
     assert_equal [@dy_shanghai,@dy_beijing],Dictionary.student_city
   end
 

metadata

@@ -2,16 +2,15 @@
 name: rails_dictionary
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors: 
-- raykin
+- Raykin Lee
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-03-21 00:00:00 +08:00
-default_executable: 
+date: 2011-04-14 00:00:00 Z
 dependencies: []
 
 description: Rails plugin for mapping static data of web application to Dictionary class
@@ -25,19 +24,26 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- CHANGELOG
 - Gemfile
 - README.rdoc
 - Rakefile
 - lib/rails_dictionary.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/engine.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_dictionary.rb
+- lib/rails_dictionary/railtie.rb
 - lib/rails_dictionary/version.rb
 - lib/tasks/dicts.rake
+- log/development.log
 - rails_dictionary.gemspec
+- spec/fake_app.rb
+- spec/rails_dictionary_spec.rb
+- spec/spec_helper.rb
 - test/rails_dictionary_test.rb
-has_rdoc: true
 homepage: https://github.com/raykin/rails_dictionary
 licenses: []
 
@@ -61,9 +67,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rails_dictionary
-rubygems_version: 1.6.2
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: dictionary data for web application
 test_files: 
+- spec/fake_app.rb
+- spec/rails_dictionary_spec.rb
+- spec/spec_helper.rb
 - test/rails_dictionary_test.rb
+has_rdoc: 

data/lib/rails_dictionary/acts_as_dict_slave.rb

@@ -1,69 +0,0 @@
-module ActsAsDictSlave
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  module ClassMethods
-    # :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={})
-      class_attribute :default_dict_locale,:instance_writer => false
-      cattr_accessor :dict_mapping_columns,:instance_writes => 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
-      end
-    end
-
-    # return columns that exist in DictType#tab_and_column
-    def columns_in_dict_type
-      DictType.tab_and_column[self.name.underscore.to_sym]
-    end
-
-    # columns which map to dictionary
-    def dict_columns(ops={})
-      conf={except: nil,add: nil}
-      conf.update(ops)
-      cidt=self.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
-      self.extend(DynamicInsMethods)
-      dict_mapping_columns.each { |e| belongs_to "#{e.to_s}_dict".to_sym,class_name: "Dictionary",foreign_key: e }
-      dict_mapping_columns.each { |ele| named_dict_value ele.to_sym }
-    end
-  end
-
-  module DynamicInsMethods
-    # generate dynamic instance method named_column to slave 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
-    def named_dict_value(method_name)
-      belongs_to_name="#{method_name.to_s}_dict".to_sym
-      method_name="named_#{method_name.to_s}"
-      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
-    end
-
-  end
-
-end
-ActiveRecord::Base.class_eval { include ActsAsDictSlave }

data/lib/rails_dictionary/acts_as_dict_type.rb

@@ -1,56 +0,0 @@
-module ActsAsDictType
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  module ClassMethods
-    def acts_as_dict_type(ops={})
-      self.class_eval do
-        has_many :dictionaries
-        include InstanceMethods
-        validates_uniqueness_of :name
-        after_save :delete_all_caches
-        after_destroy :delete_all_caches
-
-        def self.all_types
-          Rails.cache.fetch("DictType.all_types") { all.map(&:name) }.dup
-        end
-
-        def self.cached_all
-          Rails.cache.fetch("DictType.cached_all") { all }.dup
-        end
-
-        # short method to transfer id to name or name to id
-        def self.revert(arg)
-          if arg.is_a?(String)
-            DictType.where(name: arg).try(:first).id
-          elsif arg.is_a?(Fixnum)
-            DictType.where(id: arg).try(:first).name
-          end
-        end
-
-        # TODO: get a more accurate method name
-        # Parse the name value to get which column and model are listed in DictType
-        def self.tab_and_column
-          tab_and_column={}
-          # There are two chooses,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 "/"
-          all_model_class=ActiveRecord::Base.descendants.map(&:name).map(&:underscore)
-          tab_and_column=all_types.extract_to_hash(all_model_class)
-        end
-      end
-    end
-
-    module InstanceMethods
-      def delete_all_caches
-        Rails.cache.delete("DictType.all_types")
-        Rails.cache.delete("DictType.cached_all")
-        return true
-      end
-    end
-
-  end
-end
-ActiveRecord::Base.class_eval { include ActsAsDictType  }

data/lib/rails_dictionary/acts_as_dictionary.rb

@@ -1,57 +0,0 @@
-module ActsAsDictionary
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  module ClassMethods
-
-    def acts_as_dictionary
-      belongs_to :dict_type
-      after_save :delete_dicts_cache
-      after_destroy :delete_dicts_cache
-
-      # Return an instance of array
-      def dict_type_name_eq(method_name)
-        joins(:dict_type).where("dict_types.name" => method_name).all
-      end
-      #Following design is not successed with sqlite3 in test
-      # scope :dict_type_name_eq,lambda {|method_name| joins(:dict_type).where("dict_types.name" => method_name)}
-      # remove the all seems not pass test,return following errors
-      # TypeError: no marshal_dump is defined for class SQLite3::Database
-      include InstanceMethods
-      # 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
-      # Is this design good?
-      def self.method_missing(method_id,options={},&block)
-        method_name=method_id.to_s.downcase
-        if DictType.all_types.include? method_id.to_s
-          Rails.cache.fetch("Dictionary.#{method_name}") { dict_type_name_eq(method_name) }
-          listed_attr=Rails.cache.read("Dictionary.#{method_name}").dup
-          # Instance of activerelation can not be dup?
-          if options.keys.include? :locale or options.keys.include? "locale"
-            locale="name_#{ options[:locale] }"
-            listed_attr.map! { |a| [a.send(locale),a.id] }
-            listed_attr.sort {|a,b| a.last <=> b.last } # maybe remove this line
-          else
-            listed_attr
-          end
-        else
-          super
-        end
-      end
-
-    end
-  end
-
-  module InstanceMethods
-    def delete_dicts_cache
-      method_name=DictType.revert(self.dict_type_id)
-      Rails.cache.delete("Dictionary.#{method_name}")
-      return true
-    end
-  end
-
-end
-ActiveRecord::Base.class_eval { include ActsAsDictionary }