femto 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a93cec4c12adeba287bb64b1d4a48ce9efcd0ab6
+  data.tar.gz: 92011f12f45c0e25e8ecb410b1d08cf388acde05
+SHA512:
+  metadata.gz: 05f1be7d809186c663ab14b379a19c24e4e61b07444054efdf201cc9e2b5238f1d91e36cbd909a23aac7be8d6d5f5ec345e7848360965968534a8b2eceacb861
+  data.tar.gz: 6643c3a350cd4b85241a575d345f470af049274c1264278c052eb4b8c4b07d14a4bb224a0244c8f1329394eefa1881d6619fd3d1a85f07523b7840d98d15fc8f

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# RubyMine
+.idea/
+
+# Random commands
+build.command

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in femto.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 August
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,126 @@
+# Femto
+
+A tiny web framework.
+
+## Installation
+
+Add this to your Gemfile:
+```ruby
+gem 'femto', github: 'augustt198/femto'
+```
+
+## Usage
+
+First, setup your views/templates folder:
+
+```ruby
+# For example
+@templates_dir = File.join __dir__, 'views'
+```
+
+Handle requests by passing a path and block to a HTTP verb method.
+
+```ruby
+get '/' do
+    render 'home'
+end
+
+# The 'view' option automatically renders a template!
+get '/about', view: 'about_page' do
+    # You can create variables to use in your views
+    @copyright_date = '2014'
+end
+```
+
+The render method tries to render a view if a String is passed, but other
+content types can be rendered:
+```ruby
+get '/status' do
+    render json: {system_status: 'good'}
+end
+```
+
+### Models
+To use models, first you need specify the model adapter. `MongoAdapter` is the only model adapter currently:
+
+```ruby
+# Connect to database
+Femto::Model::MongoAdapter.connect host: 'localhost', port: 27107, db: 'test'
+Femto::Model.adapter = Femto::Model::MongoAdapter
+```
+
+Add models with the `model` method, for example:
+```ruby
+model :user do |m|
+    m.field :username
+    m.field :password
+    m.field :created_at
+end
+```
+
+This will create the class `User`. Use the model class to find, update, and insert:
+```ruby
+user = User.new(username: 'foo', password: 'bar')
+user.save # Saves to database or updates if it already exists
+User.find # => [#<User:0x007fcb5bef8840>]
+```
+
+The parameter passed to the block in the `model` method is the `ModelCreator`.
+You can add your own methods to the model:
+```ruby
+model :user do |m|
+    m.set_method('confirmed?') { false }
+end
+```
+
+You can also change the storage name of the model. The default is the model name + "s".
+```ruby
+model :category do |m|
+    m.storage :categories
+end
+```
+
+### Layouts
+
+You can define application-wide views by using the layout method.
+```ruby
+layout view: 'layout' do
+    # This block would be called every page load
+end
+```
+
+An example layout view:
+```html
+<div class="container">
+    <!-- the yield keyword renders the current view -->
+    <%= yield %>
+</div>
+```
+
+### Custom Renderers
+Femto comes with the renderers `:json`, `:pretty_json`, and `:text`, but you can easily
+add custom renderers.
+
+
+For instance:
+```ruby
+Femto::Renderer.renderer :custom do |content|
+    ['text/plain', content.to_s.reverse]
+end
+```
+
+All renderers should return an array with the `Content-Type` at position `[0]`, and the actual content
+at position `[1]`.
+
+### [App Example](https://github.com/augustt198/femto/tree/master/example)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+_femto_ is the SI prefix for 10<sup>-15</sup>

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/example/App.rb

