cubic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a588fe718db876392ee7fb498a236d57045b32e1
+  data.tar.gz: 6223844472a330f8db725c9cdf8d8f9e44e5d51e
+SHA512:
+  metadata.gz: 498d21669a59aebf9ec20cf52cb0bde1e1c2e0e9882fd92781e34e91bb52e802c584401d954e03320e065fff9103aae63ce24c02b0f0f78f411aace44f907ba7
+  data.tar.gz: ce24c69ee6c6ccb11902de0ff9f9eb23a3a53aaf1775158d02ceaf55066d1fdd3a714a4c8e513dce18172975ea80bdcce2f440aabf2a75c3be7b736d8cef3b3c

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'simplecov', :require => false, :group => :test
+gemspec

data/README.md

@@ -0,0 +1,141 @@
+# Cubic
+
+Cubic is a small framework built with a focus on quickly creating applications through a neat, easily readable file that defines the basic structure of you app.
+
+## Sitemap (Generator)
+---
+Cubic expects an application to be generated using a 'sitemap.rb' file. In general, you will place this file in the directory you would like to generate your application inside of, but you can also tell the Cubic to generate your application in a directory other than the one your sitemap currently resides in.
+Within the sitemap.rb file, you will design a basic structure for your application,
+then run that file with `ruby sitemap.rb` to generate it.
+
+Here is an example of how such a file might look.
+
+```ruby
+require 'cubic'
+
+Cubic.sitemap do
+
+  config do
+    root_path  File.expand_path('../', __FILE__)
+    html_type  'haml'
+    css_type   'css'
+  end
+
+  models do 
+    design(:user, {email: :string, password_digest: :string}).add('# comment')
+    design(:post, {title: :string, content: :string})
+  end
+
+  controllers do
+    design(:home, actions: [:index])
+    design(:user, actions: [:new])
+    design(:session, actions: [:new])
+    design(:post, actions: [:new, :show, :edit])
+  end
+end
+```
+
+Let's quickly run through the blocks within the sitemap file.
+
+### Config
+```ruby
+root_path  File.expand_path('../', __FILE__)
+```  
+The root_path options tells the generator where you would like the application to be generated.
+```ruby
+html_type  'haml'
+css_type   'css'
+```  
+html_type and css_type tell the generator what template engine and preprocessor language you would files to be generated with.
+
+### Models
+The models block does exactly what you think; it generates your models!
+```ruby
+design(:post, {title: :string, content: :string})
+```  
+The first argument passed to the design
+method tells the generator what you would like to name your model. The next argument, a hash,
+is what will be passed to the migrations generator to create a database table for your model.
+
+You can call `add()` on the design method to add code directly into the model to be generated.
+Every argument is a new line, so something like:
+```ruby
+add('one_to_many :authorships', 'many_to_many :books')
+```
+generates the following
+
+```ruby
+class SomeModel < Sequel::Model
+one_to_many :authorships
+many_to_many :books
+
+end
+```
+
+### Controllers
+```ruby
+design(:post, actions: [:new, :show, :edit])
+```  
+Generating a controller is similar to model. The first argument given is the name of the controller,
+then you add your actions. The array associated with the action key is what will be used to create the necessary
+views for your controller, but also the routes held within the controller. If that is kind of confusing,
+the routing section below will explain. 
+
+That is about as deep as the generator goes for now, so lets move on.
+
+## Defining routes
+---
+In a Cubic application, you define your routes within the controllers you have generated. You will notice each 
+controller has a namespace block, which all of your routes are defined within. It's okay
+to create a route outside of this block, but to keep things easy to find, all routes are defined within it by default.
+
+Below you can see an example of a normal Cubic controller. All http methods you see defined within the
+namespace block are the ones given to you at the moment.
+
+```ruby 
+class HomeController < Cubic::CubicController
+  namespace 'home' do
+
+    get 'index' do
+    end
+    
+    post 'index' do
+    end
+    
+    put 'index' do
+    end
+    
+    destroy 'index' do
+    end
+  end
+end
+```
+
+Your route can have variables, which will be translated into a params hash.
+
+```ruby 
+get 'post/:title' do
+
+end
+```
+
+Then you could get the value passed in the url from within the controller or view
+using the following:
+
+```ruby 
+params[:title]
+```
+
+## ORM
+---
+Cubic uses Sequel as its ORM. To learn more about Sequel, read the documentation here: https://github.com/jeremyevans/sequel
+
+## Differences Between Environments
+---
+As of now, Cubic's only major difference between Development and Production is the reloading of controller actions.
+Because controller actions in Cubic are also routes, they must reloaded everytime a new call is made, which also means
+any changes you make to a route also resets.
+
+## License
+---
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/cubic.rb

@@ -0,0 +1,29 @@
+require 'rack'
+require 'haml'
+require 'erb'
+
+require 'cubic/version'
+require 'cubic/core_extensions'
+require 'cubic/engine'
+require 'cubic/application'
+require 'cubic/render'
+require 'cubic/generator'
+require 'cubic/router'
+require 'cubic/response'
+
+require 'cubic/middleware/static'
+
+# Cubic is a small framework built on the idea of quick generation using templates.
+module Cubic
+  class << self
+
+    # First method to be called in the generation process.
+    def sitemap(&block)
+      Generator.run(&block)
+    end
+
+    def application
+      @app ||= Application
+    end
+  end
+end

data/lib/cubic/application.rb

@@ -0,0 +1,61 @@
+require 'cubic/application/logable'
+require 'cubic/application/configurator'
+require 'cubic/application/controller'
+
+module Cubic
+  # A cubic application inherits from the Application
+  # class, allowing it to change things such as
+  # configuration options.
+  class Application < Engine
+    class << self
+
+      # Requires all files from the generated application
+      # during startup.
+      def load_app
+        start_load if load_acceptable?
+      end
+
+      # Allows configuration options to be set within
+      # the config/application.rb file.
+      def config
+        Configurator
+      end
+
+      private
+
+      def load_acceptable?
+        !run_before? || development? ? has_run : false
+      end
+
+      def start_load
+        prime_app
+        Dir.glob(required_files).each { |f| load f }
+      end
+
+      def run_before?
+        @run_before ||= false
+      end
+
+      def has_run
+        @run_before = true
+      end
+
+      # Remove routes
+      def prime_app
+        Router.routes.clear
+      end
+
+      def development?
+        ENV['name'] == 'development'
+      end
+
+      def required_files
+        ctrls = File.join(config.root_dir, %w(app controllers *_controller.rb))
+        lib_files = File.join(config.root_dir, %w(lib ** *))
+        models = File.join(config.root_dir, %w(app models *.rb))
+
+        [ctrls, lib_files, models]
+      end
+    end
+  end
+end

data/lib/cubic/application/configurator.rb

@@ -0,0 +1,16 @@
+module Cubic
+  # Configuration stores details given during startup.
+  class Configurator
+    class << self
+      attr_accessor :template_engine
+
+      def design
+        yield self
+      end
+
+      def root_dir
+        APP_PATH
+      end
+    end
+  end
+end

data/lib/cubic/application/controller.rb

@@ -0,0 +1,48 @@
+module Cubic
+  # All classes generated by Cubic inherit from CubicController
+  class CubicController
+    extend Logable
+
+    class << self
+      attr_accessor :namespace
+  
+      # Allows for namespacing within controllers who inherit
+      # from CubicController
+      def namespace(name, &b)
+        @namespace = name
+        b.call
+      ensure
+        @namespace = nil
+      end
+      
+      def get(url, &block)
+        namespace_url(url) if @namespace
+        url[0] == '/' ? url : url.prepend('/')
+        route_setter('GET', url, block)
+      end
+
+      def post(url, &block)
+        namespace_url(url) if @namespace
+        route_setter('POST', url, block)
+      end
+
+      def put(url, &block)
+        namespace_url(url) if @namespace
+        route_setter('PUT', url, block)
+      end
+
+      def delete(url, &block)
+        namespace_url(url) if @namespace
+        route_setter('DELETE', url, block)
+      end
+
+      def route_setter(request_method, url, block)
+        Router.set_route(request_method, url, block)
+      end
+
+      def namespace_url(url)
+        url.prepend(@namespace + '/')
+      end
+    end
+  end
+end

data/lib/cubic/application/logable.rb

@@ -0,0 +1,19 @@
+module Cubic
+  # Responsibe for logging information to the current environment log file.
+  module Logable
+
+    def log(message)
+      File.open(log_path, 'a') { |file| file.write(message) }
+    end
+
+    private
+
+    def log_path
+      File.join(APP_PATH, "log/#{env}.log")
+    end
+
+    def env
+      ENV['name'] || 'test'
+    end
+  end
+end

data/lib/cubic/core_extensions.rb

@@ -0,0 +1 @@
+require 'cubic/core_extensions/string'

data/lib/cubic/core_extensions/string.rb

@@ -0,0 +1 @@
+require 'cubic/core_extensions/string/parse'

data/lib/cubic/core_extensions/string/parse.rb

@@ -0,0 +1,17 @@
+module Cubic
+  module CoreExtensions
+    module Parse
+      def integer?
+        [
+          /^[-+]?[1-9]([0-9]*)?$/,
+          /^0[0-7]+$/,
+          /^0x[0-9A-Fa-f]+$/,
+          /^0b[01]+$/
+        ].each do |match_pattern|
+          return true if self =~ match_pattern
+        end
+        false
+      end
+    end
+  end
+end

data/lib/cubic/engine.rb

@@ -0,0 +1,49 @@
+require 'cubic/router'
+require 'erb'
+
+module Cubic
+  # Engine is what makes Cubic a Rack application.
+  class Engine
+
+    def self.call(env)
+      new(env).response.finish
+    end
+
+    def initialize(env)
+      @request = Rack::Request.new(env)
+    end
+
+    def response
+      Application.load_app
+      if search_routes
+        Response.new render
+      else
+        Response.new(status_404)
+      end
+    end
+
+    private
+
+    def status_404
+      { body: 'not found', status: 404 }
+    end
+
+    # Combines the params generated when checking routes
+    # with the params given by Rack::Request.
+    def merge_params
+      @request.params.merge(Router.params)
+    end
+
+    # Render a view.
+    def render
+      Render.new(merge_params, @content[:block]).template
+    end
+
+    # Checks if path given by Rack::Request matches
+    # any defined routes.
+    def search_routes
+      route = Router.search @request.request_method, @request.path
+      route ? @content = route : nil
+    end
+  end
+end

data/lib/cubic/generator.rb

@@ -0,0 +1,42 @@
+require_relative 'generators/config'
+require_relative 'generators/base'
+require_relative 'generators/controller'
+require_relative 'generators/model'
+require_relative 'generators/migrations'
+require_relative 'generators/gemfile'
+require_relative 'generators/view'
+require_relative 'generators/app'
+
+module Cubic
+  # The generator is what reads your sitemap file
+  # and generates the proper files.
+  module Generator
+    class << self
+
+      # Begins the generation process by running the block
+      # given from sitemap.rb file.
+      def run(&b)
+        @model      = Model.new
+        @controller = Controller.new
+        @gemfile    = Gemfile.new
+
+        instance_exec(&b)
+        App.create(@model, @controller, @gemfile)
+      end
+
+      private
+
+      def config(&b)
+        Config.instance_exec(&b)
+      end
+
+      def models(&b)
+        @model.instance_exec(&b)
+      end
+
+      def controllers(&b)
+        @controller.instance_exec(&b)
+      end
+    end
+  end
+end