human_attributes 0.1.0

data/human_attributes.gemspec

@@ -0,0 +1,30 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem"s version:
+require "human_attributes/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name          = "human_attributes"
+  s.version       = HumanAttributes::VERSION
+  s.authors       = ["Platanus", "Leandro Segovia"]
+  s.email         = ["rubygems@platan.us", "ldlsegovia@gmail.com"]
+  s.homepage      = "https://github.com/platanus/human_attributes"
+  s.summary       = "Gem to generate human readable ActiveRecord attributes"
+  s.description   = "Gem to convert ActiveRecord attributes and methods to human readable attributes"
+  s.license       = "MIT"
+
+  s.files = `git ls-files`.split($/).reject { |fn| fn.start_with? "spec" }
+  s.bindir = "exe"
+  s.executables = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.test_files = Dir["spec/**/*"]
+
+  s.add_dependency "rails", "~> 4.2", ">= 4.2.0"
+  s.add_dependency "enumerize", "~> 1.1", ">= 1.1.1"
+  s.add_dependency "factory_girl_rails", "~> 4.6.0"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "pry-rails"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "rspec-rails", "~> 3.4.0"
+  s.add_development_dependency "guard-rspec", "~> 4.7"
+end

data/lib/human_attributes/active_record_extension.rb

@@ -0,0 +1,53 @@
+module HumanAttributes
+  module ActiveRecordExtension
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def humanize(*attrs, options)
+        formatters = HumanAttributes::FormattersBuilder.new(attrs, options).build
+        @builder ||= HumanAttributes::MethodBuilder.new(self)
+        @humanizers ||= []
+        formatters.each { |formatter| @humanizers << @builder.build(formatter) }
+      end
+
+      def humanize_attributes(options = {})
+        included_attrs = options.fetch(:only, nil)
+        excluded_attrs = options.fetch(:except, nil)
+        columns.each do |col|
+          next if col.name.ends_with?("_id")
+          next if included_attrs && !included_attrs.include?(col.name.to_sym)
+          next if excluded_attrs && excluded_attrs.include?(col.name.to_sym)
+          humanize_from_type(col)
+        end
+      end
+
+      def humanizers
+        return [] unless @humanizers
+        @humanizers.uniq!
+        @humanizers.reject! { |method| !method_defined?(method) }
+        @humanizers
+      end
+
+      private
+
+      def humanize_from_type(col)
+        if col.name == "id"
+          humanize(:id, custom: { formatter: ->(_o, value) { "#{model_name.human}: ##{value}" } })
+        elsif [:date, :datetime].include?(col.type)
+          humanize_date(col.name)
+        elsif [:decimal, :float, :integer].include?(col.type)
+          humanize(col.name, delimiter: true)
+        elsif col.type == :boolean
+          humanize(col.name, boolean: true)
+        end
+      end
+
+      def humanize_date(attr_name)
+        humanize(attr_name, date: true)
+        humanize(attr_name, date: { format: :short, suffix: "to_short_date" })
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, HumanAttributes::ActiveRecordExtension)

data/lib/human_attributes/config.rb

@@ -0,0 +1,92 @@
+module HumanAttributes
+  module Config
+    TYPES = [
+      {
+        name: :currency,
+        category: :numeric,
+        formatter: :number_to_currency,
+        suffix: :to_currency
+      },
+      {
+        name: :number,
+        category: :numeric,
+        formatter: :number_to_human,
+        suffix: :to_human
+      },
+      {
+        name: :size,
+        category: :numeric,
+        formatter: :number_to_human_size,
+        suffix: :to_human_size
+      },
+      {
+        name: :percentage,
+        category: :numeric,
+        formatter: :number_to_percentage,
+        suffix: :to_percentage
+      },
+      {
+        name: :phone,
+        category: :numeric,
+        formatter: :number_to_phone,
+        suffix: :to_phone
+      },
+      {
+        name: :delimiter,
+        category: :numeric,
+        formatter: :number_with_delimiter,
+        suffix: :with_delimiter
+      },
+      {
+        name: :precision,
+        category: :numeric,
+        formatter: :number_with_precision,
+        suffix: :with_precision
+      },
+      {
+        name: :date,
+        category: :date,
+        suffix: :to_human_date
+      },
+      {
+        name: :boolean,
+        category: :boolean,
+        suffix: :to_human_boolean
+      },
+      {
+        name: :enumerize,
+        category: :enumerize,
+        suffix: :to_human_enum
+      },
+      {
+        name: :custom,
+        category: :custom,
+        suffix: :to_custom_value
+      }
+    ]
+
+    def category_by_type(type)
+      type_config(type)[:category]
+    end
+
+    def formatter_by_type(type)
+      type_config(type)[:formatter]
+    end
+
+    def suffix_by_type(type)
+      type_config(type)[:suffix]
+    end
+
+    def known_type?(type)
+      !!type_config(type)
+    end
+
+    def type_config(type)
+      TYPES.select { |t| t[:name] == type }.first
+    end
+
+    def raise_error(error_class)
+      raise "HumanAttributes::Error::#{error_class}".constantize.new
+    end
+  end
+end

