lux-fw 0.1.17 → 0.1.35

data/lib/common/hash_with_indifferent_access.rb

@@ -0,0 +1,352 @@
+class HashWithIndifferentAccess
+  def initialize data=nil
+    @data = {}
+    merge! data if data
+  end
+
+  def merge! data
+    data.each { |key, value| @data[convert_key(key)] = convert_value(value) }
+  end
+  alias_method :update, :merge!
+
+  def merge data
+    copy = self.class.new @data
+    copy.merge! data
+    copy
+  end
+
+  def [] key
+    @data[convert_key(key)]
+  end
+
+  def []= key, value
+    @data[convert_key(key)] = convert_value(value)
+  end
+  alias_method :store, :[]=
+
+  def key? name
+    @data.key? convert_key(name)
+  end
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  def to_json opts=nil
+    @data.to_json opts
+  end
+
+  def delete_if &block
+    @data.delete_if(&block)
+  end
+
+  def delete key
+    @data.delete convert_key(key)
+  end
+
+  def dig *args
+    list = args.map{ |_| _.class == Symbol ? _.to_s : _ }
+    @data.dig *list
+  end
+
+  def clear
+    @data.keys.each { |key| @data.delete(key) }
+  end
+
+  def each;    @data.each { |k,v| yield(k,v) }; end
+  def keys;    @data.keys; end
+  def values;  @data.keys; end
+  def to_hash; @data; end
+
+  private
+
+  def convert_key key
+    key.kind_of?(Symbol) ? key.to_s : key
+  end
+
+  def convert_value value
+    value.is_a?(Hash) ? self.class.new(value) : value
+  end
+end
+
+
+# exrtacted from Rails
+# class HashWithIndifferentAccess < Hash
+#   # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
+#   # this class.
+#   def extractable_options?
+#     true
+#   end
+
+#   def with_indifferent_access
+#     dup
+#   end
+
+#   def initialize(constructor = {})
+#     if constructor.respond_to?(:to_hash)
+#       super()
+#       update(constructor)
+
+#       hash = constructor.to_hash
+#       self.default = hash.default if hash.default
+#       self.default_proc = hash.default_proc if hash.default_proc
+#     else
+#       super(constructor)
+#     end
+#   end
+
+#   def default(*args)
+#     arg_key = args.first
+
+#     if include?(key = convert_key(arg_key))
+#       self[key]
+#     else
+#       super
+#     end
+#   end
+
+#   def self.[](*args)
+#     new.merge!(Hash[*args])
+#   end
+
+#   alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+#   alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+#   # Assigns a new value to the hash:
+#   #
+#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
+#   #   hash[:key] = 'value'
+#   #
+#   # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
+#   def []=(key, value)
+#     regular_writer(convert_key(key), convert_value(value, for: :assignment))
+#   end
+
+#   alias_method :store, :[]=
+
+#   # Updates the receiver in-place, merging in the hash passed as argument:
+#   #
+#   #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
+#   #   hash_1[:key] = 'value'
+#   #
+#   #   hash_2 = ActiveSupport::HashWithIndifferentAccess.new
+#   #   hash_2[:key] = 'New Value!'
+#   #
+#   #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+#   #
+#   # The argument can be either an
+#   # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
+#   # In either case the merge respects the semantics of indifferent access.
+#   #
+#   # If the argument is a regular hash with keys +:key+ and +"key"+ only one
+#   # of the values end up in the receiver, but which one is unspecified.
+#   #
+#   # When given a block, the value for duplicated keys will be determined
+#   # by the result of invoking the block with the duplicated key, the value
+#   # in the receiver, and the value in +other_hash+. The rules for duplicated
+#   # keys follow the semantics of indifferent access:
+#   #
+#   #   hash_1[:key] = 10
+#   #   hash_2['key'] = 12
+#   #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
+#   def update(other_hash)
+#     if other_hash.is_a? HashWithIndifferentAccess
+#       super(other_hash)
+#     else
+#       other_hash.to_hash.each_pair do |key, value|
+#         if block_given? && key?(key)
+#           value = yield(convert_key(key), self[key], value)
+#         end
+#         regular_writer(convert_key(key), convert_value(value))
+#       end
+#       self
+#     end
+#   end
+
+#   alias_method :merge!, :update
+
+#   # Checks the hash for a key matching the argument passed in:
+#   #
+#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
+#   #   hash['key'] = 'value'
+#   #   hash.key?(:key)  # => true
+#   #   hash.key?('key') # => true
+#   def key?(key)
+#     super(convert_key(key))
+#   end
+
+#   alias_method :include?, :key?
+#   alias_method :has_key?, :key?
+#   alias_method :member?, :key?
+
+#   # Same as <tt>Hash#[]</tt> where the key passed as argument can be
+#   # either a string or a symbol:
+#   #
+#   #   counters = ActiveSupport::HashWithIndifferentAccess.new
+#   #   counters[:foo] = 1
+#   #
+#   #   counters['foo'] # => 1
+#   #   counters[:foo]  # => 1
+#   #   counters[:zoo]  # => nil
+#   def [](key)
+#     super(convert_key(key))
+#   end
+
+#   # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
+#   # either a string or a symbol:
+#   #
+#   #   counters = ActiveSupport::HashWithIndifferentAccess.new
+#   #   counters[:foo] = 1
+#   #
+#   #   counters.fetch('foo')          # => 1
+#   #   counters.fetch(:bar, 0)        # => 0
+#   #   counters.fetch(:bar) { |key| 0 } # => 0
+#   #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
+#   def fetch(key, *extras)
+#     super(convert_key(key), *extras)
+#   end
+
+#   # Returns an array of the values at the specified indices:
+#   #
+#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
+#   #   hash[:a] = 'x'
+#   #   hash[:b] = 'y'
+#   #   hash.values_at('a', 'b') # => ["x", "y"]
+#   def values_at(*indices)
+#     indices.collect { |key| self[convert_key(key)] }
+#   end
+
+#   # Returns an array of the values at the specified indices, but also
+#   # raises an exception when one of the keys can't be found.
+#   #
+#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
+#   #   hash[:a] = 'x'
+#   #   hash[:b] = 'y'
+#   #   hash.fetch_values('a', 'b') # => ["x", "y"]
+#   #   hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
+#   #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
+#   def fetch_values(*indices, &block)
+#     indices.collect { |key| fetch(key, &block) }
+#   end if Hash.method_defined?(:fetch_values)
+
+#   # Returns a shallow copy of the hash.
+#   #
+#   #   hash = ActiveSupport::HashWithIndifferentAccess.new({ a: { b: 'b' } })
+#   #   dup  = hash.dup
+#   #   dup[:a][:c] = 'c'
+#   #
+#   #   hash[:a][:c] # => nil
+#   #   dup[:a][:c]  # => "c"
+#   def dup
+#     self.class.new(self).tap do |new_hash|
+#       set_defaults(new_hash)
+#     end
+#   end
+
+#   # This method has the same semantics of +update+, except it does not
+#   # modify the receiver but rather returns a new hash with indifferent
+#   # access with the result of the merge.
+#   def merge(hash, &block)
+#     dup.update(hash, &block)
+#   end
+
+#   # Like +merge+ but the other way around: Merges the receiver into the
+#   # argument and returns a new hash with indifferent access as result:
+#   #
+#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
+#   #   hash['a'] = nil
+#   #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
+#   def reverse_merge(other_hash)
+#     super(self.class.new(other_hash))
+#   end
+#   alias_method :with_defaults, :reverse_merge
+
+#   # Same semantics as +reverse_merge+ but modifies the receiver in-place.
+#   def reverse_merge!(other_hash)
+#     replace(reverse_merge(other_hash))
+#   end
+#   alias_method :with_defaults!, :reverse_merge!
+
+#   # Replaces the contents of this hash with other_hash.
+#   #
+#   #   h = { "a" => 100, "b" => 200 }
+#   #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
+#   def replace(other_hash)
+#     super(self.class.new(other_hash))
+#   end
+
+#   # Removes the specified key from the hash.
+#   def delete(key)
+#     super(convert_key(key))
+#   end
+
+#   def stringify_keys!; self end
+#   def deep_stringify_keys!; self end
+#   def stringify_keys; dup end
+#   def deep_stringify_keys; dup end
+#   # undef :symbolize_keys!
+#   # undef :deep_symbolize_keys!
+#   def symbolize_keys; to_hash.symbolize_keys! end
+#   def deep_symbolize_keys; to_hash.deep_symbolize_keys! end
+#   def to_options!; self end
+
+#   def select(*args, &block)
+#     return to_enum(:select) unless block_given?
+#     dup.tap { |hash| hash.select!(*args, &block) }
+#   end
+
+#   def reject(*args, &block)
+#     return to_enum(:reject) unless block_given?
+#     dup.tap { |hash| hash.reject!(*args, &block) }
+#   end
+
+#   def transform_values(*args, &block)
+#     return to_enum(:transform_values) unless block_given?
+#     dup.tap { |hash| hash.transform_values!(*args, &block) }
+#   end
+
+#   def compact
+#     dup.tap(&:compact!)
+#   end
+
+#   # Convert to a regular hash with string keys.
+#   def to_hash
+#     _new_hash = Hash.new
+#     set_defaults(_new_hash)
+
+#     each do |key, value|
+#       _new_hash[key] = convert_value(value, for: :to_hash)
+#     end
+#     _new_hash
+#   end
+
+#   private
+#     def convert_key(key) # :doc:
+#       key.kind_of?(Symbol) ? key.to_s : key
+#     end
+
+#     def convert_value(value, options = {}) # :doc:
+#       if value.is_a? Hash
+#         if options[:for] == :to_hash
+#           value.to_hash
+#         else
+#           value.class == Hash ? HashWithIndifferentAccess.new(value) : value
+#         end
+#       elsif value.is_a?(Array)
+#         if options[:for] != :assignment || value.frozen?
+#           value = value.dup
+#         end
+#         value.map! { |e| convert_value(e, options) }
+#       else
+#         value
+#       end
+#     end
+
+#     def set_defaults(target) # :doc:
+#       if default_proc
+#         target.default_proc = default_proc.dup
+#       else
+#         target.default = default
+#       end
+#     end
+# end
+