@@ -0,0 +1,44 @@
+require 'femto'
+
+class App < Femto::Base
+
+  @template_dir = File.join(__dir__, 'views')
+
+  layout view: 'layout'
+
+  # Set up database
+  Femto::Model::MongoAdapter.connect host: 'localhost', port: 27017, db: 'testing'
+  Femto::Model.adapter = Femto::Model::MongoAdapter
+
+  model :user do |m|
+    m.field :password
+    m.field :username
+    m.field :created_at
+    m.set_method('confirmed?') { 42 }
+  end
+
+  get '/', view: 'home' do
+    @time = Time.now
+    @number = rand 1000
+  end
+
+  get '/json' do
+    json = {features: {json_rendering: true}}
+    render pretty_json: json
+  end
+
+  get '/new_user' do
+    user = User.new
+    user.username = 'username_goes_here'
+    user.password = 'password_goes_here'
+    render text: 'User created'
+  end
+
+  get '/list_users' do
+    users = User.find
+    results = []
+    users.each { |u| results << u.inspect }
+    render pretty_json: {users: results}
+  end
+
+end

data/example/config.ru

@@ -0,0 +1,2 @@
+require './app'
+run App

data/example/views/home.haml

@@ -0,0 +1,2 @@
+%h1= 'The current time is ' + @time.to_s
+%h2= 'Random number: ' + @number.to_s

data/example/views/layout.haml

@@ -0,0 +1,11 @@
+%head
+  %title Yet another web microframework!
+%body
+  .container
+    = yield
+
+:css
+  .container {
+      margin: 50px;
+      font-family: 'Helvetica Neue', 'Helvetica', sans-serif;
+  }

data/femto.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'femto/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "femto"
+  spec.version       = Femto::VERSION
+  spec.authors       = ["August"]
+  spec.email         = ["augustt198@gmail.com"]
+  spec.description   = %q{A tiny web framework}
+  spec.summary       = %q{A tiny web framework}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_dependency 'rack', '~> 1.4.5'
+  spec.add_dependency 'tilt', '~> 2.0.1'
+  spec.add_dependency 'haml', '~> 4.0.4'
+  spec.add_dependency 'mongo', '~> 1.10.0'
+  spec.add_dependency 'bson_ext', '~> 1.10.0'
+end

data/lib/femto.rb

@@ -0,0 +1,144 @@
+require 'femto/version'
+require 'femto/renderer'
+require 'femto/model'
+require 'tilt'
+require 'rack'
+require 'json'
+
+module Femto
+
+  class Base
+    class << self
+
+      attr_accessor :request, :response, :env, :routes, :template_dir,
+                    :render, :content_type, :layout, :layout_block
+
+      # set up methods
+      %w(get post patch put delete).each do |http_verb|
+        define_method http_verb do |path, options={}, &block|
+          set_route http_verb, path, options, block
+        end
+      end
+
+      def layout(options={}, &block)
+        if options[:template]
+          @layout = resolve_template options[:template]
+        elsif options[:view]
+          @layout = resolve_template options[:view]
+        end
+        @layout_block = block
+      end
+
+      def set_route(verb, path, options, block)
+        @routes = {} unless @routes
+        @routes[verb] = [] unless @routes[verb]
+        @routes[verb] << [path, options, block]
+      end
+
+      def handle_request
+        catch :stop do
+          verb = request.request_method.downcase
+          request_path = request.path_info
+          routes = @routes[verb]
+          if routes
+            routes.each do |group|
+              path = group[0]
+              options = group[1]
+              block = group[2]
+              if request_path == path
+                instance_eval(&block)
+                if options[:template]
+                  render options[:template]
+                elsif options[:view]
+                  render options[:view]
+                end
+                if @layout and @content_type == 'text/html'
+                  if @layout_block
+                    @layout_block.call
+                  end
+                  @render = render_template(@layout) { @render }
+                end
+                if @render == nil
+                  raise TemplateMissingException.new
+                end
+                response.write @render
+                response['Content-Type'] = content_type
+                return
+              end
+            end
+          end
+          stop
+        end
+      end
+
+      def render(options)
+        if options.is_a? Hash
+          pair = options.to_a[0]
+          type = pair[0]
+          content = pair[1]
+          render_pair = Femto::Renderer.render(type, content)
+          @content_type = render_pair[0]
+          @render = render_pair[1]
+        elsif options.is_a? String
+          @render = render_template(resolve_template(options))
+        end
+      end
+
+      def model(name, &block)
+        Femto::Model.create_model name.to_s, &block
+      end
+
+      def resolve_template(file)
+        Dir[File.join(@template_dir, file + '.*')][0]
+      end
+
+      def render_template(template, &block)
+        @content_type = 'text/html'
+        Tilt.new(template).render self, {}, &block
+      end
+
+      def stop
+        throw :stop
+      end
+
+      def builder
+        @builder = Rack::Builder.new unless @builder
+        @builder
+      end
+
+      def call(env)
+        dup.call! env
+      end
+
+      def call!(env)
+        env['PATH_INFO'] = '/' if env['PATH_INFO'].empty?
+        @request = Rack::Request.new env
+        @response = Rack::Response.new
+        @render = nil
+        @content_type = nil
+        @env = env
+        handle_request
+        @response.finish
+      end
+
+    end
+
+    class TemplateMissingException < Exception
+      def initialize
+        super 'No template to be rendered was found'
+      end
+    end
+
+  end
+
+  class RequestException < Exception
+    attr_reader :code
+    attr_reader :message
+    def initialize(code, msg)
+      super "#{code}: #{msg}"
+      @code = code
+      @message = msg
+    end
+  end
+
+end

data/lib/femto/model.rb

@@ -0,0 +1,143 @@
+require 'femto/model/mongo_adapter'
+
+module Femto
+
+  module Model
+
+    class << self
+      attr_accessor :adapter
+    end
+
+    def self.create_model(name, &block)
+      class_name = camelize name
+      begin
+        Object.const_get class_name
+        return # Class already exists
+      rescue NameError
+        # ignored
+      end
+      model_creator = ModelCreator.new
+      block.call model_creator
+
+      # Create class
+      model_class = Class.new &model_creator.class_opts
+      Object.const_set(class_name, model_class)
+
+      # Create accessors for attributes
+      model_creator.fields.each do |a|
+        model_class.module_eval { attr_accessor a }
+      end
+      model_class.module_eval { attr_accessor :id }
+
+      # Add custom methods
+      model_creator.custom_methods.each_pair do |method_name, method_block|
+        model_class.module_eval { define_method method_name, &method_block }
+      end
+
+      # Add model methods
+      model_class.define_singleton_method 'find' do |query={}|
+        Model.adapter.find(model_class, query)
+      end
+      model_class.define_singleton_method 'where' do |query={}|
+        Model.adapter.find(model_class, query)
+      end
+      model_class.define_singleton_method 'create' do |fields={}|
+        model = model_class.new fields
+        model.save
+        model
+      end
+      model_class.define_singleton_method 'all' do
+        model_class.find
+      end
+
+      model_class.module_eval do
+        define_method 'update' do
+          Model.adapter.update self
+        end
+
+        define_method 'save' do
+          Model.adapter.update self
+        end
+
+        define_method('remove') { Model.adapter.remove self }
+        define_method('delete') { Model.adapter.remove self }
+
+        define_method 'to_hash' do
+          result = {}
+          self.class.model_attrs[:fields].each do |f|
+            val = send f
+            result[f] = val if val
+          end
+          result
+        end
+
+        define_method 'initialize' do |fields={}|
+          fields.each_pair do |key, val|
+            next unless self.class.model_attrs[:fields].include? key
+            send key.to_s + '=', val
+          end
+        end
+      end
+
+      # Model attributes (fields, storage, etc...)
+      class << model_class
+        attr_accessor :model_attrs
+      end
+      storage = model_creator.storage_name ? model_creator.storage_name.to_s : name + 's'
+      model_class.model_attrs = {
+          fields: model_creator.fields,
+          storage_name: storage
+      }
+
+      # Create method for getting defined fields
+      model_class.define_singleton_method('fields') { model_creator.fields }
+    end
+
+    class ModelCreator
+      attr_accessor :fields
+      attr_accessor :defaults
+      attr_accessor :types
+      attr_accessor :class_opts
+      attr_accessor :custom_methods
+      attr_accessor :storage_name
+
+      def initialize
+        @fields = []
+        @defaults = {}
+        @types = {}
+        @custom_methods = {}
+      end
+
+      def field(name, options={})
+        return unless name
+        fields << name
+        if options[:default]
+          defaults[name]
+        end
+      end
+
+      def class_options(&block)
+        @class_opts = block
+      end
+
+      def set_method(name, &block)
+        custom_methods[name] = block
+      end
+
+      def storage(name)
+        @storage_name = name
+      end
+    end
+
+    # Taken from http://infovore.org/archives/2006/08/11/writing-your-own-camelizer-in-ruby/
+    def self.camelize(snake_case, first_upcase=true)
+      if first_upcase
+        snake_case.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      else
+        snake_case.first + camelize(snake_case)[1..-1]
+      end
+    end
+
+  end
+
+end

