light_form 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1068ccb3160f2a1059f1aaac07e446ba7e92991d
-  data.tar.gz: 7cb06749857c28860f558e4bc6cf669aada3680d
+  metadata.gz: 378076de26719aab740e5c61065c2f6afd7575bc
+  data.tar.gz: 307deab9de929cd38f8709178cdcf759932d84e1
 SHA512:
-  metadata.gz: f7b5bf89967dc0b71054bda26b3ad240c7db7126921e9da16bdf99418fbd5d4efe37f0979b787d087cec04b97d05d7b26265805c841cda41a3c4c4a4285d6b63
-  data.tar.gz: b109b70705d9e2b79e5c97e4b78ecf0df65408825d1289b3ff7f7bbd360db7b739908fffa0a5db875df76028fcc14685369adc10f3f5d5c7f13418f953b9534e
+  metadata.gz: 32ac9549f36d5d68f0e238dd54181e79655effba82ec837fcc302b3c70e5a5d6a5737aca5190310fe0c3cf2b1fae46808f7941cb295f8f9f33c06066d6871743
+  data.tar.gz: 3a921ca9efefd2d99bfc15335c61bf8c59f22f671328350fa169cadbb02ff538980216917451b89b67bc6ea9520101f1fe259373c97b7150f188e2c672f14ebb

data/lib/light_form.rb

@@ -1,5 +1,6 @@
 require 'light_form/version'
+require 'light_form/property_methods'
+require 'light_form/lash'
 require 'light_form/form'
 module LightForm
-  # Your code goes here...
 end

data/lib/light_form/form.rb

@@ -1,74 +1,17 @@
-require 'set'
 require 'active_model'
 
 module LightForm
   class Form
     include ActiveModel::Model
+    include ActiveModel::Serializers::JSON
+    include PropertyMethods
 
     def initialize(params = {})
       super(_prepare_params(params))
     end
 
-    class << self
-      def config
-        @config ||= {}
-      end
-
-      def properties(*prop_names)
-        add_property = method(:_add_property)
-        prop_names.each(&add_property)
-      end
-
-      def property(prop_name, options = {}, &_block)
-        _add_property(prop_name)
-        _add_property_transform(prop_name, options)
-        _add_property_validation(prop_name, options[:validates]) if options[:validates]
-      end
-
-      private
-
-      def _properties_transform
-        config[:properties_transform] ||= {}
-      end
-
-      def _properties
-        config[:properties] ||= Set.new
-      end
-
-      def _add_property_transform(prop_name, options = {})
-        transformations = options.slice(:from, :transform_with, :default)
-        return if transformations.empty?
-        _properties_transform[prop_name] = transformations
-      end
-
-      def _add_property(prop_name)
-        send(:attr_accessor, prop_name) if _properties.add?(prop_name)
-      end
-
-      def _add_property_validation(prop_name, validation)
-        validates(prop_name, validation)
-      end
-    end
-
-    private
-
-    def _prepare_params(value)
-      params = value.clone
-      _prepare_params_keys_and_values!(params)
-      properties = self.class.config[:properties] || []
-      params.extract!(*properties)
-    end
-
-    def _prepare_params_keys_and_values!(params)
-      properties_from = self.class.config[:properties_transform] || {}
-      properties_from.each do |key_to, hash|
-        params[key_to] = params.delete(hash[:from]) if hash[:from]
-        next params[key_to] = hash[:default] if params[key_to].empty? && hash[:default]
-        next unless hash[:transform_with]
-        transformation = hash[:transform_with]
-        trans_proc     = transformation.is_a?(Symbol) ? method(transformation) : transformation
-        params[key_to] = trans_proc.call(params[key_to])
-      end
+    def to_h(*args)
+      as_json(*args)
     end
   end
 end

data/lib/light_form/lash.rb

@@ -0,0 +1,20 @@
+require 'active_model'
+
+module LightForm
+  class Lash < Hash
+    include ActiveModel::Model
+    include PropertyMethods
+
+    def initialize(params = {})
+      _prepare_params(params).each_pair { |k, v| self[k.to_sym] = v }
+    end
+
+    def self._add_property(prop_name)
+      config[:errors_overriden] = true if prop_name == :errors
+      return unless _properties.add?(prop_name)
+      define_method(prop_name) { |&block| self.[](prop_name, &block) }
+      property_assignment = "#{prop_name}=".to_sym
+      define_method(property_assignment) { |value| self.[]=(prop_name, value) }
+    end
+  end
+end

