constant-enum 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 759b1b09e07e81784485573cadc9485f804f7b8b
+  data.tar.gz: 62fde98228b95a70b876ad8a06ca7f13ed077b0c
+SHA512:
+  metadata.gz: 7193c5713e5644d3d21389fbf8b53c4ac7506c6e5e51b3451bf837ee48acca71427b478989ab333dd09f6d294deb1049b0a8333ebffdb3602497b5ce17bde82b
+  data.tar.gz: 4bc596e832968f4e168d677cffc6c09ca685e3a9afb004baaf0f6089f80076ec2e09fb1160634d299b513c8cdb8e89495fd903d85ae63ec46ecef7c54d98fbe9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in constant-enum.gemspec
+gemspec

data/README.md

@@ -0,0 +1,102 @@
+# Constant::Enum
+
+ActiveRecord-like model for dealing with constant data.  Works well with
+[ActiveRecord 4.x enums](http://api.rubyonrails.org/classes/ActiveRecord/Enum.html).
+In their basic form, ActiveRecord enums are very simplistic, so this gem seeks to
+add more robust functionality.
+
+This does not have any dependencies and could be used standalone, with Sinatra, etc.
+
+## Usage
+
+First, create a class that inherits from `ConstantEnum::Base`, similar to how you would
+create an `ActiveRecord::Base` class.  This will hold your enum names and IDs.
+
+In the simplest structure, you specify a name and an integer ID.  Imagine we're creating
+an action sports blog that will cover certain genres, which we know ahead of time:
+
+    class Genre < ConstantEnum::Base
+      enum_of skate: 1,
+              surf:  2,
+              snow:  3,
+              bike:  4
+    end
+
+Then, in any ActiveRecord class that wants to use this enum, you specify this enum class:
+
+    class Video < ActiveRecord::Base
+      enum genre: Genre.enum
+
+      # other code...
+    end
+
+Once setup, you can now do things like:
+
+    @genre  = Genre.find_by_name!(:skate)
+    @videos = Video.where(genre: @genre)
+
+For convenience, the class method `[]` will return the ID from the name, enabling a
+shortcut calling form:
+
+    @videos = Video.where(genre: Genre[:skate])
+
+In addition to translating names to IDs, several helper methods are provided to make
+day-to-day life easier:
+
+    @genre = Genre.find_by_name!(:skate)
+    @genre.name  # :skate
+    @genre.slug  # "skate"
+    @genre.title # "Skate" - requires Rails (ActiveSupport Inflector)
+
+You can create interesting route URLs by using these in Rails `config/routes.rb`:
+
+    # /videos/bike, /videos/surf, etc
+    get 'videos/:genre' => 'videos#index', as: 'videos_genre',
+      constraints: { genre: Genre.all.map(&:slug) }
+
+Then using the shortcut form show above, you can (safely) do a query with this param:
+
+    @videos = Video.where(genre: Genre[ params[:genre] ])
+
+This will raise `ConstantEnum::RecordNotFound`, which you can catch in your controllers to provide a clean error:
+
+    rescue_from ActiveRecord::RecordNotFound, ConstantEnum::RecordNotFound do
+      # show error page
+    end
+
+When building forms, you can use the special method `dropdown`, which provides options in the
+same order that Rails form helpers expect them:
+
+     <%= f.input :genre, label: 'Genre', collection: Genre.dropdown %>
+
+This will create a nice human-readable select list with the correct names and values.
+
+Finally, if you have extra data for your enum, you can instead specify a hash:
+
+    class AssetType < ConstantEnum::Base
+      enum_of photo: {id: 1, type: 'jpg', bucket: 'photos'},
+              video: {id: 2, type: 'mp4', bucket: 'videos'}
+
+      # other code...
+    end
+
+Then, retrieving a constant "record" will give you these attributes:
+
+    @at = AssetType.find_by_type!('jpg')
+    @at.id  # 1
+    @at.bucket  # 'photos'
+
+You can even use `where` to return a list:
+
+    @ats = AssetType.where(type: 'jpg')
+    @ats = AssetType.where(bucket: 'videos')
+
+And so on.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nateware/constant-enum
+
+## Copyright
+
+Copyright (c) [Nate Wiger](http://github.com/nateware). All Rights Reserved. Released under the MIT License.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "constant_enum"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/constant-enum.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'constant_enum/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "constant-enum"
+  spec.version       = ConstantEnum::VERSION
+  spec.authors       = ["Nate Wiger"]
+  spec.email         = ["nwiger@gmail.com"]
+
+  spec.summary       = %q{ActiveRecord-like model for constant data.}
+  spec.description   = %q{ActiveRecord-like model for constant data. Designed to work well with ActiveRecord enums.}
+  spec.homepage      = "https://github.com/nateware/constant-enum"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "activesupport"
+end

data/lib/constant-enum.rb

@@ -0,0 +1 @@
+require 'constant_enum'

data/lib/constant_enum.rb

@@ -0,0 +1,2 @@
+require 'constant_enum/base'
+require 'constant_enum/version'

data/lib/constant_enum/base.rb

@@ -0,0 +1,190 @@
+module ConstantEnum
+  class RecordNotFound < StandardError; end
+  #
+  # This supports the creation of a constant class that is designed to work
+  # well with ActiveRecord enums. The benefit is you get additional functionality,
+  # like finders and slugs. Performance is excellent as these are in-memory
+  # structures and not DB calls.
+  #
+  # In the simplest structure, you specify a name and an integer ID:
+  #
+  #   class Genre < ConstantEnum::Base
+  #     enum_of skate:      1,
+  #             surf:       2,
+  #             snow:       3,
+  #             bike:       4,
+  #   end
+  #
+  # Then, in an ActiveRecord class that wants to use this enum:
+  #
+  #   class Video < ActiveRecord::Base
+  #     enum genre: Genre.enum
+  #     ...
+  #   end
+  #
+  #  From there, you can now do things like:
+  #
+  #   @genre  = Genre.find_by_name!(:skate)
+  #   @videos = Video.where(genre: genre)
+  #
+  # Interesting routes can be created like:
+  #
+  #   # /videos/bike, /videos/surf, etc
+  #   get 'videos/:genre' => 'videos#index', as: 'videos_genre',
+  #     constraints: { genre: Genre.all.map(&:slug) }
+  #
+  # If you have extra data for your enum, you can specify a hash:
+  #
+  #   class AssetType < ConstantEnum::Base
+  #     enum_of \
+  #       photo: {id: 1, type: 'jpg', bucket: 'photos'},
+  #       video: {id: 2, type: 'mp4', bucket: 'videos'}
+  #
+  class Base < Struct.new(:name, :id, :attributes)
+    extend Enumerable
+
+    def self.enum_of(hash)
+      raise ArgumentError, "#{self}.enum_of name1: id2, name2: id2" unless hash.is_a?(Hash)
+      @data = {}
+      @enum = {}
+      hash.each do |name,value|
+        if value.is_a?(Hash)
+          @enum[name] = value[:id] # for Rails
+          @data[name] = new(name, value[:id], value)
+        else
+          @enum[name] = value # for Rails
+          @data[name] = new(name, value)
+        end
+
+        # Create constants such as ADMIN=1 etc
+        const_name =
+          name.to_s.upcase.strip.gsub(/[-\s]+/,'_').sub(/^[0-9_]+/,'').gsub(/\W+/,'')
+        const_set const_name, @enum[name] unless const_defined?(const_name)
+      end
+    end
+
+    # Just return the hash. For use in ActiveRecord models, eg "enum role: Role.enum"
+    def self.enum
+      @enum
+    end
+
+    # Role[:admin] => 1 ; also Role[1] => 1 so models don't have to care.
+    def self.[](what)
+      if what.is_a?(Integer)
+        find(what).id
+      else
+        find_by_name!(what).id
+      end
+    end
+
+    def self.find_by_name!(name)
+      find_by!(name: name)
+    end
+
+    def self.find_by_name(name)
+      find_by_name!(name) rescue nil
+    end
+
+    def self.find_by_slug!(slug)
+      find_by!(slug: slug)
+    end
+
+    def self.find_by_slug(slug)
+      find_by!(slug: slug) rescue nil
+    end
+
+    def self.find(id)
+      find_by!(id: id)
+    end
+
+    def self.find_by_id(id)
+      find(id) rescue nil
+    end
+
+    def self.find_by(hash)
+      where(hash).first
+    end
+
+    def self.find_by!(hash)
+      find_by(hash) or
+        raise RecordNotFound,
+           %Q(Couldn't find #{self} with #{hash.collect{|k,v| "#{k}=#{v.inspect}"} * ' '})
+    end
+
+    def self.all
+      where()
+    end
+
+    # Allow simple detection, similar to ActiveRecord.  This method is a little
+    # verbose because we need to mimic where({}) which returns everything.
+    # It also supports where(type: 'video', active: true) for multiple restrictions.
+    def self.where(hash={})
+      raise RecordNotFound, "No records defined for #{self}" if @data.nil?
+      results = []
+      @data.each do |name,struct|
+        found = true # where({})
+        hash.each do |k,v|
+          if k.to_s == 'name'
+            found = false if name.to_s != v.to_s
+          else
+            found = false if struct.send(k) != v
+          end
+        end
+        # for where({})
+        results << struct if found
+      end
+      results
+    end
+
+    # Enumerable support
+    def self.each(&block)
+      all.each(&block)
+    end
+    singleton_class.send :alias_method, :find_each, :each
+
+    def self.ids
+      enum.map{|r| r.last}
+    end
+
+    def self.names
+      enum.map{|r| r.first}
+    end
+
+    def self.count
+      enum.keys.length
+    end
+
+    # Dropdown is actually [Title, name] for Rails 4.1 enums
+    def self.dropdown
+      enum.collect{|name,id| [name.to_s.titleize, name] }
+    end
+
+    #
+    # Instance methods: @role = Role.new ; @role.slug
+    #
+    def slug
+      name.to_s.downcase.gsub(/\W+/,'')
+    end
+
+    def title
+      name.to_s.titleize
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    # Handle extra attribute methods like .label or .delivery_type
+    def method_missing(meth, *args, &block)
+      if attributes.has_key?(meth)
+        attributes[meth]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/constant_enum/version.rb

@@ -0,0 +1,3 @@
+module ConstantEnum
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: constant-enum
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nate Wiger
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ActiveRecord-like model for constant data. Designed to work well with
+  ActiveRecord enums.
+email:
+- nwiger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- constant-enum.gemspec
+- lib/constant-enum.rb
+- lib/constant_enum.rb
+- lib/constant_enum/base.rb
+- lib/constant_enum/version.rb
+homepage: https://github.com/nateware/constant-enum
+licenses: []
+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.4.5
+signing_key: 
+specification_version: 4
+summary: ActiveRecord-like model for constant data.
+test_files: []