vue-helpers 0.1.0

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+# Adds cli options for minitest. These can also be passed from rake cli with TESTOPTS='-v ...'
+# Also see https://chriskottom.com/blog/2014/12/command-line-flags-for-minitest-in-the-raw/
+ENV['TESTOPTS'] ||= '-v'
+
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+  
+  # Rake 11 turns on ruby warnings by default.
+  # This will turn them off again on the cli:
+  #   RUBYOPT=W0
+  # Also see https://github.com/hanami/utils/issues/123
+  t.warning = false
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "vue/helpers"
+
+# 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"
+require "irb/completion"
+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/vue/helpers.rb

@@ -0,0 +1,49 @@
+require "vue/helpers/version"
+
+# See below...
+# require_relative 'helpers/methods'
+# require_relative 'helpers/server'
+
+module Vue
+  module Helpers
+  
+    @defaults = {
+      cache_store:             {},
+      callback_prefix:         '/vuecallback',
+      default_outvar:          '@_erbout',
+      external_resource:       false,
+      minify:                  false,
+      register_local:          false,
+      root_name:               'vue-root',
+      template_engine:         :erb, # This should not force template_engine, only recommend if no other can be found.
+      template_literal:        true,
+      views_path:              ['views', 'app/views'],
+      vue_outvar:              '@_vue_outvar',
+
+                               # These are ugly now, becuase I wanted to use double-quotes as the outter-quotes.
+      component_call_html:     "<\#{el_name} \#{attributes_string}>\#{block_content}</\#{el_name}>",
+      external_resource_html:  "\n<script src=\"\#{callback_prefix}/\#{key}\"></script>",
+      inline_script_html:      "\n<script>\#{compiled}\n</script>\n",
+      root_app_html:           '<div id="#{root_name}">#{block_content}</div>#{root_script_output}',
+      root_object_js:          'var #{app_name} = new Vue({el: ("##{root_name}"), components: {#{components}}, data: #{vue_data_json}})',
+      x_template_html:         "\n<script type=\"text/x-template\" id=\"\#{name}-template\">\#{template}</script>",
+    }
+    
+    @defaults.keys.each do |k|
+      define_singleton_method(k){@defaults[k]}
+      define_singleton_method("#{k}="){|v| @defaults[k] = v}
+    end
+    
+    class << self
+      attr_accessor :defaults      
+    end
+
+    def self.included(other)
+      other.send(:include, Vue::Helpers::Methods)
+    end
+    
+  end 
+end
+
+require_relative 'helpers/methods'
+require_relative 'helpers/server'

data/lib/vue/helpers/helper_refinements.rb

