fie 0.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b405e7119223dc975863c197b4e7874ac2d69feb
+  data.tar.gz: c35975258e88f2bc02dc29b51a0bad2e8f4d05b6
+SHA512:
+  metadata.gz: 193d4cc8988d4ab373b1bd7af6055104ee11d253452c3cec808c83843de133cb6fe267edc15fa4c27aa87a1b22f163066258b0da14cc5b220db6e18c6569acd8
+  data.tar.gz: 84c969b2831a1ede1f6207ab2f3dd79df7e8a505bf2c4b7dc4c0e32e432d5439b1656b87ea6da90c8d445426754103954b7b974f8dc3043f1904a264e1766578

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Eran Peer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,48 @@
+<!-- # Fie
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/fie`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+[![Join the chat at https://gitter.im/rails-fie/Lobby](https://badges.gitter.im/rails-fie/Lobby.svg)](https://gitter.im/rails-fie/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fie'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fie
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/fie. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Fie project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/fie/blob/master/CODE_OF_CONDUCT.md). 
+
+[![Beerpay](https://beerpay.io/raen79/fie/badge.svg?style=beer-square)](https://beerpay.io/raen79/fie)  [![Beerpay](https://beerpay.io/raen79/fie/make-wish.svg?style=flat-square)](https://beerpay.io/raen79/fie?focus=wish)
+-->

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fie"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/fie.rb

@@ -0,0 +1,5 @@
+module Fie
+  require 'fie/railtie'
+  require 'fie/commander'
+  require 'fie/manipulator'
+end

data/lib/fie/commander.rb

@@ -0,0 +1,118 @@
+require 'fie/state'
+require 'fie/pools'
+require 'redis'
+
+module Fie
+  class Commander < ActionCable::Channel::Base
+    @@pools_subjects = Set.new
+    @@disable_override = false
+
+    def subscribed
+      stream_from Commander.commander_name(params['identifier'])
+      initialize_pools
+    end
+
+    def initialize_state(params)
+      self.state = State.new \
+        view_variables: params['view_variables'],
+        controller_name: params['controller_name'],
+        action_name: params['action_name'],
+        uuid: self.params[:identifier]
+    end
+
+    def handle_pool_callbacks(params)
+      subject = params['subject']
+      object = Marshal.load(params['object'])
+
+      run_hook :"#{subject}_pool", object
+    end
+
+    def unsubscribed
+      redis.del Fie::Commander.commander_name(params[:identifier])
+    end
+
+    def state
+      Marshal.load redis.get(Fie::Commander.commander_name params[:identifier])
+    end
+
+    def state=(state)
+      redis.set Fie::Commander.commander_name(params[:identifier]), Marshal.dump(state)
+    end
+
+    def modify_state_using_changelog(params)
+      state.update_object_using_changelog(params['objects_changelog'])
+    end
+
+    def execute_js_function(name, *arguments)
+      ActionCable.server.broadcast \
+        Fie::Commander.commander_name(params[:identifier]),
+        command: 'execute_function',
+        parameters: {
+          name: name,
+          arguments: arguments
+        }
+    end
+
+    private
+      def redis
+        $redis ||= Redis.new
+      end
+
+      def initialize_pools
+        ActionCable.server.broadcast \
+          Fie::Commander.commander_name(params[:identifier]),
+          command: 'subscribe_to_pools',
+          parameters: {
+            subjects: @@pools_subjects.to_a
+          }
+      end
+
+    class << self
+      def pool(subject, &block)
+        @@pools_subjects.add(subject)
+
+        pool_name = Fie::Pools.pool_name(subject)
+        define_method("#{pool_name}_callback") do |object:|
+          @published_object = Marshal.load(object)
+          instance_eval(&block)
+        end
+      end
+
+      def commander_name(connection_uuid)
+        "commander_#{connection_uuid}"
+      end
+
+      def method_added(name)
+        super_commander_method_names = [:subscribed, :refresh_view, :identifier, :state, :unsubscribed, :modify_state_using_changelog]
+
+        unless @@disable_override || super_commander_method_names.include?(name)
+          @@disable_override = true
+
+          restructure_subclass_method_parameters(name)
+
+          @@disable_override = false
+        end
+      end
+
+      private
+        def restructure_subclass_method_parameters(name)
+          alias_method("sub_#{name}", name)
+          remove_method(name)
+          define_method(name) do |params|
+            @caller = params['caller'].symbolize_keys
+            @controller_name = params['controller_name']
+            @action_name = params['action_name']
+            @connection_uuid = self.params['identifier']
+
+            ['caller', 'action', 'controller_name', 'action_name'].each { |param| params.delete param }
+
+            if params.blank?
+              self.send(:"sub_#{name}")
+            else
+              self.send(:"sub_#{name}", params.symbolize_keys)
+            end
+          end
+        end
+    end
+  end
+end

data/lib/fie/commander_closed.rb

@@ -0,0 +1 @@
+class Fie::CommanderClosed < StandardError; end

data/lib/fie/manipulator.rb

@@ -0,0 +1,39 @@
+require 'fie/commander_closed'
+require 'redis'
+
+module Fie
+  module Manipulator
+    def state
+      commander_name = Commander.commander_name(@fie_connection_uuid)
+
+      if commander_exists?(commander_name)
+        Marshal.load redis.get(commander_name)
+      else
+        raise Fie::CommanderClosed, commander_name
+      end
+    end
+
+    def execute_js_function(name, *arguments)
+      commander_name = Commander.commander_name(@fie_connection_uuid)
+
+      if commander_exists?(commander_name)
+        ActionCable.server.broadcast \
+          commander_name,
+          command: 'execute_function',
+          parameters: {
+            name: name,
+            arguments: arguments
+          }
+      end
+    end
+
+    private
+      def commander_exists?(commander_name)
+        !redis.get(commander_name).nil?
+      end
+      
+      def redis
+        $redis ||= Redis.new
+      end
+  end
+end

data/lib/fie/pools.rb

@@ -0,0 +1,23 @@
+module Fie
+  class Pools < ActionCable::Channel::Base
+    def subscribed
+      stream_from Pools.pool_name(params[:identifier])
+    end
+
+    class << self
+      def pool_name(subject)
+        "pool_#{subject}"
+      end
+
+      def publish(subject, object)
+        ActionCable.server.broadcast \
+          pool_name(subject),
+          command: 'publish_to_pool',
+          parameters: {
+            subject: subject,
+            object: Marshal.dump(object)
+          }
+      end
+    end
+  end
+end

data/lib/fie/railtie.rb

@@ -0,0 +1,13 @@
+module Fie
+  class Railtie < Rails::Railtie
+    initializer 'fie.load_layout_path', :after => :add_view_paths do |app|
+      ActiveSupport.on_load(:action_controller) do
+        append_view_path("#{Gem.loaded_specs['fie'].full_gem_path}/lib")
+      end
+    end
+
+    initializer 'fie.load_javascript' do |app|
+      Rails.application.config.assets.paths << "#{Gem.loaded_specs['fie'].full_gem_path}/vendor/javascript"
+    end
+  end
+end

data/lib/fie/state.rb

@@ -0,0 +1,131 @@
+require 'redis'
+require 'fie/state/track'
+require 'fie/state/changelog'
+
+module Fie
+  class State
+    include Fie::Track
+    include Fie::Changelog
+
+    def initialize(view_variables: nil, controller_name:, action_name:, uuid:, attributes: nil)
+      @controller_name = controller_name
+      @action_name = action_name
+      @uuid = uuid
+      @view_variables = view_variables
+      
+      if !view_variables.nil?
+        initialize_getters_and_setters(view_variables)
+      else
+        initialize_getters_and_setters(attributes, variables_from_view: false)
+      end
+
+      track_changes_in_objects(self)
+    end
+
+    def attributes
+      instance_variables_names = instance_variables - [ :@controller_name, :@action_name, :@uuid, :@view_variables ]
+
+      attribute_entries_array = instance_variables_names.map do |instance_variable_name|
+        attribute_name = instance_variable_name.to_s.gsub('@', '')
+        attribute_value = instance_variable_get(instance_variable_name)
+
+        [attribute_name, attribute_value]
+      end
+
+      attribute_entries_array.to_h
+    end
+
+    def inspect
+      object_reference = self.to_s
+      pretty_print = "\e[0;33m#{object_reference[0..-2]}\e[0m "
+
+      attributes.each do |name, value|
+        if value.is_a? String
+          value = "\e[0;31m#{value.inspect}\e[0m"
+        else
+          value = "\e[1;34m#{value.inspect}\e[0m"
+        end
+        
+        pretty_print += "\n #{name}: #{value}"
+      end
+
+      pretty_print += '>'
+
+      pretty_print
+    end
+
+    def permeate
+      redis.set Fie::Commander.commander_name(@uuid), Marshal.dump(self)
+
+      rendered_view = ApplicationController.render \
+        "#{@controller_name}/#{@action_name}",
+        assigns: attributes.merge(fie_controller_name: @controller_name, fie_action_name: @action_name),
+        layout: 'fie'
+
+      ActionCable.server.broadcast \
+        Fie::Commander.commander_name(@uuid),
+        command: 'refresh_view',
+        parameters: {
+          html: rendered_view
+        }
+    end
+
+    def _dump(level)
+      untrack_changes_in_objects(self)
+
+      Marshal.dump({
+        controller_name: @controller_name,
+        action_name: @action_name,
+        uuid: @uuid,
+        attributes: attributes
+      })
+    end
+
+    def self._load(string_params)
+      params = Marshal.load(string_params)
+      new(params)
+    end
+
+    private
+      def unmarshal_value(value)
+        encryptor = ActiveSupport::MessageEncryptor.new Rails.application.credentials[:secret_key_base]
+        decrypted_value = encryptor.decrypt_and_verify(value)
+        Marshal.load(decrypted_value)
+      end
+
+      def initialize_getters_and_setters(variables, variables_from_view: true)
+        variables.delete('fie_controller_name') if variables['fie_controller_name']
+        variables.delete('fie_action_name') if variables['fie_action_name']
+
+        variables.each do |variable_name, variable_value|
+          self.class_eval do
+            define_method(variable_name) do
+              instance_variable_get("@#{variable_name}")
+            end
+  
+            define_method("#{variable_name}=") do |value|
+              instance_variable_set("@#{variable_name}", value)
+            end
+          end
+  
+          if variables_from_view
+            instance_variable_set("@#{variable_name}", unmarshal_value(variable_value))
+          else
+            instance_variable_set("@#{variable_name}", variable_value)
+          end
+        end
+      end
+
+      def redis
+        $redis ||= Redis.new
+      end
+
+      def initialize_from_attributes(attributes)
+        unless attributes.blank?
+          attributes.each do |attribute_name, attribute_value|
+            instance_variable_set("@#{attribute_name}", attribute_value)
+          end
+        end
+      end
+  end
+end

data/lib/fie/state/changelog.rb

@@ -0,0 +1,48 @@
+module Fie
+  module Changelog
+    def update_object_using_changelog(changelog, object = self)
+      object = object.with_indifferent_access if object.is_a?(Hash)
+
+      unless changelog.blank?
+        changelog.each do |node_name, _|
+          changelog_node = changelog[node_name]
+          is_not_end_of_tree = changelog_node.is_a? Hash
+
+          if is_not_end_of_tree
+            traverse \
+              changelog: changelog,
+              object: object,
+              node_name: node_name,
+              changelog_node: changelog_node
+          else
+            update_object_value \
+              object: object,
+              node_name:node_name,
+              value: changelog_node
+          end
+        end
+      end
+    end
+
+    private
+      def traverse(changelog:, object:, node_name:, changelog_node:)
+        if object.is_a?(Hash) || object.is_a?(Array)
+          node_name = node_name.to_i if object.is_a?(Array)
+          object_node = object[node_name]
+          update_object_using_changelog(changelog_node, object_node)
+        else
+          object_node = object.send(node_name)
+          update_object_using_changelog(changelog_node, object_node)
+        end
+      end
+
+      def update_object_value(object:, node_name:, value:)
+        if object.is_a?(Hash) || object.is_a?(Array)
+          node_name = node_name.to_i if object.is_a?(Array)
+          object[node_name] = value
+        else
+          object.send("#{node_name}=", value)
+        end
+      end
+  end
+end