data/lib/human_attributes/engine.rb

@@ -0,0 +1,24 @@
+module HumanAttributes
+  class Engine < ::Rails::Engine
+    isolate_namespace HumanAttributes
+
+    config.generators do |g|
+      g.test_framework :rspec, fixture: false
+      g.fixture_replacement :factory_girl, dir: "spec/factories"
+    end
+
+    initializer "initialize" do
+      require_relative "./config"
+      require_relative "./errors"
+      require_relative "./formatters_builder"
+      require_relative "./formatters/base"
+      require_relative "./formatters/numeric"
+      require_relative "./formatters/date"
+      require_relative "./formatters/boolean"
+      require_relative "./formatters/enumerize"
+      require_relative "./formatters/custom"
+      require_relative "./method_builder"
+      require_relative "./active_record_extension"
+    end
+  end
+end

data/lib/human_attributes/errors.rb

@@ -0,0 +1,46 @@
+module HumanAttributes
+  module Error
+    class NotImplemented < Exception
+      def initialize
+        super("formatter not implemented")
+      end
+    end
+
+    class InvalidHumanizeConfig < Exception
+      def initialize
+        super("humanize options needs to be a Hash")
+      end
+    end
+
+    class NotEnumerizeAttribute < Exception
+      def initialize
+        super("needs to be an Enumerize::Value object")
+      end
+    end
+
+    class MissingFormatterOption < Exception
+      def initialize
+        super("custom type needs formatter option with a proc")
+      end
+    end
+
+    class InvalidType < Exception
+      def initialize
+        types = HumanAttributes::Config::TYPES.map { |t| t[:name] }
+        super("type needs to be one of: #{types.join(', ')}")
+      end
+    end
+
+    class RequiredAttributeType < Exception
+      def initialize
+        super("type is required")
+      end
+    end
+
+    class InvalidAttributeOptions < Exception
+      def initialize
+        super("options needs to be a Hash")
+      end
+    end
+  end
+end

data/lib/human_attributes/formatters/base.rb

@@ -0,0 +1,27 @@
+module HumanAttributes
+  module Formatters
+    class Base
+      include HumanAttributes::Config
+
+      attr_reader :attribute, :type, :options, :default, :suffix
+
+      def initialize(attribute, type, options)
+        @attribute = attribute.to_sym
+        @type = type.to_sym
+        @default = options.delete(:default)
+        @suffix = options.delete(:suffix)
+        @options = options
+      end
+
+      def method_name
+        return "human_#{attribute}" if suffix.blank?
+        return "#{attribute}_#{suffix_by_type(type)}" if suffix == true
+        "#{attribute}_#{suffix}"
+      end
+
+      def apply(_instance, _value)
+        raise_error('NotImplemented')
+      end
+    end
+  end
+end

data/lib/human_attributes/formatters/boolean.rb

@@ -0,0 +1,10 @@
+module HumanAttributes
+  module Formatters
+    class Boolean < Base
+      def apply(_instance, value)
+        key = !!value ? "positive" : "negative"
+        I18n.t("boolean.#{key}")
+      end
+    end
+  end
+end

data/lib/human_attributes/formatters/custom.rb

@@ -0,0 +1,17 @@
+module HumanAttributes
+  module Formatters
+    class Custom < Base
+      attr_reader :formatter
+
+      def initialize(attribute, type, options)
+        @formatter = options.delete(:formatter)
+        raise_error('MissingFormatterOption') unless formatter.is_a?(Proc)
+        super
+      end
+
+      def apply(instance, value)
+        formatter.call(instance, value)
+      end
+    end
+  end
+end

data/lib/human_attributes/formatters/date.rb

@@ -0,0 +1,9 @@
+module HumanAttributes
+  module Formatters
+    class Date < Base
+      def apply(_instance, value)
+        I18n.l(value, options)
+      end
+    end
+  end
+end

data/lib/human_attributes/formatters/enumerize.rb

@@ -0,0 +1,11 @@
+module HumanAttributes
+  module Formatters
+    class Enumerize < Base
+      def apply(_instance, value)
+        return unless value
+        raise_error('NotEnumerizeAttribute') unless value.class.to_s == "Enumerize::Value"
+        value.text
+      end
+    end
+  end
+end

data/lib/human_attributes/formatters/numeric.rb

@@ -0,0 +1,11 @@
+module HumanAttributes
+  module Formatters
+    class Numeric < Base
+      include ActionView::Helpers::NumberHelper
+
+      def apply(_instance, value)
+        send(formatter_by_type(type), value, options)
+      end
+    end
+  end
+end

data/lib/human_attributes/formatters_builder.rb