@@ -0,0 +1,219 @@
+require 'uglifier'
+require_relative 'utilities'
+
+# This file contains the bulk of vue-helpers functions.
+# They constructed here as a module of refinements,
+# and used in the main 'controller'. However, being refinements,
+# they are invisible and inaccessible in user-space.
+#
+# The funky self-referencing refinement code on this page is
+# necessary for these refinement methods to see each other.
+# Remember... lexical scope: a refined method call must have
+# 'using...' somewhere on the same page (or sometimes in the same module).
+# So these refinements must refine themselves.
+#
+# This actually works, even with the self-refiment at the bottom of the module.
+#
+# See Ruby 2.4 release notes & changelog for more info on the refinement features used here:
+# https://github.com/ruby/ruby/blob/v2_4_0/NEWS
+#
+module Vue
+  module Helpers
+    module Methods
+    end
+
+    # This block of methods is used as refinements in Ruby >= 2.4,
+    # and is used as a regular module methods (private) in Ruby < 2.4.
+    # This is done to accommodate a wider range of Ruby versions,
+    # since Ruby < 2.4 doesn't allow refining of Modules.
+    # See if-then block below.
+    #
+    MethodsBlock = Proc.new do
+      
+      # This has to be here, NOT above under HelperRefinements.
+      using CoreRefinements
+      
+      # Can't be private, since VueObject instances call these methods.
+      #private
+      
+      # TODO: Cleanup Load/Render template calls upstream, then cleanup these methods here.
+      # These are a mess, since they were hacked together when their functionality was split up.
+      def render_ruby_template(template_text_or_file, template_engine:nil, locals:{})
+        #puts "  RENDERING ruby template '#{template_text_or_file.to_s[0..32].gsub(/\n/, ' ')}' with locals:#{locals}, template_engine:#{template_engine}, Tilt.current_tempate: '#{Tilt.current_template}'\n"
+        
+        tilt_template = load_template(template_text_or_file, template_engine:nil)
+      
+        rslt = if tilt_template.is_a?(Tilt::Template)
+          #puts "  Rendering #{tilt_template}"
+          #puts "  Rendering ruby template '#{template_text_or_file.to_s[0..32].gsub(/\n/, ' ')}...' from '#{tilt_template.file}' with locals:#{locals}, template_engine:#{template_engine}, Tilt.current_tempate: '#{Tilt.current_template}'"
+          #puts "  Rendering ruby template '#{template_text_or_file}' from '#{tilt_template.file}' with locals:#{locals}, template_engine:#{template_engine}, Tilt.current_tempate: '#{Tilt.current_template}'"
+          tilt_template.render(self, **locals)
+        else
+          #puts "  Render_ruby_template bypassing rendering for '#{template_text_or_file}', since '#{tilt_template}' is not a Tilt::Template"
+          tilt_template
+        end
+        
+        #puts "RENDER_ruby_template '#{tilt_template}' result: #{rslt}"
+        rslt
+      end
+      
+      def load_template(template_text_or_file, template_engine:nil)
+        #puts "  LOADING template '#{template_text_or_file}' with engine: #{template_engine}"
+        current_eoutvar = Thread.current.instance_variable_get(:@current_eoutvar)
+        case template_text_or_file
+        when Tilt::Template
+          #puts "  Loading existing tilt template '#{template_text_or_file}' from '#{template_text_or_file.file}' with engine: #{template_engine}"
+          template_text_or_file
+        when Symbol
+          #puts "  Loading template from symbol '#{template_text_or_file}' with engine: #{template_engine}"
+          path = template_path(template_text_or_file, template_engine:template_engine)
+          #puts "RENDER_ruby_template path-if-symbol: #{path}"
+          if File.file?(path.to_s)
+            Tilt.new(path, 1, outvar: Vue::Helpers.vue_outvar)
+          else
+            # TODO: This should be logger.debug
+            #puts "RENDER_ruby_template template-missing: #{template_text_or_file}"
+          end           
+        when String
+          #puts "  Loading template from string '#{template_text_or_file}' with engine: #{template_engine}"
+          Tilt.template_for(template_engine || current_template_engine).new(nil, 1, outvar: Vue::Helpers.vue_outvar){template_text_or_file}
+        end
+      rescue
+        # TODO: Make this a logger.debug output.
+        puts "Render_ruby_template error building tilt template for #{template_text_or_file.to_s[0..32].gsub(/\n/, ' ')}...: #{$!}"
+        puts "BACKTRACE:"
+        puts $!.backtrace
+        nil
+      ensure
+        Thread.current.instance_variable_set(:@current_eoutvar, current_eoutvar)
+      end
+      
+      # Returns nil instead of default if no current engine.
+      def current_template_engine(use_default=false)
+        #current_engine || Vue::Helpers.template_engine
+        Tilt.default_mapping.template_map.invert[Tilt.current_template.class] || (use_default && Vue::Helpers.template_engine)
+      end
+      
+      # TODO: Decide how we want to determine template-engine suffix.
+      #   Search for all possible suffixes? Search for only the given template_engine? Something else?
+      #   Is this already handled here?
+      def template_path(name, template_engine:nil)   #current_template_engine)
+        template_engine ||= '*'
+        #puts "TEMPLATE_path searching with name: #{name}, template_engine: #{template_engine}"
+        ([Vue::Helpers.views_path].flatten.uniq.compact || Dir.getwd).each do |start_path|
+          #puts "TEMPLATE_path searching views-path: #{start_path}"
+          Dir.breadth_first("*", base:start_path) do |path|
+            #puts "TEMPLATE_path inspecting file: #{path}"
+            return path if File.fnmatch(File.join('*', "#{name}.vue.#{template_engine}"), path)
+            return path if File.fnmatch(File.join('*', "#{name}.vue"), path)
+            return path if File.fnmatch(File.join('*', name.to_s), path)
+          end
+        end
+
+        return nil
+      end
+      
+      # Capture & Concat
+      # See https://gist.github.com/seanami/496702
+      # TODO: These need to handle haml & slim as well.
+      
+      def get_current_eoutvar
+        Thread.current.instance_variable_get(:@current_eoutvar)
+      end
+      
+      # Returns any buffer (even if not defined).
+      def buffer(buffer_name = nil)
+        #@_out_buf
+        #buffer_name ||= Tilt.current_template.instance_variable_get('@outvar') || @outvar || Vue::Helpers.default_outvar
+        buffer_name ||=
+          ((ct = Tilt.current_template) && ct.instance_variable_get(:@outvar)) ||
+          Thread.current.instance_variable_get(:@current_eoutvar) ||
+          Vue::Helpers.default_outvar
+        #puts "BUFFER thread-ivars: #{Thread.current.instance_variables}, thread-local-vars: #{Thread.current.send(:local_variables)}"
+        #puts "BUFFER chosen: #{buffer_name}, controller/view ivars: #{instance_variables}, controller/view local-vars: #{local_variables}"
+        #instance_variable_get(buffer_name)
+        instance_variable_get(buffer_name.to_s)
+      end
+      
+      # TODO: Probbably need to pass root_name (and other options?) on to sub-components inside block.
+      # Does vue even allow components in the block of a component call?
+      # TODO: Are *args and locals being used?
+      def capture_html(*args, root_name:Vue::Helpers.root_name, locals:{}, &block)
+        #puts "CAPTURE_HTML args: #{args}, root_name: #{root_name}, locals:#{locals}"
+        return unless block_given?
+        
+        # This is mostly for Rails. Are there other frameworks that would use this?
+        return(capture(*args, &block)) if respond_to?(:capture)
+        
+        # This is one of the points where we finally need to know what template
+        # we're using. If the actively-rendering template is not handled by Tilt,
+        # we can only take a best guess. If we're wrong, the user will need to set
+        # Vue::Helpers.defaults[:template_engine] to a known template type.
+        current_template = current_template_engine(true)
+        #puts "CAPTURE_HTML current_template: #{current_template}."
+        #puts "CAPTURE_HTML block info: block-local-vars:#{block.binding.local_variables}, block-ivars:#{block.binding.eval('instance_variables')}, controller-ivars:#{instance_variables}" if block_given?
+        
+        case current_template.to_s
+        when /erb/i
+          #puts "Capturing ERB block with eoutvar '#{get_current_eoutvar}'."
+          #puts "Tilt @outvar '#{Tilt.current_template.instance_variable_get(:@outvar)}'"
+          #return(capture(*args, &block)) if respond_to?(:capture)
+          existing_buffer = buffer
+          if existing_buffer
+            pos = existing_buffer.to_s.size
+            yield(*args)
+            modified_buffer = buffer
+            modified_buffer.to_s.slice!(pos..modified_buffer.to_s.size)
+          else
+            yield(*args)
+          end
+        when /haml/i
+          #puts "Capturing HAML block."
+          capture_haml(*args, &block)
+        else
+          #puts "Capturing (yielding) to generic template block."
+          yield(*args)
+        end
+        
+      end
+      
+      def concat_content(text='')
+        return(text) if respond_to?(:capture)
+        current_template = current_template_engine(true)
+        #puts "CONCAT_CONTENT current_template: #{current_template}."
+        case current_template.to_s
+        when /erb/i
+          #puts "Concating to ERB outvar '#{get_current_eoutvar}'"
+          #puts "Tilt @outvar '#{Tilt.current_template.instance_variable_get(:@outvar)}'"
+          buffer.to_s << text
+        when /haml/i
+          haml_concat(text)
+        else
+          text
+        end
+      end
+      
+    end # methods_block
+    
+    
+    if RUBY_VERSION.to_f < 2.4
+      # This needs to be defined anyway, since 'refine' is called
+      # in other modules/classes.
+      module HelperRefinements
+      end
+      # Use MethodsBlock as regular Module methods if Ruby < 2.4.
+      module Methods
+        class_eval(&MethodsBlock)
+      end
+    else
+      # Use MethodsBlock as Module refinements if Ruby >= 2.4.
+      module HelperRefinements
+        refine Methods do
+          MethodsBlock.call
+        end
+      end # HelperRefinements
+      using HelperRefinements
+    end
+    
+  end # Helpers
+end # Vue

