pakyow-core 0.6.1

data/pakyow-core/lib/core/helpers.rb

@@ -0,0 +1,22 @@
+module Pakyow
+
+  # Helper methods that simply provide information (for use in binders)
+  module GeneralHelpers
+    def request
+      Pakyow.app.request
+    end
+    
+    def response
+      Pakyow.app.response
+    end
+  end
+
+  # Helper methods specific to delegates and controllers.
+  module Helpers
+    include GeneralHelpers
+    
+    def app
+      Pakyow.app
+    end
+  end
+end

data/pakyow-core/lib/core/loader.rb

@@ -0,0 +1,35 @@
+module Pakyow
+  
+  # Handles the loading and reloading of a Pakyow application. If in development
+  # mode, files are automatically reloaded if modified.
+  class Loader
+
+    # Loads files in the provided path, decending into child directories.
+    def load!(path)
+      require_recursively(path)
+    end
+    
+    protected
+    
+    def require_recursively(dir)
+      @times ||= {}
+      if File.exists?(dir)
+        DirUtils.walk_dir(dir) do |path|
+          next if FileTest.directory?(path)
+            
+          split = path.split('/')
+          next if split[split.length-1].start_with?('.')
+          
+          if Configuration::Base.app.auto_reload
+            if !@times[path] || (@times[path] && File.mtime(path) - @times[path] > 0)
+              load(path)
+              @times[path] = File.mtime(path)
+            end              
+          else
+            require path
+          end
+        end
+      end
+    end
+  end
+end

data/pakyow-core/lib/core/log.rb

@@ -0,0 +1,35 @@
+module Pakyow
+  
+  # Provides an easy way to log text, warnings, etc.
+  class Log
+    
+    # Adds text to the log. 
+    def self.puts(text = "")
+      return if !Configuration::Base.app.log
+      
+      @@console ||= Logger.new($stdout)
+      @@console << "#{text}\r\n"
+      
+      dir = "#{Configuration::Base.app.log_dir}"
+      
+      if File.exists?(dir)
+        @@file ||= Logger.new("#{dir}/#{Configuration::Base.app.log_name}")
+        @@file    << "#{text}\r\n"
+      end    
+    end
+
+    class << self
+      alias :enter :puts
+    end
+    
+    # Adds warning text to the log.
+    def self.warn(text)
+      Log.enter("WARNING: #{text}")
+    end
+
+    # Adds error text to the log.
+    def self.error(text)
+      Log.enter("ERROR: #{text}")
+    end
+  end
+end

data/pakyow-core/lib/core/presenter_base.rb

@@ -0,0 +1,7 @@
+module Pakyow
+  class PresenterBase
+    def self.inherited(subclass)
+      Configuration::Base.app.presenter = subclass
+    end
+  end
+end

data/pakyow-core/lib/core/request.rb

@@ -0,0 +1,66 @@
+module Pakyow
+
+  # The Request object.
+  class Request < Rack::Request
+    attr_accessor :restful, :route_spec, :controller, :action, :format, :error
+
+    # Easy access to path_info.
+    def path
+      self.path_info
+    end
+    
+    # Determines the request method.
+    def method
+      request_method.downcase.to_sym
+    end
+
+    def format=(format)
+      @format = format ? format.to_sym : :html
+      
+      # Set response type
+      Pakyow.app.response["Content-Type"] = Rack::Mime.mime_type(".#{@format}")
+    end
+    
+    def session
+      env['rack.session'] || {}
+    end
+    
+    def cookies
+      @cookies ||= HashUtils.strhash(super)
+    end
+    
+    # Returns indifferent params (see {HashUtils.strhash} for more info on indifferent hashes).
+    def params
+      @params ||= HashUtils.strhash(super)
+    end
+    
+    # Returns array of url components.
+    def url_parts
+      unless @url
+        @url = self.class.split_url(self.env['PATH_INFO'])
+      end
+    
+      return @url
+    end
+    
+    # Returns array of referer components.
+    def referer_parts
+      unless @referer
+        @referer = self.class.split_url(self.env['HTTP_REFERER'])
+      end
+    
+      return @referer
+    end
+    
+    private
+    
+    def self.split_url(url)
+      arr = []
+      url.split('/').each { |r|
+        arr << r unless r.empty?
+      }
+      
+      return arr
+    end
+  end
+end

data/pakyow-core/lib/core/route_store.rb