data/lib/light_form/property_methods.rb

@@ -0,0 +1,190 @@
+require 'set'
+require 'active_support'
+
+module LightForm
+  TransformationError    = Class.new(StandardError)
+  MissingCollectionError = Class.new(StandardError)
+  MissingParamError      = Class.new(StandardError)
+
+  module PropertyMethods
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def config
+        @config ||= {}
+      end
+
+      def properties(*prop_names)
+        add_property = method(:_add_property)
+        prop_names.each(&add_property)
+      end
+
+      def property(prop_name, options = {}, &block)
+        _add_property(prop_name)
+        _add_property_transform(prop_name, options)
+        _add_property_validation(prop_name, options[:validates]) if options[:validates]
+        _add_property_source(prop_name, &block) if block
+      end
+
+      private
+
+      def _add_property_source(prop_name, &block)
+        klass = Class.new(Lash)
+        klass.class_eval("def self.name; \"#{ActiveSupport::Inflector.classify(prop_name)}\"; end")
+        klass.class_eval(&block)
+        _properties_sources[prop_name] = { class: klass }
+      end
+
+      def _properties_sources
+        config[:properties_sources] ||= {}
+      end
+
+      def _properties_transform
+        config[:properties_transform] ||= {}
+      end
+
+      def _properties
+        config[:properties] ||= Set.new
+      end
+
+      def _add_property_transform(prop_name, options = {})
+        transformations = options.slice(:from, :transform_with, :with, :default, :model, :collection, :uniq, :required)
+        return if transformations.empty?
+        _properties_transform[prop_name] = transformations
+      end
+
+      def _add_property(prop_name)
+        config[:errors_overriden] = true if prop_name == :errors
+        send(:attr_accessor, prop_name)  if _properties.add?(prop_name)
+      end
+
+      def _add_property_validation(prop_name, validation)
+        validates(prop_name, validation)
+      end
+    end
+
+    def _errors
+      @_errors
+    end
+
+    def errors_overriden?
+      self.class.config[:errors_overriden] == true
+    end
+
+    def valid?
+      return (_check_validation && super) unless errors_overriden?
+      @_errors = @errors
+      @errors  = ActiveModel::Errors.new(self)
+      stored_method = method(:errors)
+      errors_method = -> { @errors }
+      define_singleton_method(:errors) { errors_method.call }
+      result, store, @_errors, @errors = (_check_validation && super), @_errors, @errors, store
+      define_singleton_method(:errors) { stored_method.call }
+      result
+    end
+
+    private
+
+    def _validation_errors(obj)
+      obj.errors if obj.respond_to?(:valid?) && !obj.valid?
+    end
+
+    def _check_validation
+      @errors = ActiveModel::Errors.new(self)
+      properties = _properties.delete(_properties_sources.keys)
+      properties.each do |prop|
+        public_send(prop).tap do |subject|
+          items = subject.is_a?(Array) ? subject.map(&method(:_validation_errors)).compact : _validation_errors(subject)
+          @errors.add(prop, items) if items && !items.empty?
+        end
+      end
+      _properties_sources.each do |prop, v|
+        next unless v[:params]
+        subject = v[:params].clone
+        items = subject.is_a?(Array) ? subject.map(&method(:_validation_errors)) : _validation_errors(v[:params])
+        @errors.add(prop, items) if items && !items.empty?
+      end
+      @errors.empty?
+    end
+
+    def _properties_sources
+      @_properties_sources ||= self.class.config[:properties_sources] || {}
+    end
+
+    def _properties
+      @_properties ||= self.class.config[:properties] || []
+    end
+
+    def _prepare_params(value)
+      return if value.nil?
+      params = value.clone.symbolize_keys
+      return params if _properties.empty?
+      _prepare_sources(params)
+      _prepare_params_keys_and_values!(params)
+      params.extract!(*_properties)
+    end
+
+    def _prepare_params_keys_and_values!(params)
+      properties_from = self.class.config[:properties_transform] || {}
+      properties_from.clone.each do |key_to, hash|
+        _update_key!(params, key_to, hash)
+        fail(MissingParamError, key_to.to_s) if hash[:required] && !params.key?(key_to)
+        set_default = (params[key_to].nil? || params[key_to].empty?) && hash[:default]
+        _update_value_as_default!(params, key_to, hash) if set_default
+        _transform_value!(params, key_to, hash) unless set_default
+        _modelable_value!(params, key_to, hash)
+        _collectionaize_value!(params, key_to, hash)
+      end
+    end
+
+    def _update_key!(params, key, hash)
+      params[key] = params.delete(hash[:from]) if hash[:from]
+    end
+
+    def _update_value_as_default!(params, key, hash)
+      params[key] = hash[:default]
+    end
+
+    def _transform_value!(params, key, hash)
+      transformation = hash[:with] || hash[:transform_with]
+      return unless transformation
+      trans_proc  = transformation.is_a?(Symbol) ? method(transformation) : transformation
+      params[key] = trans_proc.call(params[key])
+    rescue => e
+      raise TransformationError, "key #{key}: #{e.message}"
+    end
+
+    def _modelable_value!(params, key, hash)
+      return unless hash[:model]
+      _save_source_params(key, params[key])
+      params[key] = hash[:model].new(params[key])
+    end
+
+    def _save_source_params(key, params)
+      _properties_sources[key][:params] = params.clone if _properties_sources[key]
+    end
+
+    def _collectionaize_value!(params, key, hash)
+      return unless hash[:collection]
+      array = params[key]
+      fail(MissingCollectionError, "on key: #{key}") unless array.is_a? Array
+      array.uniq! if hash[:uniq]
+      return params[key] = array if hash[:collection] == true
+      _save_source_params(key, array.compact)
+      params[key] = array.compact.map { |source| hash[:collection].new(source) }
+    end
+
+    def _prepare_sources(params)
+      _properties_sources.each do |k, v|
+        next unless params[k]
+        params[k] = params[k].is_a?(Array) ? params[k].map { |s| v[:class].new(s) } : v[:class].new(params[k])
+      end
+    end
+
+    def attributes
+      OpenStruct.new(keys: self.class.config[:properties])
+    end
+  end
+end

