pakyow-ui 0.11.3 → 1.0.0.rc1

data/pakyow-ui/lib/pakyow/ui/ui.rb

@@ -1,81 +0,0 @@
-require_relative 'mutator'
-require_relative 'channel_builder'
-require_relative 'ui_view'
-
-module Pakyow
-  module UI
-    # The UI context available during routing.
-    #
-    # @api public
-    class UI
-      attr_accessor :context
-      attr_reader :mutator
-
-      # Informs Pakyow that a mutation has occurred in application state,
-      # triggering all the necessary realtime view updates.
-      #
-      # @api public
-      def mutated(scope, data = nil, context = nil)
-        context ||= @context
-
-        MutationStore.instance.mutations(scope).each do |mutation|
-          view = UIView.new(mutation[:view_scope], mutation[:session])
-
-          qualified = true
-
-          # qualifiers are defined with the mutation
-          unless mutation[:qualifiers].empty? || data.nil?
-            mutation[:qualifiers].each_with_index do |qualifier, i|
-              qualified = false unless data[qualifier.to_sym].to_s == mutation[:query_args][i].to_s
-            end
-          end
-
-          qualified = false if data.nil? && !mutation[:qualifications].empty?
-
-          # qualifications are set on the subscription
-          unless !qualified || mutation[:qualifications].empty? || data.nil?
-            mutation[:qualifications].each_pair do |key, value|
-              qualified = false if data[key.to_sym].to_s != value.to_s
-            end
-          end
-
-          next unless qualified
-
-          mutable_data = Mutator.instance.mutable(scope, context).send(mutation[:query_name], *mutation[:query_args]).data
-          Mutator.instance.mutate(mutation[:mutation].to_sym, view, mutable_data)
-
-          channel = ChannelBuilder.build(
-            scope: mutation[:view_scope],
-            mutation: mutation[:mutation].to_sym,
-            qualifiers: mutation[:qualifiers],
-            data: mutable_data,
-            qualifications: mutation[:qualifications]
-          )
-
-          Pakyow.app.socket.push_message_to_socket_with_key(view.finalize, channel, mutation[:socket_key])
-        end
-      end
-
-      # Addresses a component rendered on the client-side.
-      #
-      # @api public
-      def component(name, qualifications = {})
-        UIComponent.new(name, qualifications)
-      end
-
-      # @api private
-      def load(mutators, mutables)
-        # TODO: this is another pattern I see all over the place
-        @mutator = Mutator.instance.reset
-
-        mutators.each_pair do |scope, block|
-          @mutator.set(scope, &block)
-        end
-
-        mutables.each_pair do |scope, block|
-          @mutator.mutable(scope, &block)
-        end
-      end
-    end
-  end
-end

data/pakyow-ui/lib/pakyow/ui/ui_attrs.rb

@@ -1,40 +0,0 @@
-require_relative 'ui_instructable'
-
-module Pakyow
-  module UI
-    # Builds up instructions for changing view attributes.
-    #
-    # @api private
-    class UIAttrs
-      include Instructable
-
-      def nested_instruct_object(_method, _data, _scope)
-        UIAttrs.new
-      end
-
-      def method_missing(method, value)
-        nested_instruct(method, value)
-      end
-
-      def class
-        method_missing(:class, nil)
-      end
-
-      def id
-        method_missing(:id, nil)
-      end
-
-      def <<(value)
-        method_missing(:insert, value)
-      end
-
-      def []=(method, value)
-        method_missing(method, value)
-      end
-
-      def [](method)
-        method_missing(method, nil)
-      end
-    end
-  end
-end

data/pakyow-ui/lib/pakyow/ui/ui_component.rb

@@ -1,68 +0,0 @@
-require_relative 'ui_instructable'
-
-module Pakyow
-  module UI
-    # An object for interacting with components rendered in a browser. Custom
-    # messages can be pushed and will be handled by the event listener defined
-    # on the client-side component.
-    #
-    # It's also possible to perform view transformations in realtime. Components
-    # implement a subset of transformations, including `scope` and `append`.
-    # This allows for finer control over particular components, completely
-    # bypassing mutables and mutators.
-    #
-    # @api public
-    class UIComponent
-      include Instructable
-
-      attr_reader :name, :view, :qualifications
-
-      # Intended to be created through the `ui.component` helper.
-      #
-      # @api private
-      def initialize(name, qualifications = {})
-        super()
-        @name = name
-        @qualifications = qualifications
-      end
-
-      # Pushes a message to the component.
-      #
-      # @api public
-      def push(payload = nil)
-        payload ||= { instruct: (root || self).finalize }
-
-        Pakyow.app.socket.push(
-          payload,
-
-          ChannelBuilder.build(
-            component: name,
-            qualifications: qualifications
-          )
-        )
-      end
-
-      # Narrows the scope of component instructions.
-      #
-      # @api public
-      def scope(name)
-        nested_instruct(:scope, name.to_s, name)
-      end
-
-      # Other supported transformation methods.
-      #
-      # @api public
-      %i(append prepend).each do |method|
-        define_method method do |value|
-          instruct(method, value)
-          push
-        end
-      end
-
-      # @api private
-      def nested_instruct_object(_method, _data, _scope)
-        UIComponent.new(name, qualifications)
-      end
-    end
-  end
-end

