RubyGems - bluesky - Versions diffs - 0.0.1 - Mend

bluesky 0.0.1

Files changed (13) hide show

checksums.yaml +7 -0
data/bin/bluesky +133 -0
data/lib/bluesky/application.rb +102 -0
data/lib/bluesky/dom_helper.rb +37 -0
data/lib/bluesky/navigation_controller.rb +79 -0
data/lib/bluesky/pure_component.rb +226 -0
data/lib/bluesky/try.rb +100 -0
data/lib/bluesky/version.rb +3 -0
data/lib/bluesky/view_controller.rb +153 -0
data/lib/bluesky.rb +53 -0
data/spec/bluesky_spec.rb +34 -0
data/spec/spec_helper.rb +109 -0
metadata +127 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8026d38b693a30250518feaa44d015bc53d84f6c
+  data.tar.gz: e176fc2a30755f2580ea12a2871abf415b561aca
+SHA512:
+  metadata.gz: 2e833e11e26b668e146c76cffeb5df9404ee5a938e38d5bfa04148884b3ec9203a7da46e528b0dcf6bccff416b657581c826b1c2e8a884990f1c722e52a6bcac
+  data.tar.gz: 8e4b9b75a7d66d8d934dcb5d30f6bcd3fb125b99680297f002bc75534746d8244ddc02df4f906f4da480ac7649f8263aaa88745fa2b9e33a037566e7a5f1f4e5

data/bin/bluesky ADDED Viewed

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+require 'optparse'
+class String
+  def unindent
+    gsub /^#{self[/\A[ \t]*/]}/, ''
+  end
+end
+options = {}
+opt_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: bluesky [command] [options]"
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+  end
+end
+opt_parser.parse!
+case ARGV[0]
+when "new"
+  path = File.absolute_path(ARGV[1])
+  abort "#{path} already exist! Aborting!" if File.exist?(path)
+  title = ARGV[1].capitalize
+  FileUtils.mkdir_p([
+    File.join(path, 'app/models'),
+    File.join(path, 'app/views'),
+    File.join(path, 'app/controllers'),
+  ])
+  IO.write File.join(path, 'Gemfile'), <<-RUBY.unindent
+    source 'https://rubygems.org'
+    gem 'opal', '~> 0.10'
+    gem 'clearwater', '1.0.0.rc4'
+    gem 'bluesky', path: '../'
+  RUBY
+  IO.write File.join(path, 'app/application.rb'), <<-RUBY.unindent
+    require 'bluesky'
+    include Bluesky
+    require_tree './models'
+    require_tree './views'
+    require_tree './controllers'
+    $app = Class.new(Application) do
+      def root_view_controller
+        @root_view_controller ||= NavigationController.new(RootController.new)
+      end
+    end.new
+    $app.debug!
+    $app.run
+  RUBY
+  IO.write File.join(path, 'app/controllers/root_controller.rb'), <<-RUBY.unindent
+    class RootController < ViewController
+      attribute :name, 'World'
+      def view
+        HelloView(name: name)
+      end
+      def change_name(name)
+        self.name = name
+        notify(self, :name_changed, self.name)
+      end
+    end
+  RUBY
+  IO.write File.join(path, 'app/views/hello_view.rb'), <<-RUBY.unindent
+    class HelloView < PureComponent
+      attribute :name
+      def render
+        div [header, name_input]
+      end
+      def header
+        h1("Hello \#{name}")
+      end
+      def name_input
+        handler = -> (event) { dispatch(:change_name, event.target.value) }
+        label ['Change name: ',
+               input(type: :text, value: name, oninput: handler)]
+      end
+    end
+  RUBY
+  IO.write File.join(path, 'config.ru'), <<-RUBY.unindent
+    require 'bundler'
+    Bundler.require
+    run Opal::Server.new { |s|
+      s.main = 'application'
+      s.append_path 'app'
+      s.index_path = 'index.html.erb'
+    }
+  RUBY
+  IO.write File.join(path, 'index.html.erb'), <<-ERB.unindent
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <meta charset="utf-8">
+        <title>#{title}</title>
+      </head>
+      <body>
+        <%= javascript_include_tag 'application' %>
+      </body>
+    </html>
+  ERB
+  Dir.chdir(path) do
+    system("bundle install")
+  end
+else
+  puts opt_parser
+end

