wire-framework 0.1.4.26 → 0.1.5

data/README.md

@@ -4,3 +4,19 @@ Wire is a DSL and Rack interface for quickly building web applications, without
 # Documentation
 
 [Wire RubyDoc](http://www.rubydoc.info/github/DataDrake/Wire)
+
+## License
+
+Copyright 2017 Bryan T. Meyers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/lib/app.rb

@@ -1,24 +1,43 @@
+##
+# Copyright 2017 Bryan T. Meyers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+#	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#	See the License for the specific language governing permissions and
+#	limitations under the License.
+##
+
+require_relative 'closet/config'
+
 module Wire
-	# App is a DSL function for mapping sub-URI to Wire::App(s)
-	# @author Bryan T. Meyers
-	module App
+  # App is a a REST endpoint for a Wire service
+  # @author Bryan T. Meyers
+  module App
+
+    # Callback for handling configs
+    # @param [Hash] conf the raw configuration
+    # @return [Hash] post-processed configuration
+    def self.configure(conf)
+      conf['type'] = Object.const_get(conf['type'])
+      if conf['type'].respond_to? :configure
+        conf = conf['type'].configure(conf)
+      end
+      conf
+    end
 
-		# Setup an App
-		# @param [String] base_uri the sub-URI
-		# @param [Module] type the Wire::App
-		# @param [Proc] block for configuring this App
-		# @return [void]
-		def app(base_uri, type, &block)
-			$current_uri    = base_uri
-			$apps[base_uri] = { type: type, resources: {} }
-			$current_app    = $apps[base_uri]
-			if ENV['RACK_ENV'].eql? 'development'
-				$stderr.puts "Starting App at: /#{base_uri}"
-				$stderr.puts 'Setting up resources...'
-			end
-			Docile.dsl_eval(type, &block)
-		end
-	end
+    # Read all of the configs in './configs/apps'
+    # @return [void]
+    def self.read_configs
+      $wire_apps = Wire::Config.read_config_dir('config/apps', method(:configure))
+    end
+  end
 end
 
 require_relative 'app/cache'

data/lib/app/cache.rb

@@ -1,96 +1,105 @@
-require_relative '../app'
-require_relative '../closet/resource'
-require_relative '../app/render'
+##
+# Copyright 2017 Bryan T. Meyers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+#	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#	See the License for the specific language governing permissions and
+#	limitations under the License.
+##
 
 require 'lmdb'
 
 module Cache
-	module Memory
-		include Wire::App
-		include Wire::Resource
-		extend Render
+  module Memory
 
-		$cache = {}
+    $cache = {}
 
-		def self.update_cached(context)
-			uri = context.uri.join('/')
-			all = context.uri[0..2].join('/')
-			env = $cache[context.app[:remote_uri]]
-			db = env.database
-			if context.uri[3]
-				result = forward(:read,context)
-			else
-				result = forward(:readAll,context)
-			end
-			if result[0] == 200
-				env.transaction do
-					if context.action == :delete
-						if db[uri]
-							db.delete(uri)
-						end
-					else
-						db[uri] = result[2]
-					end
-				end
-			end
-			if [:create,:update,:delete].include? context.action
-				thing = forward(:readAll,context)
-				if thing[0] == 200
-					env.transaction do
-						db[all] = thing[2]
-					end
-				end
-			end
-			result
-		end
+    def self.update_cached(context)
+      uri = context.uri.join('/')
+      all = context.uri[0..2].join('/')
+      env = $cache[context.config['remote']]
+      db  = env.database
+      if context.id
+        result = context.forward(:read)
+      else
+        result = context.forward(:readAll)
+      end
+      if result[0] == 200
+        env.transaction do
+          if context.action == :delete
+            if db[uri]
+              db.delete(uri)
+            end
+          else
+            db[uri] = result[2]
+          end
+        end
+      end
+      if [:create, :update, :delete].include? context.action
+        thing = context.forward(:readAll)
+        if thing[0] == 200
+          env.transaction do
+            db[all] = thing[2]
+          end
+        end
+      end
+      result
+    end
 
-		def self.get_cached(context)
-			uri = context.uri.join('/')
-			env = $cache[context.app[:remote_uri]]
-			db = env.database
-			result = nil
-			env.transaction do
-				result = db[uri]
-			end
-			result
-		end
+    def self.get_cached(context)
+      uri    = context.uri.join('/')
+      env    = $cache[context.config['remote']]
+      db     = env.database
+      result = nil
+      env.transaction do
+        result = db[uri]
+      end
+      result
+    end
 
-		def self.purge_cached(context)
-			uri = context.uri.join('/')
-			env = $cache[context.app[:remote_uri]]
-			db = env.database
-			result = 200
-			env.transaction do
-				begin
-					db.delete(uri)
-				rescue
-					result = 404
-				end
-			end
-			result
-		end
+    def self.purge_cached(context)
+      uri    = context.uri.join('/')
+      env    = $cache[context.config['remote']]
+      db     = env.database
+      result = 200
+      env.transaction do
+        begin
+          db.delete(uri)
+        rescue
+          result = 404
+        end
+      end
+      result
+    end
 
-		def self.invoke(actions,context)
+    def self.invoke(actions, context)
 
-			# Create Cache if not set up
-			unless $cache[context.app[:remote_uri]]
-				$cache[context.app[:remote_uri]] = LMDB.new("/tmp/cache/#{context.app[:remote_uri]}", mapsize: 2**30)
-			end
+      # Create Cache if not set up
+      unless $cache[context.config['remote']]
+        $cache[context.config['remote']] = LMDB.new("/tmp/cache/#{context.config['remote']}", mapsize: 2**30)
+      end
 
-			case context.action
-				when :create,:update,:delete
-					result = forward(context.action,context)
-					update_cached(context) # write aware
-					result
-				when :read,:readAll
-					cached = get_cached(context)
-					unless cached
-						cached = update_cached(context)
-					end
-					cached
-				else
-					403
-			end
-		end
-	end
+      case context.action
+        when :create, :update, :delete
+          result = context.forward(context.action)
+          update_cached(context) # write aware
+          result
+        when :read, :readAll
+          cached = get_cached(context)
+          unless cached
+            cached = update_cached(context)
+          end
+          cached
+        else
+          403
+      end
+    end
+  end
 end

data/lib/app/db.rb

@@ -1,209 +1,208 @@
-require 'data_objects'
-require 'dm-serializer/to_json'
-require_relative '../app'
-require_relative '../closet/resource'
+##
+# Copyright 2017 Bryan T. Meyers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+#	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#	See the License for the specific language governing permissions and
+#	limitations under the License.
+##
+
+require 'base64'
+require 'sequel'
 
 # DB is a Wire::App for generating REST wrappers for DataMapper
 # @author Bryan T. Meyers
 module DB
-	include Wire::App
-	include Wire::Resource
 
-	# Setup a DB connection
-	# @param [Symbol] namespace namespace used by DataMapper for Repositories
-	# @param [String] location connection string (e.g. mysql://localhost/Foo)
-	# @return [void]
-	def self.db(namespace, location)
-		$current_app[:db_namespace] = namespace
-		$current_app[:db_location]  = location
-		DataMapper.setup(namespace, location)
-	end
+  # DB-specific configuration
+  # @param [Hash] conf the existing configuration
+  # @return [Hash] post-processed configuration
+  def self.configure(conf)
+    Sequel.connect($environment['db'][conf['db']])
+    conf['models'].each do |m|
+      conf['models'][m] = Object.const_get(m)
+    end
+    conf
+  end
+
+  # Add a new object to the DB table
+  # @param [Hash] context the context for this request
+  # @return [Response] a valid Rack response triplet, or status code
+  def self.do_create(context)
+    model = context.config['models'][context.resource]
+    return 404 unless model
+
+    file = context.json[:file]
+    if file
+      if file[:mime].eql? 'text/csv'
+        file[:content].match(/.*base64,(.*)/) do
+          csv     = Base64.decode64($1)
+          columns = []
+          errors  = []
+          csv.split("\n").each_with_index do |v, i|
+            if i == 0
+              columns = v.split(/(?<!\[),(?!=\])/)
+              columns.map! { |c| c.delete('"').to_sym }
+            else
+              values = v.split(',')
+              values.map! do |c|
+                c.include?(';') ? c.split(';') : c
+              end
+              hash = {}
+              columns.each_with_index do |c, j|
+                if values[j].is_a? String
+                  values[j].delete!('"')
+                end
+                hash[c] = values[j]
+              end
+              m = model.find_or_create(hash)
+              unless m.modified?
+                errors << "row: #{i} errors: #{m.errors.delete("\n")}"
+              end
+            end
+          end
+          if errors.length > 0
+            [400, nil, errors]
+          else
+            200
+          end
+        end
+      else
+        415
+      end
+    else
+      #TODO user_id needs to happen in the context
+      if model.respond_to? :updated_by_id
+        context.json[:updated_by_id] = context.user
+      end
+      if model.respond_to? :created_by_id
+        context.json[:created_by_id] = context.user
+      end
+      begin
+        instance = model.create(context.json)
+        instance.save
+        if instance.modified?
+          200
+        else
+          errors = ''
+          instance.errors.each { |e| errors += "#{e.to_s}\n" }
+          [504, {}, errors]
+        end
+      rescue => e
+        [500, {}, e.message]
+      end
+    end
+  end
 
-	# Map a DataMapper::Model to a sub-URI
-	# @param [String] resource the sub-URI
-	# @param [Class] model the DataMapper model
-	# @return [void]
-	def self.model(resource, model)
-		$current_app[:resources][resource] = { model: model }
-	end
+  # Get all objects from the DB table
+  # @param [Hash] context the context for this request
+  # @return [Response] all objects, or status code
+  def self.do_read_all(context)
+    return 404 unless context.resource
+    model = context.config['models'][context.resource]
+    if model
+      hash = '[ '
+      model.each do |e|
+        hash << (e.to_json)
+        hash << ','
+      end
+      hash = hash[0...-1]
+      hash << ']'
+      [200, {}, hash]
+    else
+      404
+    end
+  end
 
-	# Add a new object to the DB table
-	# @param [Hash] context the context for this request
-	# @return [Response] a valid Rack response triplet, or status code
-	def self.do_create(context)
-		return 404 unless context.resource
-		model = context.resource[:model]
-		if model
-			file = context.json[:file]
-			if file
-				if file[:mime].eql? 'text/csv'
-					file[:content].match(/.*base64,(.*)/) do
-						csv     = Base64.decode64($1)
-						columns = []
-						errors  = []
-						csv.split("\n").each_with_index do |v, i|
-							if i == 0
-								columns = v.split(/(?<!\[),(?!=\])/)
-								columns.map! { |c| c.delete('"').to_sym }
-							else
-								values = v.split(',')
-								values.map! do |c|
-									c.include?(';') ? c.split(';') : c
-								end
-								hash = {}
-								columns.each_with_index do |c, j|
-									if values[j].is_a? String
-										values[j].delete!('"')
-									end
-									hash[c] = values[j]
-								end
-								m = model.first_or_create(hash)
-								unless m.saved?
-									errors << "row: #{i} errors: #{m.errors.delete("\n")}"
-								end
-							end
-						end
-						if errors.length > 0
-							[400, nil, errors]
-						else
-							200
-						end
-					end
-				else
-					415
-				end
-			else
-				if model.instance_methods.include?(:updated_by)
-					context.json[:updated_by] = context.user
-				end
-				if model.instance_methods.include?(:created_by)
-					context.json[:created_by] = context.user
-				end
-				begin
-					instance = model.create(context.json)
-					instance.save
-					if instance.saved?
-						200
-					else
-						errors = ''
-						instance.errors.each { |e| errors += "#{e.to_s}\n"}
-						[504,{}, errors]
-					end
-				rescue => e
-					case e.class
-						when DataObjects::IntegrityError.class
-							[400,{},e.message]
-						else
-							[500,{},e.message]
-					end
-				end
-			end
-		else
-			404
-		end
-	end
+  # Get a specific object from the DB table
+  # @param [Hash] context the context for this request
+  # @return [Response] an object, or status code
+  def self.do_read(context)
+    model = context.config['models'][context.resource]
+    return 404 unless model
+    id = context.id
+    if id.eql?('new') or id.eql? 'upload'
+      return '{}'
+    end
+    if model
+      object = model[id]
+      if object
+        return [200, {}, object.to_json]
+      end
+    end
+    [404, {}, []]
+  end
 
-	# Get all objects from the DB table
-	# @param [Hash] context the context for this request
-	# @return [Response] all objects, or status code
-	def self.do_read_all(context)
-		return 404 unless context.resource
-		model = context.resource[:model]
-		if model
-			hash = '[ '
-			model.all.each do |e|
-				hash << (e.to_json)
-				if e != model.all.last
-					hash << ','
-				end
-			end
-			hash << ']'
-			[200,{},hash]
-		else
-			404
-		end
-	end
+  # Update a specific object in the DB table
+  # @param [Hash] context the context for this request
+  # @return [Response] an object, or status code
+  def self.do_update(context)
+    model = context.config['models'][context.resource]
+    return 404 unless model
 
-	# Get a specific object from the DB table
-	# @param [Hash] context the context for this request
-	# @return [Response] an object, or status code
-	def self.do_read(context)
-		return 404 unless context.resource
-		model = context.resource[:model]
-		id    = context.uri[3]
-		if id.eql?('new') or id.eql? 'upload'
-			return '{}'
-		end
-		if model
-			object = model.get(id)
-			if object
-				return [200,{},object.to_json]
-			end
-		end
-		[404,{},[]]
-	end
+    id = context.id
+    if model
+      if model.respond_to?(:updated_by_id)
+        context.json[:updated_by_id] = context.user
+      end
+      instance = model[id]
+      instance.update(context.json)
+    else
+      404
+    end
+  end
 
-	# Update a specific object in the DB table
-	# @param [Hash] context the context for this request
-	# @return [Response] an object, or status code
-	def self.do_update(context)
-		return 404 unless context.resource
-		model = context.resource[:model]
-		id    = context.uri[3]
-		if model
-			if model.respond_to?(:updated_by)
-				context.json[:updated_by] = context.user
-			end
-			instance = model.get(id)
-			instance.update(context.json)
-		else
-			404
-		end
-	end
+  # Remove a specific object from the DB table
+  # @param [Hash] context the context for this request
+  # @return [Response] an object, or status code
+  def self.do_delete(context)
+    model = context.config['models'][context.resource]
+    return 404 unless model
 
-	# Remove a specific object from the DB table
-	# @param [Hash] context the context for this request
-	# @return [Response] an object, or status code
-	def self.do_delete(context)
-		return 404 unless context.resource
-		model = context.resource[:model]
-		id    = context.uri[3]
-		if model
-			instance = model.get(id)
-			if instance
-				if instance.destroy
-					200
-				else
-					[500,{},'Failed to delete instance']
-				end
-			else
-				404
-			end
-		else
-			404
-		end
-	end
+    id = context.id
+    if model
+      instance = model[id]
+      if instance
+        if instance.destroy
+          200
+        else
+          [500, {}, 'Failed to delete instance']
+        end
+      else
+        404
+      end
+    else
+      404
+    end
+  end
 
-	# Proxy method used when routing
-	# @param [Array] actions the allowed actions for this URI
-	# @param [Hash] context the context for this request
-	# @return [Response] a Rack Response triplet, or status code
-	def self.invoke(actions, context)
-		case context.action
-			when :create
-				do_create(context)
-			when :read
-				if context.uri[3]
-					do_read(context)
-				else
-					do_read_all(context)
-				end
-			when :update
-				do_update(context)
-			when :delete
-				do_delete(context)
-			else
-				403
-		end
-	end
+  # Proxy method used when routing
+  # @param [Array] actions the allowed actions for this URI
+  # @param [Hash] context the context for this request
+  # @return [Response] a Rack Response triplet, or status code
+  def self.invoke(actions, context)
+    case context.action
+      when :create
+        do_create(context)
+      when :read
+        if context.uri[3]
+          do_read(context)
+        else
+          do_read_all(context)
+        end
+      when :update
+        do_update(context)
+      when :delete
+        do_delete(context)
+      else
+        403
+    end
+  end
 end