degu 0.0.4

data/.gitignore

@@ -0,0 +1,6 @@
+.*.sw[pon]
+.DS_Store
+.rvmrc
+Gemfile.lock
+coverage
+pkg

data/Gemfile

@@ -0,0 +1,5 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+source :rubygems
+
+gemspec

data/README.rdoc

@@ -0,0 +1,150 @@
+= Degu
+
+Degu bundles the renum Enumeration implementation with the has_enum and has_set
+rails plugins.
+
+== Renum
+
+=== Description
+
+Renum provides a readable but terse enum facility for Ruby.  Enums are
+sometimes called object constants and are analogous to the type-safe enum
+pattern in Java, though obviously Ruby's flexibility means there's no such
+thing as type-safety.
+
+== Usage
+
+Renum allows you to do things like this:
+
+    enum :Status, %w( NOT_STARTED IN_PROGRESS COMPLETE )
+
+    enum :Size do
+      Small("Really really tiny")
+      Medium("Sort of in the middle")
+      Large("Quite big")
+
+      attr_reader :description
+
+      def init description
+        @description = description
+      end
+    end
+
+    module MyNamespace
+      enum :FooValue, [ :Bar, :Baz, :Bat ]
+    end
+
+Giving you something that satisfies this spec, plus a bit more:
+
+    describe "enum" do
+      
+      it "creates a class for the value type" do
+        Status.class.should == Class
+      end
+      
+      it "makes each value an instance of the value type" do
+        Status::NOT_STARTED.class.should == Status
+      end
+      
+      it "exposes array of values" do
+        Status.values.should == [Status::NOT_STARTED, Status::IN_PROGRESS, Status::COMPLETE]
+      end
+
+      it "provides an alternative means of declaring values where extra information can be provided for initialization" do
+        Size::Small.description.should == "Really really tiny"
+      end
+      
+      it "enumerates over values" do
+        Status.map {|s| s.name}.should == %w[NOT_STARTED IN_PROGRESS COMPLETE]
+      end
+      
+      it "indexes values" do
+        Status[2].should == Status::COMPLETE
+      end
+      
+      it "provides index lookup on values" do
+        Status::IN_PROGRESS.index.should == 1
+      end
+      
+      it "provides a reasonable to_s for values" do
+        Status::NOT_STARTED.to_s.should == "Status::NOT_STARTED"
+      end
+      
+      it "makes values comparable" do
+        Status::NOT_STARTED.should < Status::COMPLETE
+      end
+      
+      it "allows enums to be nested in other modules or classes" do
+        MyNamespace::FooValue::Bar.class.should == MyNamespace::FooValue
+      end
+      
+    end
+
+=== Rails[http://www.rubyonrails.com/] Integration
+
+To use enumerated values as ActiveRecord attribute values, use the
+constantize_attribute plugin
+(https://github.com/duelinmarkers/constantize_attribute/tree) (also by me).
+
+    class Vehicle < ActiveRecord::Base
+      enum :Status do
+        New()
+        Used()
+        Salvage(true)
+        
+        def init(warn = false)
+          @warn = warn
+        end
+        
+        def requires_warning_buyer?
+          @warn
+        end
+      end
+      
+      constantize_attribute :status
+      
+    end
+
+    v = Vehicle.create! :status => Vehicle::Status::New
+    # Now the database has the string "Vehicle::Status::New",
+    # but your record object exposes the Status object:
+    v.status.requires_warning_buyer?          # => false
+
+    v.update_attribute :status, Vehicle::Status::Salvage
+    # Now the database has the string "Vehicle::Status::Salvage".
+    v.status.requires_warning_buyer?          # => true
+
+    # Since constantize_attribute also accepts strings, it's easy
+    # to use enumerated values with forms.
+    v.status = "Vehicle::Status::Used"
+    v.status.requires_warning_buyer?          # => false
+
+=== License
+
+This code is free to use under the terms of the MIT license. 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+=== Contact
+
+Renum was created by John D. Hume. Comments are welcome. Send an email to
+duelin dot markers at gmail or "contact me via my
+blog[http://elhumidor.blogspot.com/].
+

data/Rakefile

@@ -0,0 +1,27 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+require 'rspec'
+require 'gem_hadar'
+
+GemHadar do
+  name        'degu'
+  author      'Florian Frank'
+  email       'dev@pkw.de'
+  homepage    "http://github.com/caroo/#{name}"
+  summary     'Library for enums and bitfield sets.'
+  description 'Library that includes enums, and rails support for enums and bitfield sets.'
+  test_dir    'test'
+  test_files  Dir['test/**/*_test.rb']
+  spec_dir    'spec'
+  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', '.rvmrc', 'coverage', '.DS_Store'
+  readme      'README.rdoc'
+
+  dependency  'activerecord', '~> 3.0'
+
+  development_dependency 'mocha'
+  development_dependency 'sqlite3'
+  development_dependency 'rspec'
+end
+
+desc 'Run specs and tests'
+task :default => [ :test, :spec ]

data/VERSION

@@ -0,0 +1 @@
+0.0.4

data/degu.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "degu"
+  s.version = "0.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Florian Frank"]
+  s.date = "2011-12-08"
+  s.description = "Library that includes enums, and rails support for enums and bitfield sets."
+  s.email = "dev@pkw.de"
+  s.extra_rdoc_files = ["README.rdoc", "lib/degu/has_enum.rb", "lib/degu/has_set.rb", "lib/degu/polite.rb", "lib/degu/renum/enumerated_value.rb", "lib/degu/renum/enumerated_value_type_factory.rb", "lib/degu/renum.rb", "lib/degu/rude.rb", "lib/degu/version.rb", "lib/degu.rb"]
+  s.files = [".gitignore", "Gemfile", "README.rdoc", "Rakefile", "VERSION", "degu.gemspec", "lib/degu.rb", "lib/degu/has_enum.rb", "lib/degu/has_set.rb", "lib/degu/polite.rb", "lib/degu/renum.rb", "lib/degu/renum/enumerated_value.rb", "lib/degu/renum/enumerated_value_type_factory.rb", "lib/degu/rude.rb", "lib/degu/version.rb", "spec/renum_spec.rb", "spec/spec_helper.rb", "test/has_enum_test.rb", "test/has_set_test.rb", "test/test_helper.rb", "test_helper.rb"]
+  s.homepage = "http://github.com/caroo/degu"
+  s.rdoc_options = ["--title", "Degu - Library for enums and bitfield sets.", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.11"
+  s.summary = "Library for enums and bitfield sets."
+  s.test_files = ["test/has_enum_test.rb", "test/has_set_test.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<gem_hadar>, ["~> 0.1.3"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.0"])
+    else
+      s.add_dependency(%q<gem_hadar>, ["~> 0.1.3"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<activerecord>, ["~> 3.0"])
+    end
+  else
+    s.add_dependency(%q<gem_hadar>, ["~> 0.1.3"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<activerecord>, ["~> 3.0"])
+  end
+end

data/lib/degu/has_enum.rb

@@ -0,0 +1,79 @@
+require "degu/renum"
+
+module Degu
+  module HasEnum
+    def self.included(modul)
+      modul.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+       # Use like this
+       #
+       #   class Furniture
+       #     has_enum :colors, :column_name => :custom_color_type
+       #   end
+      def has_enum(enum_name, options={})
+
+        enum_column = options.has_key?(:column_name) ? options[:column_name].to_s : "#{enum_name}_type"
+
+        self.send("validate", "#{enum_column}_check_for_valid_type_of_enum")
+
+        # throws a NameError if Enum Class doesn't exists
+        enum_class = options.has_key?(:class_name) ? options[:class_name].to_s.constantize : enum_name.to_s.camelize.constantize
+
+        # Enum must be a Renum::EnumeratedValue Enum
+        raise ArgumentError, "expected Renum::EnumeratedValue" unless enum_class.superclass == Renum::EnumeratedValue
+
+        define_method("reset_enum_changed") do
+          @enum_changed = false
+        end
+        after_save :reset_enum_changed
+
+        define_method("#{enum_name}") do
+          begin
+            return self[enum_column].present? ? enum_class.const_get(self[enum_column]) : nil
+          rescue NameError => e
+            return nil
+          end
+        end
+
+        define_method("#{enum_column}=") do |enum_literal|
+          unless enum_literal == self[enum_column]
+            self[enum_column] = enum_literal
+            @enum_changed = true
+          end
+        end
+
+        define_method("#{enum_name}=") do |enum_to_set|
+          old_value = self[enum_column]
+          enum_resolved = enum_class[enum_to_set]
+          if enum_to_set.to_s.strip.empty?
+            self[enum_column] = nil
+          elsif enum_resolved
+            self[enum_column] = enum_resolved.name
+          else
+            raise ArgumentError, "could not resolve #{enum_to_set.inspect}"
+          end
+          @enum_changed ||= self[enum_column] != old_value
+        end
+
+        define_method("#{enum_name}_has_changed?") do
+          !!@enum_changed
+        end
+
+        define_method("#{enum_column}_check_for_valid_type_of_enum") do
+          return true if self[enum_column].nil? || self[enum_column].to_s.empty?
+          begin
+            enum_class.const_get(self[enum_column])
+          rescue NameError => e
+            self.errors.add(enum_column.to_sym, "Wrong type '#{self[enum_column]}' for enum '#{enum_name}'")
+            return false
+          end
+          return true
+        end
+      end
+
+    end
+  end
+end

data/lib/degu/has_set.rb

@@ -0,0 +1,110 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'active_support'
+require 'active_record'
+module Degu
+  module HasSet
+    VERSION = '0.0.4'
+
+    module ClassMethods
+      # Use like this:
+      #
+      #   class Person < ActiveRecord::Base
+      #     has_set :interests
+      #   end
+      def has_set(set_name, options = {})
+
+        set_column = options.has_key?(:column_name) ? options[:column_name].to_s : "#{set_name}_bitfield"
+
+        begin
+          enum_class = options.has_key?(:enum_class) ? options[:enum_class] : set_name.to_s.camelcase.constantize
+        rescue NameError => ne
+          raise NameError, "There ist no class to take the set entries from (#{ne.message})."
+        end
+
+        # Extend enum_class with field_name method
+        enum_class.class_eval <<-EOF
+          def field_name
+            '#{set_name.to_s.singularize}_' + self.name.underscore
+          end
+        EOF
+
+        define_method("#{set_name}=") do |argument_value|
+          self[set_column] = 
+            unless argument_value.nil?
+              set_elements =
+                if String === argument_value
+                  argument_value.split(',').map(&:strip)
+                else
+                  Array(argument_value)
+                end.map do |set_element|
+                  enum_class[set_element]
+                end
+              set_elements.all? or raise ArgumentError, "element #{argument_value.inspect} contains invalid elements"
+              value = 0
+              set_elements.each do |set_element|
+                mask = 1 << set_element.bitfield_index
+                if mask & value == mask
+                  next
+                else
+                  value |= mask
+                end
+              end
+              value
+            end
+        end
+
+        define_method(set_name) do
+          value = self[set_column]
+          case
+          when value.blank?
+            ;;
+          when value.zero?
+            []
+          else
+            set_elements = enum_class.values.select do |enum_element|
+              send("#{set_name.to_s.singularize}_#{enum_element.name.underscore}?")
+            end
+            # special to_s method for element-array
+            class << set_elements
+              def to_s
+                map(&:name) * ', '
+              end
+            end
+            set_elements
+          end
+        end
+
+        # TODO: This should be a class method
+        define_method("available_#{set_name}") do
+          self.methods.grep(/#{set_name.to_s.singularize}_\w+[^\?=]$/).sort.map(&:to_s)
+        end
+
+        enum_class.values.each do |enum|
+          define_method("#{set_name.to_s.singularize}_#{enum.name.underscore}?") do
+            mask = 1 << enum.bitfield_index
+            self[set_column] & mask == mask
+          end
+
+          alias_method :"#{set_name.to_s.singularize}_#{enum.name.underscore}", :"#{set_name.to_s.singularize}_#{enum.name.underscore}?"
+
+          define_method("#{set_name.to_s.singularize}_#{enum.name.underscore}=") do |true_or_false|
+            mask = 1 << enum.bitfield_index
+            current_value = mask & self[set_column] == mask
+            true_or_false = true  if true_or_false.to_s == "true" || true_or_false.respond_to?(:to_i) && true_or_false.to_i == 1
+            true_or_false = false if true_or_false.to_s == "false" || true_or_false.respond_to?(:to_i) && true_or_false.to_i == 0
+
+            if current_value != true_or_false
+              true_or_false ? self[set_column] |= mask : self[set_column] &= ~mask
+            end
+          end
+        end
+      end
+    end
+
+    def self.included(modul)
+      modul.extend(ClassMethods)
+    end
+  end
+end

data/lib/degu/polite.rb

@@ -0,0 +1,6 @@
+module Degu
+end
+require 'degu/version'
+require 'degu/renum'
+require 'degu/has_set'
+require 'degu/has_enum'

data/lib/degu/renum/enumerated_value.rb

@@ -0,0 +1,226 @@
+require 'forwardable'
+begin
+  require 'json'
+rescue LoadError
+end
+
+module Degu
+  module Renum
+
+    # This is the superclass of all enumeration classes.
+    # An enumeration class is Enumerable over its values and exposes them by numeric index via [].
+    # Values are also comparable, sorting into the order in which they're declared.
+    class EnumeratedValue
+
+      class << self
+        include Enumerable
+        extend Forwardable
+
+        def_delegators :values, :first, :last, :each
+
+        # Returns an array of values in the order they're declared.
+        def values
+          @values ||= []
+        end
+
+        alias all values
+
+        # This class encapsulates an enum field (аctually a method with arity == 0).
+        class Field < Struct.new('Field', :name, :options, :block)
+          # Returns true if the :default option was given.
+          def default?
+            options.key?(:default)
+          end
+
+          # Returns the value of the :default option.
+          def default
+            options[:default]
+          end
+
+          # Returns true if a block was given.
+          def block?
+            !!block
+          end
+
+          # Determine the default value for the enum value +obj+ if +options+ is
+          # the options hash given to the init method.
+          def default_value(obj, options)
+            field_value = options[name]
+            if field_value.nil?
+              if default?
+                default_value = default
+              elsif block?
+                default_value = block[obj]
+              end
+            else
+              field_value
+            end
+          end
+
+          # Returns the name as a string.
+          def to_s
+            name.to_s
+          end
+
+          # Returns a detailed string representation of this field.
+          def inspect
+            "#<#{self.class}: #{self} #{options.inspect}>"
+          end
+        end
+
+        # Returns an array of all fields defined on this enum.
+        def fields
+          @fields ||= []
+        end
+
+        # Defines a field with the name +name+, the options +options+ and the
+        # block +block+. The only valid option at the moment is :default which is
+        # the default value the field is initialized with.
+        def field(name, options = {}, &block)
+          name = name.to_sym
+          fields.delete_if { |f| f.name == name }
+          fields << field = Field.new(name, options, block)
+          instance_eval { attr_reader field.name }
+        end
+
+        # Returns the value with the name +name+ and returns it.
+        def with_name name
+          values_by_name[name.to_s]
+        end
+
+        # Returns a hash that maps names to their respective values values.
+        def values_by_name
+          @values_by_name ||= values.inject({}) do |memo, value|
+            memo[value.name] = value
+            memo
+          end.freeze
+        end
+
+        # Returns the enum value for +index+. If +index+ is an Integer the
+        # index-th enum value is returned. Otherwise +index+ is converted into a
+        # String. For strings that start with a capital letter the with_name
+        # method is used to determine the enum value with the name +index+. If
+        # the string starts with a lowercase letter it is converted into
+        # camelcase first, that is foo_bar will be converted into FooBar, before
+        # with_name is called with this new value.
+        def [](index)
+          case index
+          when Integer
+            values[index]
+          when self
+            values[index.index]
+          else
+            name = index.to_s
+            case name
+            when /\A(\d+)\Z/
+              return values[$1.to_i]
+            when /\A[a-z]/
+              name = name.gsub(/(?:\A|_)(.)/) { $1.upcase }
+            end
+            with_name(name)
+          end
+        end
+
+        # Returns the enum instance stored in the marshalled string +string+.
+        def _load(string)
+          with_name Marshal.load(string)
+        end
+
+        if defined?(::JSON)
+          # Fetches the correct enum determined by the deserialized JSON
+          # document.
+          def json_create(data)
+            JSON.deep_const_get(data[JSON.create_id])[data['name']]
+          end
+        end
+      end
+
+      include Comparable
+
+      # Name of this enumerated value as a string.
+      attr_reader :name
+
+      # Index of this enumerated value as an integer.
+      attr_reader :index
+
+      alias_method :id, :index
+
+      # Creates an enumerated value named +name+ with a unique autoincrementing
+      # index number.
+      def initialize name
+        @name = name.to_s.freeze
+        @index = self.class.values.size
+        self.class.values << self
+      end
+
+      # This is the standard init method method which has an arbitrary number of
+      # arguments. If the last argument is a Hash and its keys are defined fields
+      # their respective values will be used to initialize the fields. If you
+      # want to use this method from an enum and define your own custom init
+      # method there, don't forget to call super from your method.
+      def init(*args)
+        if Hash === options = args.last
+          for field in self.class.fields
+            instance_variable_set "@#{field}", field.default_value(self, options)
+          end
+        end
+      end
+
+      # Returns the fully qualified name of the constant referring to this value.
+      # Don't override this if you're using Renum with the constantize_attribute
+      # plugin, which relies on this behavior.
+      def to_s
+        "#{self.class}::#{name}"
+      end
+
+      # Sorts enumerated values into the order in which they're declared.
+      def <=> other
+        index <=> other.index
+      end
+
+      # Returns a marshalled string for this enum instance.
+      def _dump(limit = -1)
+        Marshal.dump(name, limit)
+      end
+
+      if defined?(::JSON)
+        # Set the given fields in the +obj+ hash
+        def set_fields(obj, fields)
+          fields.each do |f|
+            name = f.name
+            value = instance_variable_get("@#{name}")
+            value.nil? and next
+            obj[name] = value
+          end
+        end
+
+        # Returns an enum (actually more a reference to an enum) serialized as a
+        # JSON document.
+        def as_json(opts = {}, *a)
+          opts ||= {}
+          obj = {
+            JSON.create_id => self.class.name,
+            :name          => name,
+          }
+          case fields_opt = opts[:fields]
+          when nil, false
+          when true
+            set_fields obj, self.class.fields
+          when Array
+            fields_opt = fields_opt.map(&:to_sym)
+            set_fields obj, self.class.fields.select { |field| fields_opt.include?(field.name) }
+          else
+            raise ArgumentError, "unexpected fields option #{fields_opt.inspect}"
+          end
+          obj.as_json(opts)
+        end
+
+        def to_json(opts, *a)
+          obj = as_json(opts)
+          opts.respond_to?(:fields) and opts.delete(:fields)
+          obj.to_json(opts, *a)
+        end
+      end
+    end
+  end
+end