data/lib/bluesky/application.rb ADDED Viewed

@@ -0,0 +1,102 @@
+module Bluesky
+  # Bluesky::Application
+  class Application
+    include DOMHelper
+    attr_accessor :root_view_controller, :debug, :delegate
+    def initialize
+      @dispatch_queue = []
+      @debug = false
+    end
+    def debug?
+      @debug
+    end
+    def debug!
+      @debug = true
+      @clearwater.debug! if @clearwater
+      @delegate = DebugDelegate.new(@delegate)
+      self
+    end
+    def dispatch(target, action, *payload, &block)
+      promise = Promise.new
+      delegate.try(:dispatch, target, action, *payload)
+      @dispatch_queue << lambda do
+        begin
+          result = target.send(action, *payload, &block)
+          promise.resolve(result).then { refresh }
+          delegate.try(:dispatch_resolved, target, action, *payload, result)
+        rescue => err
+          promise.reject(err)
+          delegate.try(:dispatch_rejected, target, action, *payload, err)
+        end
+      end
+      defer { process_dispatch_queue }
+      promise
+    end
+    def process_dispatch_queue
+      return if @dispatch_queue.empty?
+      @dispatch_queue.delete_if do |task|
+        task.call
+        true
+      end
+    end
+    def notify(source, event, *payload)
+      @delegate.try(:notify, source, event, *payload)
+    end
+    def refresh(&block)
+      promise = Promise.new
+      @clearwater.call { promise.resolve }
+      block ? promise.then(&block) : promise
+    end
+    def run
+      raise 'root_view_controller must be defined in Application' unless root_view_controller
+      PureComponent.install_hooks(debug?)
+      root_view_controller.parent = self
+      @clearwater = Clearwater::Application.new(component: root_view_controller)
+      @clearwater.debug! if debug?
+      root_view_controller.begin_appearance_transition(true)
+      refresh { root_view_controller.end_appearance_transition() }
+      self
+    end
+  end
+  class DebugDelegate
+    def initialize(delegate = nil)
+      @delegate = delegate
+    end
+    def dispatch(target, action, *payload)
+      @delegate.try(:dispatch, target, action, *payload)
+      puts "[DISPATCH] #{action} on #{target}"
+    end
+    def dispatch_resolved(target, action, *payload, result)
+      @delegate.try(:dispatch_resolved, result, target, action, *payload)
+      puts "[RESOLVED] #{action} on #{target} yielding #{result}"
+    end
+    def dispatch_rejected(target, action, *payload, error)
+      @delegate.try(:dispatch_rejected, target, action, *payload, error)
+      puts "[REJECTED] #{action} on #{target}"
+      warn error
+    end
+    def notify(source, event, *payload)
+      puts "[NOTIFY] #{event} from #{source}"
+    end
+  end
+end

data/lib/bluesky/dom_helper.rb ADDED Viewed

@@ -0,0 +1,37 @@
+module Bluesky
+  module DOMHelper
+    extend self
+    protected
+    # Delays execution to the main event loop
+    #
+    # == Parameters:
+    # block
+    #   A block to execute on the main event loop
+    #
+    # == Returns:
+    # A promise that resolves after block has completed
+    def defer(&block)
+      timeout(0, &block)
+    end
+    def delay(hours: 0, minutes: 0, seconds: 0, milliseconds: 0, &block)
+      timeout(((hours * 60 + minutes) * 60 + seconds) * 1000 + milliseconds, &block)
+    end
+    private
+    def timeout(milliseconds, &block)
+      promise = Promise.new
+      $$[:setTimeout].call(-> { promise.resolve }, milliseconds)
+      block ? promise.then(&block) : promise
+    end
+    def self.included(base)
+      base.extend(self)
+    end
+  end
+end

data/lib/bluesky/navigation_controller.rb ADDED Viewed