@@ -0,0 +1,117 @@
+module Pakyow
+  class RouteStore
+
+    def initialize()
+      @order = 1
+      @store =
+          {
+              # string routes are stored, for each method, as a hash of 'route'=>{:block=>b,:order=>n}
+            :string => {:get=>{}, :post=>{}, :put=>{}, :delete=>{}},
+
+              # regex routes are stored, for each method, as an array of hashes {:regex=>r,:block=>b,:order=>n,:vars=>{n=>var}}
+              # they are in definition order in the array
+            :regex => {:get=>[], :post=>[], :put=>[], :delete=>[]}
+
+              # :order is a global order across both string and regex routes.
+          }
+    end
+
+    def add_route(route_spec, block, method, data)
+      route_spec = normalize_route(route_spec)
+      route_to_match, vars = extract_route_vars(route_spec)
+      if route_to_match.class == String
+        @store[:string][method][route_to_match]={:block => block,
+                                                 :order => @order,
+                                                 :data => data}
+        @order = @order + 1
+      elsif route_to_match.class == Regexp
+        @store[:regex][method] << {:regex => route_to_match,
+                                   :block => block,
+                                   :order => @order,
+                                   :vars => vars,
+                                   :data => data}
+        @order = @order + 1
+      end
+    end
+
+    # returns block, {:vars=>{:var=>matched_value, ...}, :data=>data}
+    def get_block(route, method)
+      route = normalize_route(route)
+      # Get the match for a string route
+      string_route_match = @store[:string][method][route]
+
+      # Get first regex match
+      regex_route_match = nil
+      match_data = nil
+      @store[:regex][method].each { |rinfo|
+        if match_data = rinfo[:regex].match(route)
+          regex_route_match = rinfo
+          break
+        end
+      }
+
+      # return block for match with smaller :order
+      if string_route_match && regex_route_match
+        if string_route_match[:order] < regex_route_match[:order]
+          data = string_route_match[:data]
+          return string_route_match[:block], {:vars=>{}, :data=>data}
+        else
+          data = regex_route_match[:data]
+          return regex_route_match[:block], {:vars=>build_regex_var_values(regex_route_match[:vars], match_data), :data=>data}
+        end
+      elsif string_route_match
+        data = string_route_match[:data]
+        return string_route_match[:block], {:vars=>{}, :data=>data}
+      elsif regex_route_match
+        data = regex_route_match[:data]
+        return regex_route_match[:block], {:vars=>build_regex_var_values(regex_route_match[:vars], match_data), :data=>data}
+      else
+        return nil, {:vars=>{}, :data=>nil}
+      end
+
+    end
+
+    private
+
+    # Returns a regex and an array of variable info
+    def extract_route_vars(route_spec)
+      return route_spec, [] if route_spec.is_a?(Regexp)
+
+      unless route_spec[0,1] == ':' || route_spec.index('/:')
+        return route_spec, []
+      end
+
+      vars = []
+      position_counter = 0
+      regex_route = route_spec
+      route_spec.split('/').each_with_index do |segment, i|
+        if segment.include?(':')
+          position_counter += 1
+          vars << { :position => position_counter, :var => segment.gsub(':', '').to_sym }
+          regex_route = regex_route.gsub(segment, '([^new/]+)')
+        end
+      end
+
+      reg = Regexp.new("^#{regex_route}$")
+
+      return reg, vars
+    end
+
+    # remove leading/trailing forward slashes
+    def normalize_route(route_spec)
+      return route_spec if route_spec.is_a?(Regexp)
+      route_spec = route_spec[1, route_spec.length - 1] if route_spec[0, 1] == '/'
+      route_spec = route_spec[0, route_spec.length - 1] if route_spec[route_spec.length - 1, 1] == '/'
+      route_spec
+    end
+
+    def build_regex_var_values(vars_info, match_data)
+      var_values = {}
+      vars_info.each { |vi|
+        var_values[vi[:var]] = match_data[vi[:position]]
+      }
+      var_values
+    end
+
+  end
+end

data/pakyow-core/lib/generators/pakyow/app/app_generator.rb

@@ -0,0 +1,26 @@
+require 'fileutils'
+
+module Pakyow
+  module Generators
+    class AppGenerator
+      class << self
+        def start
+          if ARGV.first == '--help' || ARGV.first == '-h'
+            puts File.open(File.join(CORE_PATH, 'commands/USAGE-NEW')).read
+          else
+            generator = self.new
+            generator.build(ARGV.first)
+          end
+        end
+      end
+      
+      def initialize
+        @src = "#{File.expand_path('../', __FILE__)}/templates/."
+      end
+      
+      def build(dest)
+        FileUtils.cp_r(@src, dest)
+      end
+    end
+  end
+end

data/pakyow-core/lib/generators/pakyow/app/templates/README

@@ -0,0 +1,54 @@
+# Introduction
+
+Pakyow is a web framework for Ruby that knocks out projects with a serious
+punch. Pound for pound its the best way to build a web app. Get ready to rumble.
+
+Pakyow brings a unique approach to development:
+
+## Views are views.
+Views are 100% HTML, no template language required. The view has finally been 
+freed from logic.
+
+## Views are data aware.
+A view knows what it presents. Use this to create powerful connections between 
+business logic and views.
+
+## Keep you moving forward.
+Prototype an app by building the views first. Then write the view logic 
+without changing a single view.
+
+There are two main components of Pakyow. The first is Pakyow Core, which 
+handles routing requests to business logic. The second component is Pakyow 
+Presenter, which gives an application the ability to have a presentation 
+layer and provides mechanisms for the controller to bind data to the 
+presentation layer. Pakyow Core can operate independently of Pakyow 
+Presenter for those cases where an application doesn't need a presentation layer.
+
+# Getting Started
+
+1. Install Pakyow:
+
+gem install pakyow
+
+2. Create a new Pakyow application from the command prompt:
+
+pakyow new webapp
+
+3. Move to the "webapp" directory and start the application:
+
+cd webapp; pakyow server
+
+4. You'll find the application running here: http://localhost:3000
+
+# Next Steps
+
+The following resources might be handy:
+
+Website:
+http://pakyow.com
+
+Manual:
+http://pakyow.com/manual
+
+Code:
+http://github.com/metabahn/pakyow

data/pakyow-core/lib/generators/pakyow/app/templates/app/lib/application_controller.rb

@@ -0,0 +1,6 @@
+class ApplicationController
+  include Pakyow::Helpers
+  
+  def index
+  end
+end

data/pakyow-core/lib/generators/pakyow/app/templates/app/views/main.html

@@ -0,0 +1 @@
+<h1>Welcome to Pakyow!</h1>

data/pakyow-core/lib/generators/pakyow/app/templates/app/views/pakyow.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Pakyow</title>
+</head>
+
+<body>
+  <div id="wrapper">
+    <div id="main"></div>
+  </div>
+</body>
+</html>

data/pakyow-core/lib/generators/pakyow/app/templates/config/application.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'pakyow'
+
+module PakyowApplication
+  class Application < Pakyow::Application
+    config.app.default_environment = :development
+  
+    configure(:development) do
+    end
+    
+    routes do
+      default :ApplicationController, :index
+    end
+    
+    middleware do
+    end
+  end
+end

data/pakyow-core/lib/generators/pakyow/app/templates/config.ru

@@ -0,0 +1,10 @@
+require 'config/application'
+PakyowApplication::Application.stage(:development)
+
+app = Rack::Builder.new do
+  # Needed for Pakyow to work
+  use Rack::MethodOverride
+  run PakyowApplication::Application.new
+end.to_app
+
+run(app)

data/pakyow-core/lib/generators/pakyow/app/templates/rakefile

@@ -0,0 +1,5 @@
+env = ARGV[1] || 'development'
+env = env.split('=')[1] || env
+
+require 'config/application'
+PakyowApplication::Application.stage(env.to_sym)

data/pakyow-core/lib/pakyow-core.rb

@@ -0,0 +1,14 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+# Gems 
+require 'find'
+require 'rack'
+require 'rack/file'
+require 'logger'
+require 'cgi'
+
+# Base
+autoload :Pakyow, 'core/base'
+
+include Pakyow

data/pakyow-core/lib/utils/dir.rb

@@ -0,0 +1,18 @@
+module Pakyow
+
+  # Utility methods for directories and files.
+  class DirUtils
+
+      # visit dir, then all files in dir, then walk_dir each directory in dir
+      def self.walk_dir(dir, &block)
+        yield dir
+        all = Dir.entries(dir)
+        partition = all.partition{|e| File.file?("#{dir}/#{e}")}
+        files = partition[0]
+        dirs = partition[1]
+        files.each{|f| yield "#{dir}/#{f}" unless f.start_with?(".")}
+        dirs.each{|d| walk_dir("#{dir}/#{d}", &block) unless d.start_with?(".")}
+      end
+
+  end
+end

data/pakyow-core/lib/utils/hash.rb

@@ -0,0 +1,31 @@
+module Pakyow
+
+  # Utility methods for hashes.
+  class HashUtils
+    # Creates an indifferent hash. This means that when indifferentized, this hash:
+    #   { 'foo' => 'bar' }
+    #
+    # Can be accessed like this:
+    #   { :foo => 'bar' }
+    #
+    def self.strhash(hash)
+      indifferentize(hash)
+    end
+    
+    protected
+    
+    # (see {strhash})
+    def self.indifferentize(hash)
+      hash.each_pair do |key, value|
+        hash[key] = indifferentize(value) if value.is_a? Hash
+      end
+      
+      indifferent_hash.merge(hash)
+    end
+    
+    # (see {strhash})
+    def self.indifferent_hash
+      Hash.new { |hash,key| hash[key.to_s] if Symbol === key }
+    end
+  end
+end

data/pakyow-core/lib/utils/string.rb

@@ -0,0 +1,37 @@
+module Pakyow
+
+  # Utility methods for strings.
+  class StringUtils
+
+    # Creates an underscored, lowercase version of a string.
+    # This was borrowed from another library, probably ActiveSupport.
+    def self.underscore(string)
+      string.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    # split . seperated string at the last .
+    def self.split_at_last_dot(s)
+      split_index = s.rindex('.')
+      return s,nil unless split_index
+      left = s[0,split_index]
+      right = s[split_index+1,s.length-(split_index+1)]
+      return left,right
+    end
+
+    def self.remove_route_vars(route_spec)
+      return unless route_spec
+      arr = route_spec.split('/')
+      new_arr = []
+      arr.each {|e| new_arr << e unless e[0,1] == ':'}
+      ret = new_arr.join('/')
+      return '/' if ret == ''
+      return ret
+    end
+
+
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: pakyow-core
+version: !ruby/object:Gem::Version 
+  hash: 5
+  prerelease: 
+  segments: 
+  - 0
+  - 6
+  - 1
+  version: 0.6.1
+platform: ruby
+authors: 
+- Bryan Powell
+autorequire: 
+bindir: pakyow-core/bin
+cert_chain: []
+
+date: 2011-08-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  type: :runtime
+  version_requirements: *id001
+description: pakyow-core
+email: bryan@metabahn.com
+executables: 
+- pakyow
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- pakyow-core/CHANGES
+- pakyow-core/README
+- pakyow-core/MIT-LICENSE
+- pakyow-core/lib/commands/server.rb
+- pakyow-core/lib/commands/USAGE
+- pakyow-core/lib/commands/USAGE-NEW
+- pakyow-core/lib/commands/USAGE-SERVER
+- pakyow-core/lib/core/application.rb
+- pakyow-core/lib/core/base.rb
+- pakyow-core/lib/core/configuration/app.rb
+- pakyow-core/lib/core/configuration/base.rb
+- pakyow-core/lib/core/configuration/server.rb
+- pakyow-core/lib/core/helpers.rb
+- pakyow-core/lib/core/loader.rb
+- pakyow-core/lib/core/log.rb
+- pakyow-core/lib/core/presenter_base.rb
+- pakyow-core/lib/core/request.rb
+- pakyow-core/lib/core/route_store.rb
+- pakyow-core/lib/generators/pakyow/app/app_generator.rb
+- pakyow-core/lib/generators/pakyow/app/templates/app/lib/application_controller.rb
+- pakyow-core/lib/generators/pakyow/app/templates/app/views/main.html
+- pakyow-core/lib/generators/pakyow/app/templates/app/views/pakyow.html
+- pakyow-core/lib/generators/pakyow/app/templates/config/application.rb
+- pakyow-core/lib/generators/pakyow/app/templates/config.ru
+- pakyow-core/lib/generators/pakyow/app/templates/logs/requests.log
+- pakyow-core/lib/generators/pakyow/app/templates/public/favicon.ico
+- pakyow-core/lib/generators/pakyow/app/templates/rakefile
+- pakyow-core/lib/generators/pakyow/app/templates/README
+- pakyow-core/lib/pakyow-core.rb
+- pakyow-core/lib/utils/dir.rb
+- pakyow-core/lib/utils/hash.rb
+- pakyow-core/lib/utils/string.rb
+- pakyow-core/bin/pakyow
+homepage: http://pakyow.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- pakyow-core/lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: pakyow-core
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: pakyow-core
+test_files: []
+