code-box 0.0.1 → 0.0.2

data/README.md

@@ -6,7 +6,7 @@ TODO: Write a gem description
 
 Add this line to your application's Gemfile:
 
-    gem 'code-attr'
+    gem 'code-box'
 
 And then execute:
 
@@ -14,11 +14,62 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install code-attr
+    $ gem install code-box
 
 ## Usage
 
-TODO: Write usage instructions here
+### Specifying attributes as codes
+
+There are cases you want to store 'named codes' instead artificial keys.
+Codes make sense for stable references and better readability of the raw data.
+
+There are several options to specify an attribute as a code:
+  1. Attribute is a code. There is no associated object involved, but simple I18n translation of the code
+  1. Attribute is a code. There exists a code object that is looked up on access.
+  1. Attribute is a code. There exists an AR code object that is looked up through AR association.
+
+#### Lookup through I18n
+
+Example
+
+    class Person
+      iclude CodeBox::CodeAttribute
+
+      attr_accessor :nationality_code
+    end
+
+The include will create the following methods in Person:
+
+  #nationality Will return the nationality looked up through I18n on key: 'activerecord.values.person.nationality_code.de: Germany', where de would 'de' the nationality code.
+
+
+
+#### Lookup through code object
+
+Example
+
+    class Person
+      iclude CodeBox::CodeAttribute
+
+      attr_accessor :nationality_code, :lookup_type => :lookup
+    end
+
+    class Code::Nationality
+      attr_accessor :code, :name
+
+      def lookup(code)
+        return the correct Code::Nationality for the passed code
+      end
+    end
+
+The include will create the following methods in Person:
+
+  #nationality Will return the nationality looked through lookup on the associated code object.
+
+
+#### Lookup through associated AR Code Object
+to be completed ...
+
 
 ## Contributing
 

data/lib/code-box/acts_as_code.rb

@@ -6,67 +6,125 @@ module CodeBox
   module ActsAsCode
     @opts = {}
 
-    def self.[](options={})
+    def self.[](*options)
       @opts = options
       self
     end
 
     def self.included(base)
       base.extend(ClassMethods)
-      base.acts_as_code(@opts)
+      base.acts_as_code(*@opts) if @opts.size > 0
     end
 
 
     module ClassMethods
       DefaultOptions = {
+          :model_type                => :poro,
           :code_attribute            => :code,
           :polymorphic               => false,
-          :position_attribute        => :position,
-          :uniqueness_case_sensitive => false
+          :uniqueness_case_sensitive => true,
+          :position_attr             => :position,
       }
 
-      def acts_as_code(options={})
+      def acts_as_code(*codes_and_or_options)
+        options        = codes_and_or_options.extract_options!
+        codes          = codes_and_or_options
         opts           = DefaultOptions.merge(options)
         code_attr      = opts[:code_attribute]
         position_attr  = opts[:position_attribute]
         case_sensitive = opts[:uniqueness_case_sensitive]
+        model_type     = opts.delete(:model_type)
 
-        order_expression = if position_attr then
-          "coalesce(#{position_attr.to_s}, #{code_attr.to_s})"
-        else
-          code_attr.to_s
+        # Create a constant for each code
+        codes.each do |code|
+          const_set("Code#{code.to_s.camelize}", code)
         end
 
-        class_eval <<-CODE
-          validates_presence_of   :#{code_attr}
-          validates_uniqueness_of :#{code_attr}#{opts[:polymorphic] ? ', :scope => :type' : ' '}, :case_sensitive => #{case_sensitive}
+        case model_type
 