@@ -0,0 +1,79 @@
+module Bluesky
+  # Bluesky::NavigationController
+  class NavigationController < ViewController
+    attr_accessor :root_view_contrller
+    def initialize(root_view_controller)
+      raise 'NavigationController requires a root_view_controller' unless root_view_controller
+      super
+      add_child_view_controller(root_view_controller)
+    end
+    def view
+      top_view_controller.view
+    end
+    def view_will_appear
+      top_view_controller.begin_appearance_transition(true)
+    end
+    def view_did_appear
+      top_view_controller.end_appearance_transition
+    end
+    def view_will_disappear
+      top_view_controller.end_appearance_transition(false)
+    end
+    def view_did_disappear
+      top_view_controller.end_appearance_transition
+    end
+    def root_view_controller
+      @children.first
+    end
+    def top_view_controller
+      @children.last
+    end
+    def visible_view_controller
+      top_view_controller
+    end
+    def push_view_controller(view_controller)
+      old_view_controller = top_view_controller
+      old_view_controller.begin_appearance_transition(false)
+      view_controller.begin_appearance_transition(true)
+      add_child_view_controller(view_controller)
+      force_update do
+        view_controller.end_appearance_transition
+        old_view_controller.end_appearance_transition
+      end
+    end
+    def pop_view_controller
+      return nil if top_view_controller == root_view_controller
+      old_view_controller = top_view_controller
+      old_view_controller.begin_appearance_transition(false)
+      old_view_controller.remove_from_parent_view_controller
+      top_view_controller.begin_appearance_transition(true)
+      force_update do
+        top_view_controller.end_appearance_transition
+        old_view_controller.end_appearance_transition
+      end
+    end
+    def pop_to_view_controller(view_controller)
+      result = []
+      result << pop_view_controller while top_view_controller != view_controller
+    end
+    def pop_to_root_view_controller
+      pop_to_view_controller(root_view_controller)
+    end
+  end
+end

data/lib/bluesky/pure_component.rb ADDED Viewed

