rails-angulate 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2c4edfa704869f0f851c31ed0a1d6664d91f159
+  data.tar.gz: d5bbc86ee369bf6716646f3bcd490a8065313f9c
+SHA512:
+  metadata.gz: 05f74b84bdd08df8df880bc56c48261d1b9ead1df116851a54670878bf69c2a1327383b3fe6ffa89bb0e20cedb40e7e5c420f797d6bf5313df31a4fe63078639
+  data.tar.gz: 0ad0bdc1418c1f63e58f156fb82d54e7fd256df9df93920d9bf9d8544f59760e69fa147be81fb46d30bd444bf0e89ffc7fdf7d83dba4cf88ab0dca94c7bd7f68

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Stan Bondi
+
+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.

data/README.md

@@ -0,0 +1,32 @@
+# Rails::Angulate
+
+Angulate adds AngularJS client-side field and validation helpers to Rails form helpers.
+
+Under active development (started 25 June 2014) - will update readme once this is in a decent state.
+i.e DON'T use this yet!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rails-angulate'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rails-angulate
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/rails-angulate/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/rails-angulate.rb

@@ -0,0 +1,2 @@
+require 'rails/angulate'
+

data/lib/rails/angulate.rb

@@ -0,0 +1,21 @@
+require 'rails'
+require 'active_support'
+
+require 'rails/angulate/version'
+require 'rails/angulate/configuration'
+require 'rails/angulate/helpers'
+require 'rails/angulate/mappers'
+require 'rails/angulate/engine'
+
+module Rails
+  module Angulate
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.configure
+      yield configuration
+    end
+  end
+end
+

data/lib/rails/angulate/configuration.rb

@@ -0,0 +1,34 @@
+module Rails
+  module Angulate
+    class Configuration
+      attr_writer :validator_mappings
+      ##
+      # Set on what conditions do you want the validation messages to show
+      #
+      # Possible values:
+      # blur: only once the field has been visited
+      # dirty: only if the field is dirty
+      # submit_attempt: only once the user has submitted the form
+      attr_accessor :validate_on
+
+      attr_accessor :validate_show_condition
+
+      def initialize
+        self.validate_on = { submit_attempt: :or, blur: nil }
+        self.validate_show_condition = "%{field}.$invalid && (%{validate_on})"
+      end
+
+      def validator_mappings
+        @validator_mappings ||= {
+          presence: 'required',
+          format: 'pattern',
+          length: 'maxlength'
+        }
+      end
+
+      def add_mapper(name, mapper_class)
+        Rails::Angulate::Mappers.register_mapper(name, mapper_class)
+      end
+    end
+  end
+end

data/lib/rails/angulate/engine.rb

@@ -0,0 +1,12 @@
+module Rails
+  module Angulate
+    class Engine < ::Rails::Engine
+      initializer 'angulate.initialize' do
+        ActiveSupport.on_load(:action_view) do |base|
+          base.send(:include, ::Rails::Angulate::Helpers)
+          cattr_accessor(:default_form_builder) { ::Rails::Angulate::Helpers::FormBuilder }
+        end
+      end
+    end
+  end
+end

data/lib/rails/angulate/helpers.rb

@@ -0,0 +1,12 @@
+require 'rails/angulate/helpers/form_builder'
+require 'rails/angulate/helpers/form_helper'
+
+module Rails
+  module Angulate
+    module Helpers
+      extend ActiveSupport::Concern
+
+      include FormHelper
+    end
+  end
+end

data/lib/rails/angulate/helpers/form_builder.rb

