pakyow-ui 0.11.3 → 1.0.0.rc1

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

@@ -1,30 +0,0 @@
-module Pakyow
-  module Presenter
-    class ViewContext
-      MSG_NONCOMPONENT = 'Cannot subscribe a non-component view'
-
-      # Mutates a view with a registered mutator.
-      #
-      # @api public
-      def mutate(mutator, data: nil, with: nil)
-        Pakyow::UI::Mutator.instance.mutate(mutator, self, data || with || [])
-      end
-
-      # Subscribes a view and sets the `data-channel` attribute.
-      #
-      # @api public
-      def subscribe(qualifications = {})
-        fail ArgumentError, MSG_NONCOMPONENT unless component?
-
-        channel = Pakyow::UI::ChannelBuilder.build(
-          component: component_name,
-          qualifications: qualifications
-        )
-
-        context.socket.subscribe(channel)
-        attrs.send(:'data-channel=', channel)
-        self
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-require_relative 'no_op_view'
-
-# Makes it possible to fetch a particular part of a view for a path. Calls a
-# route with all view actions becoming no-ops. Then a query is run against the
-# final view, pulling out the part that was requested.
-#
-# Expects the following in the message:
-#
-# - uri: the route to call
-# - lookup: the view query
-#
-# Lookup currently supports the following keys:
-#
-# - channel
-# - version
-# - container
-# - partial
-# - scope
-# - prop
-#
-Pakyow::Realtime.handler :'fetch-view' do |message, session, response|
-  env = Rack::MockRequest.env_for(message['uri'])
-  env['pakyow.socket'] = true
-  env['rack.session'] = session
-
-  context = Pakyow::CallContext.new(env)
-
-  def context.view
-    Pakyow::Presenter::NoOpView.new(
-      Pakyow::Presenter::ViewContext.new(@presenter.view, self),
-      self
-    )
-  end
-
-  app_response = context.process.finish
-
-  body = ''
-  lookup = message['lookup']
-  view = context.presenter.view
-
-  channel = lookup['channel']
-
-  if channel
-    unqualified_channel = channel.split('::')[0]
-    view_for_channel = view.composed.doc.channel(unqualified_channel)
-
-    if view_for_channel
-      view_for_channel.set_attribute(:'data-channel', channel)
-      body = view_for_channel.to_html
-    end
-  else
-    lookup.each_pair do |key, value|
-      next if key == 'version'
-      view = view.send(key.to_sym, value.to_sym)
-    end
-
-    if view.is_a?(Pakyow::Presenter::ViewVersion)
-      body = view.use((lookup['version'] || :default).to_sym).to_html
-    else
-      body = view.to_html
-    end
-  end
-
-  response[:status]  = app_response[0]
-  response[:headers] = app_response[1]
-  response[:body] = body
-  response
-end

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

