lux-fw 0.1.17

data/lib/plugins/db_helpers/typero_attributes.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'typero'
+
+module Sequel::Plugins::TyperoAttributes
+  module ClassMethods
+    def attributes(&block)
+      self.instance_variable_set :@typero_rule, Typero.new(&block)
+    end
+
+    def typero_schema
+      self.instance_variable_get :@typero_rule
+    end
+  end
+
+  module InstanceMethods
+    # calling typero! on any object will validate all fields
+    def typero! field_name=nil
+      typero = self.class.typero_schema || return
+
+      typero.validate(self) { |name, err| errors.add(name, err) unless (errors.on(name) || []).include?(err) }
+
+      # this are rules unique to database, so we check them here
+      typero.rules.each do |field, rule|
+        # check uniqe fields
+        if rule[:uniq]
+          id    = self[:id] || 0
+          value = self[field]
+
+          # we only check if field is changed
+          if column_changed?(field) && self.class.xwhere('LOWER(%s)=LOWER(?) and id<>?' % field, value, id).first
+            error = rule[:uniq].class == TrueClass ? %[Value '"#{value}"' for #{field} allready exists] : rule[:uniq]
+            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+          end
+        end
+
+        # check protected fields
+        if rule[:protected] && self[:id]
+          if column_changed?(field)
+            error = rule[:protected].class == TrueClass ? "value once defined can't be overwritten." : rule[:protected]
+            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+          end
+        end
+      end
+
+      # check single field if single field given
+      if field_name
+        raise ArgumentError.new 'Field :%s not found in %s' % [field_name, self] unless self[field_name]
+        return unless errors.on(field_name)
+
+        errors.on(field_name).join(', ')
+      end
+
+      true
+    end
+
+    def validate
+      typero!
+      super
+    end
+  end
+
+  module DatasetMethods
+
+  end
+end
+
+Sequel::Model.plugin :typero_attributes
+

data/lib/plugins/db_logger/init.rb

@@ -0,0 +1,18 @@
+# Logs DB queries in console
+# to active just load the file
+logger = Logger.new(STDOUT)
+
+logger.formatter = proc { |severity, datetime, progname, msg|
+  elms = msg.split(/\(|s\)\s/, 3)
+  time = (elms[1].to_f * 1000).round(1)
+  if Thread.current[:db_q]
+    Thread.current[:db_q][:time] += elms[1].to_f
+    Thread.current[:db_q][:cnt] += 1
+
+    # append debug=true as query-string to see database queries
+    Lux.log(" #{Thread.current[:db_q][:cnt].to_s.rjust(2)}. #{time} : #{elms[2].cyan}\n") if Thread.current[:db_q]
+  end
+}
+
+DB.loggers << logger
+

data/lib/plugins/db_logger/lux_response_adapter.rb

@@ -0,0 +1,9 @@
+class Lux::Page
+  before do
+    Thread.current[:db_q] = { time: 0.0, cnt: 0 }
+  end
+
+  after do
+    Lux.log " #{Thread.current[:db_q][:cnt]} DB queries, #{(Thread.current[:db_q][:time]*1000).round(1)} ms" if Thread.current[:db_q][:cnt] > 0
+  end
+end

data/lib/plugins/paginate/helper.rb

@@ -0,0 +1,32 @@
+module DefaultHelper
+
+  def paginate list
+    return unless list.respond_to?(:paginate_size)
+    return nil if list.paginate_page == 1 && list.length < list.paginate_size
+
+    ret = ['<div class="paginate"><div>']
+
+    if list.paginate_page > 1
+      url = Url.current
+      list.paginate_page == 1 ? url.delete(list.paginate_param) : url.qs(list.paginate_param, list.paginate_page-1)
+      ret.push %[<a href="#{url.relative}">&larr;</a>]
+    else
+      ret.push %[<span>&larr;</span>]
+    end
+
+    ret.push %[<i>#{list.paginate_page == 1 ? '&bull;' : list.paginate_page}</i>]
+
+    if list.paginate_size == list.length
+      url = Url.current
+      url.qs(list.paginate_param, list.paginate_page+1)
+      ret.push %[<a href="#{url.relative}">&rarr;</a>]
+    else
+      ret.push %[<span>&rarr;</span>]
+    end
+
+    ret.push '</div></div>'
+    ret.join('')
+  end
+
+end
+

data/lib/plugins/paginate/sequel_adapter.rb

@@ -0,0 +1,18 @@
+module Sequel::Plugins::LuxSimplePaginate
+  module DatasetMethods
+    def page size: 20, param: :page, page: nil
+      page = (page || Lux.page.params[param]).to_i
+      page = 1 if page < 1
+
+      ret = paginate(page, size).all
+      ret.define_singleton_method(:paginate_param) do; param ;end
+      ret.define_singleton_method(:paginate_page)  do; page ;end
+      ret.define_singleton_method(:paginate_size)  do; size ;end
+
+      ret
+    end
+  end
+end
+
+Sequel::Model.db.extension :pagination
+Sequel::Model.plugin :lux_simple_paginate

data/lib/vendor/mini_assets/mini_asset/base.rb

@@ -0,0 +1,167 @@
+class MiniAsset::Base
+  attr_reader :error
+
+  def initialize source, opts={}
+    @source       = source
+    @opts         = opts
+
+    raise 'Bad source: %s' % source unless File.exist?(local_file)
+  end
+
+  def run! what
+    puts what.yellow
+
+    stdin, stdout, stderr, wait_thread = Open3.popen3(what)
+
+    error = stderr.gets
+    while line = stderr.gets do
+      error += line
+    end
+
+    # node-sass prints to stderror on complete
+    error = nil if error && error.index('Rendering Complete, saving .css file...')
+
+    if error
+      File.unlink(cache_file) if File.exists?(cache_file)
+      @error = error
+    end
+  end
+
+  def production?
+    !!@opts[:production]
+  end
+
+  def create file, opts=nil
+    MiniAsset.create file, opts || @opts
+  end
+
+  def content
+    File.read local_file
+  end
+
+  def ext
+    @source.split('.').last.to_sym
+  end
+
+  def asset_join_string
+    "\n"
+  end
+
+  def local_file
+    'app/assets/%s' % @source
+  end
+
+  def production_file
+    file = MiniAsset.manifest['files'][@source] || raise('Production file not found')
+
+    'public%s' % file
+  end
+
+  def cache_file
+    'tmp/assets/%s' % @source.gsub('/', '-')
+  end
+
+  def base_dir
+    list = @source.split('/')
+    list.pop
+    'app/assets/' + list.join('/')
+  end
+
+  def resolve_file files
+    files = files.sub(/^\.\//,'')
+    files += '/*' unless files.include?('*')
+
+    path = '%s/%s' % [base_dir, files]
+    @files += Dir[path].sort.map{ |f| f.split('app/assets/', 2).last }
+  end
+
+  def files
+    return @files if @files
+
+    @files = []
+
+    for line in content.split($/)
+      test = line.split(/^[\/\/#]=\s*req\w*\s+/)
+      resolve_file test[1] if test[1]
+    end
+
+    @files.push @source
+    @files
+  end
+
+  def path_for_comment
+    '/* Source: %s */' % @source
+  end
+
+  def do_compile?
+    return true unless File.exists?(cache_file)
+    return true if File.mtime(cache_file).to_i <= File.mtime(local_file).to_i
+    false
+  end
+
+  # compiles all the files, allways for production
+  def compile args=[]
+    data = []
+
+    for file in files
+      asset = create file, production: true
+      data.push asset.path_for_comment
+      data.push asset.compiled_data
+    end
+
+    data  = data.join(asset_join_string)
+    pfile = update_manifest(data)
+
+    unless File.exists? pfile
+      File.write(pfile, data)
+      minify!
+    end
+
+    if args.include?('gzip')
+      gzip!
+    else
+      gzip_file = '%s.gz' % pfile
+      File.unlink gzip_file if File.exists?(gzip_file)
+    end
+
+    fix_created_times!
+
+    pfile
+  end
+
+  # compiles single current file
+  def compiled_data
+    content
+  end
+
+  def minify!
+    true
+  end
+
+  def gzip!
+    f =  production_file
+    run! "gzip -f -c -1 '%{f}' > '%{f}.gz'" % { f: f } unless File.exists?('%s.gz' % f)
+  end
+
+  def fix_created_times!
+    touch_file = 'public/touch.ref'
+    `touch '#{touch_file}'` unless File.exists?(touch_file)
+
+    # touch and fix reference
+    `touch -r '#{touch_file}' #{production_file}`
+    `touch -r '#{touch_file}' #{production_file}.gz` if File.exists?("#{production_file}.gz")
+  end
+
+  def update_manifest data
+    digest = Digest::SHA1.hexdigest(data.to_s)
+    json = MiniAsset.manifest
+
+    pfile = cache_file.sub('tmp/assets/', 'public/assets/')
+    pfile = pfile.sub(/\.(\w+)/, "-#{digest}.\\1")
+
+    json['files'][@source] = pfile.sub('public/', '/')
+    MiniAsset.manifest json
+    pfile
+  end
+
+end

data/lib/vendor/mini_assets/mini_asset/css.rb

@@ -0,0 +1,38 @@
+class MiniAsset::Css < MiniAsset::Base
+
+  def content_type
+    'text/css'
+  end
+
+  def cache_file
+    super.sub(/\.(\w+)/, "#{production? ? '-p' : ''}.\\1").sub('.scss', '.css')
+  end
+
+  def update_cache
+    node_sass = './node_modules/node-sass/bin/node-sass'
+    node_opts = production? ? '--output-style compressed' : '--source-comments'
+    run! "#{node_sass} #{node_opts} '#{local_file}' '#{cache_file}'"
+  end
+
+  def compiled_data
+    if do_compile?
+      update_cache
+    else
+      # extract linked files from css cache and compile if needed
+      data = File.read cache_file
+      files = []
+      data.gsub(%r{(app/assets/[\w\-\./]+)}) { files.push($1) unless files.include?($1) }
+
+      final_check = false
+      cache_time  = File.mtime(cache_file).to_i
+      for file in files
+        final_check ||= true if cache_time <= File.mtime(file).to_i
+      end
+
+      update_cache if final_check
+    end
+
+    File.read cache_file
+  end
+
+end

data/lib/vendor/mini_assets/mini_asset/js.rb

@@ -0,0 +1,38 @@
+class MiniAsset::Js < MiniAsset::Base
+
+  def content_type
+    'text/javascript'
+  end
+
+  def asset_join_string
+    ";\n"
+  end
+
+  def cache_file
+    super.sub('.coffee', '.js')
+  end
+
+  def compiled_data
+    return content if ext == :js
+
+    if ext == :coffee && do_compile?
+      coffee_path = './node_modules/coffee-script/bin/coffee'
+      coffee_opts = production? ? '-cp' : '-Mcp --no-header'
+
+      run! "#{coffee_path} #{coffee_opts} '#{local_file}' > '#{cache_file}'"
+
+      data = File.read cache_file
+      data.gsub!(%r{//#\ssourceURL=[\w\-\.\/]+/app/assets/}, '//# sourceURL=/raw_asset/')
+      File.write cache_file, data
+    end
+
+    File.read cache_file
+  end
+
+  def minify!
+    if [:coffee, :js].include?(ext)
+      run! `./node_modules/minifier/index.js --output '#{production_file}' '#{production_file}'`
+    end
+  end
+
+end

data/lib/vendor/mini_assets/mini_asset.rb

@@ -0,0 +1,31 @@
+# asset = MiniAsset.create 'admin/index.scss'
+# asset.files          # find linked files
+# asset.compile        # compile for production and update public/maifest.json
+# asset.content_type
+# asset.compiled_data  # get compiled data
+
+module MiniAsset
+  extend self
+
+  def create file, opts={}
+    type = file.split('.').last.to_sym
+
+    klass = MiniAsset::Js  if [:js, :coffee].include?(type)
+    klass = MiniAsset::Css if [:scss].include?(type)
+
+    raise 'Not supported %s' % type unless klass
+
+    klass.new file, opts
+  end
+
+  def manifest json=nil
+    @manifest ||= Pathname.new 'public/assets/manifest.json'
+    @manifest.write '{"files":{}}' unless @manifest.exist?
+    @manifest.write json.to_json if json
+    JSON.load @manifest.read
+  end
+end
+
+require_relative './mini_asset/base'
+require_relative './mini_asset/js'
+require_relative './mini_asset/css'

data/lib/vendor/oauth/lib/facebook.rb

@@ -0,0 +1,35 @@
+# https://developers.facebook.com
+# https://developers.facebook.com/docs/facebook-login/manually-build-a-login-flow
+
+class LuxOauth::Facebook < LuxOauth
+  def login
+    'https://www.facebook.com/v2.8/dialog/oauth?scope=email&client_id=%s&redirect_uri=%s' % [@key, CGI::escape(redirect_url)]
+  end
+
+  def format_response opts
+    {
+      email:    opts['email'],
+      avatar:   '//graph.facebook.com/%s/picture?type=large' % opts['id'],
+      name:     opts['name']
+    }
+  end
+
+  def callback(session_code)
+    result = RestClient.post('https://graph.facebook.com/v2.8/oauth/access_token', {
+      redirect_uri:  redirect_url,
+      client_id:     @key,
+      client_secret: @secret,
+      code:          session_code
+    }, { :accept => :json })
+
+    access_token = JSON.parse(result)['access_token']
+
+    response = RestClient.get('https://graph.facebook.com/me', {
+      :accept => :json,
+      :params => { :access_token => access_token }
+    })
+
+    format_response JSON.parse response
+  end
+end
+

data/lib/vendor/oauth/lib/github.rb

@@ -0,0 +1,37 @@
+# https://github.com/github/platform-samples/tree/master/api/ruby/basics-of-authentication
+# https://github.com/settings/applications/404731
+
+class LuxOauth::Github < LuxOauth
+  def login
+    "https://github.com/login/oauth/authorize?scope=user:email&client_id=#{@key}"
+  end
+
+  def format_response opts
+    {
+      email:    opts['email'],
+      avatar:   opts['avatar_url'],
+      github:   opts['login'],
+      company:  opts['company'],
+      location: opts['location'],
+      bio:      opts['description'],
+      name:     opts['name']
+    }
+  end
+
+  def callback session_code
+    result = RestClient.post('https://github.com/login/oauth/access_token', {
+      client_id:     @key,
+      client_secret: @secret,
+      code:          session_code
+    }, { :accept => :json })
+
+    # extract token and granted scopes
+    access_token = JSON.parse(result)['access_token']
+    # scopes = JSON.parse(result)['scope'].split(',')
+
+    opts = JSON.parse(RestClient.get('https://api.github.com/user', {:params => {:access_token => access_token}, :accept => :json}))
+
+    format_response opts
+  end
+end
+

data/lib/vendor/oauth/lib/google.rb

@@ -0,0 +1,41 @@
+# https://console.developers.google.com
+# https://developers.google.com/identity/protocols/googlescopes
+
+class LuxOauth::Google < LuxOauth
+  def scope
+    [
+      'https://www.googleapis.com/auth/userinfo.email',
+      'https://www.googleapis.com/auth/userinfo.profile'
+    ]
+  end
+
+  def format_response opts
+    {
+      email:  opts['email'],
+      name:   opts['name'],
+      avatar: opts['picture'],
+      locale: opts['locale'],
+      gender: opts['gender']
+    }
+  end
+
+  def login
+    "https://accounts.google.com/o/oauth2/auth?client_id=#{@key}&redirect_uri=#{redirect_url}&scope=#{scope.join('%20')}&response_type=code"
+  end
+
+  def callback(session_code)
+    result = RestClient.post('https://www.googleapis.com/oauth2/v3/token', {
+      grant_type:    'authorization_code',
+      client_id:     @key,
+      client_secret: @secret,
+      code:          session_code,
+      redirect_uri:  redirect_url
+    })
+
+    hash = JSON.parse(result)
+
+    user = JSON.parse RestClient.get('https://www.googleapis.com/oauth2/v1/userinfo', { :params => {:access_token => hash['access_token'], :alt=>:json }})
+
+    format_response user
+  end
+end

data/lib/vendor/oauth/lib/linkedin.rb

@@ -0,0 +1,41 @@
+# https://developer.linkedin.com/docs/oauth2
+# https://developer.linkedin.com/docs/fields/basic-profile
+
+class LuxOauth::Linkedin < LuxOauth
+  def scope
+    [
+      'r_basicprofile',
+      'r_emailaddress'
+    ]
+  end
+
+  def login
+    "https://www.linkedin.com/oauth/v2/authorization?response_type=code&client_id=#{@key}&redirect_uri=#{redirect_url}&state=987654321&scope=#{scope.join('%20')}"
+  end
+
+  def format_response opts
+    {
+      email:       opts['emailAddress'],
+      linkedin:    opts['publicProfileUrl'],
+      description: opts['specialties'],
+      location:    opts['location'],
+      avatar:      opts['pictureUrl'],
+      name:        "#{opts['firstName']} #{opts['lastName']}"
+    }
+  end
+
+  def callback(session_code)
+    result = RestClient.post('https://www.linkedin.com/oauth/v2/accessToken', {
+      grant_type:    'authorization_code',
+      client_id:     @key,
+      client_secret: @secret,
+      code:          session_code,
+      redirect_uri:  redirect_url
+    })
+
+    access_token = JSON.parse(result)['access_token']
+    opts = JSON.parse RestClient::Request.execute(:method=>:get, :url=>'https://api.linkedin.com/v1/people/~:(id,picture-url,first-name,last-name,email-address,public-profile-url,specialties,location)?format=json', :headers => {'Authorization'=>"Bearer #{access_token}"})
+
+    format_response opts
+  end
+end

data/lib/vendor/oauth/lib/stackexchange.rb

@@ -0,0 +1,37 @@
+# https://api.stackexchange.com/docs/authentication
+
+class LuxOauth::Stackexchange < LuxOauth
+  def login
+    'https://stackexchange.com/oauth?client_id=%d&redirect_uri=%s' % [ENV.fetch('STACKEXCHANGE_OAUTH_ID'), CGI::escape(redirect_url)]
+  end
+
+  def format_response
+    {
+      stackexchnage_user_id: opts['items'].first['user_id'],
+      user: opts['items'].first
+    }
+  end
+
+  def callback session_code
+    result = RestClient.post('https://stackexchange.com/oauth/access_token', {
+      redirect_uri:  redirect_url,
+      client_id:     ENV.fetch('STACKEXCHANGE_OAUTH_ID'),
+      client_secret: @secret,
+      code:          session_code
+    }, { :accept => :json })
+
+    access_token = result.to_s.css_to_hash['access_token']
+
+    response = RestClient.get('https://api.stackexchange.com/2.2/me', {
+      accept: :json,
+      params: {
+        site: 'stackoverflow',
+        access_token: access_token,
+        key: @key
+      }
+    })
+
+    format_response JSON.parse response
+  end
+end
+

data/lib/vendor/oauth/lib/twitter.rb

@@ -0,0 +1,41 @@
+# https://developer.linkedin.com/docs/oauth2
+# https://developer.linkedin.com/docs/fields/basic-profile
+
+class LuxOauth::Twitter < LuxOauth
+  # def scope
+  #   [
+  #     'r_basicprofile',
+  #     'r_emailaddress'
+  #   ]
+  # end
+
+  # def login
+  #   'https://api.twitter.com/oauth/authorize?oauth_token=%s' % @key
+  # end
+
+  # def format_response opts
+  #   {
+  #     email:       opts['emailAddress'],
+  #     linkedin:    opts['publicProfileUrl'],
+  #     description: opts['specialties'],
+  #     location:    opts['location'],
+  #     avatar:      opts['pictureUrl'],
+  #     name:        "#{opts['firstName']} #{opts['lastName']}"
+  #   }
+  # end
+
+  # def callback(session_code)
+  #   result = RestClient.post('https://www.linkedin.com/oauth/v2/accessToken', {
+  #     grant_type:    'authorization_code',
+  #     client_id:     @key,
+  #     client_secret: @secret,
+  #     code:          session_code,
+  #     redirect_uri:  redirect_url
+  #   })
+
+  #   access_token = JSON.parse(result)['access_token']
+  #   opts = JSON.parse RestClient::Request.execute(:method=>:get, :url=>'https://api.linkedin.com/v1/people/~:(id,picture-url,first-name,last-name,email-address,public-profile-url,specialties,location)?format=json', :headers => {'Authorization'=>"Bearer #{access_token}"})
+
+  #   format_response opts
+  # end
+end