data/pakyow-ui/lib/pakyow/ui/ui_context.rb

@@ -1,16 +0,0 @@
-module Pakyow
-  module UI
-    # A simple context object used for accessing the session.
-    #
-    # @api private
-    class UIContext
-      def initialize(session)
-        @session = session
-      end
-
-      def request
-        UIRequest.new(@session)
-      end
-    end
-  end
-end

data/pakyow-ui/lib/pakyow/ui/ui_instructable.rb

@@ -1,117 +0,0 @@
-module Pakyow
-  module UI
-    # Helper methods for instructable objects.
-    #
-    # @api private
-    module Instructable
-      def self.included(klass)
-        (@instructables ||= []) << klass
-      end
-
-      def self.instructable?(object)
-        @instructables.select { |i|
-          object.is_a?(i)
-        }.any?
-      end
-
-      attr_reader :instructions
-      attr_accessor :root
-
-      def initialize
-        @instructions = []
-      end
-
-      def instruct(method, data)
-        @instructions << [clean_method(method), hashify(data)]
-        self
-      end
-
-      def nested_instruct(method, data, scope = nil)
-        view = nested_instruct_object(method, data, scope)
-        view.root = self
-
-        @instructions << [clean_method(method), hashify(data), view]
-        view
-      end
-
-      # Returns an instruction set for all view transformations.
-      #
-      # e.g. a value-less transformation:
-      # [[:remove, nil]]
-      #
-      # e.g. a transformation with a value:
-      # [[:text=, 'foo']]
-      #
-      # e.g. a nested transformation
-      # [[:scope, :post, [[:remove, nil]]]]
-      def finalize
-        @instructions.map { |instruction|
-          if Instructable.instructable?(instruction[2])
-            instruction[2] = instruction[2].finalize
-          end
-
-          instruction
-        }
-      end
-
-      private
-
-      def mixin_bindings(data, bindings = {})
-        data.map { |bindable|
-          datum = bindable.to_hash.dup
-          Pakyow::Presenter::Binder.instance.bindings_for_scope(scoped_as, bindings).keys.each do |key|
-            result = Pakyow::Presenter::Binder.instance.value_for_scoped_prop(scoped_as, key, bindable, bindings, self)
-
-            if result.is_a?(Hash)
-              # we don't currently support view manipulations that occur in bindings
-              # TODO: look into what it would take to support this
-              result.delete(:view)
-
-              content = result.delete(:content)
-              if content.respond_to?(:to_proc)
-                content = content.to_proc.call()
-              end
-
-              datum[key] = {
-                __content: content,
-                __attrs: Hash[*result.flat_map { |k, v|
-                  if v.respond_to?(:to_proc)
-                    attrs = UIAttrs.new
-                    v.call(attrs)
-                    [k, attrs.finalize]
-                  else
-                    [k, v]
-                  end
-                }]
-              }
-            else
-              datum[key] = result
-            end
-          end
-
-          datum
-        }
-      end
-
-      def hashify(data)
-        return hashify_datum(data) unless data.is_a?(Array)
-
-        data.map { |datum|
-          hashify_datum(datum)
-        }
-      end
-
-      def hashify_datum(datum)
-        if datum.respond_to?(:to_hash)
-          datum.to_hash
-        else
-          datum
-        end
-      end
-
-      def clean_method(method)
-        method.to_s.delete('=').to_sym
-      end
-    end
-  end
-end

data/pakyow-ui/lib/pakyow/ui/ui_request.rb

@@ -1,14 +0,0 @@
-module Pakyow
-  module UI
-    # A simple request object used for accessing the session.
-    #
-    # @api private
-    class UIRequest
-      attr_reader :session
-
-      def initialize(session)
-        @session = Hash.strhash(session)
-      end
-    end
-  end
-end

data/pakyow-ui/lib/pakyow/ui/ui_view.rb

