learn_rails 0.0.0 → 0.0.1

data/features/step_definitions/associations.rb

@@ -0,0 +1,7 @@
+Given(/^PENDING/) do
+  pending
+end
+
+When(/^I type/) do
+  pending # either find the right aruba step definition or create one
+end

data/features/support/env.rb

@@ -0,0 +1,3 @@
+Before do
+  @aruba_timeout_seconds = 5
+end

data/features/support/setup.rb

@@ -0,0 +1,4 @@
+require 'coveralls'
+Coveralls.wear_merged!
+
+require "aruba/cucumber"

data/learn_rails.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'learn_rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "learn_rails"
+  spec.version       = LearnRails::VERSION
+  spec.authors       = ["Peter-Jan Celis"]
+  spec.email         = ["pj@celis.org"]
+  spec.description   = %q{Gem learn_rails shows you the ruby code behind rails magic.}
+  spec.summary       = %q{Gem learn_rails shows you the ruby code behind rails magic.}
+  spec.homepage      = "http://github.com/pjc/learn_rails"
+  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_dependency "activesupport", "~> 4.0.1"
+  spec.add_dependency "thor", "~> 0.18.1"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_development_dependency "cucumber", "~> 1.3.9"
+  spec.add_development_dependency "aruba", "~> 0.5.3"
+  spec.add_development_dependency "debugger", "~> 1.6.2"
+  spec.add_development_dependency "coveralls", "~> 0.7.0"
+end

data/lib/ext/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def to_condition_string
+    self.symbolize_keys.to_s.delete("}").delete("{").gsub('=>', ' => ')
+  end
+end

data/lib/learn_rails.rb

@@ -1,3 +1,54 @@
-class LearnRails
-  # Code to be added, just claiming RubyGems gem name
-end
+require "learn_rails/version"
+require "ext/hash"
+require "learn_rails/associations"
+require "learn_rails/associations/belongs_to"
+require "learn_rails/associations/has_one"
+require "learn_rails/associations/has_many"
+require "learn_rails/accessors"
+require "active_support/core_ext/string"
+
+module LearnRails
+  def self.analyze(*magic)
+    if accessor? magic
+      remove_model_name_from_accessor magic
+      LearnRails::Accessors.code_for magic
+    elsif association? magic
+      ensure_model_name_for_association magic
+      LearnRails::Associations.code_for magic
+    else
+      error_message
+    end
+  end
+
+  private
+
+  def self.accessor? magic
+    (magic[0..1] & ['attr_reader', 'attr_writer', 'attr_accessor']).any?
+  end
+
+  def self.remove_model_name_from_accessor magic
+    magic.shift unless ['attr_reader', 'attr_writer', 'attr_accessor'].include? magic[0]
+    magic
+  end
+
+  def self.association? magic
+    (magic[0..1] & ['belongs_to', 'has_one', 'has_many']).any?
+  end
+
+  def self.ensure_model_name_for_association magic
+    if ['has_one', 'has_many'].include? magic[0]
+      puts "What is the model name for this association?"
+      model_name = $stdin.gets.strip
+      magic.unshift model_name
+    elsif magic[0] == 'belongs_to'
+      magic.unshift 'token value for params[:model]'
+    end
+  end
+
+  def self.error_message
+    <<-error.gsub(/^\s+/, '')
+      No ruby code available.
+      See http://www.github.com/pjc/learn_rails for list of valid instructions.
+    error
+  end
+end

data/lib/learn_rails/accessors.rb

@@ -0,0 +1,56 @@
+module LearnRails
+  class Accessors
+    def self.code_for(accessor)
+      @accessor = accessor
+      @code = <<-code.gsub(/^\s+/, '')
+      code
+
+      attributes.each do |attribute|
+        @code << getter_method_for(attribute) if getter_method_needed?
+        @code << setter_method_for(attribute) if setter_method_needed?
+      end
+
+      @code
+    end
+
+    private
+
+    def self.attributes
+      @accessor.drop(1).map { |attr| attr.delete(',').delete(':') }.delete_if(&:empty?)
+    end
+
+    def self.getter_method_needed?
+      @getter ||= ['reader', 'accessor'].include? accessor_type
+    end
+
+    def self.setter_method_needed?
+      @setter ||= ['writer', 'accessor'].include? accessor_type
+    end
+
+    def self.accessor_type
+      @accessor[0].split('_')[1]
+    end
+
+    def self.getter_method_for attribute
+      <<-code.gsub(/^\s+/, '')
+        #{empty_comment_line_if_needed}
+        # def #{attribute}
+        #  @#{attribute}
+        # end
+      code
+    end
+
+    def self.setter_method_for attribute
+      <<-code.gsub(/^\s+/, '')
+        #{empty_comment_line_if_needed}
+        # def #{attribute}=(value)
+        #  @#{attribute} = value
+        # end
+      code
+    end
+
+    def self.empty_comment_line_if_needed
+      @code.present? ? '#' : nil
+    end
+  end
+end

data/lib/learn_rails/associations.rb

@@ -0,0 +1,44 @@
+module LearnRails
+  class Associations
+    def self.code_for(association)
+      params = params association
+      "LearnRails::Associations::#{params[:association].camelize}".constantize.send(:code_for, params)
+    end
+
+    private
+
+    def self.params association
+      clean_up association
+      hashify_conditions_options association
+
+      params = {}
+      params[:model]        = association.shift.downcase
+      params[:association]  = association.shift
+      params[:associate]    = association.shift
+
+      options_specified = Hash[*association].symbolize_keys!
+
+      params.merge!(options_specified)
+    end
+
+    def self.clean_up association
+      association.delete "=>"
+      association.map! { |e| e.delete(':').delete(',').delete('\"') }
+    end
+
+    def self.hashify_conditions_options association
+      return association unless association.include? "conditions"
+
+      start_options_index = association.index("conditions") + 1
+      end_options_index   = association[start_options_index..-1].find_index { |e| e.match /}/ } + start_options_index
+
+      conditions = []
+      association[start_options_index..end_options_index].each do |option|
+        conditions << option.delete('{').delete('}') if option.length > 1
+        association.delete(option)
+      end
+
+      association.insert(start_options_index, Hash[*conditions])
+    end
+  end
+end

data/lib/learn_rails/associations/belongs_to.rb

@@ -0,0 +1,48 @@
+module LearnRails
+  class Associations::BelongsTo < Associations
+    def self.code_for(params)
+      associate_model = (params[:class_name] || params[:associate]).camelize
+      foreign_id      = params[:foreign_key] || params[:associate] + "_id"
+      primary_id      = params[:primary_key] || "id"
+
+      <<-code.gsub(/^\s+/, '')
+        # def #{params[:associate]}(force_reload = false)
+        #   @#{params[:associate]} = nil if force_reload
+        #   @#{params[:associate]} ||= #{finder_method params, foreign_id, associate_model}
+        # end
+        #{ setter_method(params, foreign_id, primary_id) unless params[:readonly] }
+        #
+        # def build_#{params[:associate]}(attributes = {})
+        #   self.#{params[:associate]} = #{associate_model}.new(attributes)
+        # end
+        #
+        # def create_#{params[:associate]}(attributes = {})
+        #   self.#{params[:associate]} = #{associate_model}.create(attributes)
+        # end
+        #
+        # def create_#{params[:associate]}!(attributes = {})
+        #   self.#{params[:associate]} = #{associate_model}.create!(attributes)
+        # end
+      code
+    end
+
+    private
+
+    def self.setter_method params, foreign_id, primary_id
+      <<-code.gsub(/^\s+/, '')
+          #
+          # def #{params[:associate]}=(#{params[:associate]})
+          #   self.#{foreign_id} = #{params[:associate]}.#{primary_id}
+          # end
+      code
+    end
+
+    def self.finder_method params, foreign_id, associate_model
+      if params[:conditions]
+        "#{associate_model}.first(:conditions => {:id => self.#{foreign_id}, #{params[:conditions].to_condition_string}})"
+      else
+        "#{associate_model}.find_by_id(self.#{foreign_id})"
+      end
+    end
+  end
+end

data/lib/learn_rails/associations/has_many.rb

@@ -0,0 +1,13 @@
+module LearnRails
+  class Associations::HasMany < Associations
+    def self.code_for(params)
+      associate_model = params[:associate].singularize.camelize
+
+      <<-code.gsub(/^\s+/, '')
+        # def #{params[:associate]}
+        #   #{associate_model}.where(#{params[:model]}_id: self.id)
+        # end
+      code
+    end
+  end
+end

data/lib/learn_rails/associations/has_one.rb

@@ -0,0 +1,52 @@
+module LearnRails
+  class Associations::HasOne < Associations
+    def self.code_for(params)
+      associate_model = (params[:class_name] || params[:associate]).camelize
+      foreign_id      = params[:foreign_key] || params[:model] + "_id"
+      primary_id      = params[:primary_key] || "id"
+
+      <<-code.gsub(/^\s+/, '')
+        # def #{params[:associate]}(force_reload = false)
+        #   @#{params[:associate]} = nil if force_reload
+        #   @#{params[:associate]} ||= #{finder_method params, foreign_id, primary_id, associate_model}
+        # end
+        #{ setter_method(params, foreign_id, primary_id) unless params[:readonly] }
+        #
+        # def build_#{params[:associate]}(attributes = {})
+        #   attributes[:#{foreign_id}] = self.#{primary_id}
+        #   #{associate_model}.new(attributes)
+        # end
+        #
+        # def create_#{params[:associate]}(attributes = {})
+        #   attributes[:#{foreign_id}] = self.#{primary_id}
+        #   #{associate_model}.create(attributes)
+        # end
+        #
+        # def create_#{params[:associate]}!(attributes = {})
+        #   attributes[:#{foreign_id}] = self.#{primary_id}
+        #   #{associate_model}.create!(attributes)
+        # end
+      code
+    end
+
+    private
+
+    def self.setter_method params, foreign_id, primary_id
+      <<-code.gsub(/^\s+/, '')
+        #
+        # def #{params[:associate]}=(#{params[:associate]})
+        #   #{params[:associate]}.#{foreign_id} = self.#{primary_id}
+        #   #{params[:associate]}.save
+        # end
+      code
+    end
+
+    def self.finder_method params, foreign_id, primary_id, associate_model
+      if params[:conditions]
+        "#{associate_model}.first(:conditions => {:#{foreign_id} => self.#{primary_id}, #{params[:conditions].to_condition_string}})"
+      else
+        "#{associate_model}.find_by_#{foreign_id}(self.#{primary_id})"
+      end
+    end
+  end
+end