data/lib/common/method_attr.rb

@@ -0,0 +1,69 @@
+# class Foo
+#   method_attr :name
+#   method_attr :param do |field, type=String, opts={}|
+#     opts[:name] = field
+#     opts[:type] ||= String
+#     opts
+#   end
+
+#   name "Test method desc"
+#   param :email, :email
+#   def test
+#   end
+# end
+
+# ap Foo.method_attr
+# {
+#   "test": {
+#     "name": [
+#       "Test method desc"
+#     ],
+#     "param": [
+#       {
+#         "name": "email",
+#         "type": "String"
+#       }
+#     ]
+#   }
+# }
+
+module MethodAttributes
+  extend self
+
+  @@G_OPTS = {}
+  @@M_OPTS = {}
+
+  def define klass, param_name, &block
+    klass.define_singleton_method(param_name) do |*args|
+      @@M_OPTS[param_name] ||= []
+      @@M_OPTS[param_name].push block ? block.call(*args) : args[0]
+    end
+
+    klass.define_singleton_method(:method_added) do |name|
+      return unless @@M_OPTS.keys.first
+
+      @@G_OPTS[to_s] ||= {}
+      @@G_OPTS[to_s][name] = @@M_OPTS.dup
+      @@M_OPTS.clear
+    end
+  end
+
+  def get klass, method_name=nil
+    return @@G_OPTS[klass.to_s] unless method_name
+
+    klass.ancestors.map(&:to_s).each do |a_klass|
+      v = @@G_OPTS[a_klass][method_name]
+      return v if v
+    end
+  end
+end
+
+###
+
+class Object
+  def method_attr name=nil, &block
+    return MethodAttributes.get(self).or({}) if name.nil?
+
+    MethodAttributes.define self, name, &block
+  end
+end

