fron 0.1.4 → 0.2.0rc1

data/opal/fron/core-ext/kernel.rb

@@ -1,10 +0,0 @@
-module Kernel
-  def requestAnimationFrame(&block)
-    return unless `!!window.requestAnimationFrame`
-    `window.requestAnimationFrame(function(){ #{block.call} })`
-  end
-
-  def timeout(ms = 0,&block)
-    `setTimeout(function(){#{block.call}},#{ms})`
-  end
-end

data/opal/fron/core-ext/numeric.rb

@@ -1,9 +0,0 @@
-class Numeric
-  def clamp min, max
-    [[self, max].min, min].max
-  end
-
-  def round(decimals = 0)
-    `#{self}.toFixed(#{decimals})`.to_f
-  end
-end

data/opal/fron/core-ext/proc.rb

@@ -1,9 +0,0 @@
-class Proc
-  def throttle(ms)
-    Native `throttle(#{self},#{ms}, {leading: false})`
-  end
-
-  def debounce(ms, leading = false)
-    Native `debounce(#{self},#{ms},#{leading})`
-  end
-end

data/opal/fron/core/adapters/local.rb

@@ -1,43 +0,0 @@
-require 'json'
-require 'securerandom'
-
-module Fron
-  module Adapters
-    class LocalAdapter
-      def initialize(options)
-        @options = options
-      end
-
-      def all(&block)
-        block.call Fron::Storage::LocalStorage.all
-      end
-
-      def get(id, &block)
-        block.call Fron::Storage::LocalStorage.get id
-      end
-
-      def set(model, data, &block)
-        id = model.id
-        id = SecureRandom.uuid unless id
-        data[:id] = id
-        unless (errors = validate data)
-          Fron::Storage::LocalStorage.set id, data
-          block.call nil, data
-        else
-          block.call errors, {}
-        end
-        data
-      end
-
-      def validate(data = {})
-        errors = {}
-        @options[:fields].reject{|field| field == :id}.map do |field|
-          next if data[field] && data[field] != ""
-          errors[field] = ["can't be blank"]
-          valid = false
-        end
-        errors.keys.length == 0 ? nil : errors
-      end
-    end
-  end
-end

data/opal/fron/core/adapters/rails.rb

@@ -1,65 +0,0 @@
-module Fron
-  module Adapters
-    class RailsAdapter
-
-      def initialize(options)
-        @options = options
-        @request = Request.new
-        @request.headers = {'Content-Type' => 'application/json'}
-      end
-
-      def del(model,&block)
-        setUrl model
-        @request.request 'DELETE', transform({})  do
-          block.call
-        end
-      end
-
-      def all(data = nil, &block)
-        setUrl nil
-        @request.get(data) { |response| block.call response.json }
-      end
-
-      def get(id,&block)
-        setUrl id
-        @request.get { |response| block.call response.json }
-      end
-
-      def set(model,data,&block)
-        setUrl model
-        method = model.id ? 'put' : 'post'
-        @request.send(method,transform(data)) do |response|
-          error = case response.status
-          when 201, 204
-            nil
-          when 422
-            response.json
-          end
-          block.call error, response.json
-        end
-      end
-
-      private
-
-      def setUrl(model)
-        id = model.is_a?(Fron::Model) ? model.id : model
-        endpoint = if @options[:endpoint].is_a? Proc
-            model.instance_eval &@options[:endpoint]
-          else
-            @options[:endpoint]
-          end
-        base = endpoint + "/" + @options[:resources]
-        base += id ? "/" + id.to_s : ".json"
-        @request.url = base
-      end
-
-      def transform(data)
-        newdata = {}
-        meta = DOM::Document.head.find("meta[name=csrf-token]")
-        newdata[:authenticity_token] = meta['content'] if meta
-        newdata[@options[:resource]] = data.dup
-        newdata
-      end
-    end
-  end
-end

data/opal/fron/core/application.rb