data/lib/vue/helpers/methods.rb

@@ -0,0 +1,100 @@
+require 'tilt'
+require 'erb'
+
+require_relative '../helpers'
+require_relative 'helper_refinements'
+require_relative 'utilities'
+require_relative 'vue_repository'
+
+module Vue
+  module Helpers
+    using CoreRefinements
+    using HelperRefinements
+    
+    # Include this module in your controller (or action, or routes, or whatever).
+    #
+    # SEE helper_refinements.rb for the helpers supporting methods!
+    #
+    module Methods
+    
+      def self.included(other)
+        # If Rails
+        if other.name[/Helper/] && Module.const_defined?(:ActionView)
+          # TODO: This should be logger.debug.
+          puts "#{other} including ActionView::Helpers::CaptureHelper"
+          include ActionView::Helpers::CaptureHelper
+        end
+        
+        other.send(:prepend, ControllerPrepend)
+      end
+
+      def vue_repository
+        @vue_repository ||= VueRepository.new(context=self)
+        #puts "Getting vue_repository #{@vue_repository.class} with keys: #{@vue_repository.keys}"
+        @vue_repository
+      end
+      alias_method :vue_repo, :vue_repository
+      
+      def vue_app(root_name=nil, **options)
+        vue_repository.root(root_name, **options)
+      end
+  
+      # Inserts Vue component-call block in html template.
+      # Name & file_name refer to file-name.vue.<template_engine> SFC file. Example: products.vue.erb.
+      def vue_component(name,
+          root_name:nil,
+          tag_name:nil,
+          locals:{},
+          attributes:{},
+          **options,
+          &block
+        )
+        
+        #puts "\nvue_component '#{name}' with local-vars '#{local_variables.inject({}){ |c, i| c[i.to_s] = eval(i.to_s); c }}'"
+        
+        # This should only pass args that are necessary to build the component object.
+        # Tag-name and attributes are not relevant here.
+        component = vue_app(root_name).component(name, locals:locals, **options)
+        
+        # Renders the per-call html block.
+        # Pass tag_name, attributes, locals, and block.
+        component_output = component.render(tag_name, locals:locals, attributes:attributes, &block)
+        
+        # Concat the content if block given, otherwise just return the content.
+        if block_given?
+          #puts "Vue_component concating content for '#{name}'"  #: #{component_output[0..32].gsub(/\n/, ' ')}"
+          concat_content(component_output)
+        else
+          #puts "Vue_component returning content for '#{name}'"  #: #{component_output[0..32].gsub(/\n/, ' ')}"
+          return component_output
+        end
+      end  # vue_component
+
+
+      # Inserts Vue app-call block in html template.
+      # Builds vue html and js for return to browser.
+      #
+      # Returns (or concats if block given) rendered html and js.
+      def vue_root(root_name = Vue::Helpers.root_name,
+          locals:    {},
+          **options,
+          &block
+        )
+        
+        #puts "\nvue_root '#{root_name}' with local-vars '#{local_variables.inject({}) { |c, i| c[i.to_s] = eval(i.to_s); c }}'"
+        
+        root_app = vue_app(root_name, locals:locals, **options)
+        
+        root_output = root_app.render(locals:locals, &block)
+                
+        if block_given?
+          concat_content(root_output)
+        else
+          root_output
+        end
+      end
+
+      
+    end # Methods
+  end # Helpers
+end # Vue

