active_enumeration 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 223d109ab6d201e3f8584ebc9fe3ba20402a4e4d
+  data.tar.gz: fa0283d584c8b94ef1c6cd490ad6c50d4920e5d8
+SHA512:
+  metadata.gz: 1f4116d54cc911e9f352079440806058a4404ad8639cf93de1a10f9fb54d0083e2ed96e80d5396a17e79815d3184bedb5db9a0c0dcf37f505d64054e04b49d21
+  data.tar.gz: 9c297672df23f9394cea61922e633e06088201438ffcf59ee0383afdeaefe3d47164eeec97c6982ae018e46e9e82f329f8910c941fed45e25dec5948bb666a36

data/lib/active_enumeration/base.rb

@@ -0,0 +1,134 @@
+require 'active_support/inflector'
+
+module ActiveEnumeration
+  class Base
+
+    def self.find(id)
+      id = id.to_i
+      @instances ||= {}
+      unless @instances[id] || !@active_enumeration_values[id]
+        @instances[id] = self.new *@active_enumeration_values[id]
+      end
+      @instances[id]
+    end
+
+    def self.all
+      @active_enumeration_values.keys.map { |id| self.find(id) }
+    end
+
+    def self.count
+      @active_enumeration_values.count
+    end
+
+    def self.to_a
+      all.map { |e| [e.to_s, e.instance_variable_get("@active_enumeration_id")] }
+    end
+
+    def symbol
+      self.instance_variable_get("@symbol")
+    end
+
+    protected
+
+    def self.attr_reader(*attributes)
+      super
+      @active_enumeration_attributes ||= []
+      @active_enumeration_attributes.concat(attributes.map(&:to_sym))
+    end
+
+    def initialize(*attributes)
+      key_index = self.class.active_enumeration_index_location
+      self.instance_variable_set("@active_enumeration_id", attributes[key_index].to_i)
+
+      self.class.active_enumeration_attributes.each_with_index do |attr_name, index|
+        self.instance_variable_set("@#{attr_name}", attributes[index])
+      end
+    end
+
+    def self.active_enumeration_attributes
+      @active_enumeration_attributes
+    end
+
+    def self.active_enumeration_symbols
+      @active_enumeration_symbols
+    end
+
+    def self.active_enumeration_index_location
+      active_enumeration_attributes.index(:id) || 0
+    end
+
+    def self.values(values)
+      @active_enumeration_values ||= Hash.new
+      @active_enumeration_symbols ||= Hash.new
+
+      if values.class == Hash
+        values.each_with_index { |(k, v), i| handle_hash_values(k, v, i) }
+      elsif values.class == Array
+        values.each_with_index { |v, i| handle_array_values(v, i) }
+      end
+    end
+
+    def self.groups(hash)
+      hash.each do |group, ids|
+        self.send(:define_singleton_method, group) do
+          ids.map { |id| self.find(id) }
+        end
+      end
+    end
+
+    def self.belongs_to(name, options = {})
+      class_name = (options[:class_name] || name.to_s.camelize).to_s
+      foreign_key = (options[:foreign_key] || "#{name}_id").to_s
+      
+      self.send(:define_method, name) {
+        klass = class_name.constantize
+        klass.find(self.send(foreign_key))
+      }
+
+      self.send(:define_singleton_method, "active_enumeration_belongs_to_#{class_name.underscore}".upcase) {
+        var_name = "@active_enumeration_belongs_to_#{class_name.underscore}"
+        return instance_variable_get(var_name) if instance_variable_get(var_name)
+        hash = Hash.new {Array.new}
+        self.all.each do |obj|
+          hash[obj.send(foreign_key)] = hash[obj.send(foreign_key)] << obj
+        end
+        instance_variable_set(var_name, hash)
+        hash
+      }
+    end
+
+    def self.has_many(name, options = {})
+      class_name = (options[:class_name] || name.to_s.singularize.camelize).to_s
+      self.send(:define_method, name) {
+        klass = class_name.constantize
+        klass.send("active_enumeration_belongs_to_#{self.class.name.underscore}".upcase)[self.id]
+      }
+    end
+
+    private
+
+    def self.handle_hash_values(k, v, i)
+      v = [v] unless v.class == Array
+      values_key = v[active_enumeration_index_location].to_i
+      @active_enumeration_values[values_key] = v
+
+      unless active_enumeration_attributes.index(:symbol)
+        @active_enumeration_symbols[values_key] = k.to_sym
+        self.send(:define_method, :symbol) { self.class.active_enumeration_symbols[self.instance_variable_get("@active_enumeration_id")] }
+      end
+
+      self.send(:define_singleton_method, k) { self.find(values_key) }
+
+      self.send(:define_method, "#{k}?") { self.instance_variable_get("@active_enumeration_id") == values_key }
+
+      const_set(k.to_s.upcase, values_key)
+    end
+
+    def self.handle_array_values(v, i)
+      v = [v] unless v.class == Array
+      values_key = v[active_enumeration_index_location].to_i
+      @active_enumeration_values[values_key] = v
+    end
+
+  end
+end

data/lib/active_enumeration.rb

@@ -0,0 +1,41 @@
+require 'active_support/inflector'
+require 'active_enumeration/base'
+
+module ActiveEnumeration
+
+  def self.extended(receiver)
+    receiver.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    def has_active_enumeration_for(name, options = {})
+      class_name = (options[:class_name] || name.to_s.camelize).to_s
+      foreign_key = (options[:foreign_key] || "#{name}_id").to_s
+
+      self.send(:define_method, name) do
+        klass = class_name.constantize
+        klass.find(self.send(foreign_key))
+      end
+
+      self.send(:define_method, "#{name}=") do |enum_obj|
+        self.send("#{foreign_key}=", enum_obj.instance_variable_get("@active_enumeration_id"))
+      end
+    end
+
+    def has_active_enumerations_for(name, options = {})
+      class_name = (options[:class_name] || name.to_s.camelize).to_s
+      foreign_key = (options[:foreign_key] || "#{name.to_s.singularize}_ids").to_s
+
+      self.send(:define_method, name) do
+        klass = class_name.constantize
+        self.send(foreign_key).map { |id| klass.find(id) }
+      end
+
+      self.send(:define_method, "#{name}=") do |enum_objs|
+        self.send("#{foreign_key}=", enum_objs.map { |obj| obj.instance_variable_get("@active_enumeration_id") })
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: active_enumeration
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Peter Lin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+description: A simpler way to create more complex Ruby enumerations, with ActiveRecord
+  like syntax and associations.
+email: peter@peterl.in
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_enumeration.rb
+- lib/active_enumeration/base.rb
+homepage: https://github.com/ptrln/active_enumeration
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: ActiveEnumeration
+test_files: []