abject 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 45d9afce900946a9a96389992c671a471e2d001e
+  data.tar.gz: 74e47d669de75444423662f5deecfe29ae67d640
+SHA512:
+  metadata.gz: d35980cf8344592e5a8e12799c4db4449cf5e29c997566f698fe0a7ae2b39959661cdccafbd755f0c544b3f6b7616ea4f14e0ec2c7a63673f251112b3e2d4f76
+  data.tar.gz: 73b59179bd0882ce83c436640b5825520c4a7b24294de25f54a0d103dc0a7c81009a859dc09a5a8b6ee9cf30eac4fcef4f95c2e438ef4d322a484f18d75b1183

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/specs/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dave Kinkead
+
+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,179 @@
+# Abject
+
+### Because you're been doing all it wrong!
+
+Abject Orientated Programming (Abject-O) is a set of best practices developed by [Greg Jorgensen](http://typicalprogrammer.com/abject-oriented/) that promotes code reuse and ensures programmers are producing code that can be used in production for a long time.
+
+For too long, the beauty of ruby has been sullied by the misguided follies of Gamma & his cronies.  Abject rectifies this by finally bringing Abject-O to Ruby is a snapply DSL.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+
+    gem 'abject'
+
+
+And then execute:
+
+
+    $ bundle
+
+
+Or install it yourself as:
+
+
+    $ gem install abject
+
+
+## Key Concepts
+
+### Inheritance
+
+Inheritance is a way to retain features of old code in newer code. The programmer derives from an existing function or block of code by making a copy of the code, then making changes to the copy. The derived code is often specialized by adding features not implemented in the original. In this way the old code is retained but the new code inherits from it.
+
+Unlike Object Oriented programming, inheritance in Abject-O need not be limited to classes - functions and blocks may also inherit from other code.  Programs that use inheritance are characterized by similar blocks of code with small differences appearing throughout the source. Another sign of inheritance is static members: variables and code that are not directly referenced or used, but serve to maintain a link to the original base or parent code. 
+
+
+    class Customer
+
+      def find_name(id)
+        results = DB.query :customer, id
+        fullname = "#{results[1]} #{results[2]}"
+      end
+
+
+      def find_email(id)
+        results = DB.query :customer, id
+        fullname = "#{results[1]} #{results[2]}"
+      
+        # email addresses can now be found in the 
+        # `fax-home` column 
+        email = "#{results[5]}"
+      end
+
+    end
+
+
+The function `find_email` was inherited from `find_name` when email addresses were added to the application. Inheriting code in this way leverages working code with less risk of introducing bugs.  But this is Ruby - implicit is better than explicit - so Abject provides a helpful DSL for functional and block inheritance that dynamically copies and pastes the inherited code at run time. [View source](lib/abject/inheritance.rb).
+
+
+    class Customer
+      include Abject::Inheritance
+
+      def find_name(id)
+        results = DB.query :customer, id
+        fullname = "#{results[1]} #{results[2]}"
+      end      
+
+      def find_email(id)
+        inherits_from :find_name, id: id do 
+          email = "#{results[5]}"
+        end
+      end
+
+    end
+
+
+### Polymorphism
+
+Code is polymorphic when it gives different outputs for different kinds of inputs.  To quote wikipedia, a function is polymorphic if it:
+
+> denotes different and potentially heterogeneous implementations depending on a limited range of individually specified types and combinations
+
+When learning Abject-O techniques, programmers frequently get caught up by this idea. It sounds hard but polymorphism is actually simple and easy to implement.  As an example, the functions above can be rewritten as a single polymorphic function by inheriting the code that already works and then encapsulating it into a new function:
+
+
+    class Customer
+
+      def find_customer(attrib, id)
+        if attrib == 'name'
+          results = DB.query :customer, id
+          fullname = "#{results[1]} #{results[2]}"
+        elsif attrib == 'email'
+          results = DB.query :customer, id
+          fullname = "#{results[1]} #{results[2]}"
+        
+        # email addresses can now be found in the 
+        # `fax-home` column 
+        email = "#{results[5]}"        
+      end
+
+    end
+
+
+### Encapsulation
+
+The idea behind encapsulation is to keep the data separate from the code. This is sometimes called data hiding, but the data is not really hidden, just protected inside another layer of code. For example, it’s not a good practice to scatter database lookups all over the place. An Abject-O practice is to wrap or hide the database in a function, thereby encapsulating the database. In the `find_name` function above the database is not queried directly — a function is called to read the database record. All `find_name` and `find_email` (and the many other functions like them) “know” is where in the customer record to find the bits of data they need. How the customer record is read is encapsulated in some other module.
+
+Encapsulation can also be achieved through the use of protected functions.  The importance of function safety cannot be stressed enough as unprotected methods may result in data spillage, tight object coupling, and other morally questionable behaviours. In Ruby, functions can be protected with the `#` character and many IDE's also provide macros to protect large sections of your code base efficiently - `opt arrow` on Sublime Text for example.  
+
+
+    # An exposed public method
+    def exposed_method(customer, id)
+      query = DB.find :customer, id
+      customer = Customer.new query
+    end
+
+    #  A protected method
+    # def protected_method(customer, id)
+    #   query = DB.find :customer, id
+    #   customer = Customer.new query
+    # end
+
+
+The Abject gem provides an elegant means of protecting methods from any unwanted spillage and leakage that might result from tight coupling.  Simply declare a function protected at the end of a class and let Ruby's metaprogramming magic do its work. [View source](lib/abject/encapsulation.rb).
+
+
+    class Foo
+      include Abject::Encapsulation
+
+      def bar
+        "bar"
+      end
+
+      def baz
+        "baz"
+      end
+
+      protects :baz
+
+    end
+
+    p Foo.new.bar # => "bar"
+    p Foo.new.baz # => nil
+
+
+### DRY
+
+Don’t Repeat Yourself (DRY) is a principle of software development, aimed at reducing repetition of information of all kinds, especially useful in multi-tier architectures. The DRY principle is stated as
+
+> Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.
+
+The antonym of DRY is, obviously, WET: Write Everything Twice.  When the DRY principle is applied successfully, a modification of any single element of a system does not require a change in other logically unrelated elements.
+
+Owing to their naivety and laziness, junior developers often try to implement the DRY paradigm by copying and pasting code they found somewhere on the internet.  This is of course, myopic and inefficient.  The Abject-O Rubyist doesn't need to debased themselves with such short sighted behaviour though, as the Abject gem turns the entire internet into your code base.  [View source](lib/abject/dry.rb)
+
+
+    class FizzBuzzer
+      include Abject::DRY
+
+        def fizzbuzz(number)
+          url = 'http://stackoverflow.com/questions/24435547/ruby-fizzbuzz-not-working-as-expected#24435693'
+          adjustments = {'puts' => 'return', 'def fizzbuzz(n)' => 'lambda do |n|'}
+          fuck_it_just_copy_something_from_stackoverflow(url, adjustments).call(number).last.to_s
+        end
+
+    end
+
+
+---
+
+
+## Contributing
+
+1. Download the zipped binary https://github.com/davekinkead/abject/archive/master.zip
+2. Run your [unit test]
+3. Zip your new code and appropriately name the file abject-v-0.0.1-john-smith-2014-11-20-fixed-typos.zip
+4. FTP to the SourceForge project page

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake"
+
+task default: [:specs]
+
+task :specs do 
+	$LOAD_PATH.unshift 'lib', 'specs'
+	Dir.glob('specs/*_spec*.rb').each { |file| require_relative file }
+end

data/abject.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'abject/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "abject"
+  spec.version       = Abject::VERSION
+  spec.authors       = ["Dave Kinkead"]
+  spec.email         = ["dave@kinkead.com.au"]
+  spec.summary       = %q{Abject Oriented Programming for the Rubyist}
+  spec.description   = %q{Abject provides a snappy DSL to make Abject-O a reality!}
+  spec.homepage      = "https://github.com/davekinkead/abject"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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 "curb"
+  spec.add_dependency "nokogiri"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/abject.rb

@@ -0,0 +1,4 @@
+require 'abject/version'
+require 'abject/inheritance'
+require 'abject/encapsulation'
+require 'abject/dry'

data/lib/abject/dry.rb

@@ -0,0 +1,26 @@
+require 'curb'
+require 'nokogiri'
+
+module Abject
+  module DRY
+
+    # Why copy & paste answers from stack overflow when you can curl & eval them!
+    # Expects a url#answer-id and a hash of adjustments to the answer code to gsub over
+    def fuck_it_just_copy_something_from_stackoverflow(url, adjustments)
+      # build the adjustment lambda
+      edit = "lambda { |method_string| method_string"
+      adjustments.each { |k,v| edit += ".gsub('#{k}', '#{v}')" }
+      edit += "}"
+
+      # then get some of that overflow goodness
+      answer = url.split('#').last
+      @doc ||= Nokogiri::HTML Curl.get(url).body_str
+      @doc.css("#answer-#{answer} code").each do |code|
+        # Oh yeah, it's lambda time! Eval the edit string, pass it the overflow code
+        # and eval the resulting lambda
+        return eval eval(edit).call code.content
+      end
+
+    end
+  end
+end

data/lib/abject/encapsulation.rb

@@ -0,0 +1,40 @@
+require 'abject/reader'
+
+module Abject
+
+  # The idea behind encapsulation is to keep the data separate from the code. This is sometimes 
+  # called data hiding, but the data is not really hidden, just protected inside another layer 
+  # of code. For example, it’s not a good practice to scatter database lookups all over the place. 
+  # An abject practice is to wrap or hide the database in functions or subroutines, thereby 
+  # encapsulating the database. In the `find_name` function above the database is not queried 
+  # directly — a function is called to read the database record. All `find_name` and `find_email` 
+  # (and the many other functions like them) “know” is where in the customer record to find 
+  # the bits of data they need. How the customer record is read is encapsulated in some other module.
+
+  # Encapsulation can also be achieved through the use of protected functions.  The importance 
+  # of function safety cannot be stressed enough.  Unprotected methods result in data spillage, 
+  # tight object coupling, and other morally questionable behaviours. Abject-O achieves this 
+  # with the `#` character and many IDE's also provide macros to protect large sections of 
+  # your code base efficiently - `opt arrow` on Sublime Text for example. 
+  module Encapsulation
+    include Abject::Reader
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      # Copying and pasting is so 1999.  Lets use some ruby meta programming magic to 
+      # dyanmically protect our methods with some `#` hashes at run time!
+      def protects(name)
+        location = self.instance_method(name).source_location
+        define_method name do |*args|
+          eval parse_method(location).gsub(/^/m, "#")
+        end
+
+      end
+    end
+
+  end
+end

data/lib/abject/inheritance.rb

@@ -0,0 +1,26 @@
+require 'abject/reader'
+
+module Abject
+
+  # Inheritance is a way to retain features of old code in newer code. The programmer derives 
+  # from an existing function or block of code by making a copy of the code, then making 
+  # changes to the copy. The derived code is often specialized by adding features not 
+  # implemented in the original. In this way the old code is retained but the new code inherits 
+  # from it.
+
+  # Unlike Object Oriented programming, inheritance in Abject-O need not be limited to classes 
+  # - functions and blocks may also inherit from other code.  Programs that use inheritance are 
+  # characterized by similar blocks of code with small differences appearing throughout the source.
+  # Another sign of inheritance is static members: variables and code that are not directly 
+  # referenced or used, but serve to maintain a link to the original base or parent code. 
+  module Inheritance
+    include Abject::Reader
+
+    # Method chaining helps methods adhere to the single responsibility principle as well as
+    # improving performance and saving memory by getting rid of all those pesky local variables.
+    # Such eval! So performant! Much wow!
+    def inherits_from(parent, *args, &block)
+      eval("Proc.new { |#{args.first.keys.map { |k| k.to_s }.join ','}| #{parse_method method(parent).to_proc.source_location}\n#{parse_method block.source_location} }").call args
+    end
+  end
+end

data/lib/abject/reader.rb

@@ -0,0 +1,12 @@
+module Abject
+  module Reader
+
+    private
+
+    # Save time copy & pasting old methods by doing it at run time!
+    # TODO: count block keywords for loops and conditionals
+    def parse_method(location)
+      File.readlines(location[0])[location[1].to_i..-1].join.split("end\n").first
+    end
+  end
+end

data/lib/abject/version.rb

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

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: abject
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dave Kinkead
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Abject provides a snappy DSL to make Abject-O a reality!
+email:
+- dave@kinkead.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- abject.gemspec
+- lib/abject.rb
+- lib/abject/dry.rb
+- lib/abject/encapsulation.rb
+- lib/abject/inheritance.rb
+- lib/abject/reader.rb
+- lib/abject/version.rb
+- vendor/cache/curb-0.8.6.gem
+- vendor/cache/mini_portile-0.6.1.gem
+- vendor/cache/nokogiri-1.6.4.1.gem
+- vendor/cache/rake-10.3.2.gem
+homepage: https://github.com/davekinkead/abject
+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.2
+signing_key: 
+specification_version: 4
+summary: Abject Oriented Programming for the Rubyist
+test_files: []