data/lib/vue/helpers/server.rb

@@ -0,0 +1,43 @@
+require 'rack'
+require_relative 'methods'
+require_relative 'utilities'
+
+module Vue
+  module Helpers
+    using CoreRefinements
+    
+    # Rack middleware to serve sourced vue block, see https://redpanthers.co/rack-middleware/.
+    # Usage: use Vue::Helpers::Server
+    
+    class Server
+      def initialize(app)
+        @app = app
+      end
+      
+      def call(env)
+        req = Rack::Request.new(env)
+        case req.path_info
+        #when /^\/vuesource\/([A-Za-z0-9\-_]{43})$/
+        when /^#{Vue::Helpers.callback_prefix}\/([A-Za-z0-9\-_]{43})$/
+          #puts "vue_source match: #{$1}"
+          if content = get_content($1)
+            [200, {"Content-Type" => "text/javascript"}, [content]]
+          else
+            [404, {"Content-Type" => "text/html"}, ['']]
+          end
+        when /^\/pingm$/
+          [200, {"Content-Type" => "text/javascript"}, ['Ok']]
+        else
+          #[404, {"Content-Type" => "text/html"}, ["I'm Lost!"]]
+          @app.call(env)
+        end
+      end
+      
+      def get_content(key)
+        Vue::Helpers.cache_store.delete(key)
+        #Vue::Helpers.cache_store[key]
+      end
+      
+    end # Source
+  end # Helpers
+end