@@ -0,0 +1,226 @@
+module Bluesky
+  module DSL
+    module_function
+    Clearwater::Component::HTML_TAGS.each do |tag_name|
+      define_method(tag_name) do |attributes, content|
+        %x{
+          if(!(attributes === nil || attributes.$$is_hash)) {
+            content = attributes;
+            attributes = nil;
+          }
+        }
+        tag(tag_name, attributes, content)
+      end
+    end
+    def tag(tag_name, attributes=nil, content=nil, &block)
+      if block
+        attributes ||= {}
+        content ||= []
+        block.call(NodeBuilder.new(tag_name, attributes, content))
+      end
+      Clearwater::VirtualDOM.node(
+        tag_name,
+        Clearwater::Component.sanitize_attributes(attributes),
+        Clearwater::Component.sanitize_content(content)
+      )
+    end
+  end
+  # A presentation `Component`
+  class PureComponent
+    # Example:
+    #
+    # class FooView < Bluesky::PureComponent
+    #
+    #   attribute :times
+    #
+    #   def render
+    #     div([
+    #       div("Clicked #{times}!"),
+    #       form([
+    #         label('Button to click'),
+    #         button({ onclick: -> { dispatch(:clicked) } }, [ 'click me!' ])
+    #       ])
+    #     ])
+    #   end
+    # end
+    #
+    # class FooController < Bluesky::ViewController
+    #
+    #   def initialize
+    #     @times = 0
+    #   end
+    #
+    #   def view
+    #     FormView.new({ times: @times }, self)
+    #   end
+    #
+    #   def clicked
+    #     @times += 1
+    #   end
+    # end
+    if RUBY_ENGINE == 'opal'
+    %x{
+      Opal.defn(self, 'hook', function(node, propertyName, previousValue) {
+        var self = this;
+        console.log('hook', node, propertyName, previousValue);
+        if (!previousValue) {
+          var component_did_mount = self.$component_did_mount;
+          if (component_did_mount && !component_did_mount.$$stub) {
+            self.$mount();
+            self.$component_did_mount();
+          }
+        }
+      });
+      Opal.defn(self, 'unhook', function(node, propertyName, previousValue) {
+        var self = this;
+        console.log('unhook', node, propertyName, previousValue);
+        if (!previousValue) {
+          var component_will_unmount = self.$component_will_unmount;
+          if (component_will_unmount && !component_will_unmount.$$stub) {
+            self.$unmount();
+            self.$component_will_unmount();
+          }
+        }
+      });
+    }
+    end
+    include Clearwater::Component
+    include Clearwater::CachedRender
+    include DSL
+    @descendants = []
+    def self.inherited(subclass)
+      DSL.send(:define_method, subclass.name) do |data = {}, delegate = nil, &block|
+        delegate ||= @delegate
+        component = subclass.new(data, delegate)
+        block.call(component) if block
+        component
+      end
+      @descendants << subclass
+    end
+    def self.install_hooks(debug=false)
+      @descendants.each do |subclass|
+        if subclass.instance_methods.include?(:component_did_mount) ||
+           subclass.instance_methods.include?(:component_will_unmount)
+          subclass.class_eval { `Opal.defn(self, '$$mountable', true);` }
+        end
+        if subclass.instance_methods.include?(:component_will_mount)
+          subclass.class_eval { `Opal.defn(self, '$$hook_will_mount', true);` }
+        end
+        subclass.send(:alias_method, :do_render, :render) unless
+          subclass.instance_methods.include?(:do_render)
+        subclass.send(:define_method, :render) do
+          begin
+            $$.console.time("#{subclass.name}:render") if debug
+            %x{
+              var contents = #{do_render};
+              if (self.$$mountable) contents.properties.ref = self;
+              return contents;
+            }
+          rescue Object => err
+            warn err
+            div({ class: 'broken', style: { display: :none } }, [err.message])
+          ensure
+            $$.console.timeEnd("#{subclass.name}:render") if debug
+          end
+        end
+      end
+    end
+    def self.attribute(name, *args)
+      case args.length
+      when 0
+        define_method(name) do |&block|
+          if block
+            _data.store(name, block)
+            block
+          else
+            _data.fetch(name)
+          end
+        end
+      when 1
+        if args[0].respond_to?(:call)
+          define_method(name) { _data.fetch(name) { _data.store(name, args[0].call) } }
+        else
+          define_method(name) { _data.fetch(name, args[0]) }
+        end
+      else
+        raise ArgumentError, %{ wrong number of arguments
+                                (#{args.length} for 1..2) }
+      end
+      define_method("#{name}=") { |value| _data.store(name, value) }
+    end
+    def initialize(data = {}, delegate = nil)
+      @data     = data
+      @delegate = delegate
+    end
+    def shallow_equal?(a, b)
+      a.equal?(b) || a.each_pair.all? do |k, v|
+        bk = b[k]
+        v.equal?(bk) || v.eql?(bk)
+      end
+    rescue Object => _
+      false
+    end
+    def should_render?(previous)
+      # puts "#{self.class.name}:should_render? #{(@delegate && @delegate.force_update?)}, #{!shallow_equal?(_data, previous._data)}"
+      (@delegate && @delegate.force_update?) ||
+        !shallow_equal?(_data, previous._data)
+    end
+    def dispatch(action, *payload, &block)
+      warn 'Missing delegate' unless @delegate
+      root = @delegate
+      root = root.parent while root.respond_to?(:parent) && root.parent
+      root.dispatch(@delegate, action, *payload, &block)
+    end
+    def mount
+      puts 'mount'
+      @mounted = true
+    end
+    def unmount
+      puts 'unmount'
+      @mounted = false
+    end
+    def mounted?
+      !!@mounted
+    end
+    protected
+    def _data
+      @data
+    end
+  end
+end

data/lib/bluesky/try.rb ADDED Viewed

@@ -0,0 +1,100 @@
+class Object
+  # Invokes the public method whose name goes as first argument just like
+  # +public_send+ does, except that if the receiver does not respond to it the
+  # call returns +nil+ rather than raising an exception.
+  #
+  # This method is defined to be able to write
+  #
+  #   @person.try(:name)
+  #
+  # instead of
+  #
+  #   @person.name if @person
+  #
+  # +try+ calls can be chained:
+  #
+  #   @person.try(:spouse).try(:name)
+  #
+  # instead of
+  #
+  #   @person.spouse.name if @person && @person.spouse
+  #
+  # +try+ will also return +nil+ if the receiver does not respond to the method:
+  #
+  #   @person.try(:non_existing_method) #=> nil
+  #
+  # instead of
+  #
+  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) #=> nil
+  #
+  # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
+  # to the method:
+  #
+  #   nil.try(:to_i) # => nil, rather than 0
+  #
+  # Arguments and blocks are forwarded to the method if invoked:
+  #
+  #   @posts.try(:each_slice, 2) do |a, b|
+  #     ...
+  #   end
+  #
+  # The number of arguments in the signature must match. If the object responds
+  # to the method the call is attempted and +ArgumentError+ is still raised
+  # in case of argument mismatch.
+  #
+  # If +try+ is called without arguments it yields the receiver to a given
+  # block unless it is +nil+:
+  #
+  #   @person.try do |p|
+  #     ...
+  #   end
+  #
+  # You can also call try with a block without accepting an argument, and the block
+  # will be instance_eval'ed instead:
+  #
+  #   @person.try { upcase.truncate(50) }
+  #
+  # Please also note that +try+ is defined on +Object+. Therefore, it won't work
+  # with instances of classes that do not have +Object+ among their ancestors,
+  # like direct subclasses of +BasicObject+. For example, using +try+ with
+  # +SimpleDelegator+ will delegate +try+ to the target instead of calling it on
+  # the delegator itself.
+  def try(*a, &b)
+    try!(*a, &b) if a.empty? || respond_to?(a.first)
+  end
+  # Same as #try, but will raise a NoMethodError exception if the receiver is not +nil+ and
+  # does not implement the tried method.
+  def try!(*a, &b)
+    if a.empty? && block_given?
+      if b.arity.zero?
+        instance_eval(&b)
+      else
+        yield self
+      end
+    else
+      public_send(*a, &b)
+    end
+  end
+end
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes especially helpful when navigating through associations that may return +nil+.
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && @person.children.any? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
+  def try(*args)
+    nil
+  end
+  def try!(*args)
+    nil
+  end
+end

data/lib/bluesky/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Bluesky
+  VERSION = "0.0.1"
+end

data/lib/bluesky/view_controller.rb ADDED Viewed

@@ -0,0 +1,153 @@
+module Bluesky
+  class ViewController
+    include Clearwater::Component
+    include DOMHelper
+    include DSL
+    def self.attribute(name, *args, &block)
+      case args.length
+      when 0
+        define_method(name) { data.fetch(name) }
+      when 1
+        if args[0].respond_to?(:call)
+          define_method(name) { data.fetch(name) { data.store(name, args[0].call) } }
+        else
+          define_method(name) { data.fetch(name, args[0]) }
+        end
+      else
+        raise ArgumentError, %{ wrong number of arguments
+                                (#{args.length} for 1..2) }
+      end
+      define_method("#{name}=") { |value| data.store(name, value) }
+    end
+    def self.inherited(subclass)
+      define_method(subclass.name) do |**data|
+        subclass.new(delegate: self, data: data)
+      end
+    end
+    attr_accessor :children, :parent, :data
+    def initialize(*_, children: [], parent: nil, data: {})
+      @children = children
+      @parent = parent
+      @data = data
+      @appearance = :disappeared
+      @force_update = false
+      @delegate = self
+    end
+    def force_update?
+      @force_update
+    end
+    def view
+      nil
+    end
+    def render
+      view
+    end
+    def dispatch(target, action, *payload, &block)
+      parent.try(:dispatch, target, action, *payload, &block)
+    end
+    def notify(source, event, *payload)
+      parent.try(:notify, source, event, *payload)
+    end
+    def begin_appearance_transition(appearing)
+      if appearing
+        raise "Invalid appearance #{@appearance} when appearing" if @appearance != :disappeared
+        @appearance = :appearing
+        view_will_appear()
+      else
+        raise "Invalid appearance #{@appearance} when disappearing" if @appearance != :appeared
+        @appearance = :disappearing
+        view_will_disappear()
+      end
+    end
+    def end_appearance_transition()
+      case @appearance
+      when :appearing
+        @appearance = :appeared
+        view_did_appear()
+      when :disappearing
+        @appearance = :disappeared
+        view_did_disappear()
+      else
+        raise "Invalid appearance #{@appearance} when transitioning"
+      end
+    end
+    def add_child_view_controller(view_controller)
+      view_controller.will_move_to_parent_view_controller(self)
+      view_controller.remove_from_parent_view_controller
+      children.push(view_controller)
+      view_controller.parent = self
+      view_controller.did_move_to_parent_view_controller(self)
+    end
+    def remove_from_parent_view_controller
+      return unless parent
+      parent.children.delete(self)
+    end
+    def show(_view_controller)
+      raise 'not implemented'
+    end
+    def present(_view_controller)
+      raise 'not implemented'
+    end
+    def dismiss
+      raise 'not implemented'
+    end
+    def navigation_controller
+      parent.is_a?(NavigationController) ? parent :
+        parent.try(:navigation_controller)
+    end
+    # Callbacks
+    def will_move_to_parent_view_controller(view_controller)
+    end
+    def did_move_to_parent_view_controller(view_controller)
+    end
+    def view_will_appear
+    end
+    def view_did_appear
+    end
+    def view_will_disappear
+    end
+    def view_did_disappear
+    end
+    # Dispatch methods
+    def force_update
+      @force_update = true
+      @parent.refresh do
+        @force_update = false
+        yield if block_given?
+      end
+    end
+    def refresh(&block)
+      @parent.refresh(&block)
+    end
+  end
+end

data/lib/bluesky.rb ADDED Viewed

@@ -0,0 +1,53 @@
+require 'opal'
+require 'clearwater'
+#require 'clearwater/cached_render'
+module Clearwater
+  module CachedRender
+    class Wrapper
+      attr_reader :content
+      def initialize content
+        @content = content
+        @key = content.key
+      end
+      if RUBY_ENGINE == 'opal'
+      # Hook into vdom diff/patch
+      %x{
+        def.type = 'Thunk';
+        def.render = function cached_render(prev) {
+          var self = this;
+          if(prev && prev.vnode && #{!@content.should_render?(`prev.content`)}) {
+            self.content = prev.content;
+            return prev.vnode;
+          } else {
+            var content = #{Component.sanitize_content(@content.render)};
+            while(content && content.type == 'Thunk' && content.render) {
+              content = #{Component.sanitize_content(`content.render(prev)`)};
+            }
+            return content;
+          }
+        };
+      }
+      end
+    end
+  end
+end
+require_relative 'bluesky/try.rb'
+require_relative 'bluesky/dom_helper.rb'
+require_relative 'bluesky/node_builder.rb'
+require_relative 'bluesky/pure_component.rb'
+require_relative 'bluesky/view_controller.rb'
+require_relative 'bluesky/navigation_controller.rb'
+require_relative 'bluesky/application.rb'
+require_relative 'bluesky/version'
+unless RUBY_ENGINE == 'opal'
+  begin
+    require 'opal'
+    Opal.append_path File.expand_path('..', __FILE__).untaint
+  rescue LoadError
+  end
+end

data/spec/bluesky_spec.rb ADDED Viewed

@@ -0,0 +1,34 @@
+require 'bluesky'
+class RootView < Bluesky::PureComponent
+  def render
+    nil
+  end
+end
+class RootViewController < Bluesky::ViewController
+  def view
+    RootView.new
+  end
+end
+class Application < Bluesky::Application
+  root_view_controller RootViewController
+end
+describe Application do
+  context 'when run' do
+    it 'calls render on the root_view_controller' do
+      logger = double()
+      application = Application.new
+      application.logger = logger
+      expect(logger).to receive(:render).with(application)
+      application.run
+    end
+  end
+end

data/spec/spec_helper.rb ADDED Viewed

@@ -0,0 +1,109 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'bundler/setup'
+Bundler.setup
+require 'clearwater'
+require 'bluesky'
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata ADDED Viewed

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: bluesky
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Susi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-12-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: clearwater
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc4
+- !ruby/object:Gem::Dependency
+  name: opal-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An app framework for Clearwater
+email: john@susi.se
+executables:
+- bluesky
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/bluesky
+- lib/bluesky.rb
+- lib/bluesky/application.rb
+- lib/bluesky/dom_helper.rb
+- lib/bluesky/navigation_controller.rb
+- lib/bluesky/pure_component.rb
+- lib/bluesky/try.rb
+- lib/bluesky/version.rb
+- lib/bluesky/view_controller.rb
+- spec/bluesky_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/bluesky
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- "/Users/john/Projects/bluesky/lib"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.8
+signing_key:
+specification_version: 4
+summary: An app framework for Clearwater
+test_files:
+- spec/spec_helper.rb
+- spec/bluesky_spec.rb