cat_forms 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5867215cad9448070b77390a76a9fe9e1fb390f9
-  data.tar.gz: 6ebbcb9cfa9ed393b0ea4fb78f2cbe8554a2eadb
+  metadata.gz: e41399d5ac4893087435e2e6aa5955d4d3ee284a
+  data.tar.gz: b0a5e377693ef76d875bc2b87ce9495fb9e480de
 SHA512:
-  metadata.gz: e3707d05035069c357604735aab2cb175df552e7570f550f37f5649865a78b0941443be2cbfb4e3e05ab03eef9053b13c3d1146226d9d00d1dae3f80dedba6d1
-  data.tar.gz: 7c1efd9159019bde3397587177938c83d53967eb4c20c58a057c152482ea7816e6d8ea5c28687b4374cae9d2904895038c8fcadc73ab6032d4db55c5b198232d
+  metadata.gz: 3e721107373b10dfd0557b58b905fd3a6f58420e70ce11c3eace372f325643463b41796092bdc4fa8a86c1c96903dabed26431d0a4c5a5929d109ca0ca512cf7
+  data.tar.gz: cd56fde1729f815dbc07bd1e7057f71a81852076f15d188a5e777dbad12a67b2fb1c82e2b43e6c97f91f8bc738975c789b98a821aef49950b3fc9b9616210f8f

data/lib/cat_forms/gzip_cookie.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+require 'zlib'
+require 'active_support/hash_with_indifferent_access'
+
+# Saves form as cookie as json+gzip
+module CatForms::GzipCookie
+  def self.load options={}
+    request     = options[:request]
+    cookie_name = options[:cookie_name].to_s
+    result = ActiveSupport::HashWithIndifferentAccess.new
+    return result if request.blank?
+    cookie = request.cookies[cookie_name]
+    return result if cookie.nil? or cookie.empty?
+    begin
+      result.merge!(ActiveSupport::JSON.decode(Zlib::Inflate.inflate(cookie)).stringify_keys)
+      return result
+    rescue Zlib::DataError
+      return result
+    end
+  end
+
+  def self.save options = {}
+    attributes  = options[:attributes]
+    response    = options[:response]
+    cookie_name = options[:cookie_name]
+
+    cookie_json = ActiveSupport::JSON.encode(attributes)
+    cookie_json = Zlib::Deflate.deflate(cookie_json, Zlib::BEST_COMPRESSION)
+    cookie_hash = { value: cookie_json,
+                    httponly: true,
+                  }
+    response.set_cookie(cookie_name, cookie_hash)
+  end
+end
+

data/lib/cat_forms/validation_scopes.rb

@@ -0,0 +1,66 @@
+require 'delegate'
+
+module ValidationScopes
+  def self.included(base) # :nodoc:
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def validation_scope(scope)
+      @all_scopes ||= []
+      @all_scopes << scope
+
+      def self.all_scopes
+        @all_scopes
+      end
+
+      base_class = self
+
+      proxy_class = Class.new(DelegateClass(base_class)) do
+        include ActiveModel::Validations
+
+        def initialize(record)
+          @base_record = record
+          super(record)
+        end
+
+        # Hacks to support dynamic_model helpers
+        def to_model
+          self
+        end
+
+        # Rails 3 default implementation of model_name blows up for anonymous classes
+        class << self; self; end.class_eval do
+          define_method(:model_name) do
+            base_class.model_name
+          end
+        end
+      end
+
+      yield proxy_class
+
+      define_method(scope) do
+        send("validation_scope_proxy_for_#{scope}").errors
+      end
+
+      define_method("no_#{scope}?") do
+        send("validation_scope_proxy_for_#{scope}").valid?
+      end
+
+      define_method("has_#{scope}?") do
+        send("validation_scope_proxy_for_#{scope}").invalid?
+      end
+
+      define_method("init_validation_scope_for_#{scope}") do
+        unless instance_variable_defined?("@#{scope}")
+          instance_variable_set("@#{scope}", proxy_class.new(self))
+        end
+      end
+
+      define_method("validation_scope_proxy_for_#{scope}") do
+        send "init_validation_scope_for_#{scope}"
+        instance_variable_get("@#{scope}")
+      end
+    end
+  end
+end

data/lib/cat_forms/version.rb

@@ -0,0 +1,3 @@
+module CatForms
+  VERSION = "0.0.3"
+end

data/lib/cat_forms.rb