@@ -1,42 +0,0 @@
-module Fron
-  class Application
-    class << self
-      def config
-        @configuration ||= Configuration.new
-      end
-    end
-
-    def initialize
-      @routeMap = []
-      instance_eval &config.routeBlock if config.routeBlock
-      @router = Router.new @routeMap, config
-
-      DOM::Window.on('load') { loadExternalStylesheets }
-
-      config.logger.info "Initialized Applicationation!"
-      config.logger.info "Inserting application to DOM!"
-
-      DOM::Document.title = config.title
-      DOM::Document.body << config.app
-    end
-
-    private
-
-    def loadExternalStylesheets
-      return unless config.stylesheets
-      config.stylesheets.map do |sheet|
-        link = DOM::Element.new "link[rel=stylesheet][type=text/css][href=#{sheet}]"
-        link.on('load') { config.logger.info "External stylesheet loaded: #{sheet}" }
-        DOM::Document.head << link
-      end
-    end
-
-    def map(*args)
-      @routeMap << Router.map(*args)
-    end
-
-    def config
-      self.class.config
-    end
-  end
-end

data/opal/fron/core/configuration.rb

@@ -1,29 +0,0 @@
-module Fron
-  class Configuration
-    class App < Component
-    end
-    class Yield < Component
-    end
-
-    attr_accessor :title, :stylesheets, :logger, :injectBlock
-    attr_reader :routeBlock, :main, :app
-
-    def initialize
-      @app    = App.new
-      @main   = Yield.new
-      @logger = Fron::Logger.new
-    end
-
-    def routes(&block)
-      @routeBlock = block
-    end
-
-    def layout(&block)
-      @app.instance_exec @main, &block
-    end
-
-    def customInject(&block)
-      @injectBlock = block
-    end
-  end
-end

data/opal/fron/core/controller.rb

@@ -1,41 +0,0 @@
-module Fron
-  class Controller
-    class << self
-      attr_reader :baseComponent, :routes, :beforeFilters, :events
-
-      def base(component)
-        @baseComponent = component
-      end
-
-      def route(*args)
-        @routes ||= []
-        @routes << Router.map(*args)
-      end
-
-      def on(name,action)
-        @events ||= []
-        @events << {name: name, action: action}
-      end
-
-      def before(method,actions)
-        @beforeFilters ||= []
-        @beforeFilters << {method: method, actions: actions}
-      end
-    end
-
-    attr_reader :base
-
-    def initialize
-      if self.class.baseComponent
-        @base = self.class.baseComponent.new
-      else
-        @base = DOM::Element.new 'div'
-      end
-
-      return unless self.class.events
-      self.class.events.each do |event|
-        Eventable.on event[:name] do self.send(event[:action]) end
-      end
-    end
-  end
-end

data/opal/fron/core/model.rb

@@ -1,90 +0,0 @@
-module Fron
-  class Model
-    include Eventable
-    attr_reader :errors
-
-    class << self
-      attr_accessor :fields
-      attr_accessor :adapterObject
-
-      def adapter(adapter, options = {})
-        options.merge! fields: @fields if @fields
-        @adapterObject = adapter.new options
-      end
-
-      def field(name)
-        @fields ||= []
-        @fields << name
-        define_method(name) do
-          @data[name]
-        end
-        define_method(name+"=") do |value|
-          @data[name] = value
-          trigger 'change'
-        end
-      end
-
-      def all(data = nil, &block)
-        @adapterObject.all data do |items|
-          break unless block_given?
-          block.call items.map{ |item| self.new item }
-        end
-      end
-
-      def find(id, &block)
-        user = self.new
-        @adapterObject.get id do |data|
-          user.merge data
-          block.call user
-        end
-        user
-      end
-    end
-
-    def initialize(data = {})
-      self.class.field :id
-      @data = data
-    end
-
-    def update(attributes = {}, &block)
-      data = gather.merge! attributes
-      self.class.instance_variable_get("@adapterObject").set self, data do |errors,data|
-        @errors = errors
-        merge data
-        block.call if block_given?
-      end
-    end
-
-    def dirty?
-      !self.id
-    end
-
-    private
-
-    def clone(data = {})
-      cl = self.class.new @data.merge data
-      cl.instance_variable_set "@errors", self.errors
-      cl
-    end
-
-    def destroy(&block)
-      self.class.instance_variable_get("@adapterObject").del self do
-        block.call if block_given?
-      end
-    end
-
-    def gather
-      @data.dup.reject{|key| !self.class.fields.include?(key)}
-    end
-
-    def merge(data)
-      data.each_pair do |key,value|
-        if self.respond_to?(key+"=")
-          self.send(key+"=", value)
-        else
-          @data[key] = value
-        end
-      end
-    end
-  end
-end