-          default_scope order('#{order_expression}')
-
-          def self.initialize_cache
-            all.inject({}) {|hash, obj| hash[obj.#{code_attr}] = obj; hash }
-          end
-
-          def self.for(code)
-            code_cache[code]
-          end
-
-          def hash
-            (self.class.name + '#' + #{code_attr}).hash
-          end
+          when :active_record
+            order_expression = if self.attribute_names.include?(position_attr) then
+              "coalesce(#{position_attr.to_s}, #{code_attr.to_s})"
+            else
+              code_attr.to_s
+            end
 
-          def equal?(other)
-            other && is_a?(other.class) && #{code_attr} == other.#{code_attr}
-          end
-        CODE
+            class_eval <<-CODE
+              validates_presence_of   :#{code_attr}
+              validates_uniqueness_of :#{code_attr}#{opts[:polymorphic] ? ', :scope => :type' : ' '}, :case_sensitive => #{case_sensitive}
+
+              default_scope order('#{order_expression}')
+
+              def self.initialize_cache
+                all.inject({}) {|hash, obj| hash[obj.#{code_attr}] = obj; hash }
+              end
+
+              def self.lookup(code)
+                code_cache[code]
+              end
+
+              def hash
+                (self.class.name + '#' + #{code_attr}).hash
+              end
+
+              def equal?(other)
+                other && is_a?(other.class) && #{code_attr} == other.#{code_attr}
+              end
+
+              def ==(other)
+                self.equal? other
+              end
+            CODE
+
+            instance_eval <<-CODE
+              class << self
+                def code_cache
+                  @code_cache ||= initialize_cache
+                end
+              end
+            CODE
+
+          when :poro
+            order_attr = position_attr ? position_attr.to_s : code_attr.to_s
+
+            class_eval <<-CODE
+              def self.initialize_cache
+                all.inject({}) {|hash, obj| hash[obj.#{code_attr}] = obj; hash }
+              end
+
+              def self.lookup(code)
+                code_cache[code]
+              end
+
+              def hash
+                (self.class.name + '#' + #{code_attr}).hash
+              end
+
+              def equal?(other)
+                other && is_a?(other.class) && #{code_attr} == other.#{code_attr}
+              end
+
+              def ==(other)
+                self.equal? other
+              end
+
+              def self.all
+                raise "Sublass responsibility. You should implement '.all' returning all codes"
+              end
+            CODE
+
+            instance_eval <<-CODE
+              class << self
+                def code_cache
+                  @code_cache ||= initialize_cache
+                end
+              end
+            CODE
+
+          else
+            raise ArgumentError, "'#{model_type}' is not a valid type. Use :active_record or :poro(default) instead"
+        end
 
-        instance_eval <<-CODE
-          class << self
-            def code_cache
-              @code_cache ||= initialize_cache
-            end
-          end
-        CODE
       end
     end
   end

data/lib/code-box/code_attribute.rb

@@ -12,14 +12,14 @@ module CodeBox
     module ClassMethods
       DefaultOptions = {
         :foreign_code_attribute => :code,
-        :lookup                 => :i18n,
+        :lookup_type            => :i18n,
         :code_attribute_suffix  => 'code'
       }
 
       def code_attribute(*code_names)
         options                = code_names.extract_options!
         opts                   = DefaultOptions.merge(options)
-        lookup_type            = opts.delete(:lookup)
+        lookup_type            = opts.delete(:lookup_type)
         code_attr_suffix       = (opts.delete(:code_attribute_suffix) || "code").to_s
         foreign_code_attr_name = opts.delete(:foreign_code_attribute)
 
@@ -29,11 +29,12 @@ module CodeBox
           code_class_name = opts_copy.delete(:class_name) || "::Codes::#{code_name.to_s.camelize}"
 
           case lookup_type
-            when :cache
+
+            when :lookup
               class_eval <<-RUBY_
                 # getter
                 def #{code_name}
-                  code_class_name.constantize.for(value)
+                  #{code_class_name}.lookup(#{code_attr_name})
                 end
 
                 # setter
@@ -42,26 +43,39 @@ module CodeBox
                   #{code_attr_name} = value
                 end
               RUBY_
-            when :association
+
+            when :associated
               association_options = opts_copy.merge({
                   :class_name  => "#{code_class_name}",
                   :foreign_key => "#{code_attr_name}".to_sym,
                   :primary_key => "#{foreign_code_attr_name}"
               })
               belongs_to "#{code_name}".to_sym, association_options
+
             when :i18n
               class_eval <<-RUBY_
                 # getter
                 def #{code_name}(locale=I18n.locale)
-                  value = self.#{code_attr_name}
-                  value_key = value.nil? ? :null_value : value
-                  I18n.t("activerecord.\#{self.class.name.underscore}.values.#{code_attr_name}.\#{value_key}", :locale => locale)
+                  code = self.#{code_attr_name}
+                  self.class.translate_#{code_attr_name}(code, locale)
                 end
 
                 # setter
                 def #{code_name}=(code)
                   raise "#{code_name} is a i18n code and can not be set. Use the the correct method '#{code_attr_name}='' instead."
                 end
+
+                # translator
+                class << self
+                  def translate_#{code_attr_name}(code, locale=I18n.locale)
+                    codes = Array(code)
+                    tranlsated_codes = codes.map { |code|
+                      code_key = code.nil? ? :null_value : code
+                      I18n.t("activerecord.\#{self.name.underscore}.values.#{code_attr_name}.\#{code_key}", :locale => locale)
+                    }
+                    tranlsated_codes.size == 1 ? tranlsated_codes.first : tranlsated_codes
+                  end
+                end
               RUBY_
             else
               raise ArgumentError, "'#{lookup_type}' is not valid. Must be one of [:code_cache, :association]"

data/lib/code-box/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module CodeBox
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/code-box/test_acts_as_code.rb

@@ -4,11 +4,33 @@ require 'helper'
 
 class TestActsAsCode < Test::Unit::TestCase
 
-  def setup
 
+  def test_constants
+    assert_equal 'single', Codes::CivilStatus::CodeSingle
   end
 
-  def test_author_attributes_available
-    assert_equal 1,1
+  def test_constants
+    assert_equal 2, Codes::CivilStatus::all.size
+
+    assert_equal Codes::CivilStatus.lookup('single'),  Codes::CivilStatus::all.first
+    assert_equal Codes::CivilStatus.lookup('married'), Codes::CivilStatus::all.last
+  end
+
+
+  def test_ar_code_all
+    Codes::ArCode.create(:code => 'code_1', :name => "Code_1_name")
+    Codes::ArCode.create(:code => 'code_2', :name => "Code_2_name")
+
+    assert_equal 2, Codes::ArCode.all.size
   end
+
+
+  def test_ar_code_lookup
+    code_1 = Codes::ArCode.create(:code => 'code_1', :name => "Code_1_name")
+    code_2 = Codes::ArCode.create(:code => 'code_2', :name => "Code_2_name")
+
+    assert_equal code_2, Codes::ArCode.lookup('code_2')
+  end
+
+
 end

data/test/code-box/test_code_attribute.rb

@@ -7,8 +7,10 @@ class TestCodeAttribute < Test::Unit::TestCase
   def setup
   end
 
-  def test_acts_as_code_i18n_lookup
-    obj = Code::SampleClass.new(gender_code: 'f', country_iso: 'de')
+  # :type => :i18n -------------------------------------------------------------------
+  def test_code_attribute_i18n_lookup
+    obj = Codes::SampleClass.new(gender_code: 'f', country_iso: 'de')
+    I18n.locale =:en
 
     assert_equal('f',      obj.gender_code)
     assert_equal('female', obj.gender)
@@ -22,14 +24,64 @@ class TestCodeAttribute < Test::Unit::TestCase
     assert_equal('de',          obj.country_iso)
     assert_equal('Deutschland', obj.country(:de))
 
-    # I18n.locale = :de
+  end
+
+  def test_code_attribute_i18n_translator_with_single_code
+    I18n.locale = :de
+    translation = Codes::SampleClass.translate_gender_code('f')
+    assert_equal('weiblich', translation)
+
+    translation = Codes::SampleClass.translate_gender_code('f', :en)
+    assert_equal('female', translation)
+  end
+
+  def test_code_attribute_i18n_translator_with_multiple_codes
+    I18n.locale = :de
+    translation = Codes::SampleClass.translate_gender_code(['f', 'm'])
 
-    # assert_equal(obj.gender_code, 'f')
-    # assert_equal(obj.gender, 'weiblich')
+    assert translation.kind_of? Array
+    assert_equal('weiblich', translation.first)
+    assert_equal('männlich', translation.last)
 
-    # assert_equal(obj.country_iso, 'de')
-    # assert_equal(obj.country, 'Deutschland')
+    translation = Codes::SampleClass.translate_gender_code(['f', 'm'], :en)
+
+    assert translation.kind_of? Array
+    assert_equal('female', translation.first)
+    assert_equal('male', translation.last)
   end
 
 
+  # :type => :lookup -------------------------------------------------------------------
+  def test_code_attribute_lookup_default
+    code_single  = Codes::CivilStatus.lookup('single')
+    code_married = Codes::CivilStatus.lookup('married')
+
+    code_client  = Codes::SampleClass.new(:civil_status_code => 'single')
+
+    assert_equal('single',    code_client.civil_status_code)
+    assert_equal(code_single, code_client.civil_status)
+  end
+
+  def test_code_attribute_lookup_custom_code_name
+    code_child    = Codes::AgerType.new('child')
+    code_teenager = Codes::AgerType.new('teenager')
+
+    code_client  = Codes::SampleClass.new(:ager_type_code => 'child')
+
+    assert_equal('child',    code_client.ager_type_code)
+    assert_equal(code_child, code_client.ager_type)
+  end
+
+
+  # :type => :associated ----------------------------------------------------------------
+  def test_code_attribute_lookup_associated
+    code_ch  = Codes::Country.create(:code => 'CH', :name => 'Switzerland')
+    code_de  = Codes::Country.create(:code => 'DE', :name => 'Germany')
+
+    code_client  = Codes::SampleClass.new(:country_2_code => 'CH')
+
+    assert_equal('CH',    code_client.country_2_code)
+    assert_equal(code_ch, code_client.country_2)
+  end
+
 end

data/test/resources/locale/de.yml

@@ -2,7 +2,7 @@
 ---
 de:
   activerecord:
-    code/sample_class:
+    codes/sample_class:
       values:
         gender_code:
           f: weiblich

data/test/resources/locale/en.yml

@@ -2,7 +2,7 @@
 ---
 en:
   activerecord:
-    'code/sample_class':
+    codes/sample_class:
       values:
         gender_code:
           f: female

data/test/resources/models.rb

@@ -1,13 +1,67 @@
 # ------------------------------------------------------
 # Defined the respective AR Models
 # ------------------------------------------------------
-module Code
+module Codes
+
   class SampleClass < ActiveRecord::Base
-    self.table_name = :code_sample_class
+    self.table_name = :codes_sample_class
 
     include CodeBox::CodeAttribute
 
+    # i18n codes
     code_attribute :gender
-    code_attribute :country, :lookup => :i18n, :code_attribute_suffix => 'iso'
+    code_attribute :country,      :lookup_type => :i18n, :code_attribute_suffix => 'iso'
+
+    # lookup codes
+    code_attribute :civil_status, :lookup_type => :lookup, :class_name => 'Codes::CivilStatus'
+    code_attribute :ager_type,    :lookup_type => :lookup, :foreign_code_attribute => 'code_id'
+
+    code_attribute :country_2,    :lookup_type => :associated, :class_name => 'Codes::Country'
+  end
+
+  class CivilStatus
+    include CodeBox::ActsAsCode['single', 'married', :type => :poro]
+
+    attr_accessor :code
+
+    def initialize(code)
+      @code = code
+    end
+
+    def self.all
+      [
+        Codes::CivilStatus.new('single'),
+        Codes::CivilStatus.new('married'),
+      ]
+    end
   end
+
+  class AgerType
+    @@code_cache = {}
+    attr_accessor :code_id
+
+    def initialize(code)
+      @code_id = code
+      self.class.cache_code(self)
+    end
+
+    def self.cache_code(code_obj)
+      @@code_cache[code_obj.code_id] = code_obj
+    end
+
+    def self.lookup(code)
+      @@code_cache[code]
+    end
+  end
+
+  class Country < ActiveRecord::Base
+    self.table_name = :codes_country
+  end
+
+
+  class ArCode < ActiveRecord::Base
+    include CodeBox::ActsAsCode[:model_type => :active_record]
+    self.table_name = :codes_ar_code
+  end
+
 end

data/test/resources/schema.rb

@@ -3,10 +3,25 @@
 # ------------------------------------------------------
 ActiveRecord::Schema.define(:version => 0) do
 
-  create_table :code_sample_class, :force => true do |t|
+  create_table :codes_sample_class, :force => true do |t|
     t.string :gender_code
     t.string :country_iso
+
+    t.string :civil_status_code
+    t.string :ager_type_code
+
+    t.string :country_2_code
   end
 
+  create_table :codes_country, :force => true do |t|
+    t.string :code
+    t.string :name
+  end
+
+  create_table :codes_ar_code, :force => true do |t|
+    t.string  :code
+    t.string  :name
+    t.integer :position
+  end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code-box
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-14 00:00:00.000000000 Z
+date: 2012-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord