cathode 0.0.1 → 0.1.0

data/lib/cathode/resource.rb

@@ -1,39 +1,70 @@
 module Cathode
+  # A `Resource` is paired with a Rails model and describes the actions that the
+  # resource responds to.
   class Resource
-    attr_reader :actions,
-                :name
+    include ActionDsl
+    include ResourceDsl
 
-    def initialize(resource_name, params = nil, &block)
+    attr_reader :controller_prefix,
+                :model,
+                :name,
+                :parent,
+                :singular,
+                :strong_params
+
+    # Creates a new resource.
+    # @param resource_name [Symbol] The resource's name
+    # @param params [Hash] An optional params hash, e.g. `{ actions: :all }`
+    # @param context [Resource] An optional parent resource
+    # @param block The resource's actions and properties, defined with the
+    #   {ActionDsl} and {ResourceDsl}
+    def initialize(resource_name, params = nil, context = nil, &block)
       require_resource_constant! resource_name
 
-      params ||= { actions: [] }
+      params ||= {}
+      params[:actions] ||= []
 
       @name = resource_name
 
-      Cathode.const_set "#{resource_name.to_s.camelize}Controller", Class.new(Cathode::BaseController)
+      camelized_resource = resource_name.to_s.camelize
 
-      @actions = {}
-      actions_to_add = params[:actions] == [:all] ? [:index, :show, :create, :update, :destroy] : params[:actions]
-      actions_to_add.each do |action_name|
-        action action_name
+      @controller_prefix = if context.present? && context.is_a?(Resource)
+        @parent = context
+        "#{context.controller_prefix}#{camelized_resource}"
+      else
+        camelized_resource
       end
-      self.instance_eval &block if block_given?
-      actions = @actions
 
-      Cathode::Engine.routes.draw do
-        resources resource_name, only: actions.keys
+      controller_name = "#{@controller_prefix}Controller"
+      unless Cathode.const_defined? controller_name
+        Cathode.const_set controller_name, Class.new(Cathode::BaseController)
       end
-    end
 
-  private
+      @actions = ObjectCollection.new
+      actions_to_add = params[:actions] == :all ? DEFAULT_ACTIONS : params[:actions]
+      actions_to_add.each { |action_name| action action_name }
+
+      @singular = params[:singular]
+
+      instance_eval(&block) if block_given?
 
-    def action(action, &block)
-      @actions[action] = Action.create(action, @name, &block)
+      @actions.each do |action|
+        action.after_resource_initialized if action.respond_to? :after_resource_initialized
+      end
+
+      if @strong_params.present? && actions.find(:create).nil? && actions.find(:update).nil?
+        raise UnknownActionError,
+          'An attributes block was specified without a :create or :update action'
+      end
     end
 
+  private
+
     def require_resource_constant!(resource_name)
-      if resource_name.to_s.singularize.camelize.safe_constantize.nil?
-        raise UnknownResourceError
+      constant = resource_name.to_s.singularize.camelize
+      @model = constant.safe_constantize
+      if @model.nil?
+        fail UnknownResourceError, "Could not find constant `#{constant}' for resource `#{resource_name}'"
       end
     end
   end

data/lib/cathode/resource_dsl.rb

@@ -0,0 +1,46 @@
+module Cathode
+  # Holds the domain-specific language (DSL) for describing resources.
+  module ResourceDsl
+    # Lists all the resources; initializes an empty `ObjectCollection` if there
+    # aren't any yet
+    # @return [Array] The resources
+    def _resources
+      @_resources ||= ObjectCollection.new
+    end
+
+  protected
+
+    def resources(resource_name, params = {}, &block)
+      add_resource resource_name, false, params, &block
+    end
+
+    def resource(resource_name, params = {}, &block)
+      add_resource resource_name, true, params, &block
+    end
+
+    def add_resource(resource_name, singular, params, &block)
+      params ||= {}
+      params = params.merge(singular: singular)
+      existing_resource = _resources.find resource_name
+      new_resource = Resource.new(resource_name, params, self, &block)
+
+      if existing_resource.present?
+        existing_resource.actions.add new_resource.actions.objects
+      else
+        @_resources << new_resource
+      end
+    end
+
+    def remove_resource(resources)
+      resources = [resources] unless resources.is_a?(Array)
+
+      resources.each do |resource|
+        if _resources.find(resource).nil?
+          fail UnknownResourceError, "Unknown resource `#{resource}'"
+        end
+
+        @_resources.delete(resource)
+      end
+    end
+  end
+end