data/lib/lux/api/api.rb

@@ -10,9 +10,9 @@
 # 503 Service Unavailable
 
 class Lux::Api
+  attr_accessor :message, :response
 
   BeforeAndAfter.define self, :before, :after
-
   Lux::RescueFrom.define(self)
 
   class << self
@@ -60,54 +60,55 @@ class Lux::Api
 
       klass.new.call(action.to_sym, params)
     end
-
   end
 
-  def call(action, params={})
-    @@rescue_from_ivar.call do
-      rescued_call(action, params)
-      BeforeAndAfter.execute(self, :after)
-    end
+  ###
 
-    @response
+  def call action, params={}
+    @@rescue_from_ivar.call(self) { rescued_call action, params }
+
+    BeforeAndAfter.execute(self, :after)
+
+    response.render
   end
 
   # internal method for running actions
   # UserApi.new.call(:login, { email:'', pass:'' })
-  def rescued_call(action, params={})
+  def rescued_call action, params={}
     raise ForbidenError, "Protected action call" if [:call, :rescued_call, :params, :error].index action
     raise NotFoundError, "Action #{action} not found in #{self.class.to_s}" unless respond_to? action
 
-    @response = {}
-    @message  = nil
-    @params   = params
+    @response   = Lux::Api::Response.new
+    @params     = params
     @class_name = self.class.to_s.sub(/Api$/,'')
 
     # load default object
     if @params[:_id]
       eval "@object = @#{@class_name.underscore} = #{@class_name}[@params[:_id].to_i]"
       @params.delete(:_id)
-      @response[:path] = @object.path rescue nil if @object
+      @response.meta :path, @object.path if @object.respond_to?(:path)
     end
 