data/lib/learn_rails/cli.rb

@@ -0,0 +1,11 @@
+require 'thor'
+require 'learn_rails'
+
+module LearnRails
+  class CLI < Thor
+    desc "rails MAGIC", "Prints out the ruby code behind any rails magic line"
+    def rails(*magic)
+      puts LearnRails.analyze(*magic)
+    end
+  end
+end

data/lib/learn_rails/version.rb

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

data/spec/learn_rails/accessors_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+@accessors
+describe LearnRails::Accessors do
+
+  after(@accessors) do
+    LearnRails::Accessors.instance_variable_set(:@getter, nil)
+    LearnRails::Accessors.instance_variable_set(:@setter, nil)
+  end
+
+  context "attr" do
+    context "reader" do
+      context "with one attribute" do
+        it "should return the correct code" do
+          LearnRails::Accessors.code_for(%w(attr_reader :name)).should eql attr_reader_code
+        end
+      end
+
+      context "with multiple attributes" do
+        it "should return the correct code" do
+          LearnRails::Accessors.code_for(%w(attr_reader :name, :another)).should eql attr_reader_two_attributes_code
+        end
+      end
+    end
+
+    context "writer" do
+      context "with one attribute" do
+        it "should return the correct code" do
+          LearnRails::Accessors.code_for(%w(attr_writer :name)).should eql attr_writer_code
+        end
+      end
+
+      context "with multiple attributes" do
+        it "should return the correct code" do
+          LearnRails::Accessors.code_for(%w(attr_writer :name, :another)).should eql attr_writer_two_attributes_code
+        end
+      end
+    end
+
+    context "accessor" do
+      context "with one attribute" do
+        it "should return the correct code" do
+          LearnRails::Accessors.code_for(%w(attr_accessor :name)).should eql attr_accessor_code
+        end
+      end
+
+      context "with multiple attributes" do
+        it "should return the correct code" do
+          LearnRails::Accessors.code_for(%w(attr_accessor :name, :another)).should eql attr_accessor_two_attributes_code
+        end
+      end
+    end
+  end
+
+  context "with comma" do
+    context "right after the last attribute" do
+      it "should return the correct code" do
+        LearnRails::Accessors.code_for(%w(attr_accessor :name,)).should eql attr_accessor_code
+      end
+    end
+
+    context "seperated by a space" do
+      it "should return the correct code" do
+        LearnRails::Accessors.code_for(%w(attr_accessor :name ,)).should  eql attr_accessor_code
+      end
+    end
+  end
+
+  private
+
+  def attr_reader_code
+    <<-code.gsub(/^\s+/, '')
+      # def name
+      #  @name
+      # end
+    code
+  end
+
+  def attr_writer_code
+    <<-code.gsub(/^\s+/, '')
+      # def name=(value)
+      #  @name = value
+      # end
+    code
+  end
+
+  def attr_accessor_code
+    <<-code.gsub(/^\s+/, '')
+      # def name
+      #  @name
+      # end
+      #
+      # def name=(value)
+      #  @name = value
+      # end
+    code
+  end
+
+  def attr_reader_two_attributes_code
+    <<-code.gsub(/^\s+/, '')
+      # def name
+      #  @name
+      # end
+      #
+      # def another
+      #  @another
+      # end
+    code
+  end
+
+  def attr_writer_two_attributes_code
+    <<-code.gsub(/^\s+/, '')
+      # def name=(value)
+      #  @name = value
+      # end
+      #
+      # def another=(value)
+      #  @another = value
+      # end
+    code
+  end
+
+  def attr_accessor_two_attributes_code
+    <<-code.gsub(/^\s+/, '')
+      # def name
+      #  @name
+      # end
+      #
+      # def name=(value)
+      #  @name = value
+      # end
+      #
+      # def another
+      #  @another
+      # end
+      #
+      # def another=(value)
+      #  @another = value
+      # end
+    code
+  end
+end