data/lib/cathode/show_request.rb

@@ -0,0 +1,13 @@
+module Cathode
+  # Defines the default behavior for a show request.
+  class ShowRequest < Request
+    # Determine the default action to use depending on the resource. If the
+    # resource is singular, set the body to the parent's associated record.
+    # Otherwise, lookup the record directly.
+    def default_action_block
+      proc do
+        body record
+      end
+    end
+  end
+end

data/lib/cathode/update_request.rb

@@ -0,0 +1,26 @@
+module Cathode
+  # Defines the default behavior for an update request.
+  class UpdateRequest < Request
+    # Sets the default action to update a resource. If the resource is
+    # singular, updates the parent's associated resource. Otherwise, updates the
+    # resource directly.
+    def default_action_block
+      proc do
+        begin
+          record = if resource.singular
+                    parent_model = resource.parent.model.find(parent_resource_id)
+                    parent_model.send resource.name
+                  else
+                    record = model.find(params[:id])
+                  end
+
+          record.update(instance_eval(&@strong_params))
+          body record.reload
+        rescue ActionController::ParameterMissing => error
+          body error.message
+          status :bad_request
+        end
+      end
+    end
+  end
+end

data/lib/cathode/version.rb

@@ -1,30 +1,41 @@
-require 'semantic'
-
 module Cathode
+  # A `Version` encapsulates a specific SemVer-compliant version of the API with
+  # a set of resources and actions.
   class Version
-    attr_reader :resources,
-                :version
-
-    @@all = {}
-
-    def initialize(version_number, &block)
-      @version = Semantic::Version.new Version.standardize(version_number)
-      @resources = {}
-
-      self.instance_eval &block if block_given?
+    include ActionDsl
+    include ResourceDsl
 
-      Version.all[@version.to_s] = self
-    end
+    attr_reader :ancestor,
+                :version
 
-    def perform_request(resource, params)
-      resources[resource].actions[params[:action].to_sym].perform params
-    end
+    @all = []
 
     class << self
-      def all
-        @@all
+      attr_reader :all
+
+      # Defines a new version.
+      # @param version_number [String, Fixnum, Float] A number or string
+      #   representing a SemVer-compliant version number. If a `Fixnum` or
+      #   `Float` is passed, it will be converted to a string before being
+      #   evaluated for SemVer compliance, so passing `1.5` is equivalent to
+      #   passing `'1.5.0'`.
+      # @param block A block defining the version's resources and actions, and
+      #   has access to the methods in the {Cathode::ActionDsl} and {Cathode::ResourceDsl}
+      # @return [Version]
+      def define(version_number, &block)
+        version = Version.find(version_number)
+        if version.present?
+          version.instance_eval(&block)
+        else
+          version = self.new(version_number, &block)
+        end
+        version
       end
 
+      # Polyfills a version number snippet to be SemVer-compliant.
+      # @param rough_version [String] A version number snippet such as '1' or
+      #   '2.5'
+      # @return [String] The SemVer-compliant version number
       def standardize(rough_version)
         version_parts = rough_version.to_s.split '.'
         if version_parts.count < 2
@@ -35,15 +46,93 @@ module Cathode
         version_parts.join '.'
       end
 
-      def perform_request_with_version(version, resource, params)
-        Version.all[standardize(version)].perform_request resource, params
+      # Looks up a version by version number.
+      # @param version_number [String] The version to find
+      # @return [Version, nil] The version if found, `nil` if there is no such
+      #   version
+      def find(version_number)
+        Version.all.detect { |v| v.version == standardize(version_number) }
+      rescue ArgumentError
+        nil
+      end
+
+      # Whether a given version exists
+      # @param version_number [String] The version to check
+      # @return [Boolean]
+      def exists?(version_number)
+        find(version_number).present?
       end
     end
 
+    # Initializes a new version.
+    # @param version_number [String] A SemVer-compliant version number.
+    # @param block A block defining the version's resources and actions, and
+    #   has access to the methods in the {Cathode::ActionDsl} and {Cathode::ResourceDsl}
+    def initialize(version_number, &block)
+      @version = Semantic::Version.new Version.standardize(version_number)
+
+      if Version.all.present?
+        @ancestor = Version.all.last
+        @_resources = DeepClone.clone @ancestor._resources
+        actions.add ancestor.actions.objects
+      end
+
+      instance_eval(&block) if block_given?
+
+      Version.all << self
+    end
+
+    # Whether a resource is defined on the version.
+    # @param resource [Symbol] The resource's name
+    # @return [Boolean]
+    def resource?(resource)
+      _resources.names.include? resource.to_sym
+    end
+
+    # Whether an action is defined on a resource on the version.
+    # @param resource [Symbol] The resource's name
+    # @param action [Symbol] The action's name
+    # @return [Boolean]
+    def action?(resource, action)
+      resource = resource.to_sym
+      action = action.to_sym
+
+      return false unless resource?(resource)
+
+      _resources.find(resource).actions.names.include? action
+    end
+
   private
 