data/opal/fron/core/router.rb

@@ -1,86 +0,0 @@
-module Fron
-  class Router
-    def initialize(routes,config)
-      @config = config
-      @routes = routes
-
-      DOM::Window.on 'load' do
-        route
-      end
-      DOM::Window.on 'hashchange' do
-        route
-      end
-    end
-
-    def self.map(*args)
-      data = case args.length
-      when 1
-        action = args[0]
-        {path: "*"}
-      when 2
-        action = args[1]
-        {path: Router.pathToRegexp(args[0]) }
-      end
-      if action.is_a? Class
-        data[:controller] = action.new
-      else
-        data[:action] = action.to_s
-      end
-      data
-    end
-
-    def self.pathToRegexp(path)
-      return path if path == "*"
-      {regexp: Regexp.new('^'+path.gsub(/:([^\/]+)/, '([^\/]+)')), map: path.scan(/:([^\/]+)/).flatten }
-    end
-
-    def route(hash = DOM::Window.hash, controller = nil, startParams = {})
-      routes = controller ? (controller.class.routes || []) : @routes
-      routes.each do |r|
-        if r[:path] == '*'
-          if r[:controller]
-            break route(hash,r[:controller],startParams)
-          else
-            break applyRoute(controller,r,startParams)
-          end
-        else
-          matches = hash.match(r[:path][:regexp]).to_a[1..-1]
-          if matches
-            params = {}
-            if r[:path][:map]
-              r[:path][:map].each_with_index do |key, index|
-                params[key.to_sym] = matches[index]
-              end
-            end
-            if r[:action]
-              break applyRoute(controller,r,startParams.merge(params))
-            else
-              break route hash.gsub(r[:path][:regexp],''), r[:controller], startParams.merge(params)
-            end
-          end
-        end
-      end
-    end
-
-    private
-
-    def applyRoute(controller,route, params = {})
-      if controller.class.beforeFilters
-        controller.class.beforeFilters.each do |filter|
-          if filter[:actions].include?(route[:action])
-            controller.send(filter[:method], params)
-          end
-        end
-      end
-      controller.send(:empty) if controller.respond_to?(:empty)
-      controller.send(route[:action], params)
-      @config.logger.info "Navigate >> #{controller.class}##{route[:action]} with params #{params}"
-      @config.main.empty
-      if @config.injectBlock
-        @config.injectBlock.call controller.base
-      else
-        @config.main << controller.base
-      end
-    end
-  end
-end

data/opal/fron/storage/local-storage.rb

@@ -1,34 +0,0 @@
-module Fron
-  module Storage
-    module LocalStorage
-      def self.get(key)
-        value = `window.localStorage.getItem(#{key}) || false`
-        value ? JSON.parse(value) : nil
-      end
-
-      def self.set(key, data)
-        `window.localStorage.setItem(#{key},#{data.to_json})`
-      end
-
-      def self.remove(key)
-        `window.localStorage.removeItem(#{key})`
-      end
-
-      def self.keys
-        %x{
-          ret = []
-          for (var key in localStorage){ ret.push(key) }
-          return ret
-        }
-      end
-
-      def self.all
-        self.keys.map{ |key| self.get key }
-      end
-
-      def self.clear
-        `window.localStorage.clear()`
-      end
-    end
-  end
-end