unpoly-rails 1.0.3 → 2.0.0.pre.rc2

data/lib/unpoly/rails/change/cache.rb

@@ -0,0 +1,26 @@
+module Unpoly
+  module Rails
+    class Change
+      class Cache
+
+        def initialize(change)
+          @change = change
+        end
+
+        # TODO: Docs
+        def clear(pattern = '*')
+          change.clear_cache = pattern
+        end
+
+        def keep
+          clear(false)
+        end
+
+        private
+
+        attr_reader :change
+
+      end
+    end
+  end
+end

data/lib/unpoly/rails/change/context.rb

@@ -0,0 +1,80 @@
+module Unpoly
+  module Rails
+    class Change
+      class Context
+
+        def initialize(input, changes)
+          # Response headers will only include changed keys
+          @changes = ensure_indifferent_access(changes)
+
+          # Keep a structure-cloned copy of the input hash, so we can
+          # detect changes of sub-keys and sub-arrays in #finalize_changes.
+          @input = ensure_indifferent_access(input)
+          @unmutated_input = input.deep_dup
+        end
+
+        def [](key)
+          if changes.key?(key)
+            changes[key]
+          else
+            input[key]
+          end
+        end
+
+        def delete(key)
+          self[key] = nil
+        end
+
+        # Although we have mutation tracking in finalize_changes, we're still tracking
+        # direct changes in #[]=. We don't want to force user code know whether to use
+        # up.context[]= or up.fail_context[]=. Changes in either will be pushed to the
+        # client in the X-Up-Context header.
+        def []=(key, value)
+          # No need to persist it through redirects (via params) anymore.
+          input.delete(key)
+          changes[key] = value
+        end
+
+        def to_h
+          input.merge(changes)
+        end
+
+        def replace(new_hash)
+          new_hash = new_hash.stringify_keys
+          # The frontend merges X-Up-Context updates.
+          # Hence we must nilify every key that no longer exists in the
+          # replaced hash.
+          deleted_keys = (input.keys | changes.keys) - new_hash.keys
+          changes.replace(new_hash)
+          deleted_keys.each { |deleted_key| changes[deleted_key] = nil }
+          input.clear
+          unmutated_input.clear
+        end
+
+        def finalize_changes
+          unmutated_input.each do |key, unmutated_value|
+            if input.key?(key) && !changes.key?(key)
+              input_value = input[key]
+              if unmutated_value != input_value
+                self[key] = input_value
+              end
+            end
+          end
+        end
+
+        private
+
+        attr_reader :input, :unmutated_input, :changes
+
+        def ensure_indifferent_access(hash)
+          if hash.is_a?(ActiveSupport::HashWithIndifferentAccess)
+            hash
+          else
+            raise Error, "Constructor args must be an ActiveSupport::HashWithIndifferentaccess"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/unpoly/rails/change/field.rb

@@ -0,0 +1,117 @@
+module Unpoly
+  module Rails
+    class Change
+
+      class Field
+        PARAM_PREFIX = '_up_'
+
+        def initialize(name)
+          @name = name
+        end
+
+        attr_reader :name
+
+        def header_name
+          result = name.to_s
+          result = result.capitalize
+          result = result.gsub(/_(.)/) { "-#{$1.upcase}" }
+          result = "X-Up-#{result}"
+          result
+        end
+
+        def param_name
+          "#{PARAM_PREFIX}#{name}"
+        end
+
+        def parse(raw)
+          raise NotImplementedError
+        end
+
+        def stringify(value)
+          raise NotImplementedError
+        end
+
+        class String < Field
+
+          def parse(raw)
+            raw
+          end
+
+          def stringify(value)
+            value.to_s
+          end
+
+        end
+
+        class Boolean < Field
+
+          def parse(raw)
+            raw == 'true'
+          end
+
+          def stringify(value)
+            value.to_json
+          end
+
+        end
+
+        class Time < Field
+
+          def parse(raw)
+            if raw.present?
+              ::Time.at(raw.to_i)
+            end
+            end
+
+          def stringify(value)
+            if value
+              value.to_i
+            end
+          end
+
+        end
+
+        class Hash < Field
+
+          def parse(raw)
+            if raw.present?
+              result = ActiveSupport::JSON.decode(raw)
+            else
+              result = {}
+            end
+
+            if result.is_a?(::Hash)
+              result = ActiveSupport::HashWithIndifferentAccess.new(result)
+            end
+
+            result
+          end
+
+          def stringify(value)
+            ActiveSupport::JSON.encode(value)
+          end
+
+        end
+
+        class Array < Field
+
+          def parse(raw)
+            if raw.present?
+              result = ActiveSupport::JSON.decode(raw)
+            else
+              result = []
+            end
+
+            result
+          end
+
+          def stringify(value)
+            ActiveSupport::JSON.encode(value)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/unpoly/rails/change/field_definition.rb