+    check_params_and_mock_instance_variables action
+    return if response.errors?
+
     # execte api call and verify params if possible
     BeforeAndAfter.execute(self, :before)
 
-    return unless check_params_and_mock_instance_variables action
+    api_data = send action
 
-    api_data = send(action)
-    format_response!(api_data)
+    format_response! api_data
   end
 
   def params
     @params
   end
 
-  def error(what)
-    raise StandardError, what
+  def error what
+    raise Lux::Api::Error.new(what)
   end
 
-  def format_response!(api_data=nil)
+  def format_response! api_data=nil
     if api_data
       # api_data = instance_eval(&res) if api_data.kind_of?(Proc)
       api_data = api_data.all.map{ |el| el.attributes } if api_data.class.name == 'ActiveRecord::Relation'
@@ -123,27 +124,25 @@ class Lux::Api
         api_data = api_data.attributes.reject{ |f| ['updated_by', 'updated_at', 'created_by', 'created_at'].index(f) }
       end
 
-      @response[:data] = api_data
-      @response[:message] = @message.to_s unless @message.nil?
-      # @response[:message] = api_data if !@message && api_data.kind_of?(String)
+      response.data = api_data
 
       # if we define _redirect then we will be redirected to exact page
       # useful for file uploads
       if @params[:_redirect]
-        if @response[:error]
-          Lux.page.flash.error @response[:error]
-        elsif @response[:message]
+        if response.errors
+          Lux.page.flash.error @response[:errors].join(', ')
+        elsif response.message
           Lux.page.flash.info @response[:message]
         end
         Lux.page.redirect(@params[:_redirect])
       end
     end
 
-    ap @response if Lux.config.debug_api_response
+    ap response.render if Lux.config.log_to_stdout
   end
 
   def message(what)
-    @message = what
+    response.message = what
   end
 
 end

data/lib/lux/api/lib/application_api.rb

@@ -1,15 +1,34 @@
 class ApplicationApi < Lux::Api
 
+  method_attr :user do |value|
+    raise 'Method attr :%s for :user is not allowed value' % value unless [:user, :guest, :admin].include?(value)
+    value
+  end
+
+  before do
+    if params[:api_key]
+      User.current  = User.find_by api_token: params[:api_key]
+      error 'Invalid api key' unless User.current
+    end
+
+    case @method_attr[:user].try(:first)
+      when :user
+        error 'Dostupno registriranim korinsicima' unless User.current
+      when :admin
+        error 'Samo za ADMIN usere' unless User.current.try(:is_admin)
+    end
+  end
+
   # called at the end of response
-  def decorate_response!(data=nil)
-    @response = data if data
+  def decorate_response!
     if Lux.page
-      @response[:ip] = Lux.page.request.ip
-      @response[:user] = Lux.page.var.user ? Lux.page.var.user.email : nil
-      @response[:http_status] = Lux.page.status(200)
-      @response[:error] ||= 'Bad request' if Lux.page.status != 200
+      response.meta :ip, Lux.page.request.ip
+      response.meta :user, Lux.page.var.user ? Lux.page.var.user.email : nil
+      response.meta :http_status, Lux.page.status(200)
+      # response.error 'Bad request' if response.errors? && Lux.page.status != 200
     end
-    @response
+
+    response.render
   end
 
   def after

data/lib/lux/api/lib/doc_builder.rb

@@ -1,18 +1,19 @@
-class Lux::Api
-  class << self
-    # list all availabe actions in a class
-    def actions
-      instance_level_actions = UserApi.instance_methods - Object.instance_methods - [:sinatra, :instance_run, :params]
-      @@actions[self.to_s].keys + instance_level_actions
-    end
+# class Lux::Api
+#   class << self
+#     # list all availabe actions in a class
+#     def actions
+#       UserApi.instance_methods - UserApi.ancestors[1].instance_methods
+#       instance_level_actions = UserApi.instance_methods - Object.instance_methods - [:sinatra, :instance_run, :params]
+#       @@actions[self.to_s].keys + instance_level_actions
+#     end
 
-    # get details about action
-    def action_details(name)
-      @@actions[self.to_s][name] ||= {}
-      details = @@actions[self.to_s][name].reject { |key| [:proc].index(key) }
-      details[:name] ||= "#{name.to_s} action"
-      details[:action] ||= name
-      details.h
-    end
-  end
-end
+#     # get details about action
+#     def action_details(name)
+#       @@actions[self.to_s][name] ||= {}
+#       details = @@actions[self.to_s][name].reject { |key| [:proc].index(key) }
+#       details[:name] ||= "#{name.to_s} action"
+#       details[:action] ||= name
+#       details.h
+#     end
+#   end
+# end