@@ -1,15 +0,0 @@
-module Pakyow
-  module Helpers
-    def ui
-      return @ui unless @ui.nil?
-
-      ui_dup = Pakyow.app.ui.dup
-      ui_dup.context = self
-      @ui = ui_dup
-    end
-
-    def data(scope)
-      ui.mutator.mutable(scope, self)
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Pakyow
-  module Presenter
-    # Used by NoOpView to perform mutations in a no-op manner.
-    #
-    # @api private
-    class MockMutationEval
-      def initialize(mutation_name, relation_name, view)
-        @mutation_name = mutation_name
-        @relation_name = relation_name
-        @view = view
-      end
-
-      # NOTE we don't care about qualifiers here since we're just getting
-      # the proper view template; not actually setting it up with data
-      def subscribe(*_args)
-        channel = Pakyow::UI::ChannelBuilder.build(
-          scope: @view.scoped_as,
-          mutation: @mutation_name
-        )
-
-        @view.attrs.send(:'data-channel=', channel)
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-require_relative 'mutable_data'
-
-# TODO: make it possible to register this as data instead of mutables
-
-module Pakyow
-  module UI
-    # Mutables enable PakyowUI to automatically handle changes in application
-    # state by interacting with the data layer in a declarative manner.
-    #
-    # Wraps a data source (such as a model object) and provides a convenient
-    # interface for defining and executing queries and actions. Queries accept
-    # parameters and return data sets. Actions cause a state change in
-    # application state.
-    #
-    # Once defined, all interactions with the data layer should occur through
-    # Mutables via the `data` helper method. When an action is performed that
-    # changes the state of the application, Pakyow will propogate the change
-    # through to all other connected clients automatically.
-    #
-    # Mutables should be registered with the `Pakyow::App.mutable` helper. The
-    # defined block will be executed in context of a `Mutable` instance.
-    #
-    # @api public
-    class Mutable
-      include Helpers
-
-      attr_reader :context
-
-      # @api private
-      def initialize(context, scope, &block)
-        @context = context
-        @scope   = scope
-        @actions = {}
-        @queries = {}
-
-        instance_exec(&block)
-      end
-
-      # Sets the model object.
-      #
-      # @api public
-      def model(model_class, type: nil)
-        @model_class = model_class
-
-        return if type.nil?
-        @model_type = type
-
-        # TODO: load default actions / queries based on type
-      end
-
-      # Defines an action.
-      #
-      # @api public
-      def action(name, mutation: true, &block)
-        @actions[name] = {
-          block: block,
-          mutation: mutation
-        }
-      end
-
-      # Defines a query.
-      #
-      # @api public
-      def query(name, &block)
-        @queries[name] = block
-      end
-
-      # Handles calling queries or actions. Enables convenience like:
-      #
-      # data(:some_data).{action or query}
-      #
-      # @api public
-      def method_missing(method, *args)
-        action = @actions[method]
-        query = @queries[method]
-
-        if action
-          call_action(action, *args)
-        elsif query
-          call_query(query, method, *args)
-        else
-          fail ArgumentError, "Could not find query or action named #{method}"
-        end
-      end
-
-      private
-
-      def call_action(action, *args)
-        result = action[:block].call(*args)
-        @context.ui.mutated(@scope, result, @context) if action[:mutation]
-        result
-      end
-
-      def call_query(query, method, *args)
-        MutableData.new(query, method, args, @scope)
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Pakyow
-  module UI
-    # Adds metadata to a dataset returned by a Mutable query.
-    #
-    # @api private
-    class MutableData
-      attr_reader :query_name, :query_args, :scope
-
-      def initialize(query, query_name, query_args, scope)
-        @query = query
-        @query_name = query_name
-        @query_args = query_args
-        @scope = scope
-      end
-
-      def data
-        @data ||= @query.call(*@query_args)
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-require_relative 'channel_builder'
-
-module Pakyow
-  module UI
-    # Provides helper methods to perform in context of a mutation. For example:
-    #
-    # view.scope(:foo).mutate(:bar).subscribe
-    #
-    # In the above example `mutate` returns a MutateContext object on which
-    # `subscribe` is called.
-    #
-    # @api public
-    class MutateContext
-      attr_reader :mutation, :view, :data
-
-      # Creates a new context. Intended to be created by a Mutator.
-      #
-      # @api private
-      def initialize(mutation, view, data)
-        @mutation = mutation
-        @view     = view
-        @data     = data
-      end
-
-      # Subscribes a mutation with optional qualifications. Qualifications are
-      # used to control the scope of future mutations. For example:
-      #
-      # view.scope(:foo).mutate(:bar).subscribe(user_id: 1)
-      #
-      # In the above example, a subscription is created qualified by `user_id`.
-      # Only mutations occuring with the same qualifications will cause the
-      # mutation to be performed again, triggering a view refresh.
-      #
-      # ui.mutated(:foo, user_id: 1)
-      #
-      # @api public
-      def subscribe(qualifications = {})
-        if data.is_a?(MutableData) && !view.context.request.env['pakyow.socket']
-          MutationStore.instance.register(self, view, data, qualifications, view.context.request.session)
-        end
-
-        channel = ChannelBuilder.build(
-          scope: view.scoped_as,
-          mutation: mutation[:name],
-          qualifiers: mutation[:qualifiers],
-          data: data,
-          qualifications: qualifications
-        )
-
-        # subscribe to the channel
-        view.context.socket.subscribe(channel)
-
-        # handle setting the channel on the view
-        if view.is_a?(Presenter::ViewContext)
-          working_view = view.instance_variable_get(:@view)
-        else
-          working_view = view
-        end
-
-        working_view.attrs.send(:'data-channel=', channel)
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Pakyow
-  module UI
-    # Stores mutations.
-    #
-    # @api private
-    class MutationSet
-      attr_reader :mutations
-
-      def initialize(&block)
-        @mutations = {}
-        instance_exec(&block)
-      end
-
-      # NOTE I do have some concerns about defining qualifiers in this way;
-      # mainly because it will lead to having lots of versions of the same
-      # mutator just so the proper channels will be created.
-      #
-      # It's could end up being better to pass qualifiers to `subscribe`;
-      # however it feels premature to make this decision since it'll lead
-      # to a large increase in complexity to add at this point.
-      def mutator(name, qualify: [], &block)
-        @mutations[name] = {
-          fn: block,
-          qualifiers: Array.ensure(qualify),
-          name: name
-        }
-      end
-
-      def mutation(name)
-        @mutations.fetch(name)
-      end
-
-      def each(&block)
-        @mutations.each(&block)
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-module Pakyow
-  module UI
-    # Stores mutations that have occurred in the configured registry.
-    #
-    # @api private
-    class MutationStore
-      include Singleton
-
-      def initialize
-        @registry = Config.ui.registry.instance
-      end
-
-      def register(mutate_context, view, mutable_data, qualifications, session)
-        @registry.register(
-          mutable_data.scope,
-
-          view_scope: view.scoped_as,
-          mutation: mutate_context.mutation[:name],
-          qualifiers: mutate_context.mutation[:qualifiers],
-          qualifications: qualifications,
-          query_name: mutable_data.query_name,
-          query_args: mutable_data.query_args,
-          session: session.to_hash,
-          socket_key: mutate_context.view.context.socket_digest(mutate_context.view.context.socket_connection_id)
-        )
-      end
-
-      def unregister(socket_key)
-        @registry.unregister(socket_key)
-      end
-
-      def mutations(scope)
-        @registry.mutations(scope) || []
-      end
-    end
-  end
-end
-
-Pakyow::Realtime::Websocket.on :leave do
-  Pakyow::UI::MutationStore.instance.unregister(socket_digest(socket_connection_id))
-end

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