@@ -0,0 +1,74 @@
+module Unpoly
+  module Rails
+    class Change
+      module FieldDefinition
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        # Rails 3.2 delegate generated invalid Ruby with `to: :class`.
+        delegate :fields, to: :get_class
+
+        private
+
+        def get_class
+          self.class
+        end
+
+        module ClassMethods
+
+          def field(name, type, method: name, response_header_name: nil)
+            field = type.new(name)
+
+            define_method "#{method}_field" do
+              field
+            end
+
+            define_method "#{method}_from_request_headers" do
+              raw_value = request.headers[field.header_name]
+              field.parse(raw_value)
+            end
+
+            define_method "#{method}_param_name" do
+              field.param_name
+            end
+
+            define_method "serialized_#{method}" do
+              value = send(method)
+              field.stringify(value)
+            end
+
+            # define_method "#{name}_from_response_headers" do
+            #   raw_value = response.headers[field.header_name]
+            #   field.parse(raw_value)
+            # end
+
+            define_method "#{method}_from_params" do
+              raw_value = params[field.param_name]
+              field.parse(raw_value)
+            end
+
+            define_method "#{method}_from_request" do
+              value = send("#{method}_from_request_headers")
+              if value.nil?
+                value = send("#{method}_from_params")
+              end
+              value
+            end
+
+            define_method "write_#{method}_to_response_headers" do
+              value = send(method)
+              stringified = field.stringify(value)
+              if stringified.present? # app servers don't like blank header values
+                header_name = response_header_name || field.header_name
+                response.headers[header_name] = stringified
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/unpoly/rails/change/layer.rb

@@ -0,0 +1,60 @@
+module Unpoly
+  module Rails
+    class Change
+      class Layer
+        class CannotClose < Error; end
+
+        def initialize(change, mode:, context:)
+          @change = change
+          @mode = mode.presence || 'root'
+          @context = context
+        end
+
+        ##
+        # TODO: Docs
+        attr_reader :mode
+
+        ##
+        # TODO: Docs
+        attr_reader :context
+
+        ##
+        # TODO: Docs
+        def overlay?
+          not root?
+        end
+
+        ##
+        # TODO: Docs
+        def root?
+          mode == 'root'
+        end
+
+        ##
+        # TODO: Docs
+        def emit(type, options = {})
+          change.emit(type, options.merge(layer: 'current'))
+        end
+
+        ##
+        # TODO: Docs
+        def accept(value = nil)
+          overlay? or raise CannotClose, 'Cannot accept the root layer'
+          change.response.headers['X-Up-Accept-Layer'] = value.to_json
+        end
+
+        ##
+        # TODO: Docs
+        def dismiss(value = nil)
+          overlay? or raise CannotClose, 'Cannot dismiss the root layer'
+          change.response.headers['X-Up-Dismiss-Layer'] = value.to_json
+        end
+
+        private
+
+        attr_reader :change
+
+      end
+    end
+  end
+end