data/lib/light_form/version.rb

@@ -1,3 +1,3 @@
 module LightForm
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/light_form.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'activesupport', '>= 3.0.2'
   spec.add_runtime_dependency 'activemodel', '>= 3.0.2'
   spec.add_development_dependency 'bundler', '>= 1.6'
   spec.add_development_dependency 'rake', '~> 10.4'

data/spec/lib/form_spec.rb

@@ -1,4 +1,20 @@
 describe LightForm::Form do
+  class ChildModel
+    include ActiveModel::Model
+    attr_accessor :name, :age
+    def equality_state
+      [:name, :age].map { |attr| public_send("#{attr}") }
+    end
+
+    def ==(o)
+      eql?(o)
+    end
+
+    def eql?(o)
+      o.class == self.class && o.equality_state == equality_state
+    end
+  end
+
   context '.properties' do
     subject do
       class_factory do
@@ -68,6 +84,19 @@ describe LightForm::Form do
         end
       end
 
+      context 'add with :default and :with option' do
+        let(:time) { Time.parse('2015-03-29 14:41:28 +0200') }
+        subject do
+          object_factory(attributes: { time: '' }) do
+            property :time, default: Time.parse('2015-03-29 14:41:28 +0200'), with: -> (v) { Time.parse(v) }
+          end
+        end
+
+        it 'assign property value from key :default when value is empty and skip :transform_with' do
+          expect(subject.time).to eq(time)
+        end
+      end
+
       context 'add with :transform_with option assign property value after transformation' do
         it 'by proc' do
           test_obj = object_factory(attributes: { number: '12' }) do
@@ -90,6 +119,28 @@ describe LightForm::Form do
         end
       end
 
+      context 'add with :with option assign property value after transformation' do
+        it 'by proc' do
+          test_obj = object_factory(attributes: { number: '12' }) do
+            property :number, with: -> (v) { v.to_i }
+          end
+
+          expect(test_obj.number).to eq(12)
+        end
+
+        it 'by method' do
+          test_obj = object_factory(attributes: { number: '12' }) do
+            property :number, with: :convert_to_number
+
+            def convert_to_number(value)
+              value.to_i
+            end
+          end
+
+          expect(test_obj.number).to eq(12)
+        end
+      end
+
       context 'add with :validates option' do
         subject do
           object_factory(real_class_name: 'FakeForm', attributes: { name: '' }) do
