rails_dictionary 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dictionary.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,12 @@
+= Intro
+Mapping web static data to Dictionary Class
+= Usage
+
+==
+Rail3
+          gem "dictionary",:git => 'git://github.com/raykin/dictionary'
+
+==
+
+==TODO
+Add test code.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc "Running Test"
+task :test do
+  system "ruby -I . test/dictionary_test.rb "
+end
+

data/dictionary.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dictionary/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rails_dictionary"
+  s.version     = Dictionary::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["raykin"]
+  s.email       = ["raykincoldxiao@campus.com"]
+  s.homepage    = "https://github.com/raykin/dictionary"
+  s.summary     = %q{dictionary data for application}
+  s.description = %q{mapping application static data to dictionary class and slave class}
+
+  s.rubyforge_project = "rails_dictionary"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/dictionary/acts_as_dict_slave.rb

@@ -0,0 +1,59 @@
+module ActsAsDictSlave
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    # argument except will remove dynamic column method
+    # argument add will add dynamic column method
+    def acts_as_dict_slave(ops={})
+      @@dict_columns = dict_columns(ops)
+      unless @@dict_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.downcase.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_columns.each { |e| belongs_to "#{e.to_s}_dict".to_sym,class_name: "Dictionary",foreign_key: e }
+      @@dict_columns.each { |ele| named_dict_value ele.to_sym }
+    end
+  end
+
+  module DynamicInsMethods
+    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=:en |
+        # arg.first ? locale = "name_#{arg.first}" : locale ='name_en'
+        locale ="name_#{locale}"
+        self.send(belongs_to_name).try(:send,locale)
+      end
+    end
+
+  end
+
+end
+ActiveRecord::Base.class_eval { include ActsAsDictSlave }

data/lib/dictionary/acts_as_dict_type.rb

@@ -0,0 +1,58 @@
+require "rails"
+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
+
+        def self.revert(arg)
+          if arg.class == String
+            DictType.find_by_name(arg).id
+          elsif arg.class == Fixnum
+            DictType.find_by_id(arg).name
+          end
+        end
+
+        #TODO: get a more accurate method name
+        def self.tab_and_column
+          @tab_and_column={}
+          @all_types=all_types
+          #TODO: any better way to retrive the class name in app/model ?
+          # Here maybe a problem when class like Ckeditor::Asset(.name.underscore => "ckeditor/asset"
+          all_tabs=ActiveRecord::Base.connection.tables.sort.reject! do |t|
+            ['schema_migrations', 'sessions'].include?(t)
+          end
+          all_class=all_tabs.map(&:singularize)
+          all_tabs=all_class
+          @tab_and_column=@all_types.extract_to_hash(all_tabs)
+        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/dictionary/acts_as_dictionary.rb

@@ -0,0 +1,46 @@
+module ActsAsDictionary
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def acts_as_dictionary
+      self.class_eval do
+        include InstanceMethods
+        belongs_to :dict_type
+        after_save :delete_dicts_cache
+        after_destroy :delete_dicts_cache
+
+        # TODO: need to add more function
+        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}") { Dictionary.joins(:dict_type).where('dict_types.name'=>method_name).all }
+            listed_attr=Rails.cache.read("Dictionary.#{method_name}").dup
+            if 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 one
+            else
+              listed_attr
+            end
+          else
+            super
+          end
+        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 }

data/lib/dictionary/array_core_ext.rb

@@ -0,0 +1,13 @@
+class Array
+  # returning a hash,not array
+  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/dictionary/version.rb

@@ -0,0 +1,3 @@
+module Dictionary
+  VERSION = "0.0.1"
+end

data/lib/dictionary.rb

@@ -0,0 +1,8 @@
+
+#require "active_record"
+require "dictionary/array_core_ext"
+require "dictionary/acts_as_dictionary"
+require "dictionary/acts_as_dict_slave"
+require "dictionary/acts_as_dict_type"
+
+