@@ -0,0 +1,35 @@
+module Rails
+  module Angulate
+    module Helpers
+      class FormBuilder < ::ActionView::Helpers::FormBuilder
+        # Add prefixed field helpers
+        class_attribute :ng_field_helpers
+        self.ng_field_helpers = self.field_helpers.map { |f| "ng_#{f}".to_sym }
+
+        %i{
+          ng_text_field
+          ng_email_field
+          ng_error_messages_for
+        }.each do |_adv_method|
+          define_method _adv_method do |*args, &block|
+            options = args.extract_options!
+            options = objectify_options(options)
+            @template.send(_adv_method, @object_name, *args, options, &block)
+          end
+        end
+
+        %i{
+          ng_form_name
+          ng_valid
+          ng_valid_for
+          ng_invalid_for
+          ng_invalid
+        }.each do |_simple_method|
+          define_method _simple_method do |*args, &block|
+            @template.send(_simple_method, object, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/angulate/helpers/form_helper.rb

@@ -0,0 +1,73 @@
+require 'rails/angulate/helpers/tags'
+
+module Rails
+  module Angulate
+    module Helpers
+      module FormHelper
+        extend ActiveSupport::Concern
+
+        def ng_form_for(record, options = {}, &block)
+          options[:html] ||= {}
+          options[:html][:name] ||= options[:as] || ng_form_name(record)
+          form_for(record, options, &block)
+        end
+
+        def ng_text_field(object_name, method, options = {})
+          Tags::NgTextField.new(object_name, method, self, options).render
+        end
+
+        def ng_email_field(object_name, method, options = {})
+          Tags::NgEmailField.new(object_name, method, self, options).render
+        end
+
+        def ng_error_messages_for(object_name, method, options = {})
+          Tags::NgValidationErrors.new(object_name, method, self, options).render
+        end
+
+        def ng_valid(record, &block)
+          valid_wrapper(record, '$valid', &block)
+        end
+
+        def ng_invalid(record, &block)
+          valid_wrapper(record, '$invalid', &block)
+        end
+
+        def ng_valid_for(record, attribute, &block)
+          valid_wrapper(record, '$valid', attribute, &block)
+        end
+
+        def ng_invalid_for(record, attribute, &block)
+          valid_wrapper(record, '$invalid', attribute, &block)
+        end
+
+        def ng_form_field_name(record, attribute)
+          "#{ng_form_name(record)}['#{object_name_for(record)}[#{attribute}]']"
+        end
+
+        def ng_form_name(record)
+          "#{object_name_for(record)}_form"
+        end
+
+        private
+
+        def object_name_for(record)
+          case record
+          when String, Symbol
+            record
+          else
+            object = record.is_a?(Array) ? record.last : record
+            raise ArgumentError, "First argument in form cannot contain nil or be empty" unless object
+            model_name_from_record_or_class(object).param_key
+          end
+        end
+
+        def valid_wrapper(record, type, attribute = nil, &block)
+          ng_if = attribute.nil? ? ng_form_name(record) : ng_form_field_name(record, attribute)
+          content = capture(&block)
+          content_tag :span, content.html_safe, 'ng-if' => "#{ng_if}.#{type}"
+        end
+
+      end
+    end
+  end
+end

data/lib/rails/angulate/helpers/tags.rb

@@ -0,0 +1,16 @@
+module Rails
+  module Angulate
+    module Helpers
+      module Tags
+        extend ActiveSupport::Autoload
+
+        eager_autoload do
+          autoload :TagCommon
+          autoload :NgTextField
+          autoload :NgEmailField
+          autoload :NgValidationErrors
+        end
+      end
+    end
+  end
+end

data/lib/rails/angulate/helpers/tags/ng_email_field.rb

@@ -0,0 +1,10 @@
+module Rails
+  module Angulate
+    module Helpers
+      module Tags
+        class NgEmailField < NgTextField
+        end
+      end
+    end
+  end
+end

data/lib/rails/angulate/helpers/tags/ng_text_field.rb

@@ -0,0 +1,53 @@
+module Rails
+  module Angulate
+    module Helpers
+      module Tags
+        class NgTextField < ActionView::Helpers::Tags::TextField
+          include TagCommon
+
+          def render
+            options = @options.stringify_keys
+            options["size"] = options["maxlength"] unless options.key?("size")
+            options["type"] ||= field_type
+            options["value"] = options.fetch("value") { value_before_type_cast(object)  } unless field_type == "file"
+            options["value"] &&= ERB::Util.html_escape(options["value"])
+
+            add_default_name_and_id(options)
+            set_ng_options(options)
+            add_ng_validation_attrs(options)
+
+            tag 'input', options
+          end
+
+          def set_ng_options(options)
+            if options.has_key?("ng")
+              options.delete("ng").each do |k, v|
+                options["ng-#{k}"] = v
+              end
+            end
+
+            unless options.has_key?("ng-model")
+              options["ng-model"] = options.fetch("ngModel") do
+                ng_model_name(options["id"])
+              end.to_s
+            end
+          end
+
+          def add_ng_validation_attrs(attrs)
+            validators.each do |validator|
+              attrs.reverse_merge!(validator_mapper_for(validator).ng_attributes)
+            end
+          end
+
+          def ng_model_name(id)
+            id.camelize(:lower)
+          end
+
+          def self.field_type
+            @field_type ||= super.sub(/^ng/, '')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/angulate/helpers/tags/ng_validation_errors.rb

@@ -0,0 +1,75 @@
+module Rails
+  module Angulate
+    module Helpers
+      module Tags
+        class NgValidationErrors < ActionView::Helpers::Tags::Base
+          include TagCommon
+
+          def render
+            attrs = {}
+            [:id, :class].each do |key|
+              if options.include?(key)
+                value = options[key]
+                attrs[key] = value unless value.blank?
+              end
+            end
+
+            # We can't use content_tag with a block (no self.output_buffer)
+            # so we pass in content
+            container attrs, angular_error_list_html
+          end
+
+          private
+
+          def options
+            @_options ||= @options.symbolize_keys
+          end
+
+          def container(attrs, content)
+            content_tag :ul, content, attrs.merge(container_attrs)
+          end
+
+          def angular_error_list_html
+            validators.map do |validator|
+              mapper = validator_mapper_for(validator)
+              mapper.error_messages.map do |error_type, msg|
+                content_tag :li, msg, 'ng-show' => "#{angular_form_field_object_name}.$error.#{error_type}"
+              end.join
+            end.join.html_safe
+          end
+
+          def container_attrs
+            ng_show = configuration.validate_show_condition % {
+              model: @object_name,
+              form: angular_form_object_name,
+              field: angular_form_field_object_name,
+              validate_on: validate_on || 'true'
+            }
+
+            {
+              'ng-show' => ng_show
+            }
+          end
+
+          def validate_on
+            field = angular_form_field_object_name
+            form = angular_form_object_name
+
+            configuration.validate_on.inject('') do |str, (kind, op)|
+              op = case op
+              when :and
+                ' && '
+              when :or
+                ' || '
+              else
+                ''
+              end
+
+              str << (kind == :submit_attempt ? "#{form}.$#{kind}" : "#{field}.$#{kind}") << op
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/angulate/helpers/tags/tag_common.rb

@@ -0,0 +1,33 @@
+module Rails
+  module Angulate
+    module Helpers
+      module Tags
+        module TagCommon
+          extend ActiveSupport::Concern
+          include Forwardable
+
+          protected
+
+          delegate :configuration, to: Rails::Angulate
+
+          def angular_form_object_name
+            @template_object.ng_form_name(object)
+          end
+
+          def angular_form_field_object_name
+            @template_object.ng_form_field_name(object, @method_name)
+          end
+
+          def validators
+            @validators ||=
+              object.class.validators.select { |v| v.attributes.include?(@method_name.to_sym) }
+          end
+
+          def validator_mapper_for(validator)
+            Rails::Angulate::Mappers.create_validator_mapper_for(object, @method_name, validator)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/angulate/mappers.rb

@@ -0,0 +1,39 @@
+require 'rails/angulate/mappers/base'
+
+module Rails
+  module Angulate
+    module Mappers
+      @@lock = Mutex.new
+      @@mappers = {}
+
+      def self.register_mapper(constant, kind = nil)
+        @@lock.synchronize do
+          if kind.nil?
+            kind = constant.name.split('::').last
+              .sub('ValidatorMapper', '').underscore
+          end
+
+          @@mappers[kind.to_sym] = constant unless kind.blank?
+        end
+      end
+
+      def self.create_validator_mapper_for(model, attribute_name,  validator)
+        @@lock.synchronize do
+          if klass = @@mappers[validator.kind]
+            klass.new(model, attribute_name, validator)
+          else
+            # General purpose mapper
+            ValidatorMapper.new(model, attribute_name, validator)
+          end
+        end
+      end
+
+    end
+  end
+end
+
+require 'rails/angulate/mappers/validator_mapper'
+require 'rails/angulate/mappers/length_validator_mapper'
+require 'rails/angulate/mappers/format_validator_mapper'
+require 'rails/angulate/mappers/numericality_validator_mapper'
+

data/lib/rails/angulate/mappers/base.rb

@@ -0,0 +1,77 @@
+module Rails
+  module Angulate
+    module Mappers
+      class Base
+        attr_reader :validator, :model, :attribute
+
+        def self.inherited(mapper)
+          Mappers.register_mapper(mapper)
+        end
+
+        delegate :configuration, to: Rails::Angulate
+
+        def initialize(model, attribute, validator)
+          @model = model
+          @attribute = attribute
+          @validator = validator
+        end
+
+        def error_messages
+          []
+        end
+
+        def full_message(message)
+          return message if attribute == :base
+          attr_name = attribute.to_s.tr('.', '_').humanize
+          attr_name = @model.class.human_attribute_name(attribute, default: attribute.to_s.humanize)
+          with_i18n do |locale|
+            locale.t(:format, {
+              default:  "%{attribute} %{message}",
+              attribute: attr_name,
+              message:   message
+            })
+          end
+        end
+
+        def error_messages
+          default_message = validator_options[:message]
+
+          with_i18n do |locale|
+            {
+              kind_to_ng(validator.kind) => default_message || locale.t(:"messages.#{validator.kind}", {
+                model: model.class.name.humanize,
+                  attribute: attribute
+              })
+            }
+          end
+        end
+
+        protected
+
+        def translate_params
+          {
+            model: model.class.name.humanize,
+            attribute: attribute.to_s.humanize,
+          }
+        end
+
+        def kind_to_ng(kind)
+          configuration.validator_mappings[kind] || kind
+        end
+
+        def mapped_kind
+          kind = validator.kind
+          configuration.validator_mappings[kind] || kind
+        end
+
+        def with_i18n(options = {}, &block)
+          I18n.with_options scope: [:angulate, :errors], &block
+        end
+
+        def validator_options
+          validator.options
+        end
+      end
+    end
+  end
+end

data/lib/rails/angulate/mappers/format_validator_mapper.rb

@@ -0,0 +1,34 @@
+module Rails
+  module Angulate
+    module Mappers
+      class FormatValidatorMapper < Base
+        def ng_attributes
+          {}.tap do |attrs|
+            if pattern = validator_options[:javascript_format]
+              attrs["ng-pattern"] = pattern
+            elsif pattern = validator_options[:with]
+              attrs["ng-pattern"] = javascriptify_pattern(pattern.source)
+            elsif validator_options[:without]
+              ActiveSupport::Deprecation.warn(<<-TEXT.strip)
+              Angulate does not support validates_format validation using the without option.
+              Use the 'with' and/or 'javascript_format' options instead.
+              TEXT
+            end
+          end
+        end
+
+        private
+
+        ##
+        # Will only work with simple regexes that happen to match javascript.
+        # Replaces leading \A and trailing \z with ^ and $ respectively
+        def javascriptify_pattern(pattern)
+          pattern.gsub!(/^\\A/, '^')
+          pattern.gsub!(/\\z$/, '$')
+          "/#{pattern}/"
+        end
+      end
+    end
+  end
+end
+

data/lib/rails/angulate/mappers/length_validator_mapper.rb

@@ -0,0 +1,47 @@
+module Rails
+  module Angulate
+    module Mappers
+      class LengthValidatorMapper < Base
+        OPTION_MAP = { is: :islength, minimum: :minlength, maximum: :maxlength }.freeze
+
+        def ng_attributes
+          opts = validator_options
+          {}.tap do |attrs|
+            validator_options.each do |key, value|
+              attrs["ng-#{OPTION_MAP[key]}"] = opts[key] if opts[key].present?
+            end
+          end
+        end
+
+        def error_messages
+          messages = {}
+          default_message = validator_options[:message]
+
+          with_i18n do |locale|
+            validator.class::MESSAGES.each do |key, msg|
+              if default_message.nil?
+                next unless validator_options[key]
+
+                count = validator_options[key]
+
+                message = locale.t(
+                  :"messages.#{msg}",
+                  model: model.class.name.humanize,
+                  attribute: attribute.to_s.humanize,
+                  count: count
+                )
+
+                messages[OPTION_MAP[key]] = full_message(message)
+              else
+                messages[OPTION_MAP[key]] = default_message
+              end
+            end
+          end
+
+          messages
+        end
+      end
+    end
+  end
+end
+

data/lib/rails/angulate/mappers/numericality_validator_mapper.rb

@@ -0,0 +1,84 @@
+module Rails
+  module Angulate
+    module Mappers
+      class NumericalityValidatorMapper < Base
+        CHECKS = ActiveModel::Validations::NumericalityValidator::CHECKS
+
+        def ng_attributes
+          {}.tap do |attrs|
+            attrs["ang-validator"] = "numericality"
+            attrs["ang-valid-if"] = numericality_conditions.to_json
+          end
+        end
+
+        def error_messages
+          messages = {}
+          default_message = validator_options[:message]
+
+          default_message || with_i18n do |locale|
+            numericality_options.each do |option, option_value|
+              messages[option] = full_message(
+                locale.t :"messages.#{option}",
+                translate_params.merge(count: option_value)
+              )
+
+              if allow_only_integer?
+                messages[:only_integer] = full_message(
+                  locale.t :"messages.not_an_integer",
+                  translate_params.merge(count: option_value)
+                )
+              end
+            end
+          end
+
+          messages
+        end
+
+        protected
+
+        def numericality_conditions
+          numericality_options.inject({}) do |hash, (option, option_value)|
+            case option
+            when :odd
+              hash[option] = "value % 2 != 0"
+            when :even
+              hash[option] = "value % 2 == 0"
+            else
+              case option_value
+              when Proc
+                option_value = option_value.call(record)
+              when Symbol
+                option_value = record.send(option_value)
+              end
+
+              op = CHECKS[option]
+
+              hash[option] = "value #{op} #{option_value}"
+            end
+
+            # TODO: hmm, neither isNaN nor a Regex work when called with scope.$eval
+            hash[:only_integer] = %q{!isNaN(+value)} if allow_only_integer?
+
+            hash
+          end
+        end
+
+        def allow_only_integer?
+          case validator_options[:only_integer]
+          when Symbol
+            model.send(validator_options[:only_integer])
+          when Proc
+            validator_options[:only_integer].call(model)
+          else
+            !!validator_options[:only_integer]
+          end
+        end
+
+        def numericality_options
+          @numericality_options ||= validator_options.slice(*CHECKS.keys)
+        end
+      end
+    end
+  end
+end
+

data/lib/rails/angulate/mappers/validator_mapper.rb

@@ -0,0 +1,15 @@
+module Rails
+  module Angulate
+    module Mappers
+      class ValidatorMapper < Base
+        def ng_attributes
+          {
+            "ng-#{mapped_kind}" => true
+          }
+        end
+      end
+    end
+  end
+end
+
+

data/lib/rails/angulate/railtie.rb

@@ -0,0 +1,15 @@
+require 'rails'
+require 'angulate/helpers'
+
+module Rails
+  module Angulate
+    class Railtie < ::Rails::Railtie
+      initializer :include_helpers do |app|
+        ActiveSupport.on_load(:action_view) do
+          include Rails::Angulate::Helpers
+          cattr_accessor(:default_form_builder) { Rails::Angulate::Helpers::FormBuilder }
+        end
+      end
+    end
+  end
+end

data/lib/rails/angulate/version.rb

@@ -0,0 +1,5 @@
+module Rails
+  module Angulate
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: rails-angulate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Stan Bondi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: Angulate adds AngularJS client-side field and validation helpers to Rails
+  form helpers.
+email:
+- stan@fixate.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rails-angulate.rb
+- lib/rails/angulate.rb
+- lib/rails/angulate/configuration.rb
+- lib/rails/angulate/engine.rb
+- lib/rails/angulate/helpers.rb
+- lib/rails/angulate/helpers/form_builder.rb
+- lib/rails/angulate/helpers/form_helper.rb
+- lib/rails/angulate/helpers/tags.rb
+- lib/rails/angulate/helpers/tags/ng_email_field.rb
+- lib/rails/angulate/helpers/tags/ng_text_field.rb
+- lib/rails/angulate/helpers/tags/ng_validation_errors.rb
+- lib/rails/angulate/helpers/tags/tag_common.rb
+- lib/rails/angulate/mappers.rb
+- lib/rails/angulate/mappers/base.rb
+- lib/rails/angulate/mappers/format_validator_mapper.rb
+- lib/rails/angulate/mappers/length_validator_mapper.rb
+- lib/rails/angulate/mappers/numericality_validator_mapper.rb
+- lib/rails/angulate/mappers/validator_mapper.rb
+- lib/rails/angulate/railtie.rb
+- lib/rails/angulate/version.rb
+homepage: https://github.com/fixate/rails-angulate
+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: AngularJS Rails form helpers.
+test_files: []