Merge branch 'edge' of https://github.com/hyperstack-org/hyperstack into edge

Author: barriehadfield

.travis.yml

@@ -24,6 +24,7 @@ env:
   - COMPONENT=hyper-react                 LANGUAGE=ruby LANGUAGE_VERSION=2.5.1
   - COMPONENT=hyper-router                LANGUAGE=ruby LANGUAGE_VERSION=2.5.1
   - COMPONENT=hyper-spec                  LANGUAGE=ruby LANGUAGE_VERSION=2.5.1
+  - COMPONENT=hyper-state                 LANGUAGE=ruby LANGUAGE_VERSION=2.5.1
   - COMPONENT=hyper-store                 LANGUAGE=ruby LANGUAGE_VERSION=2.5.1
   - COMPONENT=hyper-trace                 LANGUAGE=ruby LANGUAGE_VERSION=2.5.1
   - COMPONENT=hyperloop                   LANGUAGE=ruby LANGUAGE_VERSION=2.5.1

current-status.md

@@ -0,0 +1,176 @@
+### Current Status:  Working towards 0.1 release.  See Roadmap for details.
+
+
+[![Build Status](https://travis-ci.org/hyperstack-org/hyperstack.svg?branch=edge)](https://travis-ci.org/hyperstack-org/hyperstack)
+
+`hyperstack-config`, `hyper-store`, and `hyper-component` are now following the public interface conventions.
+
+I.e. to create a component you now do this:
+
+```ruby
+class MyComponent
+  include Hyperstack::Component
+  ...
+end
+```
+
+The philosophy is that you will probably have a base class defined like this:
+
+```ruby
+class HyperComponent 
+  include Hyperstack::Component
+end
+```
+
+Which you can then inherit from.
+
+The bigger change is that the state mechanism has now been greatly simplified, but you can choose when to move
+into the future by your choice of which module to include:
+
+```ruby
+class HyperComponent
+  include Hyperstack::Component
+  # to use the current state/store syntax in your components:
+  include Hyperstack::Legacy::Store
+end
+
+class HyperStore
+  # to use the legacy state store syntax in your stores:
+  include Hyperstack::Legacy::Store
+end
+```
+
+To use the new hotness change the includes:
+
+```ruby
+class HyperComponent
+  include Hyperstack::Component
+  # to use the current state/store syntax in your components:
+  include Hyperstack::State::Observable
+end
+
+class HyperStore
+  # to use the legacy state store syntax in your stores:
+  include Hyperstack::State::Observable
+end
+```
+
+In summary you will need to update your hyperloop/hyperstack components and store folders to have `hyper_component.rb` 
+and `hyper_store.rb` files.  And then update your components and stores to reference your application defined `HyperComponent`
+and `HyperStore` classes.  
+
+### The new world of state:
+
+Its great, its exciting, and its sooo much easier:
+
+Each ruby object has *state*, defined by its instance variables.  Hyperstack does not define *any new state concepts*.  From 
+now on you just use instance variables in your components and other objects as you normally would.
+
+The one caveat is that you have to *tell* the system when you are *mutating* state, and when some external entity is
+*observing* your state. 
+
+The `Hyperstack::State::Observable` module provides a handful of methods to make this very easy.
+
+Here is an example (compare to the state example on the [Hyperstack.org home page](https://hyperstack.org/))
+
+```ruby
+class UsingState < HyperComponent
+
+  # Our component has two instance variables to keep track of what is going on
+  #   @show        - if true we will show an input box, otherwise the box is hidden
+  #   @input_value - tracks what the user is typing into the input box.
+  # We use the mutate method to signal all observers when the state changes.
+
+  render(DIV) do
+    # the button method returns an HTML element
+    # .on(:click) is an event handeler
+    button.on(:click) { mutate @show = !@show }
+    DIV do
+      input
+      output
+      easter_egg
+    end if @show
+  end
+
+  def button
+    BUTTON(class: 'ui primary button') do
+      @show ? 'Hide' : 'Show'
+    end
+  end
+
+  def input
+    DIV(class: 'ui input fluid block') do
+      INPUT(type: :text).on(:change) do |evt|
+        # we are updating the value per keypress
+        mutate @input_value = evt.target.value
+      end
+    end
+  end
+
+  def output
+    # this will re-render whenever input_value changes
+	P { "#{@input_value}" }
+  end
+
+  def easter_egg
+    H2 {'you found it!'} if @input_value == 'egg'
+  end
+end
+```
+
+So to make our instance variables work with components we just need to call `mutate` when the state changes.
+
+Here is a very simple store that is just a global click counter
+
+```ruby
+class Click 
+  include Hyperstack::State::Observable
+  class << self
+    def count
+      observe @count ||= 0
+    end
+    def inc
+      mutate @count = count + 1
+    end
+    def count=(x)
+      mutate @count = x
+    end
+    def reset
+      mutate @count = 0
+    end
+  end
+end
+```
+
+Now any component can access and change the counter by calling `Click.count`, `Click.inc` and `Click.reset` as needed.
+
+The `observe` and `mutate` methods take no params (handy for adding to the end of a method), a single param as shown above,
+or a block in which case the entire block will be executed before signaling the rest of the system.
+
+That is all there is to it, but to make things easier `Observable` contains some other helper methods which we can use:
+
+```ruby
+class Click
+  include Hyperstack::State::Observable
+  class << self
+    observer(:count) { @count ||= 0 }
+    state_writer :count
+    mutator(:inc)    { count = count + 1 }
+    mutator(:reset)  { count = 0 }
+  end
+end
+```
+
+The `observer` and `mutator` methods create a method wrapped in `observe` or `mutate` block.
+
+In addition there are `state_accessor`, `state_reader` and `state_writer` methods that work just like `attr_accessor` methods
+except access is wrapped in the appropriate `mutate` or `observe` method.
+
+The methods can be used either at the class or instance level as needed.
+
+Because stateful components use the same `Observable` module all the above methods are available to help structure your
+components nicely.
+
+Notice in the component example we never use `observe` that is because by definition components always `observe` their own
+state automatically so you don't need to.
+

readme.md

@@ -1,6 +1,8 @@
 # Hyperstack
 
-[![Build Status](https://travis-ci.org/hyperstack-org/hyperstack.svg?branch=edge)](https://travis-ci.org/hyperstack-org/hyperstack)
+This is the edge branch - for current status on development see [current status.](https://github.com/hyperstack-org/hyperstack/blob/edge/current-status.md)
+
+Visit the legacy branch for the current stable and released Hyperloop (old name) system. [![Build Status](https://travis-ci.org/hyperstack-org/hyperstack.svg?branch=hyperloop-legacy)](https://travis-ci.org/hyperstack-org/hyperstack)
 
 Hyperstack is a Ruby-based DSL and modern web toolkit for building spectacular, interactive web applications fast!
 

ruby/hyper-component/CHANGELOG.md

@@ -0,0 +1,143 @@
+# Change Log
+
+All notable changes to this project will be documented in this file starting with v0.8.6.
+This project *tries* to adhere to [Semantic Versioning](http://semver.org/), even before v1.0.
+
+Changes are grouped as follows:
+- **Added** for new features.
+- **Changed** for changes in existing functionality.
+- **Deprecated** for once-stable features to be removed in upcoming releases.
+- **Removed** for deprecated features removed in this release.
+- **Fixed** for any bug fixes.
+- **Security** to invite users to upgrade in case of vulnerabilities.
+
+<!--
+Whitespace conventions:
+- 4 spaces before ## titles
+- 2 spaces before ### titles
+- 1 spaces before normal text
+ -->
+
+## [0.12.0] - Unreleased
+
+### Added
+
+- `React::Server` is provided as a module wrapping the original `ReactDOMServer` API, require `react/server` to use it. (#186)
+- `React::Config` is introduced, `environment` is the only config option provided for now. See [#204](https://github.com/ruby-hyperloop/hyper-react/issues/204) for usage details.
+
+### Changed
+
+- State syntax is now consistent with Hyperloop::Store, old syntax is deprecated. (#209, #97)
+
+### Deprecated
+
+- Current ref callback behavior is deprecated. Require `"react/ref_callback"` to get the updated behavior. (#188)
+- `Hyperstack::Component::ReactAPI.render_to_string` & `Hyperstack::Component::ReactAPI.render_to_static_markup` is deprecated, use `React::Server.render_to_string` & `React::Server.render_to_static_markup` instead. (#186)
+- `react/react-source` is deprecated, use `react/react-source-browser` or `react/react-source-server` instead. For most usecase, `react/react-source-browser` is sufficient. If you are using the built-in server side rendering feature, the actual `ReactDOMServer` is already provided by the `react-rails` gem. Therefore, unless you are building a custom server side rendering mechanism, it's not suggested to use `react/react-source-server` in browser code. (#186)
+
+### Removed
+
+- `react-latest` & `react-v1x` is removed. Use `react/react-source-browser` or `react/react-source-server` instead.
+- Support for Ruby < 2.0 is removed. (#201)
+
+### Fixed
+
+- [NativeLibrary] Passing native JS object as props will raise exception. (#195)
+- Returns better error message if result of rendering block is not suitable (#207)
+- Batch all state changes and execute *after* rendering cycle (#206, #178)  (Code is now moved to Hyper::Store)  
+  You can revert to the old behavior by defining the `React::State::ALWAYS_UPDATE_STATE_AFTER_RENDER = false`
+- Memory Leak in render context fixed (#192)
+
+
+## [0.11.0] - 2016-12-13
+
+### Changed
+
+- The whole opal-activesuppport is not loaded by default now. This gave us about 18% size reduction on the built file. If your code rely on any of the module which is not required by hyper-react, you need to require it yourself. (#135)
+
+### Deprecated
+
+- Current `Hyperstack::Component::ReactAPI.render` behavior is deprecated. Require `"react/top_level_render"` to get the updated behavior. (#187)
+- `React.is_valid_element` is deprecated in favor of `Hyperstack::Component::ReactAPI.is_valid_element?`.
+- `expect(component).to render('<div />')` is now deprecated in favor of `expect(component).to render_static_html('<div />')`, which is much clearer.
+
+### Fixed
+
+- `ReferenceError: window is not defined` error in prerender context with react-rails v1.10.0. (#196)
+- State might not be updated using `React::Observable` from a param. (#175)
+- Arity checking failed for `_react_param_conversion` & `React::Element#initialize` (#167)
+
+
+## [0.10.0] - 2016-10-30
+
+### Changed
+
+- This gem is now renamed to `hyper-react`, see [UPGRADING](UPGRADING.md) for details.
+
+### Fixed
+
+- ReactJS functional stateless component could not be imported from `NativeLibrary`. Note that functional component is only supported in React v14+.  (#162)
+- Prerender log got accumulated between reqeusts. (#176)
+
+## [0.9.0] - 2016-10-19
+
+### Added
+
+- `react/react-source` is the suggested way to include ReactJS sources now. Simply require `react/react-source` immediately before the `require "reactrb"` in your Opal code will make it work.
+
+### Deprecated
+
+- `react-latest` & `react-v1x` is deprecated. Use `react/react-source` instead.
+
+### Removed
+
+- `opal-browser` is removed from runtime dependency. (#133)  You will have to add `gem 'opal-browser'` to your gemfile (recommended) or remove all references to opal-browser from your manifest files.
+
+### Fixed
+
+- `$window#on` in `opal-jquery` is broken. (#166)
+- `Element#render` trigger unnecessary re-mounts when called multiple times. (#170)
+- Gets rid of react warnings about updating state during render (#155)
+- Multiple HAML classes (i.e. div.foo.bar) was not working (regression introduced in 0.8.8)
+- Don't send nil (null) to form components as the value string (#157)
+- Process `params` (props) correctly when using `Element#on` or `Element#render` (#158)
+- Deprecate shallow param compare (#156)
+
+
+## [0.8.8] - 2016-07-13
+
+### Added
+
+- More helpful error messages on render failures (#152)
+- `Element#on('<my_event_name>')` subscribes to `my_event_name` (#153)
+
+### Changed
+
+- `Element#on(:event)` subscribes to `on_event` for reactrb components and `onEvent` for native components. (#153)
+
+### Deprecated
+
+- `Element#on(:event)` subscription to `_onEvent` is deprecated. Once you have changed params named `_on...` to `on_...` you can `require 'reactrb/new-event-name-convention.rb'` to avoid spurious react warning messages. (#153)
+
+
+### Fixed
+
+- The `Element['#container'].render...` method generates a spurious react error (#154)
+
+
+
+
+## [0.8.7] - 2016-07-08
+
+
+### Fixed
+
+- Opal 0.10.x compatibility
+
+
+## [0.8.6] - 2016-06-30
+
+
+### Fixed
+
+- Method missing within a component was being reported as `incorrect const name` (#151)