data/test/dictionary_test.rb

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+# min test
+require "test/unit"
+require "active_support"
+require "active_record"
+require "ruby-debug"
+Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store
+require "active_support/cache"
+require "rails"
+# $: << "/home/raykin/studio/dictionary/lib" # tmply added for local testing
+require "#{File.dirname(__FILE__)}/../lib/dictionary.rb"
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+$stdout = StringIO.new
+
+def setup_db
+  ActiveRecord::Base.logger
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :dict_types do |t|
+      t.string :name
+      t.string :comment
+      t.timestamps
+    end
+    create_table :dictionaries do |t|
+      t.string :name_en
+      t.string :name_zh
+      t.string :name_fr
+      t.integer :dict_type_id
+      t.timestamps
+    end
+    create_table :students do |t|
+      t.string :email
+      t.integer :city
+      t.integer :school
+      t.timestamps
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class DictType < ActiveRecord::Base
+  acts_as_dict_type
+end
+
+class Dictionary < ActiveRecord::Base
+  acts_as_dictionary
+end
+
+class Student < ActiveRecord::Base
+end
+
+
+class CoreExtTest < Test::Unit::TestCase
+  def test_array
+    expected_hash={:student => %w[school city],:admin => %w[role]}
+    assert_equal expected_hash, %w[student_school student_city admin_role].extract_to_hash(%w[student admin])
+    assert_equal expected_hash, %w[root student_school student_city admin_role].extract_to_hash(%w[student admin])
+  end
+end
+
+class DictTypeTest < Test::Unit::TestCase
+  def setup
+    setup_db
+    #Object.const_set('Student',Class.new(ActiveRecord::Base))
+    @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
+    Student.acts_as_dict_slave
+    # the acts_as_dict_slave need real data to generate dynamic method
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_tab_and_column
+    expected_hash={:student => %w[city school]}
+    assert_equal expected_hash,DictType.tab_and_column
+  end
+
+  def test_all_types
+    assert_equal %w[student_city student_school],DictType.all_types
+  end
+
+  # test revert method in acts_as_dict_type
+  def test_dt_revert
+    assert_equal "student_school",DictType.revert(@dt_stu_school.id)
+  end
+
+  def test_dictionary_method_missing
+    assert_equal [["shanghai",1],["beijing",2]],Dictionary.student_city(:locale => :en)
+  end
+
+  def test_dictionary_method_missing_with_locale
+    assert_equal [["上海", 1], ["北京", 2]],Dictionary.student_city(:locale => :zh)
+  end
+
+  # test dynamic instance methods in slave model
+  def test_named_city
+    assert_equal %w[city school],Student.columns_in_dict_type
+    assert_equal %w[city school],Student.dict_columns
+    assert_equal "shanghai",@stu_shanghai.named_city(:en)
+    assert_equal "Pékin",@stu_beijing.named_city(:fr)
+  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)
+    @dy_wuhan.destroy
+    assert_equal [["shanghai", 1], ["beijing", 2]],Dictionary.student_city(:locale => :en)
+    assert_equal [@dy_shanghai,@dy_beijing],Dictionary.student_city
+  end
+
+  def test_delete_all_caches
+    assert_equal %w[student_city student_school],DictType.all_types
+    @dt_stu_school.destroy
+    assert_equal %w[student_city],DictType.all_types
+  end
+
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: rails_dictionary
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- raykin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-26 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: mapping application static data to dictionary class and slave class
+email: 
+- raykincoldxiao@campus.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- dictionary.gemspec
+- lib/dictionary.rb
+- lib/dictionary/acts_as_dict_slave.rb
+- lib/dictionary/acts_as_dict_type.rb
+- lib/dictionary/acts_as_dictionary.rb
+- lib/dictionary/array_core_ext.rb
+- lib/dictionary/version.rb
+- test/dictionary_test.rb
+has_rdoc: true
+homepage: https://github.com/raykin/dictionary
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: rails_dictionary
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: dictionary data for application
+test_files: 
+- test/dictionary_test.rb