@@ -1,63 +0,0 @@
-require_relative 'mutation_set'
-require_relative 'mutate_context'
-
-module Pakyow
-  module UI
-    # Performs mutations on views.
-    #
-    # @api private
-    class Mutator
-      include Singleton
-
-      attr_reader :sets
-
-      # @api private
-      def initialize
-        reset
-      end
-
-      def reset
-        @sets = {}
-        @mutables = {}
-        self
-      end
-
-      def set(scope, &block)
-        @sets[scope] = MutationSet.new(&block)
-      end
-
-      def mutable(scope, context = nil, &block)
-        if block_given?
-          @mutables[scope] = block
-        else
-          # TODO: inefficient to have to execute the block each time
-          Mutable.new(context, scope, &@mutables[scope])
-        end
-      end
-
-      def mutation(scope, name)
-        if mutations = mutations_by_scope(scope)
-          mutations.mutation(name)
-        end
-      end
-
-      # TODO: rename to mutation_set_for_scope
-      def mutations_by_scope(scope)
-        @sets[scope]
-      end
-
-      def mutate(mutation_name, view, data)
-        if mutation = mutation(view.scoped_as, mutation_name)
-          if data.is_a?(MutableData)
-            working_data = data.data
-          else
-            working_data = data
-          end
-
-          view.instance_exec(view, working_data, &mutation[:fn])
-          MutateContext.new(mutation, view, data)
-        end
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-require_relative 'mock_mutation_eval'
-
-module Pakyow
-  module Presenter
-    # Stands in for a real View object and makes any attempted transformation
-    # a no-op.
-    #
-    # @api private
-    class NoOpView
-      include Helpers
-      VIEW_CLASSES = [ViewContext]
-
-      # The arities of misc view methods that switch the behavior from
-      # instance_exec to yield.
-      #
-      EXEC_ARITIES = { with: 0, for: 1, for_with_index: 2, repeat: 1,
-                       repeat_with_index: 2, bind: 1, bind_with_index: 2,
-                       apply: 1 }
-
-      def initialize(view, context)
-        @view = view
-        @context = context
-      end
-
-      def is_a?(klass)
-        @view.is_a?(klass)
-      end
-
-      # View methods that should be a no-op
-      #
-      %i(bind bind_with_index apply).each do |method|
-        define_method(method) do |_data, **_kargs, &_block|
-          self
-        end
-      end
-
-      def mutate(mutator, with: nil, data: nil)
-        MockMutationEval.new(mutator, with || data, self)
-      end
-
-      # Pass these through, handling the return value.
-      #
-      def method_missing(method, *args, &block)
-        ret = @view.send(method, *args, &wrap(method, &block))
-        handle_return_value(ret)
-      end
-
-      private
-
-      def view?(obj)
-        VIEW_CLASSES.include?(obj.class)
-      end
-
-      # Returns a new context for returned views, or the return value.
-      #
-      def handle_return_value(value)
-        return NoOpView.new(value, @context) if view?(value)
-
-        value
-      end
-
-      # Wrap the block, substituting the view with the current view context.
-      #
-      def wrap(method, &block)
-        return if block.nil?
-
-        proc do |*args|
-          ctx = args.map! { |arg|
-            view?(arg) ? NoOpView.new(arg, @context) : arg
-          }.find { |arg| arg.is_a?(ViewContext) }
-
-          case block.arity
-          when EXEC_ARITIES[method]
-            # Rejecting ViewContext handles the edge cases around the order of
-            # arguments from view methods (since view is not present in some
-            # situations and when it is present, is always the first arg).
-            ctx.instance_exec(*args.reject { |arg|
-              arg.is_a?(ViewContext)
-            }, &block)
-          else
-            block.call(*args)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-require 'json'
-
-module Pakyow
-  module UI
-    # Manages mutations.
-    #
-    # This is the default registry in production systems and is required in
-    # deployments with more than one app instance.
-    #
-    # @api private
-    class RedisMutationRegistry
-      include Singleton
-
-      def initialize
-      end
-
-      def register(scope, mutation)
-        Pakyow::Realtime.redis.sadd(key(scope: scope, socket_key: mutation[:socket_key]), mutation.to_json)
-      end
-
-      def mutations(scope)
-        mutations = []
-
-        keys(key(scope: scope)) do |key|
-          Pakyow::Realtime.redis.smembers(key).each do |m|
-            mutations << Hash.strhash(JSON.parse(m))
-          end
-        end
-
-        mutations
-      end
-
-      def unregister(socket_key)
-        keys(key(socket_key: socket_key)) do |key|
-          Pakyow::Realtime.redis.del(key)
-        end
-      end
-
-      private
-
-      def key(scope: nil, socket_key: nil)
-        if socket_key.nil?
-          base = "*:"
-        else
-          base = "#{socket_key}:"
-        end
-
-        if scope.nil?
-          "#{base}*"
-        else
-          "#{base}pui-mutation-#{scope}"
-        end
-      end
-
-      def keys(match)
-        cursor = 0
-
-        loop do
-          cursor, keys = Pakyow::Realtime.redis.scan(cursor, match: match)
-
-          keys.each do |key|
-            yield key
-          end
-
-          break if cursor == '0'
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Pakyow
-  module UI
-    # Manages mutations.
-    #
-    # Intended only for use in development or single app-instance deployments.
-    #
-    # @api private
-    class SimpleMutationRegistry
-      include Singleton
-
-      def initialize
-        reset
-      end
-
-      def reset
-        @mutations = {}
-      end
-
-      def register(scope, mutation)
-        @mutations[scope] ||= []
-        @mutations[scope] << mutation
-      end
-
-      def unregister(socket_key)
-        @mutations.each do |_, mutations|
-          mutations.delete_if { |mutation|
-            mutation[:socket_key] == socket_key
-          }
-        end
-      end
-
-      def mutations(scope)
-        @mutations[scope]
-      end
-    end
-  end
-end