@@ -0,0 +1,254 @@
+# Warning: This code is atrocious.
+#
+# ActiveModel is sorta confusing in Rails 3.2.  I think
+# it's improved in 4.0?
+#
+# TODO we should be checking the type of things when saving
+
+module CatForms
+  require 'active_model'
+  require 'virtus'
+  require 'active_support/core_ext/class/attribute'
+  require 'cat_forms/validation_scopes'
+  autoload :GzipCookie, 'cat_forms/gzip_cookie'
+
+  # TODO not sure thy this is necessary. tests run, but
+  # when this is included by rails, i get already defined
+  # errors and super class mismatch errors.
+  if !defined?(CatForms::Boolean)
+    class Boolean < Virtus::Attribute::Boolean
+    end
+  end
+
+  module Form
+
+    def self.included base
+      base.send :include, ActiveModel::Validations
+      base.send :extend,  ActiveModel::Callbacks
+      base.send :include, Virtus.model
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+      base.send :include, ValidationScopes
+      base.instance_eval do
+        define_model_callbacks :initialize, :save
+        class_attribute :_form_name
+      end
+    end
+
+    module ClassMethods
+      # Overrides how Virtus handles attributes of the wrong type.
+      # Ideally virtus would coerce everything to the right type,
+      # use the default, or return nil.
+      # There's a related discussion here: https://github.com/solnic/virtus/issues/99
+      def attribute(name, type, opts = {})
+        super(name, type, opts)
+        define_method(name) do
+          data = super()
+          default_value = -> { opts[:default].respond_to?(:call) ? opts[:default].call : opts[:default] }
+
+          # If they want a BigDecimal or Int, but data is a string, strip
+          # the stuff of bad data and try to convert manually.
+          if type == BigDecimal or type == Integer
+            if data.class == String
+              data.gsub!(/[^\d\.]/, '')
+              if data.present?
+                if type == BigDecimal
+                  data = BigDecimal.new(data)
+                else
+                  data = Integer(data)
+                end
+              end
+            end
+          end
+
+          #if type.class != Array and !data.is_a?(type) and !data.nil? and (type != CatForms::Boolean and !data.is_a?(Boolean))
+            #puts "cat forms expected a #{type} for #{ name }, received #{ data.inspect }"
+            #puts caller
+          #end
+
+          if type == CatForms::Boolean and (data == true or data == false)
+            return data
+          end
+
+          if type.class == Array
+            # Not validating more right now.
+            return data
+          end
+
+          if data.is_a?(type)
+            # Override for default string
+            if type == String and opts.has_key?(:default) and data == ""
+              return default_value.call
+            else
+              return data
+            end
+          end
+
+          return default_value.call
+        end
+      end
+
+      def form_name name
+        name = name.to_s
+
+        def name.i18n_key
+          self
+        end
+
+        def name.human
+          self
+        end
+
+        def name.singular
+          self
+        end
+
+        def name.plural
+          self
+        end
+
+        def name.param_key
+          self
+        end
+
+        self.class.instance_eval do
+          define_method :model_name do
+            name
+          end
+        end
+
+        self._form_name = name
+      end
+
+      def model_name
+        self._form_name || super
+      end
+
+      def form_attribute name, klass, options={}
+        # Setup the default values for each attribute.
+        if !options.has_key?(:default)
+          options[:default] =
+            if klass.kind_of?(Array)
+              []
+            elsif klass == BigDecimal or klass == Boolean or klass == CatForms::Boolean
+              nil
+            elsif klass.respond_to?(:new)
+              proc { klass.new }
+            else
+              nil
+            end
+        end
+        attribute name, klass, options
+        if options[:validations]
+          validates(name, options[:validations])
+        end
+
+        # Define an association_attributes= method
+        # Rails's fields_for looks for this.
+        if klass.kind_of?(Array)
+          define_method "#{name}_attributes=" do |hash|
+            hash.each do |_index, opts|
+              # If the array is nil, set it to an empty array.
+              self.send("#{name}=", []) if self.send(name).nil?
+              self.send(name) << klass.first.new(opts)
+            end
+          end
+        end
+      end
+
+      def custom_attribute attribute_name
+        class_eval do
+          attr_reader attribute_name
+        end
+      end
+
+      def validates_associated(*associations)
+        validates_each(associations) do |record, _associate_name, value|
+          (value.respond_to?(:each) ? value : [value]).each do |rec|
+            if rec && !rec.valid?
+              rec.errors.each do |key, val|
+                record.errors.add(key, val)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      # Need to look into all the below methods, not sure if they are
+      # correct.
+      def persisted?
+        false
+      end
+
+      def to_model
+        self
+      end
+
+      def to_partial_path
+        "some_path" # TODO figure out what's needed here for Rails 3.2
+      end
+
+      def to_param
+        nil
+      end
+
+      def to_key
+        nil
+      end
+
+      def save
+        run_callbacks :save do
+          if !valid?
+            return false
+          end
+        end
+        self
+      end
+
+      def initialize options = {}
+        run_callbacks(:initialize) do
+          # can sometimes be a string
+          if options.class != Hash
+            options = {}
+          end
+          options[:form] ||= {}
+
+          # TODO fix
+          # This allows setting of custom things
+          options.each do |key, value|
+            instance_variable_set "@#{key}", value
+          end
+
+          CatForms::GzipCookie.load(storage_options).each do |key, value|
+            method = "#{key}="
+            if respond_to?(method)
+              self.send method, value
+            end
+          end
+
+          options[:form].each do |name, value|
+            value.strip! if value.respond_to?(:strip)
+            self.send "#{name}=", value
+          end
+
+        end
+        super
+      end
+
+      def save_to_storage!
+        options = storage_options.merge(attributes: attributes)
+        CatForms::GzipCookie.save(options)
+      end
+
+      def storage_options
+        {
+          cookie_name: @cookie_name,
+          request: @request,
+          response: @response
+        }
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cat_forms
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Joe Van Dyk
@@ -44,7 +44,11 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/cat_forms.rb
+- lib/cat_forms/gzip_cookie.rb
+- lib/cat_forms/validation_scopes.rb
+- lib/cat_forms/version.rb
 homepage: https://github.com/joevandyk/cat_forms
 licenses: []
 metadata: {}