data/lib/femto/model/mongo_adapter.rb

@@ -0,0 +1,69 @@
+require 'mongo'
+
+module Femto
+  module Model
+    class MongoAdapter
+      class << self
+
+        attr_accessor :client
+        attr_accessor :db
+
+        def connect(options=nil)
+          if options
+            @client = Mongo::Connection.new(options[:host], options[:port])
+            @db = @client[options[:db]]
+          else
+            @client = Mongo::Connection.new
+            @db = @client['test']
+          end
+        end
+
+        def to_hash(model)
+          result = {}
+          model.class.model_attrs[:fields].each do |f|
+            var = model.send f
+            result[f] = var if var
+          end
+          result
+        end
+
+        def find(cls, query)
+          results = []
+          get_coll(cls).find(query).each do |res|
+            model = cls.new(symbolize_keys(res))
+            model.id = res['_id']
+            results << model
+          end
+          results
+        end
+
+        def update(model)
+          coll = get_coll model.class
+          if model.id
+            coll.update({:_id => model.id}, model.to_hash)
+          else
+            model.id = coll.insert model.to_hash
+          end
+        end
+
+        def remove(model)
+          coll = get_coll model.class
+          if model.id
+            coll.remove(:_id => model.id)
+          end
+        end
+
+        def get_coll(cls)
+          @db[cls.model_attrs[:storage_name]]
+        end
+
+        def symbolize_keys(hash)
+          hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/femto/renderer.rb

@@ -0,0 +1,32 @@
+require 'json'
+
+module Femto
+
+  module Renderer
+
+    @renderers = {}
+
+    def self.render(type, content)
+      renderer = @renderers[type]
+      raise RendererNotFoundException.new('No renderer for type ' + type.inspect) unless renderer
+      renderer.call content
+    end
+
+    def self.renderer(type, &block)
+      @renderers[type] = block
+    end
+
+    # Setup default renderers
+    renderer(:json) { |c| ['application/json', c.to_json] }
+    renderer(:pretty_json) { |c| ['application/json', JSON.pretty_generate(c)] }
+    renderer(:text) { |c| ['text/plain', c.to_s] }
+
+    class RendererNotFoundException < Exception
+      def initialize(reason)
+        super reason
+      end
+    end
+
+  end
+
+end

data/lib/femto/version.rb

@@ -0,0 +1,3 @@
+module Femto
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: femto
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- August
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.4
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+description: A tiny web framework
+email:
+- augustt198@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- example/App.rb
+- example/config.ru
+- example/views/home.haml
+- example/views/layout.haml
+- femto.gemspec
+- lib/femto.rb
+- lib/femto/model.rb
+- lib/femto/model/mongo_adapter.rb
+- lib/femto/renderer.rb
+- lib/femto/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0.rc.1
+signing_key: 
+specification_version: 4
+summary: A tiny web framework
+test_files: []