@@ -102,17 +153,216 @@ describe LightForm::Form do
           expect(subject.errors.as_json).to eq(name: ["can't be blank"])
         end
       end
+
+      context 'add with :model option' do
+        subject do
+          object_factory(attributes: { child: { name: 'Tom', age: 2 } }) do
+            property :child, model: ChildModel
+          end
+        end
+
+        it 'create model for attribute' do
+          expect(subject.child).to be_a(ChildModel)
+          expect(subject.child.name).to eq('Tom')
+          expect(subject.child.age).to eq(2)
+        end
+      end
+
+      context 'add with :collection option' do
+        it 'raise error when is not a Array' do
+          expect {
+            object_factory(attributes: { children: { name: 'Tom', age: 2 } }) do
+              property :children, collection: true
+            end
+          }.to raise_error
+        end
+
+        context 'with :model' do
+          subject do
+            attributes = {
+              children: [
+                { name: 'Tom', age: 2 },
+                { name: 'Emi', age: 4 }
+              ]
+            }
+
+            object_factory(attributes: attributes) do
+              property :children, collection: ChildModel
+            end
+          end
+
+          it 'returns array of models' do
+            expect(subject.children.map(&:class)).to eq([ChildModel, ChildModel])
+            expect(subject.children.count).to eq(2)
+            expect(subject.children.first.name).to eq('Tom')
+            expect(subject.children.last.name).to eq('Emi')
+          end
+        end
+
+        context 'with :model and :uniq' do
+          subject do
+            attributes = {
+              children: [
+                { name: 'Tom', age: 2 },
+                { name: 'Tom', age: 2 }
+              ]
+            }
+
+            object_factory(attributes: attributes) do
+              property :children, collection: ChildModel, uniq: true
+            end
+          end
+
+          it 'returns array of models' do
+            expect(subject.children.map(&:class)).to eq([ChildModel])
+            expect(subject.children.count).to eq(1)
+            expect(subject.children.first.name).to eq('Tom')
+          end
+        end
+      end
+
+      context 'add with :required option' do
+        it 'raise MissingParamError when required param missing' do
+          expect {
+            object_factory { property :abc, required: true }
+          }.to raise_error(LightForm::MissingParamError, 'abc')
+        end
+      end
+    end
+
+    context 'add nested' do
+      let(:attributes) do
+        {
+          ab: {
+            cd: {
+              child: { age: '1', name: 'pawel', skip: 'av' }
+            },
+            ef: [
+              { age: '31', name: 'Pawel', skip: 'wrong' },
+              { age: '32', name: 'Sylwia', skip: 'bad' }
+            ],
+            gh: [
+              { age: '31', name: 'Pawel', skip: 'wrong' },
+              { age: '32', name: 'Sylwia', skip: 'bad' },
+              { age: '32', name: 'Sylwia', skip: 'bad' }
+            ]
+          }
+        }
+      end
+
+      it 'hold proper structure' do
+        test_obj = object_factory(attributes: attributes) do
+          property :ab do
+            property :cd do
+              property :child, model: ChildModel do
+                properties :name, :age
+              end
+            end
+
+            property :ef, collection: true do
+              property :name
+              property :age, with: -> (v) { v.to_i }
+            end
+
+            property :gh, collection: ChildModel, uniq: true do
+              properties :name, :age
+            end
+
+            property :ij, collection: true, with: -> (v) { (v.nil? || v.empty?) ? [] : v }
+          end
+        end
+
+        expect(test_obj.ab).not_to eq(nil)
+        expect(test_obj.ab.cd.child).to be_a(ChildModel)
+        expect(test_obj.ab.cd.child.age).to eq('1')
+        expect(test_obj.ab.cd.child.name).to eq('pawel')
+        expect { test_obj.ab.cd.child.skip }.to raise_error
+        expect(test_obj.ab.ef[0].name).to eq('Pawel')
+        expect(test_obj.ab.ef[0].age).to eq(31)
+        expect(test_obj.ab.gh[0]).to be_a(ChildModel)
+        expect(test_obj.ab.gh.count).to eq(2)
+        expect(test_obj.ab.ij).to eq([])
+      end
+
+      it 'validation works' do
+        test_obj = object_factory(
+          attributes: {
+            test: {
+              child: { age: '1', name: '', skip: 'av' },
+              children_hash: [
+                { age: '31', name: '', skip: 'wrong' },
+                { age: '32', name: 'Sylwia', skip: 'bad' }
+              ],
+              children: [
+                { age: '31', name: 'Pawel', skip: 'wrong' },
+                { age: '32', name: '', skip: 'bad' },
+                { age: '32', name: '', skip: 'bad' }
+              ]
+            }
+          }
+        ) do
+          property :test do
+            property :child, model: ChildModel do
+              property :name, validates: { presence: true }
+              property :age, validates: { numericality: true }
+            end
+
+            property :children_hash, collection: true do
+              property :name, validates: { presence: true }
+              property :age, with: -> (v) { v.to_i }
+            end
+
+            property :children, collection: ChildModel, uniq: true do
+              property :name, validates: { presence: true }
+              property :age, validates: { numericality: true }
+            end
+          end
+        end
+
+        expect(test_obj.valid?).to eq(false)
+      end
+
+      it 'to_h' do
+        test_obj = object_factory(attributes: attributes) do
+          property :ab do
+            property :cd do
+              property :child, model: ChildModel do
+                properties :name, :age
+              end
+            end
+
+            property :ef, collection: true do
+              property :name
+              property :age, with: -> (v) { v.to_i }
+            end
+
+            property :gh, collection: ChildModel, uniq: true do
+              properties :name, :age
+            end
+
+            property :ij, collection: true, with: -> (v) { (v.nil? || v.empty?) ? [] : v }
+          end
+        end
+
+        expect(test_obj.to_h).to eq(
+          {
+            ab: {
+              cd: {
+                child: ChildModel.new(age: '1', name: 'pawel')
+              },
+              ef: [
+                { age: 31, name: 'Pawel' },
+                { age: 32, name: 'Sylwia' }
+              ],
+              gh: [
+                ChildModel.new(age: '31', name: 'Pawel'),
+                ChildModel.new(age: '32', name: 'Sylwia')
+              ],
+              ij: []
+            }
+          }
+        )
+      end
     end