-    def resource(resource, params = nil, &block)
-      @resources[resource] = Resource.new(resource, params, &block)
+    def remove_action(*args)
+      if args.last.is_a?(Hash)
+        resource_name = args.last[:from]
+        resource = @_resources.find(resource_name)
+        actions_to_remove = args.take args.size - 1
+
+        if resource.nil?
+          fail UnknownResourceError, "Unknown resource `#{resource_name}' on ancestor version #{ancestor.version}"
+        end
+
+        actions_to_remove.each do |action|
+          if resource.actions.find(action).nil?
+            fail UnknownActionError, "Unknown action `#{action}' on resource `#{resource_name}'"
+          end
+
+          resource.actions.delete action
+        end
+      else
+        args.each do |action|
+          if actions.find(action).nil?
+            fail UnknownActionError, "Unknown action `#{action}' on ancestor version #{ancestor.version}"
+          end
+
+          actions.delete action
+        end
+      end
     end
+
+    alias_method :remove_resources, :remove_resource
+    alias_method :remove_actions, :remove_action
   end
 end

data/lib/tasks/cathode_tasks.rake

@@ -1,4 +1,5 @@
-# desc "Explaining what the task does"
-# task :cathode do
-#   # Task goes here
-# end
+namespace :cathode do
+  task :info do
+    puts Cathode::Debug.info
+  end
+end

data/spec/dummy/app/models/payment.rb

@@ -0,0 +1,3 @@
+class Payment < ActiveRecord::Base
+  belongs_to :sale
+end

data/spec/dummy/app/models/product.rb

@@ -1,2 +1,3 @@
 class Product < ActiveRecord::Base
+  has_many :sales
 end

data/spec/dummy/app/models/sale.rb

@@ -0,0 +1,5 @@
+class Sale < ActiveRecord::Base
+  belongs_to :salesperson
+  belongs_to :product
+  has_one :payment
+end

data/spec/dummy/app/models/salesperson.rb

@@ -0,0 +1,3 @@
+class Salesperson < ActiveRecord::Base
+  has_many :sales
+end

data/spec/dummy/db/migrate/20140409183635_create_sales.rb

@@ -0,0 +1,11 @@
+class CreateSales < ActiveRecord::Migration
+  def change
+    create_table :sales do |t|
+      t.integer :product_id
+      t.integer :subtotal
+      t.integer :taxes
+
+      t.timestamps
+    end
+  end
+end

data/spec/dummy/db/migrate/20140423172419_create_salespeople.rb

@@ -0,0 +1,11 @@
+class CreateSalespeople < ActiveRecord::Migration
+  def change
+    create_table :salespeople do |t|
+      t.string :name
+
+      t.timestamps
+    end
+
+    add_column :sales, :salesperson_id, :integer
+  end
+end

data/spec/dummy/db/migrate/20140424181343_create_payments.rb

@@ -0,0 +1,10 @@
+class CreatePayments < ActiveRecord::Migration
+  def change
+    create_table :payments do |t|
+      t.integer :amount
+      t.integer :sale_id
+
+      t.timestamps
+    end
+  end
+end

data/spec/dummy/db/schema.rb

@@ -11,7 +11,22 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20140404222551) do
+ActiveRecord::Schema.define(version: 20140425164100) do
+
+  create_table "cathode_tokens", force: true do |t|
+    t.boolean  "active",     default: true
+    t.datetime "expired_at"
+    t.string   "token"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "payments", force: true do |t|
+    t.integer  "amount"
+    t.integer  "sale_id"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
 
   create_table "products", force: true do |t|
     t.string   "title"
@@ -20,4 +35,19 @@ ActiveRecord::Schema.define(version: 20140404222551) do
     t.datetime "updated_at"
   end
 
+  create_table "sales", force: true do |t|
+    t.integer  "product_id"
+    t.integer  "subtotal"
+    t.integer  "taxes"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+    t.integer  "salesperson_id"
+  end
+
+  create_table "salespeople", force: true do |t|
+    t.string   "name"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
 end