@@ -0,0 +1,44 @@
+module HumanAttributes
+  class FormattersBuilder
+    include HumanAttributes::Config
+
+    def initialize(attributes, config)
+      raise_error('InvalidHumanizeConfig') unless config.is_a?(Hash)
+      @attributes = attributes
+      @config = config
+    end
+
+    def build
+      formatters = []
+
+      get_types(@config).each do |type|
+        raise_error('InvalidType') unless known_type?(type)
+        options = get_options(@config[type])
+        formatters << @attributes.map do |attribute|
+          formatter_class(type).new(attribute, type, options)
+        end
+      end
+
+      formatters.flatten
+    end
+
+    private
+
+    def formatter_class(type)
+      category = category_by_type(type)
+      "HumanAttributes::Formatters::#{category.to_s.classify}".constantize
+    end
+
+    def get_types(options)
+      size = options.keys.count
+      raise_error('RequiredAttributeType') if size.zero?
+      options.keys
+    end
+
+    def get_options(options)
+      return {} if options == true
+      raise_error('InvalidAttributeOptions') unless options.is_a?(Hash)
+      options
+    end
+  end
+end

data/lib/human_attributes/method_builder.rb

@@ -0,0 +1,20 @@
+module HumanAttributes
+  class MethodBuilder
+    include HumanAttributes::Config
+
+    attr_reader :model_class
+
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+    def build(formatter)
+      model_class.send(:define_method, formatter.method_name) do
+        value = send(formatter.attribute) || formatter.default
+        formatter.apply(self, value)
+      end
+
+      formatter.method_name
+    end
+  end
+end

data/lib/human_attributes/version.rb

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

data/lib/human_attributes.rb

@@ -0,0 +1,26 @@
+require "enumerize"
+require "human_attributes/engine"
+
+module HumanAttributes
+  extend self
+
+  # You can add, in this module, your own configuration options as in the example below...
+  #
+  # attr_writer :my_option
+  #
+  # def my_option
+  #   return "Default Value" unless @my_option
+  #   @my_option
+  # end
+  #
+  # Then, you can customize the default behaviour (typically in a Rails initializer) like this:
+  #
+  # HumanAttributes.setup do |config|
+  #   config.root_url = "Another value"
+  # end
+
+  def setup
+    yield self
+    require "human_attributes"
+  end
+end

data/lib/tasks/human_attributes_tasks.rake

@@ -0,0 +1,32 @@
+require "factory_girl_rails"
+
+namespace :human_attrs do
+  desc "Show generated human attributes for ActiveRecord models"
+  task :show, [:model] => [:environment] do |_t, args|
+    model_name = args[:model].tableize.singularize
+    model = args[:model].classify.constantize
+    instance = begin
+      FactoryGirl.build(model_name)
+    rescue
+      nil
+    end
+
+    if instance
+      instance.id = 1 if instance.respond_to?(:id)
+      instance.created_at = DateTime.current if instance.respond_to?(:created_at)
+      instance.updated_at = DateTime.current if instance.respond_to?(:updated_at)
+    end
+
+    result = model.humanizers.map do |m|
+      value = begin
+        instance.send(m)
+      rescue
+        nil
+      end
+
+      !!value ? "#{m} => #{value}" : m
+    end
+
+    puts result.join("\n")
+  end
+end

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/models/purchase.rb

@@ -0,0 +1,28 @@
+# == Schema Information
+#
+# Table name: purchases
+#
+#  id          :integer          not null, primary key
+#  paid        :boolean
+#  commission  :decimal(, )
+#  quantity    :integer
+#  state       :string
+#  expired_at  :datetime
+#  amount      :decimal(, )
+#  description :text
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+
+class Purchase < ActiveRecord::Base
+  extend Enumerize
+
+  STATES = %i{pending canceled finished}
+
+  enumerize :state, in: STATES, default: :pending
+
+  humanize_attributes
+  humanize :state, enumerize: true
+  humanize :commission, percentage: true
+  humanize :amount, currency: true
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track' => true %>
+  <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/spec/dummy/bin/bundle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+load Gem.bin_path('bundler', 'bundle')

data/spec/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../../config/application', __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run

data/spec/dummy/bin/setup

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'pathname'
+
+# path to your application root.
+APP_ROOT = Pathname.new File.expand_path('../../',  __FILE__)
+
+Dir.chdir APP_ROOT do
+  # This script is a starting point to setup your application.
+  # Add necessary setup steps to this file:
+
+  puts "== Installing dependencies =="
+  system "gem install bundler --conservative"
+  system "bundle check || bundle install"
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   system "cp config/database.yml.sample config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system "bin/rake db:setup"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system "rm -f log/*"
+  system "rm -rf tmp/cache"
+
+  puts "\n== Restarting application server =="
+  system "touch tmp/restart.txt"
+end

data/spec/dummy/config/application.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../boot', __FILE__)
+
+# Pick the frameworks you want:
+require "active_record/railtie"
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "action_view/railtie"
+require "sprockets/railtie"
+# require "rails/test_unit/railtie"
+
+Bundler.require(*Rails.groups)
+require "human_attributes"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+
+    # Do not swallow errors in after_commit/after_rollback callbacks.
+    config.active_record.raise_in_transactional_callbacks = true
+  end
+end
+