@@ -1,200 +0,0 @@
-require_relative 'ui_attrs'
-require_relative 'ui_instructable'
-require_relative 'ui_context'
-require_relative 'ui_request'
-
-module Pakyow
-  module UI
-    # Translates view transformations to instructions.
-    #
-    # @api private
-    class UIView
-      include Instructable
-      include Pakyow::Helpers
-
-      def initialize(scope, session = {})
-        super()
-        @scope = scope.to_sym
-        @session = session
-        @context = UIContext.new(session)
-      end
-
-      def nested_instruct_object(_method, _data, scope)
-        UIView.new(scope || @scope, @session)
-      end
-
-      def scoped_as
-        @scope
-      end
-
-      def attrs_instruct
-        attrs = UIAttrs.new
-        @instructions << [:attrs, nil, attrs]
-        attrs
-      end
-
-      ### view methods w/o args
-
-      %i(
-        remove
-        clear
-      ).each do |method|
-        define_method method do
-          instruct(method, nil)
-        end
-      end
-
-      ### view methods w/ args
-
-      %i(
-        title=
-        text=
-        html=
-        append
-        prepend
-        after
-        before
-        replace
-        use
-      ).each do |method|
-        define_method method do |value|
-          instruct(method, value.to_s)
-        end
-      end
-
-      ### misc view methods
-
-      def with(&block)
-        if block.arity == 0
-          instance_exec(&block)
-        else
-          yield(self)
-        end
-
-        self
-      end
-
-      def match(data)
-        instruct(:match, Array.ensure(data))
-      end
-
-      def scope(name)
-        nested_instruct(:scope, name.to_s, name)
-      end
-
-      def attrs
-        attrs_instruct
-      end
-
-      ### view methods that change context
-
-      %i(
-        prop
-        component
-      ).each do |method|
-        define_method method do |value|
-          nested_instruct(method, value.to_s)
-        end
-      end
-
-      ### view methods that continue into a new context
-
-      def version(data, &block)
-        nested = nested_instruct(:version, data)
-        Array.ensure(data).each do |datum|
-          sub = UIView.new(@scope)
-
-          if block.arity == 1
-            sub.instance_exec(datum, &block)
-          else
-            block.call(sub, datum)
-          end
-
-          nested.instructions << sub.finalize
-        end
-
-        self
-      end
-
-      def for(data, &block)
-        nested = nested_instruct(:for, data)
-        Array.ensure(data).each do |datum|
-          sub = UIView.new(@scope)
-
-          if block.arity == 1
-            sub.instance_exec(datum, &block)
-          else
-            block.call(sub, datum)
-          end
-
-          nested.instructions << sub.finalize
-        end
-      end
-
-      def for_with_index(*args, &block)
-        self.for(*args, &block)
-      end
-
-      def repeat(data, &block)
-        nested = nested_instruct(:repeat, data)
-        Array.ensure(data).each do |datum|
-          sub = UIView.new(@scope)
-
-          if block.arity == 1
-            sub.instance_exec(datum, &block)
-          else
-            block.call(sub, datum)
-          end
-
-          nested.instructions << sub.finalize
-        end
-      end
-
-      def repeat_with_index(*args, &block)
-        repeat(*args, &block)
-      end
-
-      def bind(data, bindings: {}, context: nil, &block)
-        # TODO: handle context?
-
-        nested = nested_instruct(:bind, mixin_bindings(Array.ensure(data), bindings))
-        return self unless block_given?
-
-        data.each do |datum|
-          sub = UIView.new(@scope)
-
-          if block.arity == 1
-            sub.instance_exec(datum, &block)
-          else
-            block.call(sub, datum)
-          end
-
-          nested.instructions << sub.finalize
-        end
-      end
-
-      def bind_with_index(*args, &block)
-        bind(*args, &block)
-      end
-
-      def apply(data, bindings: {}, context: nil, &block)
-        # TODO: handle context?
-
-        nested = nested_instruct(:apply, mixin_bindings(Array.ensure(data), bindings))
-        return self unless block_given?
-
-        data.each do |datum|
-          sub = UIView.new(@scope, @session)
-
-          if block.arity == 1
-            sub.instance_exec(datum, &block)
-          else
-            block.call(sub, datum)
-          end
-
-          nested.instructions << sub.finalize
-        end
-      end
-    end
-  end
-end

data/pakyow-ui/lib/pakyow/ui.rb

@@ -1 +0,0 @@
-require 'pakyow/ui/base'

data/pakyow-ui/lib/pakyow-ui.rb

@@ -1 +0,0 @@
-require 'pakyow/ui'