-    # context 'add nested' do
-    #   it 'first_level' do
-    #     test_obj = object_factory(attributes: { ab: { cd: 'cd'} }) do
-    #       property :ab do
-    #         property :cd
-    #       end
-    #     end
-
-    #     expect(test_obj.ab).to eq(cd: 'cd')
-    #   end
-    # end
   end
 end

data/spec/lib/lash_spec.rb

@@ -0,0 +1,161 @@
+describe LightForm::Lash do
+  context '.properties' do
+    subject do
+      class_factory do
+        properties :ab, :cd
+        properties :cd, :ef
+      end
+    end
+
+    it 'add attributes' do
+      instance = subject.new(ab: 'ab', cd: 'cd', ef: 'ef', skip: 'this')
+      expect(instance.ab).to eq('ab')
+      expect(instance.cd).to eq('cd')
+      expect(instance.ef).to eq('ef')
+      expect { instance.skip }.to raise_error(NoMethodError)
+    end
+  end
+
+  context 'property' do
+    context 'add' do
+      it 'new property' do
+        test_obj = object_factory(attributes: { ab: 'ab', cd: 'cd', skip: 'this' }) do
+          property :ab
+          property :cd
+        end
+
+        expect(test_obj.ab).to eq('ab')
+        expect(test_obj.cd).to eq('cd')
+        expect { test_obj.skip }.to raise_error(NoMethodError)
+      end
+    end
+
+    context 'with options' do
+      context 'add with :from option' do
+        subject do
+          object_factory(attributes: { aB: 'ab' }) do
+            property :ab, from: :aB
+          end
+        end
+
+        it 'assign property value from key provided by :from option' do
+          expect(subject.ab).to eq('ab')
+        end
+      end
+
+      context 'add with :default option' do
+        subject do
+          object_factory(attributes: { ab: '' }) do
+            property :ab, default: 'Default'
+          end
+        end
+
+        it 'assign property value from key provided by :default option when value is empty' do
+          expect(subject.ab).to eq('Default')
+        end
+      end
+
+      context 'add with :default and :transform_with option' do
+        let(:time) { Time.parse('2015-03-29 14:41:28 +0200') }
+        subject do
+          object_factory(attributes: { time: '' }) do
+            property :time, default: Time.parse('2015-03-29 14:41:28 +0200'), transform_with: -> (v) { Time.parse(v) }
+          end
+        end
+
+        it 'assign property value from key :default when value is empty and skip :transform_with' do
+          expect(subject.time).to eq(time)
+        end
+      end
+
+      context 'add with :default and :with option' do
+        let(:time) { Time.parse('2015-03-29 14:41:28 +0200') }
+        subject do
+          object_factory(attributes: { time: '' }) do
+            property :time, default: Time.parse('2015-03-29 14:41:28 +0200'), with: -> (v) { Time.parse(v) }
+          end
+        end
+
+        it 'assign property value from key :default when value is empty and skip :transform_with' do
+          expect(subject.time).to eq(time)
+        end
+      end
+
+      context 'add with :transform_with option assign property value after transformation' do
+        it 'by proc' do
+          test_obj = object_factory(attributes: { number: '12' }) do
+            property :number, transform_with: -> (v) { v.to_i }
+          end
+
+          expect(test_obj.number).to eq(12)
+        end
+
+        it 'by method' do
+          test_obj = object_factory(attributes: { number: '12' }) do
+            property :number, transform_with: :convert_to_number
+
+            def convert_to_number(value)
+              value.to_i
+            end
+          end
+
+          expect(test_obj.number).to eq(12)
+        end
+      end
+
+      context 'add with :with option assign property value after transformation' do
+        it 'by proc' do
+          test_obj = object_factory(attributes: { number: '12' }) do
+            property :number, with: -> (v) { v.to_i }
+          end
+
+          expect(test_obj.number).to eq(12)
+        end
+
+        it 'by method' do
+          test_obj = object_factory(attributes: { number: '12' }) do
+            property :number, with: :convert_to_number
+
+            def convert_to_number(value)
+              value.to_i
+            end
+          end
+
+          expect(test_obj.number).to eq(12)
+        end
+      end
+
+      context 'add with :validates option' do
+        subject do
+          object_factory(real_class_name: 'FakeHash', attributes: { name: '' }) do
+            property :name, validates: { presence: true }
+          end
+        end
+
+        it 'attribute has validation' do
+          expect(subject.valid?).to eq(false)
+          expect(subject.errors.as_json).to eq(name: ["can't be blank"])
+        end
+      end
+    end
+
+    it 'is a hash' do
+      test_obj = object_factory(real_class_name: 'LashTest', attributes: { name: '' }) do
+        property :name, validates: { presence: true }
+      end
+
+      expect(test_obj).to eq(name: '')
+    end
+
+    it 'is a hash' do
+      test_obj = object_factory(real_class_name: 'LashTest1', attributes: { errors: '' }) do
+        property :errors, validates: { presence: true }
+      end
+      expect(test_obj.valid?).to eq(false)
+      expect(test_obj).to eq(errors: '')
+      expect(test_obj.errors).to eq('')
+      expect(test_obj.errors_overriden?).to eq(true)
+      expect(test_obj._errors.as_json).to eq(errors: ["can't be blank"])
+    end
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: light_form
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Pawel Niemczyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-29 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.2
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
@@ -154,9 +168,12 @@ files:
 - Rakefile
 - lib/light_form.rb
 - lib/light_form/form.rb
+- lib/light_form/lash.rb
+- lib/light_form/property_methods.rb
 - lib/light_form/version.rb
 - light_form.gemspec
 - spec/lib/form_spec.rb
+- spec/lib/lash_spec.rb
 - spec/spec_helper.rb
 - spec/support/factory_helper.rb
 homepage: https://github.com/pniemczyk/light_form
@@ -185,5 +202,6 @@ specification_version: 4
 summary: Light Form
 test_files:
 - spec/lib/form_spec.rb
+- spec/lib/lash_spec.rb
 - spec/spec_helper.rb
 - spec/support/factory_helper.rb